PageRenderTime 27ms CodeModel.GetById 14ms app.highlight 8ms RepoModel.GetById 1ms app.codeStats 0ms

/js/lib/Socket.IO-node/support/expresso/deps/jscoverage/js/jsbuiltins.h

http://github.com/onedayitwillmake/RealtimeMultiplayerNodeJs
C++ Header | 374 lines | 224 code | 39 blank | 111 comment | 1 complexity | 92a62f42fe3f3379462b8554aedac1a2 MD5 | raw file
  1/* -*- 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
 48enum JSTNErrType { INFALLIBLE, FAIL_NULL, FAIL_NEG, FAIL_VOID, FAIL_JSVAL };
 49enum { 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 */
 79struct 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
318jsdouble FASTCALL
319js_StringToNumber(JSContext* cx, JSString* str);
320
321jsdouble FASTCALL
322js_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 */
340JS_DECLARE_CALLINFO(js_Array_dense_setelem)
341JS_DECLARE_CALLINFO(js_FastNewArray)
342JS_DECLARE_CALLINFO(js_Array_1int)
343JS_DECLARE_CALLINFO(js_Array_1str)
344JS_DECLARE_CALLINFO(js_Array_2obj)
345JS_DECLARE_CALLINFO(js_Array_3num)
346
347/* Defined in jsdate.cpp */
348JS_DECLARE_CALLINFO(js_FastNewDate)
349
350/* Defined in jsnum.cpp */
351JS_DECLARE_CALLINFO(js_NumberToString)
352
353/* Defined in jsstr.cpp */
354JS_DECLARE_CALLINFO(js_ConcatStrings)
355JS_DECLARE_CALLINFO(js_String_getelem)
356JS_DECLARE_CALLINFO(js_String_p_charCodeAt)
357JS_DECLARE_CALLINFO(js_EqualStrings)
358JS_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___ */