Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-16 06:45:42 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 714696 - rm lingering remains of tracer in js::Value (r=waldo)

Browse Source 
--HG--
extra : rebase_source : c0d377c97e450b515941a5677eaafd5b23122d2c
This commit is contained in:
Luke Wagner 2012-01-02 15:06:15 -08:00
parent 72db3d7ea9
commit 65cc085d05
10 changed files with 24 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
js/src/gc/Barrier-inl.h
View File

@ -203,15 +203,6 @@ HeapValue::set(JSCompartment *comp, const Value &v)
post(comp);
}
inline void
HeapValue::boxNonDoubleFrom(JSValueType type, uint64_t *out)
{
pre();
value.boxNonDoubleFrom(type, out);
JS_ASSERT(!IsPoisonedValue(value));
post();
}
inline
HeapId::HeapId(jsid id)
: value(id)

4
js/src/gc/Barrier.h
View File

@ -342,10 +342,6 @@ class HeapValue
JSGCTraceKind gcKind() const { return value.gcKind(); }
inline void boxNonDoubleFrom(JSValueType type, uint64_t *out);
uint64_t asRawBits() const { return value.asRawBits(); }
#ifdef DEBUG
JSWhyMagic whyMagic() const { return value.whyMagic(); }
#endif

66
js/src/jsapi.h
View File

