mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Backed out changeset ca733f2cc237; looks like some include system weirdness is biting where an old version of jsapi.h is being included which then causes a *newer* included version to miscompile. Weird, still investigating...

This commit is contained in:
Jeff Walden 2009-02-03 15:48:30 -08:00
Родитель 0b939d9ca1
Коммит 3b82f419a6
15 изменённых файлов: 65 добавлений и 163 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

2
dom/src/base/nsJSEnvironment.cpp
Просмотреть файл

@ -1991,7 +1991,7 @@ nsJSContext::CallEventHandler(nsISupports* aTarget, void *aScope, void *aHandler
AutoFreeJSStack stackGuard(mContext, mark); // ensure always freed.
jsval funval = OBJECT_TO_JSVAL(static_cast<JSObject *>(aHandler));
jsval funval = OBJECT_TO_JSVAL(aHandler);
JSAutoRequest ar(mContext);
PRBool ok = ::JS_CallFunctionValue(mContext, target,
funval, argc, argv, &rval);

15
js/src/jsapi.cpp
Просмотреть файл

@ -743,21 +743,6 @@ JS_NewRuntime(uint32 maxbytes)
#include "js.msg"
#undef MSG_DEF
/*
* If it were possible for pure inline function calls with constant
* arguments to be computed at compile time, these would be static
* assertions, but since it isn't, this is the best we can do.
*/
JS_ASSERT(JSVAL_NULL == OBJECT_TO_JSVAL(NULL));
JS_ASSERT(JSVAL_ZERO == INT_TO_JSVAL(0));
JS_ASSERT(JSVAL_ONE == INT_TO_JSVAL(1));
JS_ASSERT(JSVAL_FALSE == BOOLEAN_TO_JSVAL(JS_FALSE));
JS_ASSERT(JSVAL_TRUE == BOOLEAN_TO_JSVAL(JS_TRUE));
JS_ASSERT(JSVAL_TO_PSEUDO_BOOLEAN(JSVAL_VOID) == 2);
JS_ASSERT(JSVAL_TO_PSEUDO_BOOLEAN(JSVAL_HOLE) == 3);
JS_ASSERT(JSVAL_TO_PSEUDO_BOOLEAN(JSVAL_ARETURN) == 4);
js_NewRuntimeWasCalled = JS_TRUE;
}
#endif /* DEBUG */

109
js/src/jsapi.h
Просмотреть файл

