Changeset 155558 in webkit


Ignore:
Timestamp:
Sep 11, 2013 1:34:09 PM (11 years ago)
Author:
commit-queue@webkit.org
Message:

MapData and WeakMapData don't need to be objects
​https://bugs.webkit.org/show_bug.cgi?id=121167

Patch by Sam Weinig <​sam@webkit.org> on 2013-09-11
Reviewed by Geoffrey Garen.

  • runtime/JSGlobalObject.cpp:

(JSC::JSGlobalObject::reset):
(JSC::JSGlobalObject::visitChildren):

  • runtime/JSGlobalObject.h:

(JSC::JSGlobalObject::mapStructure):
Remove MapData and WeakMapData structures (they moved to VM with other non-object Structures).

  • runtime/JSMap.cpp:

(JSC::JSMap::finishCreation):

  • runtime/JSMap.h:

(JSC::JSMap::create):

  • runtime/JSSet.cpp:

(JSC::JSSet::finishCreation):

  • runtime/JSSet.h:

(JSC::JSSet::create):

  • runtime/JSWeakMap.cpp:

(JSC::JSWeakMap::finishCreation):

  • runtime/JSWeakMap.h:

(JSC::JSWeakMap::create):
Update to not pass a global object to the MapData or WeakMapData Structure.

  • runtime/MapData.cpp:

(JSC::MapData::MapData):

  • runtime/MapData.h:

(JSC::MapData::create):
(JSC::MapData::createStructure):

  • runtime/WeakMapData.cpp:

(JSC::WeakMapData::WeakMapData):
(JSC::WeakMapData::set): Change to take a VM rather than a CallFrame, as that it all it needs.

  • runtime/WeakMapData.h:

(JSC::WeakMapData::create):
(JSC::WeakMapData::createStructure):
Instead of inheriting from JSDestructibleObject, inherit from JSCell and mark self as needing destruction
and having an immortal structure.

  • runtime/VM.cpp:

(JSC::VM::VM):

  • runtime/VM.h:

Add MapData and WeakMapData Structures.

  • runtime/WeakMapPrototype.cpp:

(JSC::protoFuncWeakMapSet):
Pass a VM rather than an ExecState.

