1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "xptcprivate.h"
#include <stddef.h>
#include <stdlib.h>
// "This code is for IA64 only"
/* Implement shared vtbl methods. */
extern "C" nsresult ATTRIBUTE_USED
PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex,
uint64_t* intargs, uint64_t* floatargs, uint64_t* restargs)
{
nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
const nsXPTMethodInfo* info;
uint64_t* iargs = intargs;
uint64_t* fargs = floatargs;
uint8_t paramCount;
uint8_t i;
NS_ASSERTION(self,"no self");
self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);
NS_ASSERTION(info,"no interface info");
paramCount = info->GetParamCount();
const uint8_t indexOfJSContext = info->IndexOfJSContext();
for(i = 0; i < paramCount; ++i)
{
int isfloat = 0;
const nsXPTParamInfo& param = info->GetParam(i);
const nsXPTType& type = param.GetType();
nsXPTCMiniVariant* dp = ¶mBuffer[i];
MOZ_CRASH("NYI: support implicit JSContext*, bug 1475699");
if(param.IsOut() || !type.IsArithmetic())
{
#ifdef __LP64__
/* 64 bit pointer mode */
dp->val.p = (void*) *iargs;
#else
/* 32 bit pointer mode */
uint32_t* adr = (uint32_t*) iargs;
dp->val.p = (void*) (*(adr+1));
#endif
}
else
switch(type)
{
case nsXPTType::T_I8 : dp->val.i8 = *(iargs); break;
case nsXPTType::T_I16 : dp->val.i16 = *(iargs); break;
case nsXPTType::T_I32 : dp->val.i32 = *(iargs); break;
case nsXPTType::T_I64 : dp->val.i64 = *(iargs); break;
case nsXPTType::T_U8 : dp->val.u8 = *(iargs); break;
case nsXPTType::T_U16 : dp->val.u16 = *(iargs); break;
case nsXPTType::T_U32 : dp->val.u32 = *(iargs); break;
case nsXPTType::T_U64 : dp->val.u64 = *(iargs); break;
case nsXPTType::T_FLOAT :
isfloat = 1;
if (i < 7)
dp->val.f = (float) *((double*) fargs); /* register */
else
dp->val.u32 = *(fargs); /* memory */
break;
case nsXPTType::T_DOUBLE :
isfloat = 1;
dp->val.u64 = *(fargs);
break;
case nsXPTType::T_BOOL : dp->val.b = *(iargs); break;
case nsXPTType::T_CHAR : dp->val.c = *(iargs); break;
case nsXPTType::T_WCHAR : dp->val.wc = *(iargs); break;
default:
NS_ERROR("bad type");
break;
}
if (i < 7)
{
/* we are parsing register arguments */
if (i == 6)
{
// run out of register arguments, move on to memory arguments
iargs = restargs;
fargs = restargs;
}
else
{
++iargs; // advance one integer register slot
if (isfloat) ++fargs; // advance float register slot if isfloat
}
}
else
{
/* we are parsing memory arguments */
++iargs;
++fargs;
}
}
nsresult result = self->mOuter->CallMethod((uint16_t) methodIndex, info,
paramBuffer);
return result;
}
extern "C" nsresult SharedStub(uint64_t,uint64_t,uint64_t,uint64_t,
uint64_t,uint64_t,uint64_t,uint64_t,uint64_t,uint64_t *);
/* Variable a0-a7 were put there so we can have access to the 8 input
registers on Stubxyz entry */
#define STUB_ENTRY(n) \
nsresult nsXPTCStubBase::Stub##n(uint64_t a1, \
uint64_t a2,uint64_t a3,uint64_t a4,uint64_t a5,uint64_t a6,uint64_t a7, \
uint64_t a8) \
{ uint64_t a0 = (uint64_t) this; \
return SharedStub(a0,a1,a2,a3,a4,a5,a6,a7,(uint64_t) n, &a8); \
}
#define SENTINEL_ENTRY(n) \
nsresult nsXPTCStubBase::Sentinel##n() \
{ \
NS_ERROR("nsXPTCStubBase::Sentinel called"); \
return NS_ERROR_NOT_IMPLEMENTED; \
}
#include "xptcstubsdef.inc"
|