@ -251,8 +251,8 @@ inline bool IsPoisonedPtr(T *v)
* example, if cx->exception has a magic value, the reason must be
* JS_GENERATOR_CLOSING.
*
* - A key difference between jsval and JS::Value is that JS::Value gives null
* a separate type. Thus
* - A key difference between JSVAL_* and JS::Value operations is that
* JS::Value gives null a separate type. Thus
*
* JSVAL_IS_OBJECT(v) === v.isObjectOrNull()
* !JSVAL_IS_PRIMITIVE(v) === v.isObject()
@ -326,11 +326,6 @@ class Value
data = OBJECT_TO_JSVAL_IMPL(&obj);
}
JS_ALWAYS_INLINE
void setObject(const JS::Anchor<JSObject *> &obj) {
setObject(*obj.get());
}
JS_ALWAYS_INLINE
void setBoolean(bool b) {
data = BOOLEAN_TO_JSVAL_IMPL(b);
@ -482,13 +477,6 @@ class Value
return isMagic() && data.s.payload.why == why;
}
#if JS_BITS_PER_WORD == 64
JS_ALWAYS_INLINE
bool hasPtrPayload() const {
return data.asBits >= JSVAL_LOWER_INCL_SHIFTED_TAG_OF_PTR_PAYLOAD_SET;
}
#endif
JS_ALWAYS_INLINE
bool isMarkable() const {
return JSVAL_IS_TRACEABLE_IMPL(data);
@ -576,59 +564,11 @@ class Value
return data.s.payload.u32;
}
JS_ALWAYS_INLINE
uint64_t asRawBits() const {
return data.asBits;
}
JS_ALWAYS_INLINE
void setRawBits(uint64_t bits) {
data.asBits = bits;
}
/*
* In the extract/box/unbox functions below, "NonDouble" means this
* functions must not be called on a value that is a double. This allows
* these operations to be implemented more efficiently, since doubles
* generally already require special handling by the caller.
*/
JS_ALWAYS_INLINE
JSValueType extractNonDoubleType() const {
return JSVAL_EXTRACT_NON_DOUBLE_TYPE_IMPL(data);
}
JS_ALWAYS_INLINE
JSValueTag extractNonDoubleTag() const {
return JSVAL_EXTRACT_NON_DOUBLE_TAG_IMPL(data);
}
JS_ALWAYS_INLINE
void unboxNonDoubleTo(uint64_t *out) const {
UNBOX_NON_DOUBLE_JSVAL(data, out);
}
JS_ALWAYS_INLINE
void boxNonDoubleFrom(JSValueType type, uint64_t *out) {
data = BOX_NON_DOUBLE_JSVAL(type, out);
}
/*
* The trace-jit specializes JSVAL_TYPE_OBJECT into JSVAL_TYPE_FUNOBJ and
* JSVAL_TYPE_NONFUNOBJ. Since these two operations just return the type of
* a value, the caller must handle JSVAL_TYPE_OBJECT separately.
*/
JS_ALWAYS_INLINE
JSValueType extractNonDoubleObjectTraceType() const {
JS_ASSERT(!isObject());
return JSVAL_EXTRACT_NON_DOUBLE_TYPE_IMPL(data);
}
JS_ALWAYS_INLINE
JSValueTag extractNonDoubleObjectTraceTag() const {
JS_ASSERT(!isObject());
return JSVAL_EXTRACT_NON_DOUBLE_TAG_IMPL(data);
}
/*
* Private API
*
@ -846,7 +786,7 @@ template<>
inline Anchor<Value>::~Anchor()
{
volatile uint64_t bits;
bits = hold.asRawBits();
bits = JSVAL_TO_IMPL(hold).asBits;
}
#endif

2
js/src/jsgc.h
View File

@ -1295,7 +1295,7 @@ struct WrapperHasher
typedef Value Lookup;
static HashNumber hash(Value key) {
uint64_t bits = key.asRawBits();
uint64_t bits = JSVAL_TO_IMPL(key).asBits;
return uint32_t(bits) ^ uint32_t(bits >> 32);
}

98
js/src/jsval.h
View File

@ -137,17 +137,9 @@ JS_ENUM_HEADER(JSValueType, uint8_t)
JSVAL_TYPE_NULL = 0x06,
JSVAL_TYPE_OBJECT = 0x07,
/* The below types never appear in a jsval; they are only used in tracing and type inference. */
/* This never appears in a jsval; it is only provided as an out-of-band value. */
JSVAL_TYPE_UNKNOWN = 0x20
JSVAL_TYPE_UNKNOWN = 0x20,
JSVAL_TYPE_NONFUNOBJ = 0x57,
JSVAL_TYPE_FUNOBJ = 0x67,
JSVAL_TYPE_STRORNULL = 0x77,
JSVAL_TYPE_OBJORNULL = 0x78,
JSVAL_TYPE_BOXED = 0x79
} JS_ENUM_FOOTER(JSValueType);
JS_STATIC_ASSERT(sizeof(JSValueType) == 1);
@ -214,12 +206,6 @@ typedef uint8_t JSValueType;
#define JSVAL_TYPE_NULL ((uint8_t)0x06)
#define JSVAL_TYPE_OBJECT ((uint8_t)0x07)
#define JSVAL_TYPE_UNKNOWN ((uint8_t)0x20)
#define JSVAL_TYPE_NONFUNOBJ ((uint8_t)0x57)
#define JSVAL_TYPE_FUNOBJ ((uint8_t)0x67)
#define JSVAL_TYPE_STRORNULL ((uint8_t)0x77)
#define JSVAL_TYPE_OBJORNULL ((uint8_t)0x78)
#define JSVAL_TYPE_BOXED ((uint8_t)0x79)
#define JSVAL_TYPE_UNINITIALIZED ((uint8_t)0x7d)
#if JS_BITS_PER_WORD == 32
@ -262,8 +248,6 @@ typedef uint64_t JSValueShiftedTag;
#define JSVAL_UPPER_EXCL_TYPE_OF_PRIMITIVE_SET JSVAL_TYPE_OBJECT
#define JSVAL_UPPER_INCL_TYPE_OF_NUMBER_SET JSVAL_TYPE_INT32
#define JSVAL_LOWER_INCL_TYPE_OF_PTR_PAYLOAD_SET JSVAL_TYPE_MAGIC
#define JSVAL_UPPER_INCL_TYPE_OF_VALUE_SET JSVAL_TYPE_OBJECT
#define JSVAL_UPPER_INCL_TYPE_OF_BOXABLE_SET JSVAL_TYPE_FUNOBJ
#if JS_BITS_PER_WORD == 32
@ -284,7 +268,6 @@ typedef uint64_t JSValueShiftedTag;
#define JSVAL_LOWER_INCL_SHIFTED_TAG_OF_OBJ_OR_NULL_SET JSVAL_SHIFTED_TAG_NULL
#define JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_PRIMITIVE_SET JSVAL_SHIFTED_TAG_OBJECT
#define JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_NUMBER_SET JSVAL_SHIFTED_TAG_UNDEFINED
#define JSVAL_LOWER_INCL_SHIFTED_TAG_OF_PTR_PAYLOAD_SET JSVAL_SHIFTED_TAG_MAGIC
#define JSVAL_LOWER_INCL_SHIFTED_TAG_OF_GCTHING_SET JSVAL_SHIFTED_TAG_STRING
#endif /* JS_BITS_PER_WORD */
@ -663,42 +646,6 @@ JSVAL_EXTRACT_NON_DOUBLE_TYPE_IMPL(jsval_layout l)
return (JSValueType)type;
}
static JS_ALWAYS_INLINE JSValueTag
JSVAL_EXTRACT_NON_DOUBLE_TAG_IMPL(jsval_layout l)
{
JSValueTag tag = l.s.tag;
JS_ASSERT(tag >= JSVAL_TAG_INT32);
return tag;
}
#ifdef __cplusplus
JS_STATIC_ASSERT((JSVAL_TYPE_NONFUNOBJ & 0xF) == JSVAL_TYPE_OBJECT);
JS_STATIC_ASSERT((JSVAL_TYPE_FUNOBJ & 0xF) == JSVAL_TYPE_OBJECT);
#endif
static JS_ALWAYS_INLINE jsval_layout
BOX_NON_DOUBLE_JSVAL(JSValueType type, uint64_t *slot)
{
jsval_layout l;
JS_ASSERT(type > JSVAL_TYPE_DOUBLE && type <= JSVAL_UPPER_INCL_TYPE_OF_BOXABLE_SET);
JS_ASSERT_IF(type == JSVAL_TYPE_STRING ||
type == JSVAL_TYPE_OBJECT ||
type == JSVAL_TYPE_NONFUNOBJ ||
type == JSVAL_TYPE_FUNOBJ,
*(uint32_t *)slot != 0);
l.s.tag = JSVAL_TYPE_TO_TAG(type & 0xF);
/* A 32-bit value in a 64-bit slot always occupies the low-addressed end. */
l.s.payload.u32 = *(uint32_t *)slot;
return l;
}
static JS_ALWAYS_INLINE void
UNBOX_NON_DOUBLE_JSVAL(jsval_layout l, uint64_t *out)
{
JS_ASSERT(!JSVAL_IS_DOUBLE_IMPL(l));
*(uint32_t *)out = l.s.payload.u32;
}
#elif JS_BITS_PER_WORD == 64
static JS_ALWAYS_INLINE jsval_layout
@ -964,47 +911,6 @@ JSVAL_EXTRACT_NON_DOUBLE_TYPE_IMPL(jsval_layout l)
return (JSValueType)type;
}
static JS_ALWAYS_INLINE JSValueTag
JSVAL_EXTRACT_NON_DOUBLE_TAG_IMPL(jsval_layout l)
{
uint64_t tag = l.asBits >> JSVAL_TAG_SHIFT;
JS_ASSERT(tag > JSVAL_TAG_MAX_DOUBLE);
return (JSValueTag)tag;
}
#ifdef __cplusplus
JS_STATIC_ASSERT((JSVAL_TYPE_NONFUNOBJ & 0xF) == JSVAL_TYPE_OBJECT);
JS_STATIC_ASSERT((JSVAL_TYPE_FUNOBJ & 0xF) == JSVAL_TYPE_OBJECT);
#endif
static JS_ALWAYS_INLINE jsval_layout
BOX_NON_DOUBLE_JSVAL(JSValueType type, uint64_t *slot)
{
uint32_t isI32 = (uint32_t)(type < JSVAL_LOWER_INCL_TYPE_OF_PTR_PAYLOAD_SET);
uint32_t shift = isI32 * 32;
uint64_t mask = ((uint64_t)-1) >> shift;
uint64_t payload = *slot & mask;
jsval_layout l;
/* N.B. for 32-bit payloads, the high 32 bits of the slot are trash. */
JS_ASSERT(type > JSVAL_TYPE_DOUBLE && type <= JSVAL_UPPER_INCL_TYPE_OF_BOXABLE_SET);
JS_ASSERT_IF(type == JSVAL_TYPE_STRING ||
type == JSVAL_TYPE_OBJECT ||
type == JSVAL_TYPE_NONFUNOBJ ||
type == JSVAL_TYPE_FUNOBJ,
payload != 0);
l.asBits = payload | JSVAL_TYPE_TO_SHIFTED_TAG(type & 0xF);
return l;
}
static JS_ALWAYS_INLINE void
UNBOX_NON_DOUBLE_JSVAL(jsval_layout l, uint64_t *out)
{
JS_ASSERT(!JSVAL_IS_DOUBLE_IMPL(l));
*out = (l.asBits & JSVAL_PAYLOAD_MASK);
}
#endif /* JS_BITS_PER_WORD */
static JS_ALWAYS_INLINE double

