/[jscoverage]/trunk/js/jsbuiltins.h
ViewVC logotype

Annotation of /trunk/js/jsbuiltins.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 399 - (hide annotations)
Tue Dec 9 03:37:47 2008 UTC (11 years, 10 months ago) by siliconforks
File MIME type: text/plain
File size: 20380 byte(s)
Use SpiderMonkey from Firefox 3.1b2.

1 siliconforks 399 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2     * vim: set ts=8 sw=4 et tw=99:
3     *
4     * ***** BEGIN LICENSE BLOCK *****
5     * Version: MPL 1.1/GPL 2.0/LGPL 2.1
6     *
7     * The contents of this file are subject to the Mozilla Public License Version
8     * 1.1 (the "License"); you may not use this file except in compliance with
9     * the License. You may obtain a copy of the License at
10     * http://www.mozilla.org/MPL/
11     *
12     * Software distributed under the License is distributed on an "AS IS" basis,
13     * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
14     * for the specific language governing rights and limitations under the
15     * License.
16     *
17     * The Original Code is Mozilla SpiderMonkey JavaScript 1.9 code, released
18     * May 28, 2008.
19     *
20     * The Initial Developer of the Original Code is
21     * Mozilla Corporation.
22     *
23     * Contributor(s):
24     * Jason Orendorff <jorendorff@mozilla.com>
25     *
26     * Alternatively, the contents of this file may be used under the terms of
27     * either of the GNU General Public License Version 2 or later (the "GPL"),
28     * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
29     * in which case the provisions of the GPL or the LGPL are applicable instead
30     * of those above. If you wish to allow use of your version of this file only
31     * under the terms of either the GPL or the LGPL, and not to allow others to
32     * use your version of this file under the terms of the MPL, indicate your
33     * decision by deleting the provisions above and replace them with the notice
34     * and other provisions required by the GPL or the LGPL. If you do not delete
35     * the provisions above, a recipient may use your version of this file under
36     * the terms of any one of the MPL, the GPL or the LGPL.
37     *
38     * ***** END LICENSE BLOCK ***** */
39    
40     #ifndef jsbuiltins_h___
41     #define jsbuiltins_h___
42    
43     #ifdef JS_TRACER
44    
45     #include "nanojit/nanojit.h"
46     #include "jstracer.h"
47    
48     enum JSTNErrType { INFALLIBLE, FAIL_NULL, FAIL_NEG, FAIL_VOID, FAIL_JSVAL };
49     enum { JSTN_ERRTYPE_MASK = 7, JSTN_MORE = 8 };
50    
51     #define JSTN_ERRTYPE(jstn) ((jstn)->flags & JSTN_ERRTYPE_MASK)
52    
53     /*
54     * |prefix| and |argtypes| declare what arguments should be passed to the
55     * native function. |prefix| can contain the following characters:
56     *
57     * 'C': a JSContext* argument
58     * 'T': |this| as a JSObject* argument (bails if |this| is not an object)
59     * 'S': |this| as a JSString* argument (bails if |this| is not a string)
60     * 'R': a JSRuntime* argument
61     * 'P': the pc as a jsbytecode*
62     * 'D': |this| as a number (jsdouble)
63     * 'f': the function being called, as a JSObject*
64     * 'p': the .prototype of the function, as a JSObject*
65     *
66     * The corresponding things will get passed as arguments to the builtin in
67     * reverse order (so TC means JSContext* as the first arg, and the
68     * JSObject* for |this| as the second arg).
69     *
70     * |argtypes| can contain the following characters:
71     * 'd': a number (double) argument
72     * 'i': an integer argument
73     * 's': a JSString* argument
74     * 'o': a JSObject* argument
75     * 'r': a JSObject* argument that is of class js_RegExpClass
76     * 'f': a JSObject* argument that is of class js_FunctionClass
77     * 'v': a jsval argument (boxing whatever value is actually being passed in)
78     */
79     struct JSTraceableNative {
80     JSFastNative native;
81     const nanojit::CallInfo *builtin;
82     const char *prefix;
83     const char *argtypes;
84     uintN flags; /* JSTN_MORE | JSTNErrType */
85     };
86    
87     /*
88     * We use a magic boxed pointer value to represent error conditions that
89     * trigger a side exit. The address is so low that it should never be actually
90     * in use. If it is, a performance regression occurs, not an actual runtime
91     * error.
92     */
93     #define JSVAL_ERROR_COOKIE OBJECT_TO_JSVAL((void*)0x10)
94    
95     /* Macros used by JS_DEFINE_CALLINFOn. */
96     #ifdef DEBUG
97     #define _JS_CI_NAME(op) ,#op
98     #else
99     #define _JS_CI_NAME(op)
100     #endif
101    
102     #define _JS_I32_ARGSIZE nanojit::ARGSIZE_LO
103     #define _JS_I32_RETSIZE nanojit::ARGSIZE_LO
104     #define _JS_F64_ARGSIZE nanojit::ARGSIZE_F
105     #define _JS_F64_RETSIZE nanojit::ARGSIZE_F
106     #define _JS_PTR_ARGSIZE nanojit::ARGSIZE_LO
107     #if defined AVMPLUS_64BIT
108     # define _JS_PTR_RETSIZE nanojit::ARGSIZE_Q
109     #else
110     # define _JS_PTR_RETSIZE nanojit::ARGSIZE_LO
111     #endif
112    
113     /*
114     * Supported types for builtin functions.
115     *
116     * Types with -- for the two string fields are not permitted as argument types
117     * in JS_DEFINE_TRCINFO.
118     *
119     * If a traceable native can fail, the values that indicate failure are part of
120     * the return type:
121     * JSVAL_FAIL: JSVAL_ERROR_COOKIE
122     * BOOL_FAIL: JSVAL_TO_BOOLEAN(JSVAL_VOID)
123     * INT32_FAIL: any negative value
124     * STRING_FAIL: NULL
125     * OBJECT_FAIL_NULL: NULL
126     * OBJECT_FAIL_VOID: JSVAL_TO_OBJECT(JSVAL_VOID)
127     * (NULL means the function successfully returned JS null.)
128     *
129     * Special builtins known to the tracer can have their own idiosyncratic
130     * error codes.
131     *
132     * When a traceable native returns a value indicating failure, we fall off
133     * trace. If an exception is pending, it is thrown; otherwise, we assume the
134     * builtin had no side effects and retry the current bytecode in the
135     * interpreter.
136     *
137     * So a builtin must not return a value indicating failure after causing side
138     * effects (such as reporting an error), without setting an exception pending.
139     * The operation would be retried, despite the first attempt's observable
140     * effects.
141     */
142     #define _JS_CTYPE(ctype, size, pch, ach, flags) (ctype, size, pch, ach, flags)
143     #define _JS_CTYPE_CONTEXT _JS_CTYPE(JSContext *, _JS_PTR,"C", "", INFALLIBLE)
144     #define _JS_CTYPE_RUNTIME _JS_CTYPE(JSRuntime *, _JS_PTR,"R", "", INFALLIBLE)
145     #define _JS_CTYPE_THIS _JS_CTYPE(JSObject *, _JS_PTR,"T", "", INFALLIBLE)
146     #define _JS_CTYPE_THIS_DOUBLE _JS_CTYPE(jsdouble, _JS_F64,"D", "", INFALLIBLE)
147     #define _JS_CTYPE_THIS_STRING _JS_CTYPE(JSString *, _JS_PTR,"S", "", INFALLIBLE)
148     #define _JS_CTYPE_PC _JS_CTYPE(jsbytecode *, _JS_PTR,"P", "", INFALLIBLE)
149     #define _JS_CTYPE_JSVAL _JS_CTYPE(jsval, _JS_PTR, "","v", INFALLIBLE)
150     #define _JS_CTYPE_JSVAL_FAIL _JS_CTYPE(jsval, _JS_PTR, --, --, FAIL_JSVAL)
151     #define _JS_CTYPE_BOOL _JS_CTYPE(JSBool, _JS_I32, "","i", INFALLIBLE)
152     #define _JS_CTYPE_BOOL_FAIL _JS_CTYPE(int32, _JS_I32, --, --, FAIL_VOID)
153     #define _JS_CTYPE_INT32 _JS_CTYPE(int32, _JS_I32, "","i", INFALLIBLE)
154     #define _JS_CTYPE_INT32_FAIL _JS_CTYPE(int32, _JS_I32, --, --, FAIL_NEG)
155     #define _JS_CTYPE_UINT32 _JS_CTYPE(uint32, _JS_I32, --, --, INFALLIBLE)
156     #define _JS_CTYPE_DOUBLE _JS_CTYPE(jsdouble, _JS_F64, "","d", INFALLIBLE)
157     #define _JS_CTYPE_STRING _JS_CTYPE(JSString *, _JS_PTR, "","s", INFALLIBLE)
158     #define _JS_CTYPE_STRING_FAIL _JS_CTYPE(JSString *, _JS_PTR, --, --, FAIL_NULL)
159     #define _JS_CTYPE_OBJECT _JS_CTYPE(JSObject *, _JS_PTR, "","o", INFALLIBLE)
160     #define _JS_CTYPE_OBJECT_FAIL_NULL _JS_CTYPE(JSObject *, _JS_PTR, --, --, FAIL_NULL)
161     #define _JS_CTYPE_OBJECT_FAIL_VOID _JS_CTYPE(JSObject *, _JS_PTR, --, --, FAIL_VOID)
162     #define _JS_CTYPE_REGEXP _JS_CTYPE(JSObject *, _JS_PTR, "","r", INFALLIBLE)
163     #define _JS_CTYPE_SCOPEPROP _JS_CTYPE(JSScopeProperty *, _JS_PTR, --, --, INFALLIBLE)
164     #define _JS_CTYPE_SIDEEXIT _JS_CTYPE(SideExit *, _JS_PTR, --, --, INFALLIBLE)
165     #define _JS_CTYPE_INTERPSTATE _JS_CTYPE(InterpState *, _JS_PTR, --, --, INFALLIBLE)
166     #define _JS_CTYPE_FRAGMENT _JS_CTYPE(nanojit::Fragment *, _JS_PTR, --, --, INFALLIBLE)
167    
168     #define _JS_EXPAND(tokens) tokens
169    
170     #define _JS_CTYPE_TYPE2(t,s,p,a,f) t
171     #define _JS_CTYPE_TYPE(tyname) _JS_EXPAND(_JS_CTYPE_TYPE2 _JS_CTYPE_##tyname)
172     #define _JS_CTYPE_RETSIZE2(t,s,p,a,f) s##_RETSIZE
173     #define _JS_CTYPE_RETSIZE(tyname) _JS_EXPAND(_JS_CTYPE_RETSIZE2 _JS_CTYPE_##tyname)
174     #define _JS_CTYPE_ARGSIZE2(t,s,p,a,f) s##_ARGSIZE
175     #define _JS_CTYPE_ARGSIZE(tyname) _JS_EXPAND(_JS_CTYPE_ARGSIZE2 _JS_CTYPE_##tyname)
176     #define _JS_CTYPE_PCH2(t,s,p,a,f) p
177     #define _JS_CTYPE_PCH(tyname) _JS_EXPAND(_JS_CTYPE_PCH2 _JS_CTYPE_##tyname)
178     #define _JS_CTYPE_ACH2(t,s,p,a,f) a
179     #define _JS_CTYPE_ACH(tyname) _JS_EXPAND(_JS_CTYPE_ACH2 _JS_CTYPE_##tyname)
180     #define _JS_CTYPE_FLAGS2(t,s,p,a,f) f
181     #define _JS_CTYPE_FLAGS(tyname) _JS_EXPAND(_JS_CTYPE_FLAGS2 _JS_CTYPE_##tyname)
182    
183     #define _JS_static_TN(t) static t
184     #define _JS_static_CI static
185     #define _JS_extern_TN(t) extern t
186     #define _JS_extern_CI
187     #define _JS_FRIEND_TN(t) extern JS_FRIEND_API(t)
188     #define _JS_FRIEND_CI
189     #define _JS_TN_LINKAGE(linkage, t) _JS_##linkage##_TN(t)
190     #define _JS_CI_LINKAGE(linkage) _JS_##linkage##_CI
191    
192     #define _JS_CALLINFO(name) name##_ci
193    
194     #if defined(JS_NO_FASTCALL) && defined(NANOJIT_IA32)
195     #define _JS_DEFINE_CALLINFO(linkage, name, crtype, cargtypes, argtypes, cse, fold) \
196     _JS_TN_LINKAGE(linkage, crtype) name cargtypes; \
197     _JS_CI_LINKAGE(linkage) const nanojit::CallInfo _JS_CALLINFO(name) = \
198     { (intptr_t) &name, argtypes, cse, fold, nanojit::ABI_CDECL _JS_CI_NAME(name) };
199     #else
200     #define _JS_DEFINE_CALLINFO(linkage, name, crtype, cargtypes, argtypes, cse, fold) \
201     _JS_TN_LINKAGE(linkage, crtype) FASTCALL name cargtypes; \
202     _JS_CI_LINKAGE(linkage) const nanojit::CallInfo _JS_CALLINFO(name) = \
203     { (intptr_t) &name, argtypes, cse, fold, nanojit::ABI_FASTCALL _JS_CI_NAME(name) };
204     #endif
205    
206     /*
207     * Declare a C function named <op> and a CallInfo struct named <op>_callinfo so the
208     * tracer can call it. |linkage| controls the visibility of both the function
209     * and the CallInfo global. It can be extern, static, or FRIEND, which
210     * specifies JS_FRIEND_API linkage for the function.
211     */
212     #define JS_DEFINE_CALLINFO_1(linkage, rt, op, at0, cse, fold) \
213     _JS_DEFINE_CALLINFO(linkage, op, _JS_CTYPE_TYPE(rt), (_JS_CTYPE_TYPE(at0)), \
214     (_JS_CTYPE_ARGSIZE(at0) << 2) | _JS_CTYPE_RETSIZE(rt), cse, fold)
215     #define JS_DEFINE_CALLINFO_2(linkage, rt, op, at0, at1, cse, fold) \
216     _JS_DEFINE_CALLINFO(linkage, op, _JS_CTYPE_TYPE(rt), \
217     (_JS_CTYPE_TYPE(at0), _JS_CTYPE_TYPE(at1)), \
218     (_JS_CTYPE_ARGSIZE(at0) << 4) | (_JS_CTYPE_ARGSIZE(at1) << 2) | \
219     _JS_CTYPE_RETSIZE(rt), \
220     cse, fold)
221     #define JS_DEFINE_CALLINFO_3(linkage, rt, op, at0, at1, at2, cse, fold) \
222     _JS_DEFINE_CALLINFO(linkage, op, _JS_CTYPE_TYPE(rt), \
223     (_JS_CTYPE_TYPE(at0), _JS_CTYPE_TYPE(at1), _JS_CTYPE_TYPE(at2)), \
224     (_JS_CTYPE_ARGSIZE(at0) << 6) | (_JS_CTYPE_ARGSIZE(at1) << 4) | \
225     (_JS_CTYPE_ARGSIZE(at2) << 2) | _JS_CTYPE_RETSIZE(rt), \
226     cse, fold)
227     #define JS_DEFINE_CALLINFO_4(linkage, rt, op, at0, at1, at2, at3, cse, fold) \
228     _JS_DEFINE_CALLINFO(linkage, op, _JS_CTYPE_TYPE(rt), \
229     (_JS_CTYPE_TYPE(at0), _JS_CTYPE_TYPE(at1), _JS_CTYPE_TYPE(at2), \
230     _JS_CTYPE_TYPE(at3)), \
231     (_JS_CTYPE_ARGSIZE(at0) << 8) | (_JS_CTYPE_ARGSIZE(at1) << 6) | \
232     (_JS_CTYPE_ARGSIZE(at2) << 4) | (_JS_CTYPE_ARGSIZE(at3) << 2) | \
233     _JS_CTYPE_RETSIZE(rt), \
234     cse, fold)
235     #define JS_DEFINE_CALLINFO_5(linkage, rt, op, at0, at1, at2, at3, at4, cse, fold) \
236     _JS_DEFINE_CALLINFO(linkage, op, _JS_CTYPE_TYPE(rt), \
237     (_JS_CTYPE_TYPE(at0), _JS_CTYPE_TYPE(at1), _JS_CTYPE_TYPE(at2), \
238     _JS_CTYPE_TYPE(at3), _JS_CTYPE_TYPE(at4)), \
239     (_JS_CTYPE_ARGSIZE(at0) << 10) | (_JS_CTYPE_ARGSIZE(at1) << 8) | \
240     (_JS_CTYPE_ARGSIZE(at2) << 6) | (_JS_CTYPE_ARGSIZE(at3) << 4) | \
241     (_JS_CTYPE_ARGSIZE(at4) << 2) | _JS_CTYPE_RETSIZE(rt), \
242     cse, fold)
243    
244     #define JS_DECLARE_CALLINFO(name) extern const nanojit::CallInfo _JS_CALLINFO(name);
245    
246     #define _JS_TN_INIT_HELPER_n(n, args) _JS_TN_INIT_HELPER_##n args
247    
248     #define _JS_TN_INIT_HELPER_1(linkage, rt, op, at0, cse, fold) \
249     &_JS_CALLINFO(op), \
250     _JS_CTYPE_PCH(at0), \
251     _JS_CTYPE_ACH(at0), \
252     _JS_CTYPE_FLAGS(rt)
253    
254     #define _JS_TN_INIT_HELPER_2(linkage, rt, op, at0, at1, cse, fold) \
255     &_JS_CALLINFO(op), \
256     _JS_CTYPE_PCH(at1) _JS_CTYPE_PCH(at0), \
257     _JS_CTYPE_ACH(at0) _JS_CTYPE_ACH(at1), \
258     _JS_CTYPE_FLAGS(rt)
259    
260     #define _JS_TN_INIT_HELPER_3(linkage, rt, op, at0, at1, at2, cse, fold) \
261     &_JS_CALLINFO(op), \
262     _JS_CTYPE_PCH(at2) _JS_CTYPE_PCH(at1) _JS_CTYPE_PCH(at0), \
263     _JS_CTYPE_ACH(at0) _JS_CTYPE_ACH(at1) _JS_CTYPE_ACH(at2), \
264     _JS_CTYPE_FLAGS(rt)
265    
266     #define _JS_TN_INIT_HELPER_4(linkage, rt, op, at0, at1, at2, at3, cse, fold) \
267     &_JS_CALLINFO(op), \
268     _JS_CTYPE_PCH(at3) _JS_CTYPE_PCH(at2) _JS_CTYPE_PCH(at1) _JS_CTYPE_PCH(at0), \
269     _JS_CTYPE_ACH(at0) _JS_CTYPE_ACH(at1) _JS_CTYPE_ACH(at2) _JS_CTYPE_ACH(at3), \
270     _JS_CTYPE_FLAGS(rt)
271    
272     #define _JS_TN_INIT_HELPER_5(linkage, rt, op, at0, at1, at2, at3, at4, cse, fold) \
273     &_JS_CALLINFO(op), \
274     _JS_CTYPE_PCH(at4) _JS_CTYPE_PCH(at3) _JS_CTYPE_PCH(at2) _JS_CTYPE_PCH(at1) \
275     _JS_CTYPE_PCH(at0), \
276     _JS_CTYPE_ACH(at0) _JS_CTYPE_ACH(at1) _JS_CTYPE_ACH(at2) _JS_CTYPE_ACH(at3) \
277     _JS_CTYPE_ACH(at4), \
278     _JS_CTYPE_FLAGS(rt)
279    
280     #define JS_DEFINE_TRCINFO_1(name, tn0) \
281     _JS_DEFINE_CALLINFO_n tn0 \
282     JSTraceableNative name##_trcinfo[] = { \
283     { name, _JS_TN_INIT_HELPER_n tn0 } \
284     };
285    
286     #define JS_DEFINE_TRCINFO_2(name, tn0, tn1) \
287     _JS_DEFINE_CALLINFO_n tn0 \
288     _JS_DEFINE_CALLINFO_n tn1 \
289     JSTraceableNative name##_trcinfo[] = { \
290     { name, _JS_TN_INIT_HELPER_n tn0 | JSTN_MORE }, \
291     { name, _JS_TN_INIT_HELPER_n tn1 } \
292     };
293    
294     #define JS_DEFINE_TRCINFO_3(name, tn0, tn1, tn2) \
295     _JS_DEFINE_CALLINFO_n tn0 \
296     _JS_DEFINE_CALLINFO_n tn1 \
297     _JS_DEFINE_CALLINFO_n tn2 \
298     JSTraceableNative name##_trcinfo[] = { \
299     { name, _JS_TN_INIT_HELPER_n tn0 | JSTN_MORE }, \
300     { name, _JS_TN_INIT_HELPER_n tn1 | JSTN_MORE }, \
301     { name, _JS_TN_INIT_HELPER_n tn2 } \
302     };
303    
304     #define JS_DEFINE_TRCINFO_4(name, tn0, tn1, tn2, tn3) \
305     _JS_DEFINE_CALLINFO_n tn0 \
306     _JS_DEFINE_CALLINFO_n tn1 \
307     _JS_DEFINE_CALLINFO_n tn2 \
308     _JS_DEFINE_CALLINFO_n tn3 \
309     JSTraceableNative name##_trcinfo[] = { \
310     { name, _JS_TN_INIT_HELPER_n tn0 | JSTN_MORE }, \
311     { name, _JS_TN_INIT_HELPER_n tn1 | JSTN_MORE }, \
312     { name, _JS_TN_INIT_HELPER_n tn2 | JSTN_MORE }, \
313     { name, _JS_TN_INIT_HELPER_n tn3 } \
314     };
315    
316     #define _JS_DEFINE_CALLINFO_n(n, args) JS_DEFINE_CALLINFO_##n args
317    
318     jsdouble FASTCALL
319     js_StringToNumber(JSContext* cx, JSString* str);
320    
321     jsdouble FASTCALL
322     js_BooleanOrUndefinedToNumber(JSContext* cx, int32 unboxed);
323    
324     #else
325    
326     #define JS_DEFINE_CALLINFO_1(linkage, rt, op, at0, cse, fold)
327     #define JS_DEFINE_CALLINFO_2(linkage, rt, op, at0, at1, cse, fold)
328     #define JS_DEFINE_CALLINFO_3(linkage, rt, op, at0, at1, at2, cse, fold)
329     #define JS_DEFINE_CALLINFO_4(linkage, rt, op, at0, at1, at2, at3, cse, fold)
330     #define JS_DEFINE_CALLINFO_5(linkage, rt, op, at0, at1, at2, at3, at4, cse, fold)
331     #define JS_DECLARE_CALLINFO(name)
332     #define JS_DEFINE_TRCINFO_1(name, tn0)
333     #define JS_DEFINE_TRCINFO_2(name, tn0, tn1)
334     #define JS_DEFINE_TRCINFO_3(name, tn0, tn1, tn2)
335     #define JS_DEFINE_TRCINFO_4(name, tn0, tn1, tn2, tn3)
336    
337     #endif /* !JS_TRACER */
338    
339     /* Defined in jsarray.cpp */
340     JS_DECLARE_CALLINFO(js_Array_dense_setelem)
341     JS_DECLARE_CALLINFO(js_FastNewArray)
342     JS_DECLARE_CALLINFO(js_Array_1int)
343     JS_DECLARE_CALLINFO(js_Array_1str)
344     JS_DECLARE_CALLINFO(js_Array_2obj)
345     JS_DECLARE_CALLINFO(js_Array_3num)
346    
347     /* Defined in jsdate.cpp */
348     JS_DECLARE_CALLINFO(js_FastNewDate)
349    
350     /* Defined in jsnum.cpp */
351     JS_DECLARE_CALLINFO(js_NumberToString)
352    
353     /* Defined in jsstr.cpp */
354     JS_DECLARE_CALLINFO(js_ConcatStrings)
355     JS_DECLARE_CALLINFO(js_String_getelem)
356     JS_DECLARE_CALLINFO(js_String_p_charCodeAt)
357     JS_DECLARE_CALLINFO(js_EqualStrings)
358     JS_DECLARE_CALLINFO(js_CompareStrings)
359    
360     /* Defined in jsbuiltins.cpp */
361     #define BUILTIN1(linkage, rt, op, at0, cse, fold) JS_DECLARE_CALLINFO(op)
362     #define BUILTIN2(linkage, rt, op, at0, at1, cse, fold) JS_DECLARE_CALLINFO(op)
363     #define BUILTIN3(linkage, rt, op, at0, at1, at2, cse, fold) JS_DECLARE_CALLINFO(op)
364     #define BUILTIN4(linkage, rt, op, at0, at1, at2, at3, cse, fold) JS_DECLARE_CALLINFO(op)
365     #define BUILTIN5(linkage, rt, op, at0, at1, at2, at3, at4, cse, fold) JS_DECLARE_CALLINFO(op)
366     #include "builtins.tbl"
367     #undef BUILTIN
368     #undef BUILTIN1
369     #undef BUILTIN2
370     #undef BUILTIN3
371     #undef BUILTIN4
372     #undef BUILTIN5
373    
374     #endif /* jsbuiltins_h___ */

  ViewVC Help
Powered by ViewVC 1.1.24