Changeset 144113 in webkit


Ignore:
Timestamp:
Feb 26, 2013 2:57:17 PM (11 years ago)
Author:
commit-queue@webkit.org
Message:

Unreviewed, rolling out r144074.
​http://trac.webkit.org/changeset/144074
​https://bugs.webkit.org/show_bug.cgi?id=110897

Causing 20+ crashes on Mac (Requested by bradee-oh on
#webkit).

Patch by Sheriff Bot <​webkit.review.bot@gmail.com> on 2013-02-26

(JSC::JSGlobalData::JSGlobalData):

  • runtime/JSGlobalData.h:

(JSGlobalData):

  • runtime/PropertyMapHashTable.h:

(PropertyTable):
(JSC::PropertyTable::PropertyTable):
(JSC):
(JSC::PropertyTable::~PropertyTable):
(JSC::PropertyTable::copy):

  • runtime/PropertyTable.cpp: Removed.
  • runtime/Structure.cpp:

(JSC::Structure::materializePropertyMap):
(JSC::Structure::addPropertyTransition):
(JSC::Structure::changePrototypeTransition):
(JSC::Structure::despecifyFunctionTransition):
(JSC::Structure::attributeChangeTransition):
(JSC::Structure::toDictionaryTransition):
(JSC::Structure::preventExtensionsTransition):
(JSC::Structure::nonPropertyTransition):
(JSC::Structure::copyPropertyTable):
(JSC::Structure::copyPropertyTableForPinning):
(JSC::Structure::putSpecificValue):
(JSC::Structure::createPropertyMap):
(JSC::Structure::visitChildren):

  • runtime/Structure.h:

(JSC):
(JSC::Structure::putWillGrowOutOfLineStorage):
(JSC::Structure::checkOffsetConsistency):
(Structure):

  • runtime/StructureInlines.h:
Location:
trunk/Source/JavaScriptCore
Files:
1 deleted
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/CMakeLists.txt

    r144074 r144113  
    281281    runtime/PropertyNameArray.cpp
    282282    runtime/PropertySlot.cpp
    283     runtime/PropertyTable.cpp
    284283    runtime/PrototypeMap.cpp
    285284    runtime/RegExp.cpp

  • trunk/Source/JavaScriptCore/ChangeLog

    r144111 r144113  
     12013-02-26  Sheriff Bot  <webkit.review.bot@gmail.com>
     2
     3        Unreviewed, rolling out r144074.
     4        http://trac.webkit.org/changeset/144074
     5        https://bugs.webkit.org/show_bug.cgi?id=110897
     6
     7        Causing 20+ crashes on Mac (Requested by bradee-oh on
     8        #webkit).
     9
     10        * CMakeLists.txt:
     11        * GNUmakefile.list.am:
     12        * JavaScriptCore.gypi:
     13        * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
     14        * JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
     15        * JavaScriptCore.xcodeproj/project.pbxproj:
     16        * Target.pri:
     17        * runtime/JSGlobalData.cpp:
     18        (JSC::JSGlobalData::JSGlobalData):
     19        * runtime/JSGlobalData.h:
     20        (JSGlobalData):
     21        * runtime/PropertyMapHashTable.h:
     22        (PropertyTable):
     23        (JSC::PropertyTable::PropertyTable):
     24        (JSC):
     25        (JSC::PropertyTable::~PropertyTable):
     26        (JSC::PropertyTable::copy):
     27        * runtime/PropertyTable.cpp: Removed.
     28        * runtime/Structure.cpp:
     29        (JSC::Structure::materializePropertyMap):
     30        (JSC::Structure::addPropertyTransition):
     31        (JSC::Structure::changePrototypeTransition):
     32        (JSC::Structure::despecifyFunctionTransition):
     33        (JSC::Structure::attributeChangeTransition):
     34        (JSC::Structure::toDictionaryTransition):
     35        (JSC::Structure::preventExtensionsTransition):
     36        (JSC::Structure::nonPropertyTransition):
     37        (JSC::Structure::copyPropertyTable):
     38        (JSC::Structure::copyPropertyTableForPinning):
     39        (JSC::Structure::putSpecificValue):
     40        (JSC::Structure::createPropertyMap):
     41        (JSC::Structure::visitChildren):
     42        * runtime/Structure.h:
     43        (JSC):
     44        (JSC::Structure::putWillGrowOutOfLineStorage):
     45        (JSC::Structure::checkOffsetConsistency):
     46        (Structure):
     47        * runtime/StructureInlines.h:
     48
    1492013-02-26  Roger Fong  <roger_fong@apple.com>
    250

  • trunk/Source/JavaScriptCore/GNUmakefile.list.am

    r144074 r144113  
    723723        Source/JavaScriptCore/runtime/PropertySlot.cpp \
    724724        Source/JavaScriptCore/runtime/PropertySlot.h \
    725         Source/JavaScriptCore/runtime/PropertyTable.cpp \
    726725        Source/JavaScriptCore/runtime/PrototypeMap.cpp \
    727726        Source/JavaScriptCore/runtime/PrototypeMap.h \

  • trunk/Source/JavaScriptCore/JavaScriptCore.gypi

    r144074 r144113  
    760760            'runtime/PropertySlot.cpp',
    761761            'runtime/PropertySlot.h',
    762             'runtime/PropertyTable.cpp',
    763762            'runtime/PropertyStorage.h',
    764763            'runtime/Protect.h',

  • trunk/Source/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj

    r144074 r144113  
    11751175                        </File>
    11761176                        <File
    1177                                 RelativePath="..\..\runtime\PropertyTable.cpp"
    1178                                 >
    1179                         </File>
    1180                         <File
    11811177                                RelativePath="..\..\runtime\PrototypeMap.cpp"
    11821178                                >

  • trunk/Source/JavaScriptCore/JavaScriptCore.vcxproj/JavaScriptCore.vcxproj

    r144074 r144113  
    306306    <ClCompile Include="..\runtime\PropertyNameArray.cpp" />
    307307    <ClCompile Include="..\runtime\PropertySlot.cpp" />
    308     <ClCompile Include="..\runtime\PropertyTable.cpp" />
    309308    <ClCompile Include="..\runtime\PrototypeMap.cpp" />
    310309    <ClCompile Include="..\runtime\RegExp.cpp" />

  • trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj

    r144074 r144113  
    706706                A7FB61001040C38B0017A286 /* PropertyDescriptor.h in Headers */ = {isa = PBXBuildFile; fileRef = A7FB604B103F5EAB0017A286 /* PropertyDescriptor.h */; settings = {ATTRIBUTES = (Private, ); }; };
    707707                A8A4748E151A8306004123FF /* libWTF.a in Frameworks */ = {isa = PBXBuildFile; fileRef = A8A4748D151A8306004123FF /* libWTF.a */; };
    708                 ADE39FFF16DD144B0003CD4A /* PropertyTable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = AD1CF06816DCAB2D00B97123 /* PropertyTable.cpp */; };
    709708                BC02E90D0E1839DB000F9297 /* ErrorConstructor.h in Headers */ = {isa = PBXBuildFile; fileRef = BC02E9050E1839DB000F9297 /* ErrorConstructor.h */; };
    710709                BC02E90F0E1839DB000F9297 /* ErrorPrototype.h in Headers */ = {isa = PBXBuildFile; fileRef = BC02E9070E1839DB000F9297 /* ErrorPrototype.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    16241623                A8E894310CD0602400367179 /* JSCallbackObjectFunctions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSCallbackObjectFunctions.h; sourceTree = "<group>"; };
    16251624                A8E894330CD0603F00367179 /* JSGlobalObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSGlobalObject.h; sourceTree = "<group>"; };
    1626                 AD1CF06816DCAB2D00B97123 /* PropertyTable.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PropertyTable.cpp; sourceTree = "<group>"; };
    16271625                BC021BF2136900C300FC5467 /* ToolExecutable.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = ToolExecutable.xcconfig; sourceTree = "<group>"; };
    16281626                BC02E9040E1839DB000F9297 /* ErrorConstructor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ErrorConstructor.cpp; sourceTree = "<group>"; };
    … …  
    25152513                                65621E6C089E859700760F35 /* PropertySlot.h */,
    25162514                                0FB7F39015ED8E3800F167B2 /* PropertyStorage.h */,
    2517                                 AD1CF06816DCAB2D00B97123 /* PropertyTable.cpp */,
    25182515                                65C02FBB0637462A003E7EE6 /* Protect.h */,
    25192516                                14D844A216AA2C7000A65AF0 /* PrototypeMap.cpp */,
    … …  
    40354032                                0FBE0F7616C1DB0F0082C5E8 /* DFGUnificationPhase.cpp in Sources */,
    40364033                                0F493AFA16D0CAD30084508B /* SourceProvider.cpp in Sources */,
    4037                                 ADE39FFF16DD144B0003CD4A /* PropertyTable.cpp in Sources */,
    40384034                        );
    40394035                        runOnlyForDeploymentPostprocessing = 0;

  • trunk/Source/JavaScriptCore/Target.pri

    r144074 r144113  
    299299    runtime/PropertyNameArray.cpp \
    300300    runtime/PropertySlot.cpp \
    301     runtime/PropertyTable.cpp \
    302301    runtime/PrototypeMap.cpp \
    303302    runtime/RegExpConstructor.cpp \

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

    r144074 r144113  
    233233    unlinkedEvalCodeBlockStructure.set(*this, UnlinkedEvalCodeBlock::createStructure(*this, 0, jsNull()));
    234234    unlinkedFunctionCodeBlockStructure.set(*this, UnlinkedFunctionCodeBlock::createStructure(*this, 0, jsNull()));
    235     propertyTableStructure.set(*this, PropertyTable::createStructure(*this, 0, jsNull()));
    236235    smallStrings.initializeCommonStrings(*this);
    237236

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

    r144074 r144113  
    257257        Strong<Structure> unlinkedEvalCodeBlockStructure;
    258258        Strong<Structure> unlinkedFunctionCodeBlockStructure;
    259         Strong<Structure> propertyTableStructure;
    260259
    261260        IdentifierTable* identifierTable;

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

    r144074 r144113  
    2323
    2424#include "PropertyOffset.h"
    25 #include "Structure.h"
    2625#include "WriteBarrier.h"
    2726#include <wtf/HashTable.h>
    … …  
    8786};
    8887
    89 class PropertyTable : public JSCell {
     88class PropertyTable {
     89    WTF_MAKE_FAST_ALLOCATED;
    9090
    9191    // This is the implementation for 'iterator' and 'const_iterator',
    … …  
    130130
    131131public:
    132     static const bool needsDestruction = true;
    133     static const bool hasImmortalStructure = true;
    134     static void destroy(JSCell*);
    135 
    136     static JS_EXPORTDATA const ClassInfo s_info;
    137 
    138     static Structure* createStructure(JSGlobalData& globalData, JSGlobalObject* globalObject, JSValue prototype)
    139     {
    140         return Structure::create(globalData, globalObject, prototype, TypeInfo(CompoundType, OverridesVisitChildren), &s_info);
    141     }
    142 
    143     static void visitChildren(JSCell*, SlotVisitor&);
    144 
    145132    typedef StringImpl* KeyType;
    146133    typedef PropertyMapEntry ValueType;
    … …  
    156143
    157144    // Constructor is passed an initial capacity, a PropertyTable to copy, or both.
    158     static PropertyTable* create(JSGlobalData&, unsigned initialCapacity);
    159     static PropertyTable* clone(JSGlobalData&, JSCell* owner, const PropertyTable&);
    160     static PropertyTable* clone(JSGlobalData&, JSCell* owner, unsigned initialCapacity, const PropertyTable&);
     145    explicit PropertyTable(unsigned initialCapacity);
     146    PropertyTable(JSGlobalData&, JSCell*, const PropertyTable&);
     147    PropertyTable(JSGlobalData&, JSCell*, unsigned initialCapacity, const PropertyTable&);
    161148    ~PropertyTable();
    162149
    … …  
    195182
    196183    // Copy this PropertyTable, ensuring the copy has at least the capacity provided.
    197     PropertyTable* copy(JSGlobalData&, JSCell* owner, unsigned newCapacity);
     184    PassOwnPtr<PropertyTable> copy(JSGlobalData&, JSCell* owner, unsigned newCapacity);
    198185
    199186#ifndef NDEBUG
    … …  
    203190
    204191private:
    205     PropertyTable(JSGlobalData&, unsigned initialCapacity);
    206     PropertyTable(JSGlobalData&, JSCell*, const PropertyTable&);
    207     PropertyTable(JSGlobalData&, JSCell*, unsigned initialCapacity, const PropertyTable&);
    208 
    209192    PropertyTable(const PropertyTable&);
    210193    // Used to insert a value known not to be in the table, and where we know capacity to be available.
    … …  
    257240};
    258241
     242inline PropertyTable::PropertyTable(unsigned initialCapacity)
     243    : m_indexSize(sizeForCapacity(initialCapacity))
     244    , m_indexMask(m_indexSize - 1)
     245    , m_index(static_cast<unsigned*>(fastZeroedMalloc(dataSize())))
     246    , m_keyCount(0)
     247    , m_deletedCount(0)
     248{
     249    ASSERT(isPowerOf2(m_indexSize));
     250}
     251
     252inline PropertyTable::PropertyTable(JSGlobalData&, JSCell* owner, const PropertyTable& other)
     253    : m_indexSize(other.m_indexSize)
     254    , m_indexMask(other.m_indexMask)
     255    , m_index(static_cast<unsigned*>(fastMalloc(dataSize())))
     256    , m_keyCount(other.m_keyCount)
     257    , m_deletedCount(other.m_deletedCount)
     258{
     259    ASSERT(isPowerOf2(m_indexSize));
     260
     261    memcpy(m_index, other.m_index, dataSize());
     262
     263    iterator end = this->end();
     264    for (iterator iter = begin(); iter != end; ++iter) {
     265        iter->key->ref();
     266        Heap::writeBarrier(owner, iter->specificValue.get());
     267    }
     268
     269    // Copy the m_deletedOffsets vector.
     270    Vector<PropertyOffset>* otherDeletedOffsets = other.m_deletedOffsets.get();
     271    if (otherDeletedOffsets)
     272        m_deletedOffsets = adoptPtr(new Vector<PropertyOffset>(*otherDeletedOffsets));
     273}
     274
     275inline PropertyTable::PropertyTable(JSGlobalData&, JSCell* owner, unsigned initialCapacity, const PropertyTable& other)
     276    : m_indexSize(sizeForCapacity(initialCapacity))
     277    , m_indexMask(m_indexSize - 1)
     278    , m_index(static_cast<unsigned*>(fastZeroedMalloc(dataSize())))
     279    , m_keyCount(0)
     280    , m_deletedCount(0)
     281{
     282    ASSERT(isPowerOf2(m_indexSize));
     283    ASSERT(initialCapacity >= other.m_keyCount);
     284
     285    const_iterator end = other.end();
     286    for (const_iterator iter = other.begin(); iter != end; ++iter) {
     287        ASSERT(canInsert());
     288        reinsert(*iter);
     289        iter->key->ref();
     290        Heap::writeBarrier(owner, iter->specificValue.get());
     291    }
     292
     293    // Copy the m_deletedOffsets vector.
     294    Vector<PropertyOffset>* otherDeletedOffsets = other.m_deletedOffsets.get();
     295    if (otherDeletedOffsets)
     296        m_deletedOffsets = adoptPtr(new Vector<PropertyOffset>(*otherDeletedOffsets));
     297}
     298
     299inline PropertyTable::~PropertyTable()
     300{
     301    iterator end = this->end();
     302    for (iterator iter = begin(); iter != end; ++iter)
     303        iter->key->deref();
     304
     305    fastFree(m_index);
     306}
     307
    259308inline PropertyTable::iterator PropertyTable::begin()
    260309{
    … …  
    454503}
    455504
    456 inline PropertyTable* PropertyTable::copy(JSGlobalData& globalData, JSCell* owner, unsigned newCapacity)
     505inline PassOwnPtr<PropertyTable> PropertyTable::copy(JSGlobalData& globalData, JSCell* owner, unsigned newCapacity)
    457506{
    458507    ASSERT(newCapacity >= m_keyCount);
    … …  
    461510    // save rehashing all keys.
    462511    if (sizeForCapacity(newCapacity) == m_indexSize)
    463         return PropertyTable::clone(globalData, owner, *this);
    464     return PropertyTable::clone(globalData, owner, newCapacity, *this);
     512        return adoptPtr(new PropertyTable(globalData, owner, *this));
     513    return adoptPtr(new PropertyTable(globalData, owner, newCapacity, *this));
    465514}
    466515

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

    r144074 r144113  
    248248            ASSERT(!structure->previousID());
    249249
    250             m_propertyTable.set(globalData, this, structure->m_propertyTable->copy(globalData, 0, numberOfSlotsForLastOffset(m_offset, m_inlineCapacity)));
     250            m_propertyTable = structure->m_propertyTable->copy(globalData, 0, numberOfSlotsForLastOffset(m_offset, m_inlineCapacity));
    251251            break;
    252252        }
    … …  
    256256
    257257    if (!m_propertyTable)
    258         createPropertyMap(globalData, numberOfSlotsForLastOffset(m_offset, m_inlineCapacity));
     258        createPropertyMap(numberOfSlotsForLastOffset(m_offset, m_inlineCapacity));
    259259
    260260    for (ptrdiff_t i = structures.size() - 1; i >= 0; --i) {
    … …  
    377377        structure->checkOffsetConsistency();
    378378        if (structure->m_isPinnedPropertyTable)
    379             transition->m_propertyTable.set(globalData, transition, structure->m_propertyTable->copy(globalData, transition, structure->m_propertyTable->size() + 1));
    380         else {
    381             transition->m_propertyTable.set(globalData, transition, structure->m_propertyTable.get());
    382             structure->m_propertyTable.clear();
    383         }
     379            transition->m_propertyTable = structure->m_propertyTable->copy(globalData, transition, structure->m_propertyTable->size() + 1);
     380        else
     381            transition->m_propertyTable = structure->m_propertyTable.release();
    384382    } else {
    385383        if (structure->previousID())
    386384            transition->materializePropertyMap(globalData);
    387385        else
    388             transition->createPropertyMap(globalData);
     386            transition->createPropertyMap();
    389387    }
    390388    transition->m_offset = structure->m_offset;
    … …  
    418416
    419417    structure->materializePropertyMapIfNecessary(globalData);
    420     transition->m_propertyTable.set(globalData, transition, structure->copyPropertyTableForPinning(globalData, transition));
     418    transition->m_propertyTable = structure->copyPropertyTableForPinning(globalData, transition);
    421419    transition->m_offset = structure->m_offset;
    422420    transition->pin();
    … …  
    434432
    435433    structure->materializePropertyMapIfNecessary(globalData);
    436     transition->m_propertyTable.set(globalData, transition, structure->copyPropertyTableForPinning(globalData, transition));
     434    transition->m_propertyTable = structure->copyPropertyTableForPinning(globalData, transition);
    437435    transition->m_offset = structure->m_offset;
    438436    transition->pin();
    … …  
    455453
    456454        structure->materializePropertyMapIfNecessary(globalData);
    457         transition->m_propertyTable.set(globalData, transition, structure->copyPropertyTableForPinning(globalData, transition));
     455        transition->m_propertyTable = structure->copyPropertyTableForPinning(globalData, transition);
    458456        transition->m_offset = structure->m_offset;
    459457        transition->pin();
    … …  
    478476
    479477    structure->materializePropertyMapIfNecessary(globalData);
    480     transition->m_propertyTable.set(globalData, transition, structure->copyPropertyTableForPinning(globalData, transition));
     478    transition->m_propertyTable = structure->copyPropertyTableForPinning(globalData, transition);
    481479    transition->m_offset = structure->m_offset;
    482480    transition->m_dictionaryKind = kind;
    … …  
    538536
    539537    structure->materializePropertyMapIfNecessary(globalData);
    540     transition->m_propertyTable.set(globalData, transition, structure->copyPropertyTableForPinning(globalData, transition));
     538    transition->m_propertyTable = structure->copyPropertyTableForPinning(globalData, transition);
    541539    transition->m_offset = structure->m_offset;
    542540    transition->m_preventExtensions = true;
    … …  
    578576        structure->checkOffsetConsistency();
    579577        if (structure->m_isPinnedPropertyTable)
    580             transition->m_propertyTable.set(globalData, transition, structure->m_propertyTable->copy(globalData, transition, structure->m_propertyTable->size() + 1));
    581         else {
    582             transition->m_propertyTable.set(globalData, transition, structure->m_propertyTable.get());
    583             structure->m_propertyTable.clear();
    584         }
     578            transition->m_propertyTable = structure->m_propertyTable->copy(globalData, transition, structure->m_propertyTable->size() + 1);
     579        else
     580            transition->m_propertyTable = structure->m_propertyTable.release();
    585581    } else {
    586582        if (structure->previousID())
    587583            transition->materializePropertyMap(globalData);
    588584        else
    589             transition->createPropertyMap(globalData);
     585            transition->createPropertyMap();
    590586    }
    591587   
    … …  
    742738#endif
    743739
    744 PropertyTable* Structure::copyPropertyTable(JSGlobalData& globalData, Structure* owner)
    745 {
    746     if (!m_propertyTable)
    747         return 0;
    748     return PropertyTable::clone(globalData, owner, *m_propertyTable.get());
    749 }
    750 
    751 PropertyTable* Structure::copyPropertyTableForPinning(JSGlobalData& globalData, Structure* owner)
    752 {
    753     if (m_propertyTable)
    754         return PropertyTable::clone(globalData, owner, *m_propertyTable.get());
    755     return PropertyTable::create(globalData, numberOfSlotsForLastOffset(m_offset, m_inlineCapacity));
     740PassOwnPtr<PropertyTable> Structure::copyPropertyTable(JSGlobalData& globalData, Structure* owner)
     741{
     742    return adoptPtr(m_propertyTable ? new PropertyTable(globalData, owner, *m_propertyTable) : 0);
     743}
     744
     745PassOwnPtr<PropertyTable> Structure::copyPropertyTableForPinning(JSGlobalData& globalData, Structure* owner)
     746{
     747    return adoptPtr(m_propertyTable ? new PropertyTable(globalData, owner, *m_propertyTable) : new PropertyTable(numberOfSlotsForLastOffset(m_offset, m_inlineCapacity)));
    756748}
    757749
    … …  
    810802
    811803    if (!m_propertyTable)
    812         createPropertyMap(globalData);
     804        createPropertyMap();
    813805
    814806    PropertyOffset newOffset = m_propertyTable->nextOffset(m_inlineCapacity);
    … …  
    842834}
    843835
    844 void Structure::createPropertyMap(JSGlobalData& globalData, unsigned capacity)
     836void Structure::createPropertyMap(unsigned capacity)
    845837{
    846838    ASSERT(!m_propertyTable);
    847839
    848840    checkConsistency();
    849     m_propertyTable.set(globalData, this, PropertyTable::create(globalData, capacity));
     841    m_propertyTable = adoptPtr(new PropertyTable(capacity));
    850842}
    851843
    … …  
    891883    visitor.append(&thisObject->m_previousOrRareData);
    892884    visitor.append(&thisObject->m_specificValueInPrevious);
    893 
    894     if (thisObject->m_isPinnedPropertyTable) {
    895         ASSERT(thisObject->m_propertyTable);
    896         visitor.append(&thisObject->m_propertyTable);
    897     } else if (thisObject->m_propertyTable)
    898         thisObject->m_propertyTable.clear();
     885    if (thisObject->m_propertyTable) {
     886        PropertyTable::iterator end = thisObject->m_propertyTable->end();
     887        for (PropertyTable::iterator ptr = thisObject->m_propertyTable->begin(); ptr != end; ++ptr)
     888            visitor.append(&ptr->specificValue);
     889    }
    899890}
    900891

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

    r144074 r144113  
    3232#include "JSCell.h"
    3333#include "JSType.h"
     34#include "PropertyMapHashTable.h"
    3435#include "PropertyName.h"
    3536#include "PropertyNameArray.h"
    36 #include "PropertyOffset.h"
    3737#include "Protect.h"
    3838#include "StructureRareData.h"
    … …  
    4141#include "Watchpoint.h"
    4242#include "Weak.h"
     43#include <wtf/PassOwnPtr.h>
    4344#include <wtf/PassRefPtr.h>
    4445#include <wtf/RefCounted.h>
    … …  
    5152class PropertyNameArray;
    5253class PropertyNameArrayData;
    53 class PropertyTable;
    5454class StructureChain;
    5555class SlotVisitor;
    … …  
    109109    bool isExtensible() const { return !m_preventExtensions; }
    110110    bool didTransition() const { return m_didTransition; }
    111     bool putWillGrowOutOfLineStorage();
     111    bool putWillGrowOutOfLineStorage()
     112    {
     113        checkOffsetConsistency();
     114           
     115        ASSERT(outOfLineCapacity() >= outOfLineSize());
     116           
     117        if (!m_propertyTable) {
     118            unsigned currentSize = numberOfOutOfLineSlotsForLastOffset(m_offset);
     119            ASSERT(outOfLineCapacity() >= currentSize);
     120            return currentSize == outOfLineCapacity();
     121        }
     122           
     123        ASSERT(totalStorageCapacity() >= m_propertyTable->propertyStorageSize());
     124        if (m_propertyTable->hasDeletedOffset())
     125            return false;
     126           
     127        ASSERT(totalStorageCapacity() >= m_propertyTable->size());
     128        return m_propertyTable->size() == totalStorageCapacity();
     129    }
    112130    JS_EXPORT_PRIVATE size_t suggestedNewOutOfLineStorageCapacity();
    113131
    … …  
    365383    PropertyOffset remove(PropertyName);
    366384
    367     void createPropertyMap(JSGlobalData&, unsigned keyCount = 0);
     385    void createPropertyMap(unsigned keyCount = 0);
    368386    void checkConsistency();
    369387
    … …  
    371389    void despecifyAllFunctions(JSGlobalData&);
    372390
    373     PropertyTable* copyPropertyTable(JSGlobalData&, Structure* owner);
    374     PropertyTable* copyPropertyTableForPinning(JSGlobalData&, Structure* owner);
     391    PassOwnPtr<PropertyTable> copyPropertyTable(JSGlobalData&, Structure* owner);
     392    PassOwnPtr<PropertyTable> copyPropertyTableForPinning(JSGlobalData&, Structure* owner);
    375393    JS_EXPORT_PRIVATE void materializePropertyMap(JSGlobalData&);
    376394    void materializePropertyMapIfNecessary(JSGlobalData& globalData)
    … …  
    428446    }
    429447       
    430     bool checkOffsetConsistency() const;
     448    ALWAYS_INLINE bool checkOffsetConsistency() const
     449    {
     450        if (!m_propertyTable) {
     451            ASSERT(!m_isPinnedPropertyTable);
     452            return true;
     453        }
     454           
     455        RELEASE_ASSERT(numberOfSlotsForLastOffset(m_offset, m_inlineCapacity) == m_propertyTable->propertyStorageSize());
     456        unsigned totalSize = m_propertyTable->propertyStorageSize();
     457        RELEASE_ASSERT((totalSize < inlineCapacity() ? 0 : totalSize - inlineCapacity()) == numberOfOutOfLineSlotsForLastOffset(m_offset));
     458           
     459        return true;
     460    }
    431461
    432462    void allocateRareData(JSGlobalData&);
    … …  
    453483    StructureTransitionTable m_transitionTable;
    454484
    455     WriteBarrier<PropertyTable> m_propertyTable;
     485    OwnPtr<PropertyTable> m_propertyTable;
    456486
    457487    mutable InlineWatchpointSet m_transitionWatchpointSet;

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

    r144074 r144113  
    2727#define StructureInlines_h
    2828
    29 #include "PropertyMapHashTable.h"
    3029#include "Structure.h"
    3130
    … …  
    181180}
    182181
    183 inline bool Structure::putWillGrowOutOfLineStorage()
    184 {
    185     checkOffsetConsistency();
    186 
    187     ASSERT(outOfLineCapacity() >= outOfLineSize());
    188 
    189     if (!m_propertyTable) {
    190         unsigned currentSize = numberOfOutOfLineSlotsForLastOffset(m_offset);
    191         ASSERT(outOfLineCapacity() >= currentSize);
    192         return currentSize == outOfLineCapacity();
    193     }
    194 
    195     ASSERT(totalStorageCapacity() >= m_propertyTable->propertyStorageSize());
    196     if (m_propertyTable->hasDeletedOffset())
    197         return false;
    198 
    199     ASSERT(totalStorageCapacity() >= m_propertyTable->size());
    200     return m_propertyTable->size() == totalStorageCapacity();
    201 }
    202 
    203 ALWAYS_INLINE bool Structure::checkOffsetConsistency() const
    204 {
    205     if (!m_propertyTable) {
    206         ASSERT(!m_isPinnedPropertyTable);
    207         return true;
    208     }
    209 
    210     RELEASE_ASSERT(numberOfSlotsForLastOffset(m_offset, m_inlineCapacity) == m_propertyTable->propertyStorageSize());
    211     unsigned totalSize = m_propertyTable->propertyStorageSize();
    212     RELEASE_ASSERT((totalSize < inlineCapacity() ? 0 : totalSize - inlineCapacity()) == numberOfOutOfLineSlotsForLastOffset(m_offset));
    213 
    214     return true;
    215 }
    216 
    217182} // namespace JSC
    218183
Note: See TracChangeset for help on using the changeset viewer.