mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
Bug 1176090 - Change all RelocatablePtr to HeapPtr and remove the |using|; r=jonco
This commit is contained in:
parent
708256b2b2
commit
8e8fb5c0c3
@ -851,7 +851,7 @@ class AsmJSModule
|
||||
uint8_t * interruptExit_;
|
||||
uint8_t * outOfBoundsExit_;
|
||||
StaticLinkData staticLinkData_;
|
||||
RelocatablePtrArrayBufferObjectMaybeShared maybeHeap_;
|
||||
HeapPtrArrayBufferObjectMaybeShared maybeHeap_;
|
||||
AsmJSModule ** prevLinked_;
|
||||
AsmJSModule * nextLinked_;
|
||||
bool dynamicallyLinked_;
|
||||
|
@ -1199,7 +1199,7 @@ MapObject::set(JSContext* cx, HandleObject obj, HandleValue k, HandleValue v)
|
||||
if (!key.setValue(cx, k))
|
||||
return false;
|
||||
|
||||
RelocatableValue rval(v);
|
||||
HeapValue rval(v);
|
||||
if (!map->put(key, rval)) {
|
||||
ReportOutOfMemory(cx);
|
||||
return false;
|
||||
@ -1294,7 +1294,7 @@ MapObject::construct(JSContext* cx, unsigned argc, Value* vp)
|
||||
if (!hkey.setValue(cx, key))
|
||||
return false;
|
||||
|
||||
RelocatableValue rval(val);
|
||||
HeapValue rval(val);
|
||||
if (!map->put(hkey, rval)) {
|
||||
ReportOutOfMemory(cx);
|
||||
return false;
|
||||
@ -1451,7 +1451,7 @@ MapObject::set_impl(JSContext* cx, CallArgs args)
|
||||
|
||||
ValueMap& map = extract(args);
|
||||
ARG0_KEY(cx, args, key);
|
||||
RelocatableValue rval(args.get(1));
|
||||
HeapValue rval(args.get(1));
|
||||
if (!map.put(key, rval)) {
|
||||
ReportOutOfMemory(cx);
|
||||
return false;
|
||||
@ -1472,14 +1472,14 @@ bool
|
||||
MapObject::delete_impl(JSContext* cx, CallArgs args)
|
||||
{
|
||||
// MapObject::mark does not mark deleted entries. Incremental GC therefore
|
||||
// requires that no RelocatableValue objects pointing to heap values be
|
||||
// left alive in the ValueMap.
|
||||
// requires that no HeapValue objects pointing to heap values be left alive
|
||||
// in the ValueMap.
|
||||
//
|
||||
// OrderedHashMap::remove() doesn't destroy the removed entry. It merely
|
||||
// calls OrderedHashMap::MapOps::makeEmpty. But that is sufficient, because
|
||||
// makeEmpty clears the value by doing e->value = Value(), and in the case
|
||||
// of a ValueMap, Value() means RelocatableValue(), which is the same as
|
||||
// RelocatableValue(UndefinedValue()).
|
||||
// of a ValueMap, Value() means HeapValue(), which is the same as
|
||||
// HeapValue(UndefinedValue()).
|
||||
MOZ_ASSERT(MapObject::is(args.thisv()));
|
||||
|
||||
ValueMap& map = extract(args);
|
||||
|
@ -77,7 +77,7 @@ template <class T, class OrderedHashPolicy, class AllocPolicy>
|
||||
class OrderedHashSet;
|
||||
|
||||
typedef OrderedHashMap<HashableValue,
|
||||
RelocatableValue,
|
||||
HeapValue,
|
||||
HashableValue::Hasher,
|
||||
RuntimeAllocPolicy> ValueMap;
|
||||
|
||||
|
@ -133,15 +133,13 @@
|
||||
* the init naming idiom in many places to signify that a field is being
|
||||
* assigned for the first time.
|
||||
*
|
||||
* This file implements four classes, illustrated here:
|
||||
* This file implements three classes, illustrated here:
|
||||
*
|
||||
* BarrieredBase abstract base class which provides common operations
|
||||
* | | |
|
||||
* | | PreBarriered provides pre-barriers only
|
||||
* | |
|
||||
* | HeapPtr provides pre- and post-barriers
|
||||
* |
|
||||
* RelocatablePtr provides pre- and post-barriers and is relocatable
|
||||
* BarrieredBase abstract base class which provides common operations
|
||||
* | |
|
||||
* | PreBarriered provides pre-barriers only
|
||||
* |
|
||||
* HeapPtr provides pre- and post-barriers
|
||||
*
|
||||
* The implementation of the barrier logic is implemented on T::writeBarrier.*,
|
||||
* via:
|
||||
@ -154,7 +152,7 @@
|
||||
* -> InternalGCMethods<T*>::preBarrier
|
||||
* -> T::writeBarrierPre
|
||||
*
|
||||
* HeapPtr<T>::post and RelocatablePtr<T>::post
|
||||
* HeapPtr<T>::post
|
||||
* -> InternalGCMethods<T*>::postBarrier
|
||||
* -> T::writeBarrierPost
|
||||
* -> InternalGCMethods<Value>::postBarrier
|
||||
@ -348,10 +346,10 @@ class BarrieredBaseMixins<JS::Value> : public ValueOperations<BarrieredBase<JS::
|
||||
};
|
||||
|
||||
/*
|
||||
* PreBarriered only automatically handles pre-barriers. Post-barriers must
|
||||
* be manually implemented when using this class. HeapPtr and RelocatablePtr
|
||||
* should be used in all cases that do not require explicit low-level control
|
||||
* of moving behavior, e.g. for HashMap keys.
|
||||
* PreBarriered only automatically handles pre-barriers. Post-barriers must be
|
||||
* manually implemented when using this class. HeapPtr should be used in all
|
||||
* cases that do not require explicit low-level control of moving behavior,
|
||||
* e.g. for HashMap keys.
|
||||
*/
|
||||
template <class T>
|
||||
class PreBarriered : public BarrieredBase<T>
|
||||
@ -449,13 +447,6 @@ class HeapPtr : public BarrieredBase<T>
|
||||
}
|
||||
};
|
||||
|
||||
/*
|
||||
* This name is kept so that complete conversion to HeapPtr can be done
|
||||
* incrementally.
|
||||
*/
|
||||
template <typename T>
|
||||
using RelocatablePtr = HeapPtr<T>;
|
||||
|
||||
/*
|
||||
* This is a hack for RegExpStatics::updateFromMatch. It allows us to do two
|
||||
* barriers with only one branch to check if we're in an incremental GC.
|
||||
@ -463,8 +454,8 @@ using RelocatablePtr = HeapPtr<T>;
|
||||
template <class T1, class T2>
|
||||
static inline void
|
||||
BarrieredSetPair(Zone* zone,
|
||||
RelocatablePtr<T1*>& v1, T1* val1,
|
||||
RelocatablePtr<T2*>& v2, T2* val2)
|
||||
HeapPtr<T1*>& v1, T1* val1,
|
||||
HeapPtr<T2*>& v2, T2* val2)
|
||||
{
|
||||
if (T1::needWriteBarrierPre(zone)) {
|
||||
v1.pre();
|
||||
@ -615,20 +606,6 @@ typedef PreBarriered<jit::JitCode*> PreBarrieredJitCode;
|
||||
typedef PreBarriered<JSString*> PreBarrieredString;
|
||||
typedef PreBarriered<JSAtom*> PreBarrieredAtom;
|
||||
|
||||
typedef RelocatablePtr<JSObject*> RelocatablePtrObject;
|
||||
typedef RelocatablePtr<JSFunction*> RelocatablePtrFunction;
|
||||
typedef RelocatablePtr<PlainObject*> RelocatablePtrPlainObject;
|
||||
typedef RelocatablePtr<JSScript*> RelocatablePtrScript;
|
||||
typedef RelocatablePtr<NativeObject*> RelocatablePtrNativeObject;
|
||||
typedef RelocatablePtr<NestedScopeObject*> RelocatablePtrNestedScopeObject;
|
||||
typedef RelocatablePtr<Shape*> RelocatablePtrShape;
|
||||
typedef RelocatablePtr<ObjectGroup*> RelocatablePtrObjectGroup;
|
||||
typedef RelocatablePtr<jit::JitCode*> RelocatablePtrJitCode;
|
||||
typedef RelocatablePtr<JSLinearString*> RelocatablePtrLinearString;
|
||||
typedef RelocatablePtr<JSString*> RelocatablePtrString;
|
||||
typedef RelocatablePtr<JSAtom*> RelocatablePtrAtom;
|
||||
typedef RelocatablePtr<ArrayBufferObjectMaybeShared*> RelocatablePtrArrayBufferObjectMaybeShared;
|
||||
|
||||
typedef HeapPtr<NativeObject*> HeapPtrNativeObject;
|
||||
typedef HeapPtr<ArrayObject*> HeapPtrArrayObject;
|
||||
typedef HeapPtr<ArrayBufferObjectMaybeShared*> HeapPtrArrayBufferObjectMaybeShared;
|
||||
@ -649,11 +626,9 @@ typedef HeapPtr<jit::JitCode*> HeapPtrJitCode;
|
||||
typedef HeapPtr<ObjectGroup*> HeapPtrObjectGroup;
|
||||
|
||||
typedef PreBarriered<Value> PreBarrieredValue;
|
||||
typedef RelocatablePtr<Value> RelocatableValue;
|
||||
typedef HeapPtr<Value> HeapValue;
|
||||
|
||||
typedef PreBarriered<jsid> PreBarrieredId;
|
||||
typedef RelocatablePtr<jsid> RelocatableId;
|
||||
typedef HeapPtr<jsid> HeapId;
|
||||
|
||||
typedef ImmutableTenuredPtr<PropertyName*> ImmutablePropertyNamePtr;
|
||||
@ -676,7 +651,7 @@ typedef ReadBarriered<Value> ReadBarrieredValue;
|
||||
|
||||
// A pre- and post-barriered Value that is specialized to be aware that it
|
||||
// resides in a slots or elements vector. This allows it to be relocated in
|
||||
// memory, but with substantially less overhead than a RelocatablePtr.
|
||||
// memory, but with substantially less overhead than a HeapPtr.
|
||||
class HeapSlot : public BarrieredBase<Value>
|
||||
{
|
||||
public:
|
||||
|
@ -41,21 +41,17 @@ FRAGMENT(Root, barriers) {
|
||||
JSObject* obj = JS_NewPlainObject(cx);
|
||||
js::PreBarriered<JSObject*> prebarriered(obj);
|
||||
js::HeapPtr<JSObject*> heapptr(obj);
|
||||
js::RelocatablePtr<JSObject*> relocatable(obj);
|
||||
|
||||
JS::Value val = JS::ObjectValue(*obj);
|
||||
js::PreBarrieredValue prebarrieredValue(JS::ObjectValue(*obj));
|
||||
js::HeapValue heapValue(JS::ObjectValue(*obj));
|
||||
js::RelocatableValue relocatableValue(JS::ObjectValue(*obj));
|
||||
|
||||
breakpoint();
|
||||
|
||||
(void) prebarriered;
|
||||
(void) heapptr;
|
||||
(void) relocatable;
|
||||
(void) val;
|
||||
(void) prebarrieredValue;
|
||||
(void) heapValue;
|
||||
(void) relocatableValue;
|
||||
}
|
||||
|
||||
|
@ -119,11 +119,11 @@ struct BaselineScript
|
||||
|
||||
private:
|
||||
// Code pointer containing the actual method.
|
||||
RelocatablePtrJitCode method_;
|
||||
HeapPtrJitCode method_;
|
||||
|
||||
// For heavyweight scripts, template objects to use for the call object and
|
||||
// decl env object (linked via the call object's enclosing scope).
|
||||
RelocatablePtrObject templateScope_;
|
||||
HeapPtrObject templateScope_;
|
||||
|
||||
// Allocated space for fallback stubs.
|
||||
FallbackICStubSpace fallbackStubSpace_;
|
||||
|
@ -316,7 +316,7 @@ class JitProfilingFrameIterator
|
||||
class RInstructionResults
|
||||
{
|
||||
// Vector of results of recover instructions.
|
||||
typedef mozilla::Vector<RelocatableValue, 1, SystemAllocPolicy> Values;
|
||||
typedef mozilla::Vector<HeapValue, 1, SystemAllocPolicy> Values;
|
||||
mozilla::UniquePtr<Values, JS::DeletePolicy<Values> > results_;
|
||||
|
||||
// The frame pointer is used as a key to check if the current frame already
|
||||
@ -341,7 +341,7 @@ class RInstructionResults
|
||||
|
||||
JitFrameLayout* frame() const;
|
||||
|
||||
RelocatableValue& operator[](size_t index);
|
||||
HeapValue& operator[](size_t index);
|
||||
|
||||
void trace(JSTracer* trc);
|
||||
};
|
||||
|
@ -1745,7 +1745,7 @@ RInstructionResults::frame() const
|
||||
return fp_;
|
||||
}
|
||||
|
||||
RelocatableValue&
|
||||
HeapValue&
|
||||
RInstructionResults::operator [](size_t index)
|
||||
{
|
||||
return (*results_)[index];
|
||||
|
@ -32,54 +32,54 @@ BEGIN_TEST(testGCStoreBufferRemoval)
|
||||
// Hide the horrors herein from the static rooting analysis.
|
||||
AutoIgnoreRootingHazards ignore;
|
||||
|
||||
// Test removal of store buffer entries added by RelocatablePtr<T>.
|
||||
// Test removal of store buffer entries added by HeapPtr<T>.
|
||||
{
|
||||
JSObject* badObject = reinterpret_cast<JSObject*>(1);
|
||||
JSObject* punnedPtr = nullptr;
|
||||
RelocatablePtrObject* relocPtr =
|
||||
reinterpret_cast<RelocatablePtrObject*>(&punnedPtr);
|
||||
new (relocPtr) RelocatablePtrObject;
|
||||
HeapPtrObject* relocPtr =
|
||||
reinterpret_cast<HeapPtrObject*>(&punnedPtr);
|
||||
new (relocPtr) HeapPtrObject;
|
||||
*relocPtr = NurseryObject();
|
||||
relocPtr->~RelocatablePtrObject();
|
||||
relocPtr->~HeapPtrObject();
|
||||
punnedPtr = badObject;
|
||||
JS_GC(cx->runtime());
|
||||
|
||||
new (relocPtr) RelocatablePtrObject;
|
||||
new (relocPtr) HeapPtrObject;
|
||||
*relocPtr = NurseryObject();
|
||||
*relocPtr = tenuredObject;
|
||||
relocPtr->~RelocatablePtrObject();
|
||||
relocPtr->~HeapPtrObject();
|
||||
punnedPtr = badObject;
|
||||
JS_GC(cx->runtime());
|
||||
|
||||
new (relocPtr) RelocatablePtrObject;
|
||||
new (relocPtr) HeapPtrObject;
|
||||
*relocPtr = NurseryObject();
|
||||
*relocPtr = nullptr;
|
||||
relocPtr->~RelocatablePtrObject();
|
||||
relocPtr->~HeapPtrObject();
|
||||
punnedPtr = badObject;
|
||||
JS_GC(cx->runtime());
|
||||
}
|
||||
|
||||
// Test removal of store buffer entries added by RelocatableValue.
|
||||
// Test removal of store buffer entries added by HeapValue.
|
||||
{
|
||||
Value punnedValue;
|
||||
RelocatableValue* relocValue = reinterpret_cast<RelocatableValue*>(&punnedValue);
|
||||
new (relocValue) RelocatableValue;
|
||||
HeapValue* relocValue = reinterpret_cast<HeapValue*>(&punnedValue);
|
||||
new (relocValue) HeapValue;
|
||||
*relocValue = ObjectValue(*NurseryObject());
|
||||
relocValue->~RelocatableValue();
|
||||
relocValue->~HeapValue();
|
||||
punnedValue = ObjectValueCrashOnTouch();
|
||||
JS_GC(cx->runtime());
|
||||
|
||||
new (relocValue) RelocatableValue;
|
||||
new (relocValue) HeapValue;
|
||||
*relocValue = ObjectValue(*NurseryObject());
|
||||
*relocValue = ObjectValue(*tenuredObject);
|
||||
relocValue->~RelocatableValue();
|
||||
relocValue->~HeapValue();
|
||||
punnedValue = ObjectValueCrashOnTouch();
|
||||
JS_GC(cx->runtime());
|
||||
|
||||
new (relocValue) RelocatableValue;
|
||||
new (relocValue) HeapValue;
|
||||
*relocValue = ObjectValue(*NurseryObject());
|
||||
*relocValue = NullValue();
|
||||
relocValue->~RelocatableValue();
|
||||
relocValue->~HeapValue();
|
||||
punnedValue = ObjectValueCrashOnTouch();
|
||||
JS_GC(cx->runtime());
|
||||
}
|
||||
|
@ -201,7 +201,7 @@ class Bindings
|
||||
friend class BindingIter;
|
||||
friend class AliasedFormalIter;
|
||||
|
||||
RelocatablePtrShape callObjShape_;
|
||||
HeapPtrShape callObjShape_;
|
||||
uintptr_t bindingArrayAndFlag_;
|
||||
uint16_t numArgs_;
|
||||
uint16_t numBlockScoped_;
|
||||
|
@ -2486,7 +2486,7 @@ Debugger::trace(JSTracer* trc)
|
||||
* frames.)
|
||||
*/
|
||||
for (FrameMap::Range r = frames.all(); !r.empty(); r.popFront()) {
|
||||
RelocatablePtrNativeObject& frameobj = r.front().value();
|
||||
HeapPtrNativeObject& frameobj = r.front().value();
|
||||
MOZ_ASSERT(MaybeForwarded(frameobj.get())->getPrivate());
|
||||
TraceEdge(trc, &frameobj, "live Debugger.Frame");
|
||||
}
|
||||
|
@ -64,11 +64,11 @@ typedef HashSet<ReadBarrieredGlobalObject,
|
||||
* created.
|
||||
*/
|
||||
template <class UnbarrieredKey, bool InvisibleKeysOk=false>
|
||||
class DebuggerWeakMap : private WeakMap<PreBarriered<UnbarrieredKey>, RelocatablePtrObject>
|
||||
class DebuggerWeakMap : private WeakMap<PreBarriered<UnbarrieredKey>, HeapPtrObject>
|
||||
{
|
||||
private:
|
||||
typedef PreBarriered<UnbarrieredKey> Key;
|
||||
typedef RelocatablePtrObject Value;
|
||||
typedef HeapPtrObject Value;
|
||||
|
||||
typedef HashMap<JS::Zone*,
|
||||
uintptr_t,
|
||||
@ -286,10 +286,10 @@ class Debugger : private mozilla::LinkedListElement<Debugger>
|
||||
static AllocationSite* create(JSContext* cx, HandleObject frame, double when,
|
||||
HandleObject obj);
|
||||
|
||||
RelocatablePtrObject frame;
|
||||
HeapPtrObject frame;
|
||||
double when;
|
||||
const char* className;
|
||||
RelocatablePtrAtom ctorName;
|
||||
HeapPtrAtom ctorName;
|
||||
};
|
||||
typedef mozilla::LinkedList<AllocationSite> AllocationSiteList;
|
||||
|
||||
@ -362,7 +362,7 @@ class Debugger : private mozilla::LinkedListElement<Debugger>
|
||||
* has to be different.
|
||||
*/
|
||||
typedef HashMap<AbstractFramePtr,
|
||||
RelocatablePtrNativeObject,
|
||||
HeapPtrNativeObject,
|
||||
DefaultHasher<AbstractFramePtr>,
|
||||
RuntimeAllocPolicy> FrameMap;
|
||||
FrameMap frames;
|
||||
|
@ -218,9 +218,9 @@ DebuggerMemory::drainAllocationsLog(JSContext* cx, unsigned argc, Value* vp)
|
||||
|
||||
result->setDenseElement(i, ObjectValue(*obj));
|
||||
|
||||
// Pop the front queue entry, and delete it immediately, so that
|
||||
// the GC sees the AllocationSite's RelocatablePtr barriers run
|
||||
// atomically with the change to the graph (the queue link).
|
||||
// Pop the front queue entry, and delete it immediately, so that the GC
|
||||
// sees the AllocationSite's HeapPtr barriers run atomically with the
|
||||
// change to the graph (the queue link).
|
||||
MOZ_ALWAYS_TRUE(dbg->allocationsLog.popFirst() == allocSite);
|
||||
js_delete(allocSite);
|
||||
}
|
||||
|
@ -120,7 +120,7 @@ class RegExpShared
|
||||
|
||||
struct RegExpCompilation
|
||||
{
|
||||
RelocatablePtrJitCode jitCode;
|
||||
HeapPtrJitCode jitCode;
|
||||
uint8_t* byteCode;
|
||||
|
||||
RegExpCompilation() : byteCode(nullptr) {}
|
||||
@ -132,7 +132,7 @@ class RegExpShared
|
||||
};
|
||||
|
||||
/* Source to the RegExp, for lazy compilation. */
|
||||
RelocatablePtrAtom source;
|
||||
HeapPtrAtom source;
|
||||
|
||||
RegExpFlag flags;
|
||||
size_t parenCount;
|
||||
|
@ -21,19 +21,19 @@ class RegExpStatics
|
||||
{
|
||||
/* The latest RegExp output, set after execution. */
|
||||
VectorMatchPairs matches;
|
||||
RelocatablePtrLinearString matchesInput;
|
||||
HeapPtrLinearString matchesInput;
|
||||
|
||||
/*
|
||||
* The previous RegExp input, used to resolve lazy state.
|
||||
* A raw RegExpShared cannot be stored because it may be in
|
||||
* a different compartment via evalcx().
|
||||
*/
|
||||
RelocatablePtrAtom lazySource;
|
||||
HeapPtrAtom lazySource;
|
||||
RegExpFlag lazyFlags;
|
||||
size_t lazyIndex;
|
||||
|
||||
/* The latest RegExp input, set before execution. */
|
||||
RelocatablePtrString pendingInput;
|
||||
HeapPtrString pendingInput;
|
||||
RegExpFlag flags;
|
||||
|
||||
/*
|
||||
|
@ -829,7 +829,7 @@ class LiveScopeVal
|
||||
friend class MissingScopeKey;
|
||||
|
||||
AbstractFramePtr frame_;
|
||||
RelocatablePtrObject staticScope_;
|
||||
HeapPtrObject staticScope_;
|
||||
|
||||
void sweep();
|
||||
static void staticAsserts();
|
||||
|
@ -804,7 +804,7 @@ class PreliminaryObjectArray
|
||||
|
||||
class PreliminaryObjectArrayWithTemplate : public PreliminaryObjectArray
|
||||
{
|
||||
RelocatablePtrShape shape_;
|
||||
HeapPtrShape shape_;
|
||||
|
||||
public:
|
||||
explicit PreliminaryObjectArrayWithTemplate(Shape* shape)
|
||||
@ -881,7 +881,7 @@ class TypeNewScript
|
||||
|
||||
private:
|
||||
// Scripted function which this information was computed for.
|
||||
RelocatablePtrFunction function_;
|
||||
HeapPtrFunction function_;
|
||||
|
||||
// Any preliminary objects with the type. The analyses are not performed
|
||||
// until this array is cleared.
|
||||
@ -893,7 +893,7 @@ class TypeNewScript
|
||||
// allocation kind to use. This is null if the new objects have an unboxed
|
||||
// layout, in which case the UnboxedLayout provides the initial structure
|
||||
// of the object.
|
||||
RelocatablePtrPlainObject templateObject_;
|
||||
HeapPtrPlainObject templateObject_;
|
||||
|
||||
// Order in which definite properties become initialized. We need this in
|
||||
// case the definite properties are invalidated (such as by adding a setter
|
||||
@ -910,11 +910,11 @@ class TypeNewScript
|
||||
// shape contains all such additional properties (plus the definite
|
||||
// properties). When an object of this group acquires this shape, it is
|
||||
// fully initialized and its group can be changed to initializedGroup.
|
||||
RelocatablePtrShape initializedShape_;
|
||||
HeapPtrShape initializedShape_;
|
||||
|
||||
// Group with definite properties set for all properties found by
|
||||
// both the definite and acquired properties analyses.
|
||||
RelocatablePtrObjectGroup initializedGroup_;
|
||||
HeapPtrObjectGroup initializedGroup_;
|
||||
|
||||
public:
|
||||
TypeNewScript() { mozilla::PodZero(this); }
|
||||
|
@ -12,11 +12,11 @@
|
||||
|
||||
namespace js {
|
||||
|
||||
class ObjectValueMap : public WeakMap<PreBarrieredObject, RelocatableValue>
|
||||
class ObjectValueMap : public WeakMap<PreBarrieredObject, HeapValue>
|
||||
{
|
||||
public:
|
||||
ObjectValueMap(JSContext* cx, JSObject* obj)
|
||||
: WeakMap<PreBarrieredObject, RelocatableValue>(cx, obj) {}
|
||||
: WeakMap<PreBarrieredObject, HeapValue>(cx, obj) {}
|
||||
|
||||
virtual bool findZoneEdges();
|
||||
};
|
||||
|
Loading…
Reference in New Issue
Block a user