@ -83,54 +83,13 @@ JS_BEGIN_EXTERN_C
/* Objects, strings, and doubles are GC'ed. */
#define JSVAL_IS_GCTHING(v) (!((v) & JSVAL_INT) && \
JSVAL_TAG(v) != JSVAL_BOOLEAN)
static JS_ALWAYS_INLINE void *
JSVAL_TO_GCTHING(jsval v)
{
JS_ASSERT(JSVAL_IS_GCTHING(v));
return (void *) JSVAL_CLRTAG(v);
}
static JS_ALWAYS_INLINE JSObject *
JSVAL_TO_OBJECT(jsval v)
{
JS_ASSERT(JSVAL_IS_OBJECT(v));
return (JSObject *) JSVAL_TO_GCTHING(v);
}
static JS_ALWAYS_INLINE jsdouble *
JSVAL_TO_DOUBLE(jsval v)
{
JS_ASSERT(JSVAL_IS_DOUBLE(v));
return (jsdouble *) JSVAL_TO_GCTHING(v);
}
static JS_ALWAYS_INLINE JSString *
JSVAL_TO_STRING(jsval v)
{
JS_ASSERT(JSVAL_IS_STRING(v));
return (JSString *) JSVAL_TO_GCTHING(v);
}
static JS_ALWAYS_INLINE jsval
OBJECT_TO_JSVAL(JSObject *obj)
{
JS_ASSERT(((jsval) obj & JSVAL_TAGBITS) == JSVAL_OBJECT);
JS_STATIC_ASSERT(JSVAL_OBJECT == 0);
return (jsval) obj;
}
static JS_ALWAYS_INLINE jsval
DOUBLE_TO_JSVAL(jsdouble *dp)
{
return JSVAL_SETTAG((jsval) dp, JSVAL_DOUBLE);
}
static JS_ALWAYS_INLINE jsval
STRING_TO_JSVAL(JSString *str)
{
return JSVAL_SETTAG((jsval) str, JSVAL_STRING);
}
#define JSVAL_TO_GCTHING(v) ((void *)JSVAL_CLRTAG(v))
#define JSVAL_TO_OBJECT(v) ((JSObject *)JSVAL_TO_GCTHING(v))
#define JSVAL_TO_DOUBLE(v) ((jsdouble *)JSVAL_TO_GCTHING(v))
#define JSVAL_TO_STRING(v) ((JSString *)JSVAL_TO_GCTHING(v))
#define OBJECT_TO_JSVAL(obj) ((jsval)(obj))
#define DOUBLE_TO_JSVAL(dp) JSVAL_SETTAG((jsval)(dp), JSVAL_DOUBLE)
#define STRING_TO_JSVAL(str) JSVAL_SETTAG((jsval)(str), JSVAL_STRING)
/* Lock and unlock the GC thing held by a jsval. */
#define JSVAL_LOCK(cx,v) (JSVAL_IS_GCTHING(v) \
@ -150,45 +109,10 @@ STRING_TO_JSVAL(JSString *str)
#define JSVAL_TO_INT(v) ((jsint)(v) >> 1)
#define INT_TO_JSVAL(i) (((jsval)(i) << 1) | JSVAL_INT)
/*
* A pseudo-boolean is a 29-bit (for 32-bit jsval) or 61-bit (for 64-bit jsval)
* value other than 0 or 1 encoded as a jsval whose tag is JSVAL_BOOLEAN.
*
* JSVAL_VOID happens to be defined as a jsval encoding a pseudo-boolean, but
* embedders MUST NOT rely on this. All other possible pseudo-boolean values
* are implementation-reserved and MUST NOT be constructed by any embedding of
* SpiderMonkey.
*/
#define JSVAL_TO_PSEUDO_BOOLEAN(v) ((JSBool) ((v) >> JSVAL_TAGBITS))
#define PSEUDO_BOOLEAN_TO_JSVAL(b) \
JSVAL_SETTAG((jsval) (b) << JSVAL_TAGBITS, JSVAL_BOOLEAN)
/*
* Well-known JS values. The extern'd variables are initialized when the
* first JSContext is created by JS_NewContext (see below).
*/
#define JSVAL_NULL ((jsval) 0)
#define JSVAL_ZERO INT_TO_JSVAL(0)
#define JSVAL_ONE INT_TO_JSVAL(1)
#define JSVAL_FALSE PSEUDO_BOOLEAN_TO_JSVAL(JS_FALSE)
#define JSVAL_TRUE PSEUDO_BOOLEAN_TO_JSVAL(JS_TRUE)
#define JSVAL_VOID PSEUDO_BOOLEAN_TO_JSVAL(2)
/* Convert between boolean and jsval, asserting that inputs are valid. */
static JS_ALWAYS_INLINE JSBool
JSVAL_TO_BOOLEAN(jsval v)
{
JS_ASSERT(v == JSVAL_TRUE || v == JSVAL_FALSE);
return JSVAL_TO_PSEUDO_BOOLEAN(v);
}
static JS_ALWAYS_INLINE jsval
BOOLEAN_TO_JSVAL(JSBool b)
{
JS_ASSERT(b == JS_TRUE || b == JS_FALSE);
return PSEUDO_BOOLEAN_TO_JSVAL(b);
}
/* Convert between boolean and jsval. */
#define JSVAL_TO_BOOLEAN(v) ((JSBool)((v) >> JSVAL_TAGBITS))
#define BOOLEAN_TO_JSVAL(b) JSVAL_SETTAG((jsval)(b) << JSVAL_TAGBITS, \
JSVAL_BOOLEAN)
/* A private data pointer (2-byte-aligned) can be stored as an int jsval. */
#define JSVAL_TO_PRIVATE(v) ((void *)((v) & ~JSVAL_INT))
@ -255,6 +179,17 @@ BOOLEAN_TO_JSVAL(JSBool b)
*/
#define JSFUN_GENERIC_NATIVE JSFUN_LAMBDA
/*
* Well-known JS values. The extern'd variables are initialized when the
* first JSContext is created by JS_NewContext (see below).
*/
#define JSVAL_VOID BOOLEAN_TO_JSVAL(2)
#define JSVAL_NULL OBJECT_TO_JSVAL(0)
#define JSVAL_ZERO INT_TO_JSVAL(0)
#define JSVAL_ONE INT_TO_JSVAL(1)
#define JSVAL_FALSE BOOLEAN_TO_JSVAL(JS_FALSE)
#define JSVAL_TRUE BOOLEAN_TO_JSVAL(JS_TRUE)
/*
* Microseconds since the epoch, midnight, January 1, 1970 UTC. See the
* comment in jstypes.h regarding safe int64 usage.

1
js/src/jsatom.cpp
Просмотреть файл

@ -78,6 +78,7 @@ js_AtomToPrintableString(JSContext *cx, JSAtom *atom)
* asserts check these relations.
*/
JS_STATIC_ASSERT(JSTYPE_LIMIT == 8);
JS_STATIC_ASSERT(JSVAL_TO_BOOLEAN(JSVAL_VOID) == 2);
JS_STATIC_ASSERT(JSTYPE_VOID == 0);
const char *const js_common_atom_names[] = {

6
js/src/jsbool.h
Просмотреть файл

@ -54,10 +54,10 @@ JS_BEGIN_EXTERN_C
*
* JSVAL_ARETURN is used to throw asynchronous return for generator.close().
*
* NB: PSEUDO_BOOLEAN_TO_JSVAL(2) is JSVAL_VOID (see jsapi.h).
* NB: BOOLEAN_TO_JSVAL(2) is JSVAL_VOID (see jsapi.h).
*/
#define JSVAL_HOLE PSEUDO_BOOLEAN_TO_JSVAL(3)
#define JSVAL_ARETURN PSEUDO_BOOLEAN_TO_JSVAL(4)
#define JSVAL_HOLE BOOLEAN_TO_JSVAL(3)
#define JSVAL_ARETURN BOOLEAN_TO_JSVAL(4)
extern JSClass js_BooleanClass;

6
js/src/jsbuiltins.cpp
Просмотреть файл

@ -383,8 +383,7 @@ js_TypeOfObject(JSContext* cx, JSObject* obj)
JSString* FASTCALL
js_TypeOfBoolean(JSContext* cx, int32 unboxed)
{
/* Watch out for pseudo-booleans. */
jsval boxed = PSEUDO_BOOLEAN_TO_JSVAL(unboxed);
jsval boxed = BOOLEAN_TO_JSVAL(unboxed);
JS_ASSERT(JSVAL_IS_VOID(boxed) || JSVAL_IS_BOOLEAN(boxed));
JSType type = JS_TypeOfValue(cx, boxed);
return ATOM_TO_STRING(cx->runtime->atomState.typeAtoms[type]);
@ -393,9 +392,8 @@ js_TypeOfBoolean(JSContext* cx, int32 unboxed)
jsdouble FASTCALL
js_BooleanOrUndefinedToNumber(JSContext* cx, int32 unboxed)
{
if (unboxed == JSVAL_TO_PSEUDO_BOOLEAN(JSVAL_VOID))
if (unboxed == JSVAL_TO_BOOLEAN(JSVAL_VOID))
return js_NaN;
JS_ASSERT(unboxed == JS_TRUE || unboxed == JS_FALSE);
return unboxed;
}

2
js/src/jsbuiltins.h
Просмотреть файл

@ -94,7 +94,7 @@ struct JSTraceableNative {
* in use. If it is, a performance regression occurs, not an actual runtime
* error.
*/
#define JSVAL_ERROR_COOKIE OBJECT_TO_JSVAL((JSObject*)0x10)
#define JSVAL_ERROR_COOKIE OBJECT_TO_JSVAL((void*)0x10)
/* Macros used by JS_DEFINE_CALLINFOn. */
#ifdef DEBUG

3
js/src/jsdbgapi.cpp
Просмотреть файл

@ -651,8 +651,7 @@ js_watch_set(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
#endif
ok = !wp->setter ||
((sprop->attrs & JSPROP_SETTER)
? js_InternalCall(cx, obj,
OBJECT_TO_JSVAL((JSObject *)wp->setter),
? js_InternalCall(cx, obj, OBJECT_TO_JSVAL(wp->setter),
1, vp, vp)
: wp->setter(cx, OBJ_THIS_OBJECT(cx, obj), userid, vp));
if (injectFrame) {

2
js/src/jsinterp.cpp
Просмотреть файл

@ -3589,7 +3589,7 @@ js_Interpret(JSContext *cx)
JSXMLObjectOps *ops; \
\
ops = (JSXMLObjectOps *) obj2->map->ops; \
if (JSVAL_IS_OBJECT(rval) && obj2 == JSVAL_TO_OBJECT(rval)) \
if (obj2 == JSVAL_TO_OBJECT(rval)) \
rval = lval; \
if (!ops->equality(cx, obj2, rval, &cond)) \
goto error; \

4
js/src/jsobj.cpp
Просмотреть файл

@ -1863,7 +1863,7 @@ obj_lookupGetter(JSContext *cx, uintN argc, jsval *vp)
if (OBJ_IS_NATIVE(pobj)) {
sprop = (JSScopeProperty *) prop;
if (sprop->attrs & JSPROP_GETTER)
*vp = OBJECT_TO_JSVAL((JSObject *) sprop->getter);
*vp = OBJECT_TO_JSVAL(sprop->getter);
}
OBJ_DROP_PROPERTY(cx, pobj, prop);
}
@ -1888,7 +1888,7 @@ obj_lookupSetter(JSContext *cx, uintN argc, jsval *vp)
if (OBJ_IS_NATIVE(pobj)) {
sprop = (JSScopeProperty *) prop;
if (sprop->attrs & JSPROP_SETTER)
*vp = OBJECT_TO_JSVAL((JSObject *) sprop->setter);
*vp = OBJECT_TO_JSVAL(sprop->setter);
}
OBJ_DROP_PROPERTY(cx, pobj, prop);
}

8
js/src/jsscope.h
Просмотреть файл

@ -334,8 +334,8 @@ struct JSScopeProperty {
#define SPROP_GET(cx,sprop,obj,obj2,vp) \
(((sprop)->attrs & JSPROP_GETTER) \
? js_InternalGetOrSet(cx, obj, (sprop)->id, \
OBJECT_TO_JSVAL((JSObject *) (sprop)->getter), \
JSACC_READ, 0, 0, vp) \
OBJECT_TO_JSVAL((sprop)->getter), JSACC_READ, \
0, 0, vp) \
: (sprop)->getter(cx, OBJ_THIS_OBJECT(cx,obj), SPROP_USERID(sprop), vp))
/*
@ -345,8 +345,8 @@ struct JSScopeProperty {
#define SPROP_SET(cx,sprop,obj,obj2,vp) \
(((sprop)->attrs & JSPROP_SETTER) \
? js_InternalGetOrSet(cx, obj, (sprop)->id, \
OBJECT_TO_JSVAL((JSObject *) (sprop)->setter), \
JSACC_WRITE, 1, vp, vp) \
OBJECT_TO_JSVAL((sprop)->setter), JSACC_WRITE, \
1, vp, vp) \
: ((sprop)->attrs & JSPROP_GETTER) \
? (JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, \
JSMSG_GETTER_ONLY, NULL), JS_FALSE) \

47
js/src/jstracer.cpp
Просмотреть файл

@ -1456,9 +1456,8 @@ ValueToNative(JSContext* cx, jsval v, uint8 type, double* slot)
debug_only_v(printf("double<%g> ", d);)
return;
case JSVAL_BOOLEAN:
/* Watch out for pseudo-booleans. */
JS_ASSERT(tag == JSVAL_BOOLEAN);
*(JSBool*)slot = JSVAL_TO_PSEUDO_BOOLEAN(v);
*(JSBool*)slot = JSVAL_TO_BOOLEAN(v);
debug_only_v(printf("boolean<%d> ", *(JSBool*)slot);)
return;
case JSVAL_STRING:
@ -1541,8 +1540,7 @@ NativeToValue(JSContext* cx, jsval& v, uint8 type, double* slot)
jsdouble d;
switch (type) {
case JSVAL_BOOLEAN:
/* Watch out for pseudo-booleans. */
v = PSEUDO_BOOLEAN_TO_JSVAL(*(JSBool*)slot);
v = BOOLEAN_TO_JSVAL(*(JSBool*)slot);
debug_only_v(printf("boolean<%d> ", *(JSBool*)slot);)
break;
case JSVAL_INT:
@ -4838,7 +4836,7 @@ TraceRecorder::ifop()
if (JSVAL_TAG(v) == JSVAL_BOOLEAN) {
/* Test for boolean is true, negate later if we are testing for false. */
cond = JSVAL_TO_PSEUDO_BOOLEAN(v) == JS_TRUE;
cond = JSVAL_TO_BOOLEAN(v) == 1;
x = lir->ins2i(LIR_eq, v_ins, 1);
} else if (isNumber(v)) {
jsdouble d = asNumber(v);
@ -5107,10 +5105,10 @@ TraceRecorder::equalityHelper(jsval l, jsval r, LIns* l_ins, LIns* r_ins,
fp = true;
}
} else if (JSVAL_IS_NULL(l) && JSVAL_TAG(r) == JSVAL_BOOLEAN) {
l_ins = lir->insImm(JSVAL_TO_PSEUDO_BOOLEAN(JSVAL_VOID));
l_ins = lir->insImm(JSVAL_TO_BOOLEAN(JSVAL_VOID));
cond = (r == JSVAL_VOID);
} else if (JSVAL_TAG(l) == JSVAL_BOOLEAN && JSVAL_IS_NULL(r)) {
r_ins = lir->insImm(JSVAL_TO_PSEUDO_BOOLEAN(JSVAL_VOID));
r_ins = lir->insImm(JSVAL_TO_BOOLEAN(JSVAL_VOID));
cond = (l == JSVAL_VOID);
} else if (isNumber(l) && JSVAL_IS_STRING(r)) {
args[0] = r_ins, args[1] = cx_ins;
@ -5361,13 +5359,13 @@ TraceRecorder::binary(LOpcode op)
if (JSVAL_TAG(l) == JSVAL_BOOLEAN) {
LIns* args[] = { a, cx_ins };
a = lir->insCall(&js_BooleanOrUndefinedToNumber_ci, args);
lnum = js_BooleanOrUndefinedToNumber(cx, JSVAL_TO_PSEUDO_BOOLEAN(l));
lnum = js_BooleanOrUndefinedToNumber(cx, JSVAL_TO_BOOLEAN(l));
leftIsNumber = true;
}
if (JSVAL_TAG(r) == JSVAL_BOOLEAN) {
LIns* args[] = { b, cx_ins };
b = lir->insCall(&js_BooleanOrUndefinedToNumber_ci, args);
rnum = js_BooleanOrUndefinedToNumber(cx, JSVAL_TO_PSEUDO_BOOLEAN(r));
rnum = js_BooleanOrUndefinedToNumber(cx, JSVAL_TO_BOOLEAN(r));
rightIsNumber = true;
}
if (leftIsNumber && rightIsNumber) {
@ -5664,10 +5662,13 @@ TraceRecorder::native_get(LIns* obj_ins, LIns* pobj_ins, JSScopeProperty* sprop,
if (sprop->slot != SPROP_INVALID_SLOT)
v_ins = stobj_get_slot(pobj_ins, sprop->slot, dslots_ins);
else
v_ins = INS_CONST(JSVAL_TO_PSEUDO_BOOLEAN(JSVAL_VOID));
v_ins = INS_CONST(JSVAL_TO_BOOLEAN(JSVAL_VOID));
return true;
}
// So box_jsval can emit no LIR_or at all to tag an object jsval.
JS_STATIC_ASSERT(JSVAL_OBJECT == 0);
JS_REQUIRES_STACK void
TraceRecorder::box_jsval(jsval v, LIns*& v_ins)
{
@ -5926,7 +5927,7 @@ TraceRecorder::record_EnterFrame()
debug_only_v(
js_Disassemble(cx, cx->fp->script, JS_TRUE, stdout);
printf("----\n");)
LIns* void_ins = INS_CONST(JSVAL_TO_PSEUDO_BOOLEAN(JSVAL_VOID));
LIns* void_ins = INS_CONST(JSVAL_TO_BOOLEAN(JSVAL_VOID));
jsval* vp = &fp->argv[fp->argc];
jsval* vpstop = vp + ptrdiff_t(fp->fun->nargs) - ptrdiff_t(fp->argc);
@ -5965,7 +5966,7 @@ TraceRecorder::record_LeaveFrame()
JS_REQUIRES_STACK bool
TraceRecorder::record_JSOP_PUSH()
{
stack(0, INS_CONST(JSVAL_TO_PSEUDO_BOOLEAN(JSVAL_VOID)));
stack(0, INS_CONST(JSVAL_TO_BOOLEAN(JSVAL_VOID)));
return true;
}
@ -6614,7 +6615,7 @@ success:
break;
}
case FAIL_VOID:
guard(false, lir->ins2i(LIR_eq, res_ins, JSVAL_TO_PSEUDO_BOOLEAN(JSVAL_VOID)), OOM_EXIT);
guard(false, lir->ins2i(LIR_eq, res_ins, JSVAL_TO_BOOLEAN(JSVAL_VOID)), OOM_EXIT);
break;
default:;
}
@ -6670,7 +6671,7 @@ TraceRecorder::record_JSOP_TYPEOF()
if (JSVAL_TAG(r) == JSVAL_BOOLEAN) {
// We specialize identically for boolean and undefined. We must not have a hole here.
// Pass the unboxed type here, since TypeOfBoolean knows how to handle it.
JS_ASSERT(r == JSVAL_TRUE || r == JSVAL_FALSE || r == JSVAL_VOID);
JS_ASSERT(JSVAL_TO_BOOLEAN(r) <= 2);
type = lir->insCall(&js_TypeOfBoolean_ci, args);
} else {
JS_ASSERT(JSVAL_TAG(r) == JSVAL_OBJECT);
@ -6684,7 +6685,7 @@ TraceRecorder::record_JSOP_TYPEOF()
JS_REQUIRES_STACK bool
TraceRecorder::record_JSOP_VOID()
{
stack(-1, INS_CONST(JSVAL_TO_PSEUDO_BOOLEAN(JSVAL_VOID)));
stack(-1, INS_CONST(JSVAL_TO_BOOLEAN(JSVAL_VOID)));
return true;
}
@ -7455,7 +7456,7 @@ TraceRecorder::prop(JSObject* obj, LIns* obj_ins, uint32& slot, LIns*& v_ins)
/* Check for non-existent property reference, which results in undefined. */
const JSCodeSpec& cs = js_CodeSpec[*cx->fp->regs->pc];
if (PCVAL_IS_NULL(pcval)) {
v_ins = INS_CONST(JSVAL_TO_PSEUDO_BOOLEAN(JSVAL_VOID));
v_ins = INS_CONST(JSVAL_TO_BOOLEAN(JSVAL_VOID));
JS_ASSERT(cs.ndefs == 1);
stack(-cs.nuses, v_ins);
slot = SPROP_INVALID_SLOT;
@ -7546,7 +7547,7 @@ TraceRecorder::elem(jsval& oval, jsval& idx, jsval*& vp, LIns*& v_ins, LIns*& ad
offsetof(JSRuntime, anyArrayProtoHasElement))),
MISMATCH_EXIT);
// Return undefined and indicate that we didn't actually read this (addr_ins).
v_ins = lir->insImm(JSVAL_TO_PSEUDO_BOOLEAN(JSVAL_VOID));
v_ins = lir->insImm(JSVAL_TO_BOOLEAN(JSVAL_VOID));
addr_ins = NULL;
return true;
}
@ -7567,7 +7568,7 @@ TraceRecorder::elem(jsval& oval, jsval& idx, jsval*& vp, LIns*& v_ins, LIns*& ad
if (JSVAL_TAG(*vp) == JSVAL_BOOLEAN) {
// Optimize to guard for a hole only after untagging, so we know that
// we have a boolean, to avoid an extra guard for non-boolean values.
guard(false, lir->ins2(LIR_eq, v_ins, INS_CONST(JSVAL_TO_PSEUDO_BOOLEAN(JSVAL_HOLE))),
guard(false, lir->ins2(LIR_eq, v_ins, INS_CONST(JSVAL_TO_BOOLEAN(JSVAL_HOLE))),
MISMATCH_EXIT);
}
return true;
@ -8045,7 +8046,7 @@ TraceRecorder::record_JSOP_IN()
ABORT_TRACE("string or integer expected");
}
guard(false, lir->ins2i(LIR_eq, x, JSVAL_TO_PSEUDO_BOOLEAN(JSVAL_VOID)), OOM_EXIT);
guard(false, lir->ins2i(LIR_eq, x, JSVAL_TO_BOOLEAN(JSVAL_VOID)), OOM_EXIT);
x = lir->ins2i(LIR_eq, x, 1);
JSObject* obj2;
@ -8655,7 +8656,7 @@ TraceRecorder::record_JSOP_CALLPROP()
} else if (JSVAL_TAG(l) == JSVAL_BOOLEAN) {
if (l == JSVAL_VOID)
ABORT_TRACE("callprop on void");
guard(false, lir->ins2i(LIR_eq, get(&l), JSVAL_TO_PSEUDO_BOOLEAN(JSVAL_VOID)), MISMATCH_EXIT);
guard(false, lir->ins2i(LIR_eq, get(&l), JSVAL_TO_BOOLEAN(JSVAL_VOID)), MISMATCH_EXIT);
i = JSProto_Boolean;
debug_only(protoname = "Boolean.prototype";)
} else {
@ -8758,7 +8759,7 @@ TraceRecorder::record_JSOP_STOP()
JS_ASSERT(OBJECT_TO_JSVAL(fp->thisp) == fp->argv[-1]);
rval_ins = get(&fp->argv[-1]);
} else {
rval_ins = INS_CONST(JSVAL_TO_PSEUDO_BOOLEAN(JSVAL_VOID));
rval_ins = INS_CONST(JSVAL_TO_BOOLEAN(JSVAL_VOID));
}
clearFrameSlotsFromCache();
return true;
@ -8802,7 +8803,7 @@ TraceRecorder::record_JSOP_ENTERBLOCK()
JSObject* obj;
JS_GET_SCRIPT_OBJECT(script, GET_FULL_INDEX(0), obj);
LIns* void_ins = INS_CONST(JSVAL_TO_PSEUDO_BOOLEAN(JSVAL_VOID));
LIns* void_ins = INS_CONST(JSVAL_TO_BOOLEAN(JSVAL_VOID));
for (int i = 0, n = OBJ_BLOCK_COUNT(cx, obj); i < n; i++)
stack(i, void_ins);
return true;
@ -9147,7 +9148,7 @@ TraceRecorder::record_JSOP_NEWARRAY()
JS_REQUIRES_STACK bool
TraceRecorder::record_JSOP_HOLE()
{
stack(0, INS_CONST(JSVAL_TO_PSEUDO_BOOLEAN(JSVAL_HOLE)));
stack(0, INS_CONST(JSVAL_TO_BOOLEAN(JSVAL_HOLE)));
return true;
}

2
js/src/jstypes.h
Просмотреть файл

@ -183,7 +183,7 @@
# elif defined _MSC_VER
# define JS_ALWAYS_INLINE __forceinline
# elif defined __GNUC__
# define JS_ALWAYS_INLINE __attribute__((always_inline)) JS_INLINE
# define JS_ALWAYS_INLINE __attribute__((always_inline))
# else
# define JS_ALWAYS_INLINE JS_INLINE
# endif

15
js/src/trace-test.js
Просмотреть файл

@ -4148,21 +4148,6 @@ testInterpreterReentry7.expected = "grue bleen";
test(testInterpreterReentry7);
*/
function testHolePushing() {
var a = ["foobar", "baz"];
for (var i = 0; i < 5; i++)
a = [, "overwritten", "new"];
var s = "[";
for (i = 0; i < a.length; i++) {
s += (i in a) ? a[i] : "<hole>";
if (i != a.length - 1)
s += ",";
}
return s + "], " + (0 in a);
}
testHolePushing.expected = "[<hole>,overwritten,new], false";
test(testHolePushing);
/*****************************************************************************
* *
* _____ _ _ _____ ______ _____ _______ *

6
js/src/xpconnect/src/xpcquickstubs.cpp
Просмотреть файл

@ -255,8 +255,7 @@ LookupGetterOrSetter(JSContext *cx, JSBool wantGetter, jsval *vp)
{
if(attrs & JSPROP_GETTER)
{
JS_SET_RVAL(cx, vp,
OBJECT_TO_JSVAL(reinterpret_cast<JSObject *>(getter)));
JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(getter));
return JS_TRUE;
}
}
@ -264,8 +263,7 @@ LookupGetterOrSetter(JSContext *cx, JSBool wantGetter, jsval *vp)
{
if(attrs & JSPROP_SETTER)
{
JS_SET_RVAL(cx, vp,
OBJECT_TO_JSVAL(reinterpret_cast<JSObject *>(setter)));
JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(setter));
return JS_TRUE;
}
}