4
js/src/methodjit/FastOps.cpp
View File

@ -734,7 +734,7 @@ mjit::Compiler::jsop_typeof()
if (op == JSOP_STRICTEQ || op == JSOP_EQ || op == JSOP_STRICTNE || op == JSOP_NE) {
JSAtom *atom = script->getAtom(fullAtomIndex(PC + JSOP_TYPEOF_LENGTH));
JSRuntime *rt = cx->runtime;
JSValueType type = JSVAL_TYPE_BOXED;
JSValueType type = JSVAL_TYPE_UNKNOWN;
Assembler::Condition cond = (op == JSOP_STRICTEQ || op == JSOP_EQ)
? Assembler::Equal
: Assembler::NotEqual;
@ -752,7 +752,7 @@ mjit::Compiler::jsop_typeof()
cond = (cond == Assembler::Equal) ? Assembler::BelowOrEqual : Assembler::Above;
}
if (type != JSVAL_TYPE_BOXED) {
if (type != JSVAL_TYPE_UNKNOWN) {
PC += JSOP_STRING_LENGTH;;
PC += JSOP_EQ_LENGTH;

8
js/src/methodjit/InvokeHelpers.cpp
View File

@ -816,14 +816,16 @@ js_InternalInterpret(void *returnData, void *returnType, void *returnReg, js::VM
switch (rejoin) {
case REJOIN_SCRIPTED: {
jsval_layout rval;
#ifdef JS_NUNBOX32
uint64_t rvalBits = ((uint64_t)returnType << 32) | (uint32_t)returnData;
rval.asBits = ((uint64_t)returnType << 32) | (uint32_t)returnData;
#elif JS_PUNBOX64
uint64_t rvalBits = (uint64_t)returnType | (uint64_t)returnData;
rval.asBits = (uint64_t)returnType | (uint64_t)returnData;
#else
#error "Unknown boxing format"
#endif
nextsp[-1].setRawBits(rvalBits);
nextsp[-1] = IMPL_TO_JSVAL(rval);
/*
* When making a scripted call at monitored sites, it is the caller's

15
js/src/methodjit/NunboxAssembler.h
View File

@ -163,17 +163,13 @@ class NunboxAssembler : public JSC::MacroAssembler
}
void loadValueAsComponents(const Value &val, RegisterID type, RegisterID payload) {
jsval_layout jv;
jv.asBits = val.asRawBits();
jsval_layout jv = JSVAL_TO_IMPL(val);
move(ImmTag(jv.s.tag), type);
move(Imm32(jv.s.payload.u32), payload);
}
void loadValuePayload(const Value &val, RegisterID payload) {
jsval_layout jv;
jv.asBits = val.asRawBits();
jsval_layout jv = JSVAL_TO_IMPL(val);
move(Imm32(jv.s.payload.u32), payload);
}
@ -257,8 +253,7 @@ class NunboxAssembler : public JSC::MacroAssembler
/* Overloaded for storing constant type and data. */
DataLabel32 storeValueWithAddressOffsetPatch(const Value &v, Address address) {
jsval_layout jv;
jv.asBits = v.asRawBits();
jsval_layout jv = JSVAL_TO_IMPL(v);
ImmTag type(jv.s.tag);
Imm32 payload(jv.s.payload.u32);
DataLabel32 start = dataLabel32();
@ -296,9 +291,7 @@ class NunboxAssembler : public JSC::MacroAssembler
*/
template <typename T>
Label storeValue(const Value &v, T address) {
jsval_layout jv;
jv.asBits = v.asRawBits();
jsval_layout jv = JSVAL_TO_IMPL(v);
store32(ImmTag(jv.s.tag), tagOf(address));
Label l = label();
store32(Imm32(jv.s.payload.u32), payloadOf(address));

11
js/src/methodjit/PunboxAssembler.h
View File

@ -129,12 +129,13 @@ class PunboxAssembler : public JSC::MacroAssembler
}
void loadValueAsComponents(const Value &val, RegisterID type, RegisterID payload) {
move(Imm64(val.asRawBits() & JSVAL_TAG_MASK), type);
move(Imm64(val.asRawBits() & JSVAL_PAYLOAD_MASK), payload);
uint64_t bits = JSVAL_TO_IMPL(val).asBits;
move(Imm64(bits & JSVAL_TAG_MASK), type);
move(Imm64(bits & JSVAL_PAYLOAD_MASK), payload);
}
void loadValuePayload(const Value &val, RegisterID payload) {
move(Imm64(val.asRawBits() & JSVAL_PAYLOAD_MASK), payload);
move(Imm64(JSVAL_TO_IMPL(val).asBits & JSVAL_PAYLOAD_MASK), payload);
}
/*
@ -180,7 +181,7 @@ class PunboxAssembler : public JSC::MacroAssembler
/* Overload for constant type and constant data. */
DataLabel32 storeValueWithAddressOffsetPatch(const Value &v, Address address) {
move(ImmPtr(reinterpret_cast<void*>(v.asRawBits())), Registers::ValueReg);
move(ImmPtr(JSVAL_TO_IMPL(v).asPtr), Registers::ValueReg);
return storePtrWithAddressOffsetPatch(Registers::ValueReg, valueOf(address));
}
@ -248,7 +249,7 @@ class PunboxAssembler : public JSC::MacroAssembler
template <typename T>
void storeValue(const Value &v, T address) {
storePtr(Imm64(v.asRawBits()), valueOf(address));
storePtr(Imm64(JSVAL_TO_IMPL(v).asBits), valueOf(address));
}
template <typename T>

2
js/xpconnect/src/nsXPConnect.cpp
View File

@ -2931,7 +2931,7 @@ JS_EXPORT_API(void) DumpJSObject(JSObject* obj)
JS_EXPORT_API(void) DumpJSValue(jsval val)
{
printf("Dumping 0x%llu.\n", (long long) val.asRawBits());
printf("Dumping 0x%llu.\n", (long long) JSVAL_TO_IMPL(val).asBits);
if (JSVAL_IS_NULL(val)) {
printf("Value is null\n");
} else if (JSVAL_IS_OBJECT(val) || JSVAL_IS_NULL(val)) {