Location:
trunk/Source/JavaScriptCore
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r155499 r155558  
     12013-09-11  Sam Weinig  <sam@webkit.org>
     2
     3        MapData and WeakMapData don't need to be objects
     4        https://bugs.webkit.org/show_bug.cgi?id=121167
     5
     6        Reviewed by Geoffrey Garen.
     7
     8        * runtime/JSGlobalObject.cpp:
     9        (JSC::JSGlobalObject::reset):
     10        (JSC::JSGlobalObject::visitChildren):
     11        * runtime/JSGlobalObject.h:
     12        (JSC::JSGlobalObject::mapStructure):
     13        Remove MapData and WeakMapData structures (they moved to VM with other non-object Structures).
     14
     15        * runtime/JSMap.cpp:
     16        (JSC::JSMap::finishCreation):
     17        * runtime/JSMap.h:
     18        (JSC::JSMap::create):
     19        * runtime/JSSet.cpp:
     20        (JSC::JSSet::finishCreation):
     21        * runtime/JSSet.h:
     22        (JSC::JSSet::create):
     23        * runtime/JSWeakMap.cpp:
     24        (JSC::JSWeakMap::finishCreation):
     25        * runtime/JSWeakMap.h:
     26        (JSC::JSWeakMap::create):
     27        Update to not pass a global object to the MapData or WeakMapData Structure.
     28
     29        * runtime/MapData.cpp:
     30        (JSC::MapData::MapData):
     31        * runtime/MapData.h:
     32        (JSC::MapData::create):
     33        (JSC::MapData::createStructure):
     34        * runtime/WeakMapData.cpp:
     35        (JSC::WeakMapData::WeakMapData):
     36        (JSC::WeakMapData::set): Change to take a VM rather than a CallFrame, as that it all it needs.
     37        * runtime/WeakMapData.h:
     38        (JSC::WeakMapData::create):
     39        (JSC::WeakMapData::createStructure):
     40        Instead of inheriting from JSDestructibleObject, inherit from JSCell and mark self as needing destruction
     41        and having an immortal structure.
     42
     43        * runtime/VM.cpp:
     44        (JSC::VM::VM):
     45        * runtime/VM.h:
     46        Add MapData and WeakMapData Structures.
     47
     48        * runtime/WeakMapPrototype.cpp:
     49        (JSC::protoFuncWeakMapSet):
     50        Pass a VM rather than an ExecState.
     51
    1522013-09-10  Filip Pizlo  <fpizlo@apple.com>
    253

  • trunk/Source/JavaScriptCore/runtime/JSGlobalObject.cpp

    r155473 r155558  
    7777#include "Lookup.h"
    7878#include "MapConstructor.h"
    79 #include "MapData.h"
    8079#include "MapPrototype.h"
    8180#include "MathObject.h"
    … …  
    102101#include "StringPrototype.h"
    103102#include "WeakMapConstructor.h"
    104 #include "WeakMapData.h"
    105103#include "WeakMapPrototype.h"
    106104
    … …  
    311309    m_promiseWrapperCallbackStructure.set(exec->vm(), this, JSPromiseWrapperCallback::createStructure(exec->vm(), this, m_functionPrototype.get()));
    312310#endif // ENABLE(PROMISES)
    313 
    314 
    315     m_mapDataStructure.set(exec->vm(), this, MapData::createStructure(exec->vm(), this, jsNull()));
    316     m_weakMapDataStructure.set(exec->vm(), this, WeakMapData::createStructure(exec->vm(), this, jsNull()));
    317311
    318312#define CREATE_PROTOTYPE_FOR_SIMPLE_TYPE(capitalName, lowerName, properName, instanceType, jsName) \
    … …  
    645639#undef VISIT_SIMPLE_TYPE
    646640
    647     visitor.append(&thisObject->m_mapDataStructure);
    648     visitor.append(&thisObject->m_weakMapDataStructure);
    649 
    650641    for (unsigned i = NUMBER_OF_TYPED_ARRAY_TYPES; i--;) {
    651642        visitor.append(&thisObject->m_typedArrays[i].prototype);

  • trunk/Source/JavaScriptCore/runtime/JSGlobalObject.h

    r155473 r155558  
    201201#endif // ENABLE(PROMISES)
    202202
    203     WriteBarrier<Structure> m_mapDataStructure;
    204     WriteBarrier<Structure> m_weakMapDataStructure;
    205 
    206203#define DEFINE_STORAGE_FOR_SIMPLE_TYPE(capitalName, lowerName, properName, instanceType, jsName) \
    207204    WriteBarrier<capitalName ## Prototype> m_ ## lowerName ## Prototype; \
    … …  
    400397    Structure* internalFunctionStructure() const { return m_internalFunctionStructure.get(); }
    401398    Structure* mapStructure() const { return m_mapStructure.get(); }
    402     Structure* mapDataStructure() const { return m_mapDataStructure.get(); }
    403     Structure* weakMapDataStructure() const { return m_weakMapDataStructure.get(); }
    404399    Structure* regExpMatchesArrayStructure() const { return m_regExpMatchesArrayStructure.get(); }
    405400    Structure* regExpStructure() const { return m_regExpStructure.get(); }

  • trunk/Source/JavaScriptCore/runtime/JSMap.cpp

    r154861 r155558  
    4242}
    4343
    44 void JSMap::finishCreation(VM& vm, JSGlobalObject* globalObject)
     44void JSMap::finishCreation(VM& vm)
    4545{
    4646    Base::finishCreation(vm);
    47     m_mapData.set(vm, this, MapData::create(vm, globalObject));
     47    m_mapData.set(vm, this, MapData::create(vm));
    4848}
    4949

  • trunk/Source/JavaScriptCore/runtime/JSMap.h

    r155008 r155558  
    4747    {
    4848        JSMap* instance = new (NotNull, allocateCell<JSMap>(vm.heap)) JSMap(vm, structure);
    49         instance->finishCreation(vm, structure->globalObject());
     49        instance->finishCreation(vm);
    5050        return instance;
    5151    }
    … …  
    5959
    6060private:
    61 
    6261    static const unsigned StructureFlags = OverridesVisitChildren | Base::StructureFlags;
    6362
    … …  
    6766    }
    6867
    69     JS_EXPORT_PRIVATE void finishCreation(VM&, JSGlobalObject*);
     68    JS_EXPORT_PRIVATE void finishCreation(VM&);
    7069
    7170    static void visitChildren(JSCell*, SlotVisitor&);

  • trunk/Source/JavaScriptCore/runtime/JSSet.cpp

    r154916 r155558  
    4242}
    4343
    44 void JSSet::finishCreation(VM& vm, JSGlobalObject* globalObject)
     44void JSSet::finishCreation(VM& vm)
    4545{
    4646    Base::finishCreation(vm);
    47     m_mapData.set(vm, this, MapData::create(vm, globalObject));
     47    m_mapData.set(vm, this, MapData::create(vm));
    4848}
    4949

  • trunk/Source/JavaScriptCore/runtime/JSSet.h

    r155008 r155558  
    4747    {
    4848        JSSet* instance = new (NotNull, allocateCell<JSSet>(vm.heap)) JSSet(vm, structure);
    49         instance->finishCreation(vm, structure->globalObject());
     49        instance->finishCreation(vm);
    5050        return instance;
    5151    }
    … …  
    6767    }
    6868
    69     JS_EXPORT_PRIVATE void finishCreation(VM&, JSGlobalObject*);
     69    JS_EXPORT_PRIVATE void finishCreation(VM&);
    7070   
    7171    static void visitChildren(JSCell*, SlotVisitor&);

  • trunk/Source/JavaScriptCore/runtime/JSWeakMap.cpp

    r155473 r155558  
    3535const ClassInfo JSWeakMap::s_info = { "WeakMap", &Base::s_info, 0, 0, CREATE_METHOD_TABLE(JSWeakMap) };
    3636
    37 void JSWeakMap::finishCreation(VM& vm, JSGlobalObject* globalObject)
     37void JSWeakMap::finishCreation(VM& vm)
    3838{
    3939    Base::finishCreation(vm);
    40     m_weakMapData.set(vm, this, WeakMapData::create(vm, globalObject));
     40    m_weakMapData.set(vm, this, WeakMapData::create(vm));
    4141}
    4242

  • trunk/Source/JavaScriptCore/runtime/JSWeakMap.h

    r155473 r155558  
    4444    }
    4545
     46    static JSWeakMap* create(VM& vm, Structure* structure)
     47    {
     48        JSWeakMap* instance = new (NotNull, allocateCell<JSWeakMap>(vm.heap)) JSWeakMap(vm, structure);
     49        instance->finishCreation(vm);
     50        return instance;
     51    }
     52
    4653    static JSWeakMap* create(ExecState* exec, Structure* structure)
    4754    {
    48         VM& vm = exec->vm();
    49         JSWeakMap* instance = new (NotNull, allocateCell<JSWeakMap>(vm.heap)) JSWeakMap(vm, structure);
    50         instance->finishCreation(vm, structure->globalObject());
    51         return instance;
     55        return create(exec->vm(), structure);
    5256    }
    5357
    … …  
    6266
    6367private:
    64 
    6568    static const unsigned StructureFlags = OverridesVisitChildren | Base::StructureFlags;
    6669
    … …  
    7073    }
    7174
    72     void finishCreation(VM&, JSGlobalObject*);
     75    void finishCreation(VM&);
    7376    static void visitChildren(JSCell*, SlotVisitor&);
    7477

  • trunk/Source/JavaScriptCore/runtime/MapData.cpp

    r155487 r155558  
    3838namespace JSC {
    3939
    40 const ClassInfo MapData::s_info = { "MapData", &Base::s_info, 0, 0, CREATE_METHOD_TABLE(MapData) };
     40const ClassInfo MapData::s_info = { "MapData", 0, 0, 0, CREATE_METHOD_TABLE(MapData) };
    4141
    4242static const int32_t minimumMapSize = 8;
    4343
    44 MapData::MapData(VM& vm, JSGlobalObject* globalObject)
    45     : Base(vm, globalObject->mapDataStructure())
     44MapData::MapData(VM& vm)
     45    : Base(vm, vm.mapDataStructure.get())
    4646    , m_capacity(0)
    4747    , m_size(0)

  • trunk/Source/JavaScriptCore/runtime/MapData.h

    r155487 r155558  
    2727#define MapData_h
    2828
    29 #include "CallFrame.h"
    30 #include "JSCJSValue.h"
    31 #include "JSDestructibleObject.h"
    32 
     29#include "JSCell.h"
     30#include "Structure.h"
    3331#include <wtf/HashFunctions.h>
    3432#include <wtf/HashMap.h>
    … …  
    3735namespace JSC {
    3836
    39 class MapData : public JSDestructibleObject {
     37class MapData : public JSCell {
    4038public:
    41     typedef JSDestructibleObject Base;
     39    typedef JSCell Base;
    4240
    4341    struct const_iterator {
    … …  
    6967    };
    7068
    71     static MapData* create(VM& vm, JSGlobalObject* globalObject)
     69    static MapData* create(VM& vm)
    7270    {
    73         MapData* mapData = new (NotNull, allocateCell<MapData>(vm.heap)) MapData(vm, globalObject);
     71        MapData* mapData = new (NotNull, allocateCell<MapData>(vm.heap)) MapData(vm);
    7472        mapData->finishCreation(vm);
    7573        return mapData;
    … …  
    7876    static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
    7977    {
    80         return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
    81     }
     78        return Structure::create(vm, globalObject, prototype, TypeInfo(CompoundType, StructureFlags), info());
     79    }
     80
     81    static const bool needsDestruction = true;
     82    static const bool hasImmortalStructure = true;
    8283
    8384    JS_EXPORT_PRIVATE void set(CallFrame*, KeyType, JSValue);
    … …  
    110111    size_t capacityInBytes() { return m_capacity * sizeof(Entry); }
    111112
    112     MapData(VM&, JSGlobalObject*);
     113    MapData(VM&);
    113114    static void destroy(JSCell*);
    114115    static void visitChildren(JSCell*, SlotVisitor&);

  • trunk/Source/JavaScriptCore/runtime/VM.cpp

    r155495 r155558  
    4747#include "IncrementalSweeper.h"
    4848#include "Interpreter.h"
     49#include "JSAPIValueWrapper.h"
    4950#include "JSActivation.h"
    50 #include "JSAPIValueWrapper.h"
    5151#include "JSArray.h"
    5252#include "JSFunction.h"
    … …  
    6969#include "StrongInlines.h"
    7070#include "UnlinkedCodeBlock.h"
     71#include "WeakMapData.h"
    7172#include <wtf/ProcessID.h>
    7273#include <wtf/RetainPtr.h>
    … …  
    242243    unlinkedFunctionCodeBlockStructure.set(*this, UnlinkedFunctionCodeBlock::createStructure(*this, 0, jsNull()));
    243244    propertyTableStructure.set(*this, PropertyTable::createStructure(*this, 0, jsNull()));
     245    mapDataStructure.set(*this, MapData::createStructure(*this, 0, jsNull()));
     246    weakMapDataStructure.set(*this, WeakMapData::createStructure(*this, 0, jsNull()));
     247
    244248    smallStrings.initializeCommonStrings(*this);
    245249

  • trunk/Source/JavaScriptCore/runtime/VM.h

    r155219 r155558  
    271271        Strong<Structure> unlinkedFunctionCodeBlockStructure;
    272272        Strong<Structure> propertyTableStructure;
     273        Strong<Structure> mapDataStructure;
     274        Strong<Structure> weakMapDataStructure;
    273275
    274276        IdentifierTable* identifierTable;

  • trunk/Source/JavaScriptCore/runtime/WeakMapData.cpp

    r155473 r155558  
    3535#include <wtf/MathExtras.h>
    3636
    37 
    3837namespace JSC {
    3938
    40 const ClassInfo WeakMapData::s_info = { "WeakMapData", &Base::s_info, 0, 0, CREATE_METHOD_TABLE(WeakMapData) };
     39const ClassInfo WeakMapData::s_info = { "WeakMapData", 0, 0, 0, CREATE_METHOD_TABLE(WeakMapData) };
    4140
    42 WeakMapData::WeakMapData(VM& vm, JSGlobalObject* globalObject)
    43     : Base(vm, globalObject->weakMapDataStructure())
     41WeakMapData::WeakMapData(VM& vm)
     42    : Base(vm, vm.weakMapDataStructure.get())
    4443    , m_deadKeyCleaner(this)
    4544{
    … …  
    6968}
    7069
    71 void WeakMapData::set(CallFrame* callFrame, JSObject* key, JSValue value)
     70void WeakMapData::set(VM& vm, JSObject* key, JSValue value)
    7271{
    7372    // Here we force the write barrier on the key.
    74     auto result = m_map.add(WriteBarrier<JSObject>(callFrame->vm(), this, key).get(), WriteBarrier<Unknown>());
    75     result.iterator->value.set(callFrame->vm(), this, value);
     73    auto result = m_map.add(WriteBarrier<JSObject>(vm, this, key).get(), WriteBarrier<Unknown>());
     74    result.iterator->value.set(vm, this, value);
    7675}
    7776

  • trunk/Source/JavaScriptCore/runtime/WeakMapData.h

    r155473 r155558  
    2727#define WeakMapData_h
    2828
    29 #include "CallFrame.h"
    30 #include "JSCJSValue.h"
    31 #include "JSDestructibleObject.h"
    32 
     29#include "JSCell.h"
     30#include "Structure.h"
    3331#include <wtf/HashFunctions.h>
    3432#include <wtf/HashMap.h>
    … …  
    3735namespace JSC {
    3836
    39 class WeakImpl;
    40 class WeakMapData;
     37class WeakMapData : public JSCell {
     38public:
     39    typedef JSCell Base;
    4140
    42 class WeakMapData : public JSDestructibleObject {
    43 public:
    44     typedef JSDestructibleObject Base;
    45 
    46     static WeakMapData* create(VM& vm, JSGlobalObject* globalObject)
     41    static WeakMapData* create(VM& vm)
    4742    {
    48         WeakMapData* weakMapData = new (NotNull, allocateCell<WeakMapData>(vm.heap)) WeakMapData(vm, globalObject);
     43        WeakMapData* weakMapData = new (NotNull, allocateCell<WeakMapData>(vm.heap)) WeakMapData(vm);
    4944        weakMapData->finishCreation(vm);
    5045        return weakMapData;
    … …  
    5348    static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
    5449    {
    55         return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
     50        return Structure::create(vm, globalObject, prototype, TypeInfo(CompoundType, StructureFlags), info());
    5651    }
    5752
    58     void set(CallFrame*, JSObject*, JSValue);
     53    static const bool needsDestruction = true;
     54    static const bool hasImmortalStructure = true;
     55
     56    void set(VM&, JSObject*, JSValue);
    5957    JSValue get(JSObject*);
    6058    bool remove(JSObject*);
    61     void removeDead(JSObject*);
    6259    bool contains(JSObject*);
    6360    void clear();
    6461
    6562    DECLARE_INFO;
     63
    6664    static const unsigned StructureFlags = OverridesVisitChildren | Base::StructureFlags;
    6765
    6866private:
    69     WeakMapData(VM&, JSGlobalObject*);
     67    WeakMapData(VM&);
    7068    static void destroy(JSCell*);
    7169    static void visitChildren(JSCell*, SlotVisitor&);

  • trunk/Source/JavaScriptCore/runtime/WeakMapPrototype.cpp

    r155473 r155558  
    120120    if (!key.isObject())
    121121        return JSValue::encode(throwTypeError(callFrame, WTF::ASCIILiteral("Attempted to set a non-object key in a WeakMap")));
    122     map->set(callFrame, asObject(key), callFrame->argument(1));
     122    map->set(callFrame->vm(), asObject(key), callFrame->argument(1));
    123123    return JSValue::encode(callFrame->thisValue());
    124124}
Note: See TracChangeset for help on using the changeset viewer.