diff options
Diffstat (limited to 'js/src/jsbuiltins.h')
| -rw-r--r-- | js/src/jsbuiltins.h | 635 |
1 files changed, 635 insertions, 0 deletions
diff --git a/js/src/jsbuiltins.h b/js/src/jsbuiltins.h new file mode 100644 index 0000000..5381814 --- /dev/null +++ b/js/src/jsbuiltins.h @@ -0,0 +1,635 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * vim: set ts=8 sw=4 et tw=99: + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Mozilla SpiderMonkey JavaScript 1.9 code, released + * May 28, 2008. + * + * The Initial Developer of the Original Code is + * Mozilla Corporation. + * + * Contributor(s): + * Jason Orendorff <jorendorff@mozilla.com> + * + * Alternatively, the contents of this file may be used under the terms of + * either of the GNU General Public License Version 2 or later (the "GPL"), + * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef jsbuiltins_h___ +#define jsbuiltins_h___ + +#ifdef JS_TRACER + +#include "nanojit/nanojit.h" +#include "jsvalue.h" + +#ifdef THIS +#undef THIS +#endif + +enum JSTNErrType { INFALLIBLE, FAIL_STATUS, FAIL_NULL, FAIL_NEG, FAIL_NEITHER }; +enum { + JSTN_ERRTYPE_MASK = 0x07, + JSTN_UNBOX_AFTER = 0x08, + JSTN_MORE = 0x10, + JSTN_CONSTRUCTOR = 0x20, + JSTN_RETURN_NULLABLE_STR = 0x40, + JSTN_RETURN_NULLABLE_OBJ = 0x80 +}; + +#define JSTN_ERRTYPE(jstn) ((jstn)->flags & JSTN_ERRTYPE_MASK) + +/* + * Type describing a type specialization of a js::Native. + * + * |prefix| and |argtypes| declare what arguments should be passed to the + * native function. |prefix| can contain the following characters: + * + * 'C': a JSContext* argument + * 'T': |this| as a JSObject* argument (bails if |this| is not an object) + * 'S': |this| as a JSString* argument (bails if |this| is not a string) + * 'R': a JSRuntime* argument + * 'P': the pc as a jsbytecode* + * 'D': |this| as a number (jsdouble) + * 'f': the function being called, as a JSObject* + * 'p': the .prototype of the function, as a JSObject* + * + * The corresponding things will get passed as arguments to the builtin in + * reverse order (so TC means JSContext* as the first arg, and the + * JSObject* for |this| as the second arg). + * + * |argtypes| can contain the following characters: + * 'd': a number (double) argument + * 'i': an integer argument + * 's': a JSString* argument + * 'o': a JSObject* argument + * 'r': a JSObject* argument that is of class js_RegExpClass + * 'f': a JSObject* argument that is of class js_FunctionClass + * 'v': a value argument: on 32-bit, a Value*, on 64-bit, a jsval + */ +struct JSSpecializedNative { + const nanojit::CallInfo *builtin; + const char *prefix; + const char *argtypes; + uintN flags; /* JSTNErrType | JSTN_UNBOX_AFTER | JSTN_MORE | + JSTN_CONSTRUCTOR */ +}; + +/* + * Type holding extra trace-specific information about a fast native. + * + * 'specializations' points to a static array of available specializations + * terminated by the lack of having the JSTN_MORE flag set. + */ +struct JSNativeTraceInfo { + js::Native native; + JSSpecializedNative *specializations; +}; + +/* Macros used by JS_DEFINE_CALLINFOn. */ +#ifdef DEBUG +#define _JS_CI_NAME(op) ,#op +#else +#define _JS_CI_NAME(op) +#endif + +#define _JS_I32_ARGTYPE nanojit::ARGTYPE_I +#define _JS_I32_RETTYPE nanojit::ARGTYPE_I +#define _JS_U64_ARGTYPE nanojit::ARGTYPE_Q +#define _JS_U64_RETTYPE nanojit::ARGTYPE_Q +#define _JS_F64_ARGTYPE nanojit::ARGTYPE_D +#define _JS_F64_RETTYPE nanojit::ARGTYPE_D +#define _JS_PTR_ARGTYPE nanojit::ARGTYPE_P +#define _JS_PTR_RETTYPE nanojit::ARGTYPE_P + +struct ClosureVarInfo; + +/* + * Supported types for builtin functions. + * + * Types with -- for the two string fields are not permitted as argument types + * in JS_DEFINE_TRCINFO. + * + * There are three kinds of traceable-native error handling. + * + * - If a traceable native's return type ends with _FAIL, it always runs to + * completion. It can either succeed or fail with an error or exception; + * on success, it may or may not stay on trace. There may be side effects + * in any case. If the call succeeds but bails off trace, we resume in the + * interpreter at the next opcode. + * + * _FAIL builtins indicate failure or bailing off trace by setting bits in + * cx->interpState->builtinStatus. + * + * - If a traceable native's return type contains _RETRY, it can either + * succeed, fail with a JS exception, or tell the caller to bail off trace + * and retry the call from the interpreter. The last case happens if the + * builtin discovers that it can't do its job without examining the JS + * stack, reentering the interpreter, accessing properties of the global + * object, etc. + * + * The builtin must detect the need to retry before committing any side + * effects. If a builtin can't do this, it must use a _FAIL return type + * instead of _RETRY. + * + * _RETRY builtins indicate failure with a special return value that + * depends on the return type: + * + * BOOL_RETRY: JS_NEITHER + * INT32_RETRY: any negative value + * STRING_RETRY: NULL + * OBJECT_RETRY_NULL: NULL + * + * _RETRY function calls are faster than _FAIL calls. Each _RETRY call + * saves two writes to tm->bailExit and a read from state->builtinStatus. + * + * - All other traceable natives are infallible (e.g. Date.now, Math.log). + * + * Special builtins known to the tracer can have their own idiosyncratic + * error codes. + * + * When a traceable native returns a value indicating failure, we fall off + * trace. If an exception is pending, it is thrown; otherwise, we assume the + * builtin had no side effects and retry the current bytecode in the + * interpreter. + * + * So a builtin must not return a value indicating failure after causing side + * effects (such as reporting an error), without setting an exception pending. + * The operation would be retried, despite the first attempt's observable + * effects. + */ +#define _JS_CTYPE(ctype, size, pch, ach, flags) (ctype, size, pch, ach, flags) + +#define _JS_CTYPE_CONTEXT _JS_CTYPE(JSContext *, _JS_PTR,"C", "", INFALLIBLE) +#define _JS_CTYPE_RUNTIME _JS_CTYPE(JSRuntime *, _JS_PTR,"R", "", INFALLIBLE) +#define _JS_CTYPE_MATHCACHE _JS_CTYPE(js::MathCache *, _JS_PTR,"M", "", INFALLIBLE) +#define _JS_CTYPE_THIS _JS_CTYPE(JSObject *, _JS_PTR,"T", "", INFALLIBLE) +#define _JS_CTYPE_THIS_DOUBLE _JS_CTYPE(jsdouble, _JS_F64,"D", "", INFALLIBLE) +#define _JS_CTYPE_THIS_STRING _JS_CTYPE(JSString *, _JS_PTR,"S", "", INFALLIBLE) +#define _JS_CTYPE_CALLEE _JS_CTYPE(JSObject *, _JS_PTR,"f", "", INFALLIBLE) +#define _JS_CTYPE_CALLEE_PROTOTYPE _JS_CTYPE(JSObject *, _JS_PTR,"p", "", INFALLIBLE) +#define _JS_CTYPE_FUNCTION _JS_CTYPE(JSFunction *, _JS_PTR, --, --, INFALLIBLE) +#define _JS_CTYPE_PC _JS_CTYPE(jsbytecode *, _JS_PTR,"P", "", INFALLIBLE) +#define _JS_CTYPE_VALUEPTR _JS_CTYPE(js::Value *, _JS_PTR, --, --, INFALLIBLE) +#define _JS_CTYPE_CVALUEPTR _JS_CTYPE(const js::Value *, _JS_PTR, --, --, INFALLIBLE) +#define _JS_CTYPE_JSID _JS_CTYPE(jsid, _JS_PTR, --, --, INFALLIBLE) +#define _JS_CTYPE_JSVAL _JS_CTYPE(js::Value, _JS_U64, --, --, INFALLIBLE) +#define _JS_CTYPE_BOOL _JS_CTYPE(JSBool, _JS_I32, "","i", INFALLIBLE) +#define _JS_CTYPE_BOOL_RETRY _JS_CTYPE(JSBool, _JS_I32, --, --, FAIL_NEITHER) +#define _JS_CTYPE_BOOL_FAIL _JS_CTYPE(JSBool, _JS_I32, --, --, FAIL_STATUS) +#define _JS_CTYPE_BOOLPTR _JS_CTYPE(JSBool *, _JS_PTR, --, --, INFALLIBLE) +#define _JS_CTYPE_INT32 _JS_CTYPE(int32, _JS_I32, "","i", INFALLIBLE) +#define _JS_CTYPE_INT32_RETRY _JS_CTYPE(int32, _JS_I32, --, --, FAIL_NEG) +#define _JS_CTYPE_INT32_FAIL _JS_CTYPE(int32, _JS_I32, --, --, FAIL_STATUS) +#define _JS_CTYPE_INT32PTR _JS_CTYPE(int32 *, _JS_PTR, --, --, INFALLIBLE) +#define _JS_CTYPE_UINT32 _JS_CTYPE(uint32, _JS_I32, "","i", INFALLIBLE) +#define _JS_CTYPE_UINT32_RETRY _JS_CTYPE(uint32, _JS_I32, --, --, FAIL_NEG) +#define _JS_CTYPE_UINT32_FAIL _JS_CTYPE(uint32, _JS_I32, --, --, FAIL_STATUS) +#define _JS_CTYPE_DOUBLE _JS_CTYPE(jsdouble, _JS_F64, "","d", INFALLIBLE) +#define _JS_CTYPE_DOUBLE_FAIL _JS_CTYPE(jsdouble, _JS_F64, --, --, FAIL_STATUS) +#define _JS_CTYPE_STRING _JS_CTYPE(JSString *, _JS_PTR, "","s", INFALLIBLE) +#define _JS_CTYPE_STRING_RETRY _JS_CTYPE(JSString *, _JS_PTR, --, --, FAIL_NULL) +#define _JS_CTYPE_STRING_FAIL _JS_CTYPE(JSString *, _JS_PTR, --, --, FAIL_STATUS) +#define _JS_CTYPE_STRING_OR_NULL_FAIL _JS_CTYPE(JSString *, _JS_PTR, --, --, FAIL_STATUS | \ + JSTN_RETURN_NULLABLE_STR) +#define _JS_CTYPE_STRINGPTR _JS_CTYPE(JSString **, _JS_PTR, --, --, INFALLIBLE) +#define _JS_CTYPE_OBJECT _JS_CTYPE(JSObject *, _JS_PTR, "","o", INFALLIBLE) +#define _JS_CTYPE_OBJECT_RETRY _JS_CTYPE(JSObject *, _JS_PTR, --, --, FAIL_NULL) +#define _JS_CTYPE_OBJECT_FAIL _JS_CTYPE(JSObject *, _JS_PTR, --, --, FAIL_STATUS) +#define _JS_CTYPE_OBJECT_OR_NULL_FAIL _JS_CTYPE(JSObject *, _JS_PTR, --, --, FAIL_STATUS | \ + JSTN_RETURN_NULLABLE_OBJ) +#define _JS_CTYPE_OBJECTPTR _JS_CTYPE(JSObject **, _JS_PTR, --, --, INFALLIBLE) +#define _JS_CTYPE_CONSTRUCTOR_RETRY _JS_CTYPE(JSObject *, _JS_PTR, --, --, FAIL_NULL | \ + JSTN_CONSTRUCTOR) +#define _JS_CTYPE_REGEXP _JS_CTYPE(JSObject *, _JS_PTR, "","r", INFALLIBLE) +#define _JS_CTYPE_SHAPE _JS_CTYPE(js::Shape *, _JS_PTR, --, --, INFALLIBLE) +#define _JS_CTYPE_TRACERSTATE _JS_CTYPE(TracerState *, _JS_PTR, --, --, INFALLIBLE) +#define _JS_CTYPE_FRAGMENT _JS_CTYPE(nanojit::Fragment *, _JS_PTR, --, --, INFALLIBLE) +#define _JS_CTYPE_CLASS _JS_CTYPE(js::Class *, _JS_PTR, --, --, INFALLIBLE) +#define _JS_CTYPE_DOUBLEPTR _JS_CTYPE(double *, _JS_PTR, --, --, INFALLIBLE) +#define _JS_CTYPE_CHARPTR _JS_CTYPE(char *, _JS_PTR, --, --, INFALLIBLE) +#define _JS_CTYPE_CVIPTR _JS_CTYPE(const ClosureVarInfo *, _JS_PTR, --, --, INFALLIBLE) +#define _JS_CTYPE_FRAMEINFO _JS_CTYPE(FrameInfo *, _JS_PTR, --, --, INFALLIBLE) +#define _JS_CTYPE_PICTABLE _JS_CTYPE(PICTable *, _JS_PTR, --, --, INFALLIBLE) +#define _JS_CTYPE_UINTN _JS_CTYPE(uintN, _JS_PTR, --, --, INFALLIBLE) + +/* + * The "VALUE" type is used to indicate that a native takes a js::Value + * parameter by value. Unfortunately, for technical reasons, we can't simply + * have the parameter type be js::Value. Furthermore, the right thing to pass + * differs based on word size. Thus, a native that declares a parameter of type + * VALUE should have the corresponding argument type be: + * - on 32-bit: const Value* + * - on 64-bit: jsval (which is a uint64) + * + * To write code that just does the right thing, use the pattern: + * void foo(js::ValueArgType arg) { + * const js::Value &v = js::ValueArgToConstRef(arg); + */ +#if JS_BITS_PER_WORD == 32 +# define _JS_CTYPE_VALUE _JS_CTYPE(js::ValueArgType, _JS_PTR, "","v", INFALLIBLE) +#elif JS_BITS_PER_WORD == 64 +# define _JS_CTYPE_VALUE _JS_CTYPE(js::ValueArgType, _JS_U64, "","v", INFALLIBLE) +#endif + +#define _JS_EXPAND(tokens) tokens + +#define _JS_CTYPE_TYPE2(t,s,p,a,f) t +#define _JS_CTYPE_TYPE(tyname) _JS_EXPAND(_JS_CTYPE_TYPE2 _JS_CTYPE_##tyname) +#define _JS_CTYPE_RETTYPE2(t,s,p,a,f) s##_RETTYPE +#define _JS_CTYPE_RETTYPE(tyname) _JS_EXPAND(_JS_CTYPE_RETTYPE2 _JS_CTYPE_##tyname) +#define _JS_CTYPE_ARGTYPE2(t,s,p,a,f) s##_ARGTYPE +#define _JS_CTYPE_ARGTYPE(tyname) _JS_EXPAND(_JS_CTYPE_ARGTYPE2 _JS_CTYPE_##tyname) +#define _JS_CTYPE_PCH2(t,s,p,a,f) p +#define _JS_CTYPE_PCH(tyname) _JS_EXPAND(_JS_CTYPE_PCH2 _JS_CTYPE_##tyname) +#define _JS_CTYPE_ACH2(t,s,p,a,f) a +#define _JS_CTYPE_ACH(tyname) _JS_EXPAND(_JS_CTYPE_ACH2 _JS_CTYPE_##tyname) +#define _JS_CTYPE_FLAGS2(t,s,p,a,f) f +#define _JS_CTYPE_FLAGS(tyname) _JS_EXPAND(_JS_CTYPE_FLAGS2 _JS_CTYPE_##tyname) + +#define _JS_static_TN(t) static t +#define _JS_static_CI static +#define _JS_extern_TN(t) extern t +#define _JS_extern_CI +#define _JS_FRIEND_TN(t) extern JS_FRIEND_API(t) +#define _JS_FRIEND_CI +#define _JS_TN_LINKAGE(linkage, t) _JS_##linkage##_TN(t) +#define _JS_CI_LINKAGE(linkage) _JS_##linkage##_CI + +#define _JS_CALLINFO(name) name##_ci + +#if defined(JS_NO_FASTCALL) && defined(NANOJIT_IA32) +#define _JS_DEFINE_CALLINFO(linkage, name, crtype, cargtypes, argtypes, isPure, storeAccSet) \ + _JS_TN_LINKAGE(linkage, crtype) name cargtypes; \ + _JS_CI_LINKAGE(linkage) const nanojit::CallInfo _JS_CALLINFO(name) = \ + { (intptr_t) &name, argtypes, nanojit::ABI_CDECL, isPure, storeAccSet _JS_CI_NAME(name) };\ + JS_STATIC_ASSERT_IF(isPure, (storeAccSet) == nanojit::ACCSET_NONE); + +#else +#define _JS_DEFINE_CALLINFO(linkage, name, crtype, cargtypes, argtypes, isPure, storeAccSet) \ + _JS_TN_LINKAGE(linkage, crtype) FASTCALL name cargtypes; \ + _JS_CI_LINKAGE(linkage) const nanojit::CallInfo _JS_CALLINFO(name) = \ + { (intptr_t) &name, argtypes, nanojit::ABI_FASTCALL, isPure, storeAccSet _JS_CI_NAME(name) }; \ + JS_STATIC_ASSERT_IF(isPure, (storeAccSet) == nanojit::ACCSET_NONE); +#endif + +/* + * This macro is used for builtin functions that can be called from JITted + * code. It declares a C function named <op> and a CallInfo struct named + * <op>_ci so the tracer can call it. The <N> in JS_DEFINE_CALLINFO_<N> is + * the number of arguments the builtin takes. Builtins with no arguments + * are not supported. Using a macro is clunky but ensures that the types + * for each C function matches those for the corresponding CallInfo struct; + * mismatched types can cause subtle problems. + * + * The macro arguments are: + * + * - The linkage for the function and the associated CallInfo global. It + * can be extern, static, or FRIEND, which specifies JS_FRIEND_API linkage + * for the function. + * + * - The return type. This identifier must name one of the _JS_TYPEINFO_* + * macros defined in jsbuiltins.h. + * + * - The builtin name. + * + * - The parameter types. + * + * - The isPure flag. Set to 1 if: + * (a) the function's return value is determined solely by its arguments + * (ie. no hidden state, no implicit inputs used such as global + * variables or the result of an I/O operation); and + * (b) the function causes no observable side-effects (ie. no writes to + * global variables, no I/O output). + * Multiple calls to a pure function can be merged during CSE. + * + * - The storeAccSet. This indicates which memory access regions the function + * accesses. It must be ACCSET_NONE if the function is pure; use + * ACCSET_STORE_ANY if you're not sure. Used to determine if each call site + * of the function aliases any loads. + */ +#define JS_DEFINE_CALLINFO_1(linkage, rt, op, at0, isPure, storeAccSet) \ + _JS_DEFINE_CALLINFO(linkage, op, \ + _JS_CTYPE_TYPE(rt), \ + (_JS_CTYPE_TYPE(at0)), \ + nanojit::CallInfo::typeSig1(_JS_CTYPE_RETTYPE(rt), \ + _JS_CTYPE_ARGTYPE(at0)), \ + isPure, storeAccSet) +#define JS_DEFINE_CALLINFO_2(linkage, rt, op, at0, at1, isPure, storeAccSet) \ + _JS_DEFINE_CALLINFO(linkage, op, \ + _JS_CTYPE_TYPE(rt), \ + (_JS_CTYPE_TYPE(at0), \ + _JS_CTYPE_TYPE(at1)), \ + nanojit::CallInfo::typeSig2(_JS_CTYPE_RETTYPE(rt), \ + _JS_CTYPE_ARGTYPE(at0), \ + _JS_CTYPE_ARGTYPE(at1)), \ + isPure, storeAccSet) +#define JS_DEFINE_CALLINFO_3(linkage, rt, op, at0, at1, at2, isPure, storeAccSet) \ + _JS_DEFINE_CALLINFO(linkage, op, \ + _JS_CTYPE_TYPE(rt), \ + (_JS_CTYPE_TYPE(at0), \ + _JS_CTYPE_TYPE(at1), \ + _JS_CTYPE_TYPE(at2)), \ + nanojit::CallInfo::typeSig3(_JS_CTYPE_RETTYPE(rt), \ + _JS_CTYPE_ARGTYPE(at0), \ + _JS_CTYPE_ARGTYPE(at1), \ + _JS_CTYPE_ARGTYPE(at2)), \ + isPure, storeAccSet) +#define JS_DEFINE_CALLINFO_4(linkage, rt, op, at0, at1, at2, at3, isPure, storeAccSet) \ + _JS_DEFINE_CALLINFO(linkage, op, \ + _JS_CTYPE_TYPE(rt), \ + (_JS_CTYPE_TYPE(at0), \ + _JS_CTYPE_TYPE(at1), \ + _JS_CTYPE_TYPE(at2), \ + _JS_CTYPE_TYPE(at3)), \ + nanojit::CallInfo::typeSig4(_JS_CTYPE_RETTYPE(rt), \ + _JS_CTYPE_ARGTYPE(at0), \ + _JS_CTYPE_ARGTYPE(at1), \ + _JS_CTYPE_ARGTYPE(at2), \ + _JS_CTYPE_ARGTYPE(at3)), \ + isPure, storeAccSet) +#define JS_DEFINE_CALLINFO_5(linkage, rt, op, at0, at1, at2, at3, at4, isPure, storeAccSet) \ + _JS_DEFINE_CALLINFO(linkage, op, \ + _JS_CTYPE_TYPE(rt), \ + (_JS_CTYPE_TYPE(at0), \ + _JS_CTYPE_TYPE(at1), \ + _JS_CTYPE_TYPE(at2), \ + _JS_CTYPE_TYPE(at3), \ + _JS_CTYPE_TYPE(at4)), \ + nanojit::CallInfo::typeSig5(_JS_CTYPE_RETTYPE(rt), \ + _JS_CTYPE_ARGTYPE(at0), \ + _JS_CTYPE_ARGTYPE(at1), \ + _JS_CTYPE_ARGTYPE(at2), \ + _JS_CTYPE_ARGTYPE(at3), \ + _JS_CTYPE_ARGTYPE(at4)), \ + isPure, storeAccSet) +#define JS_DEFINE_CALLINFO_6(linkage, rt, op, at0, at1, at2, at3, at4, at5, isPure, storeAccSet) \ + _JS_DEFINE_CALLINFO(linkage, op, \ + _JS_CTYPE_TYPE(rt), \ + (_JS_CTYPE_TYPE(at0), \ + _JS_CTYPE_TYPE(at1), \ + _JS_CTYPE_TYPE(at2), \ + _JS_CTYPE_TYPE(at3), \ + _JS_CTYPE_TYPE(at4), \ + _JS_CTYPE_TYPE(at5)), \ + nanojit::CallInfo::typeSig6(_JS_CTYPE_RETTYPE(rt), \ + _JS_CTYPE_ARGTYPE(at0), \ + _JS_CTYPE_ARGTYPE(at1), \ + _JS_CTYPE_ARGTYPE(at2), \ + _JS_CTYPE_ARGTYPE(at3), \ + _JS_CTYPE_ARGTYPE(at4), \ + _JS_CTYPE_ARGTYPE(at5)), \ + isPure, storeAccSet) +#define JS_DEFINE_CALLINFO_7(linkage, rt, op, at0, at1, at2, at3, at4, at5, at6, isPure, \ + storeAccSet) \ + _JS_DEFINE_CALLINFO(linkage, op, \ + _JS_CTYPE_TYPE(rt), \ + (_JS_CTYPE_TYPE(at0), \ + _JS_CTYPE_TYPE(at1), \ + _JS_CTYPE_TYPE(at2), \ + _JS_CTYPE_TYPE(at3), \ + _JS_CTYPE_TYPE(at4), \ + _JS_CTYPE_TYPE(at5), \ + _JS_CTYPE_TYPE(at6)), \ + nanojit::CallInfo::typeSig7(_JS_CTYPE_RETTYPE(rt), \ + _JS_CTYPE_ARGTYPE(at0), \ + _JS_CTYPE_ARGTYPE(at1), \ + _JS_CTYPE_ARGTYPE(at2), \ + _JS_CTYPE_ARGTYPE(at3), \ + _JS_CTYPE_ARGTYPE(at4), \ + _JS_CTYPE_ARGTYPE(at5), \ + _JS_CTYPE_ARGTYPE(at6)), \ + isPure, storeAccSet) +#define JS_DEFINE_CALLINFO_8(linkage, rt, op, at0, at1, at2, at3, at4, at5, at6, at7, isPure, \ + storeAccSet) \ + _JS_DEFINE_CALLINFO(linkage, op, \ + _JS_CTYPE_TYPE(rt), \ + (_JS_CTYPE_TYPE(at0), \ + _JS_CTYPE_TYPE(at1), \ + _JS_CTYPE_TYPE(at2), \ + _JS_CTYPE_TYPE(at3), \ + _JS_CTYPE_TYPE(at4), \ + _JS_CTYPE_TYPE(at5), \ + _JS_CTYPE_TYPE(at6), \ + _JS_CTYPE_TYPE(at7)), \ + nanojit::CallInfo::typeSig8(_JS_CTYPE_RETTYPE(rt), \ + _JS_CTYPE_ARGTYPE(at0), \ + _JS_CTYPE_ARGTYPE(at1), \ + _JS_CTYPE_ARGTYPE(at2), \ + _JS_CTYPE_ARGTYPE(at3), \ + _JS_CTYPE_ARGTYPE(at4), \ + _JS_CTYPE_ARGTYPE(at5), \ + _JS_CTYPE_ARGTYPE(at6), \ + _JS_CTYPE_ARGTYPE(at7)), \ + isPure, storeAccSet) + +#define JS_DECLARE_CALLINFO(name) extern const nanojit::CallInfo _JS_CALLINFO(name); + +#define _JS_TN_INIT_HELPER_n(n, args) _JS_TN_INIT_HELPER_##n args + +#define _JS_TN_INIT_HELPER_1(linkage, rt, op, at0, isPure, storeAccSet) \ + &_JS_CALLINFO(op), \ + _JS_CTYPE_PCH(at0), \ + _JS_CTYPE_ACH(at0), \ + _JS_CTYPE_FLAGS(rt) + +#define _JS_TN_INIT_HELPER_2(linkage, rt, op, at0, at1, isPure, storeAccSet) \ + &_JS_CALLINFO(op), \ + _JS_CTYPE_PCH(at1) _JS_CTYPE_PCH(at0), \ + _JS_CTYPE_ACH(at1) _JS_CTYPE_ACH(at0), \ + _JS_CTYPE_FLAGS(rt) + +#define _JS_TN_INIT_HELPER_3(linkage, rt, op, at0, at1, at2, isPure, storeAccSet) \ + &_JS_CALLINFO(op), \ + _JS_CTYPE_PCH(at2) _JS_CTYPE_PCH(at1) _JS_CTYPE_PCH(at0), \ + _JS_CTYPE_ACH(at2) _JS_CTYPE_ACH(at1) _JS_CTYPE_ACH(at0), \ + _JS_CTYPE_FLAGS(rt) + +#define _JS_TN_INIT_HELPER_4(linkage, rt, op, at0, at1, at2, at3, isPure, storeAccSet) \ + &_JS_CALLINFO(op), \ + _JS_CTYPE_PCH(at3) _JS_CTYPE_PCH(at2) _JS_CTYPE_PCH(at1) _JS_CTYPE_PCH(at0), \ + _JS_CTYPE_ACH(at3) _JS_CTYPE_ACH(at2) _JS_CTYPE_ACH(at1) _JS_CTYPE_ACH(at0), \ + _JS_CTYPE_FLAGS(rt) + +#define _JS_TN_INIT_HELPER_5(linkage, rt, op, at0, at1, at2, at3, at4, isPure, storeAccSet) \ + &_JS_CALLINFO(op), \ + _JS_CTYPE_PCH(at4) _JS_CTYPE_PCH(at3) _JS_CTYPE_PCH(at2) _JS_CTYPE_PCH(at1) \ + _JS_CTYPE_PCH(at0), \ + _JS_CTYPE_ACH(at4) _JS_CTYPE_ACH(at3) _JS_CTYPE_ACH(at2) _JS_CTYPE_ACH(at1) \ + _JS_CTYPE_ACH(at0), \ + _JS_CTYPE_FLAGS(rt) + +#define _JS_TN_INIT_HELPER_6(linkage, rt, op, at0, at1, at2, at3, at4, at5, isPure, storeAccSet) \ + &_JS_CALLINFO(op), \ + _JS_CTYPE_PCH(at5) _JS_CTYPE_PCH(at4) _JS_CTYPE_PCH(at3) _JS_CTYPE_PCH(at2) \ + _JS_CTYPE_PCH(at1) _JS_CTYPE_PCH(at0), \ + _JS_CTYPE_ACH(at5) _JS_CTYPE_ACH(at4) _JS_CTYPE_ACH(at3) _JS_CTYPE_ACH(at2) \ + _JS_CTYPE_ACH(at1) _JS_CTYPE_ACH(at0), \ + _JS_CTYPE_FLAGS(rt) + +#define _JS_TN_INIT_HELPER_7(linkage, rt, op, at0, at1, at2, at3, at4, at5, at6, isPure, storeAccSet) \ + &_JS_CALLINFO(op), \ + _JS_CTYPE_PCH(at6) _JS_CTYPE_PCH(at5) _JS_CTYPE_PCH(at4) _JS_CTYPE_PCH(at3) \ + _JS_CTYPE_PCH(at2) _JS_CTYPE_PCH(at1) _JS_CTYPE_PCH(at0), \ + _JS_CTYPE_ACH(at6) _JS_CTYPE_ACH(at5) _JS_CTYPE_ACH(at4) _JS_CTYPE_ACH(at3) \ + _JS_CTYPE_ACH(at2) _JS_CTYPE_ACH(at1) _JS_CTYPE_ACH(at0), \ + _JS_CTYPE_FLAGS(rt) + +#define _JS_TN_INIT_HELPER_8(linkage, rt, op, at0, at1, at2, at3, at4, at5, at6, at7, isPure, storeAccSet) \ + &_JS_CALLINFO(op), \ + _JS_CTYPE_PCH(at7) _JS_CTYPE_PCH(at6) _JS_CTYPE_PCH(at5) _JS_CTYPE_PCH(at4) \ + _JS_CTYPE_PCH(at3) _JS_CTYPE_PCH(at2) _JS_CTYPE_PCH(at1) _JS_CTYPE_PCH(at0), \ + _JS_CTYPE_ACH(at7) _JS_CTYPE_ACH(at6) _JS_CTYPE_ACH(at5) _JS_CTYPE_ACH(at4) \ + _JS_CTYPE_ACH(at3) _JS_CTYPE_ACH(at2) _JS_CTYPE_ACH(at1) _JS_CTYPE_ACH(at0), \ + _JS_CTYPE_FLAGS(rt) + +#define JS_DEFINE_TRCINFO_1(name, tn0) \ + _JS_DEFINE_CALLINFO_n tn0 \ + JSSpecializedNative name##_sns[] = { \ + { _JS_TN_INIT_HELPER_n tn0 } \ + }; \ + JSNativeTraceInfo name##_trcinfo = { JS_VALUEIFY_NATIVE(name), name##_sns }; + +#define JS_DEFINE_TRCINFO_2(name, tn0, tn1) \ + _JS_DEFINE_CALLINFO_n tn0 \ + _JS_DEFINE_CALLINFO_n tn1 \ + JSSpecializedNative name##_sns[] = { \ + { _JS_TN_INIT_HELPER_n tn0 | JSTN_MORE }, \ + { _JS_TN_INIT_HELPER_n tn1 } \ + }; \ + JSNativeTraceInfo name##_trcinfo = { JS_VALUEIFY_NATIVE(name), name##_sns }; + +#define JS_DEFINE_TRCINFO_3(name, tn0, tn1, tn2) \ + _JS_DEFINE_CALLINFO_n tn0 \ + _JS_DEFINE_CALLINFO_n tn1 \ + _JS_DEFINE_CALLINFO_n tn2 \ + JSSpecializedNative name##_sns[] = { \ + { _JS_TN_INIT_HELPER_n tn0 | JSTN_MORE }, \ + { _JS_TN_INIT_HELPER_n tn1 | JSTN_MORE }, \ + { _JS_TN_INIT_HELPER_n tn2 } \ + }; \ + JSNativeTraceInfo name##_trcinfo = { JS_VALUEIFY_NATIVE(name), name##_sns }; + +#define JS_DEFINE_TRCINFO_4(name, tn0, tn1, tn2, tn3) \ + _JS_DEFINE_CALLINFO_n tn0 \ + _JS_DEFINE_CALLINFO_n tn1 \ + _JS_DEFINE_CALLINFO_n tn2 \ + _JS_DEFINE_CALLINFO_n tn3 \ + JSSpecializedNative name##_sns[] = { \ + { _JS_TN_INIT_HELPER_n tn0 | JSTN_MORE }, \ + { _JS_TN_INIT_HELPER_n tn1 | JSTN_MORE }, \ + { _JS_TN_INIT_HELPER_n tn2 | JSTN_MORE }, \ + { _JS_TN_INIT_HELPER_n tn3 } \ + }; \ + JSNativeTraceInfo name##_trcinfo = { JS_VALUEIFY_NATIVE(name), name##_sns }; + +#define _JS_DEFINE_CALLINFO_n(n, args) JS_DEFINE_CALLINFO_##n args + +jsdouble FASTCALL +js_StringToNumber(JSContext* cx, JSString* str, JSBool *ok); + +/* Extern version of SetBuiltinError. */ +extern JS_FRIEND_API(void) +js_SetTraceableNativeFailed(JSContext *cx); + +extern jsdouble FASTCALL +js_dmod(jsdouble a, jsdouble b); + +#else + +#define JS_DEFINE_CALLINFO_1(linkage, rt, op, at0, isPure, storeAccSet) +#define JS_DEFINE_CALLINFO_2(linkage, rt, op, at0, at1, isPure, storeAccSet) +#define JS_DEFINE_CALLINFO_3(linkage, rt, op, at0, at1, at2, isPure, storeAccSet) +#define JS_DEFINE_CALLINFO_4(linkage, rt, op, at0, at1, at2, at3, isPure, storeAccSet) +#define JS_DEFINE_CALLINFO_5(linkage, rt, op, at0, at1, at2, at3, at4, isPure, storeAccSet) +#define JS_DEFINE_CALLINFO_6(linkage, rt, op, at0, at1, at2, at3, at4, at5, isPure, storeAccSet) +#define JS_DEFINE_CALLINFO_7(linkage, rt, op, at0, at1, at2, at3, at4, at5, at6, isPure, storeAccSet) +#define JS_DEFINE_CALLINFO_8(linkage, rt, op, at0, at1, at2, at3, at4, at5, at6, at7, isPure, storeAccSet) +#define JS_DECLARE_CALLINFO(name) +#define JS_DEFINE_TRCINFO_1(name, tn0) +#define JS_DEFINE_TRCINFO_2(name, tn0, tn1) +#define JS_DEFINE_TRCINFO_3(name, tn0, tn1, tn2) +#define JS_DEFINE_TRCINFO_4(name, tn0, tn1, tn2, tn3) + +#endif /* !JS_TRACER */ + +/* Defined in jsarray.cpp. */ +namespace js { +JS_DECLARE_CALLINFO(NewDenseEmptyArray) +JS_DECLARE_CALLINFO(NewDenseAllocatedArray) +JS_DECLARE_CALLINFO(NewDenseUnallocatedArray) +} +JS_DECLARE_CALLINFO(js_ArrayCompPush_tn) +JS_DECLARE_CALLINFO(js_EnsureDenseArrayCapacity) + +/* Defined in jsbuiltins.cpp. */ +JS_DECLARE_CALLINFO(js_UnboxDouble) +JS_DECLARE_CALLINFO(js_UnboxInt32) +JS_DECLARE_CALLINFO(js_dmod) +JS_DECLARE_CALLINFO(js_imod) +JS_DECLARE_CALLINFO(js_DoubleToInt32) +JS_DECLARE_CALLINFO(js_DoubleToUint32) +JS_DECLARE_CALLINFO(js_StringToNumber) +JS_DECLARE_CALLINFO(js_StringToInt32) +JS_DECLARE_CALLINFO(js_AddProperty) +JS_DECLARE_CALLINFO(js_AddAtomProperty) +JS_DECLARE_CALLINFO(js_HasNamedProperty) +JS_DECLARE_CALLINFO(js_HasNamedPropertyInt32) +JS_DECLARE_CALLINFO(js_TypeOfObject) +JS_DECLARE_CALLINFO(js_BooleanIntToString) +JS_DECLARE_CALLINFO(js_NewNullClosure) + +/* Defined in jsfun.cpp. */ +JS_DECLARE_CALLINFO(js_AllocFlatClosure) +JS_DECLARE_CALLINFO(js_PutArgumentsOnTrace) +JS_DECLARE_CALLINFO(js_PutCallObjectOnTrace) +JS_DECLARE_CALLINFO(js_SetCallVar) +JS_DECLARE_CALLINFO(js_SetCallArg) +JS_DECLARE_CALLINFO(js_CloneFunctionObject) +JS_DECLARE_CALLINFO(js_CreateCallObjectOnTrace) +JS_DECLARE_CALLINFO(js_NewArgumentsOnTrace) + +/* Defined in jsnum.cpp. */ +JS_DECLARE_CALLINFO(js_NumberToString) + +/* Defined in jsobj.cpp. */ +JS_DECLARE_CALLINFO(js_Object_tn) +JS_DECLARE_CALLINFO(js_CreateThisFromTrace) +JS_DECLARE_CALLINFO(js_InitializerObject) + +/* Defined in jsregexp.cpp. */ +JS_DECLARE_CALLINFO(js_CloneRegExpObject) + +/* Defined in jsstr.cpp. */ +JS_DECLARE_CALLINFO(js_String_tn) +JS_DECLARE_CALLINFO(js_CompareStringsOnTrace) +JS_DECLARE_CALLINFO(js_ConcatStrings) +JS_DECLARE_CALLINFO(js_EqualStringsOnTrace) +JS_DECLARE_CALLINFO(js_Flatten) + +/* Defined in jstypedarray.cpp. */ +JS_DECLARE_CALLINFO(js_TypedArray_uint8_clamp_double) + +#endif /* jsbuiltins_h___ */ |