Ignore:
Timestamp:
Jan 31, 2011, 12:07:21 PM (14 years ago)
Author:
[email protected]
Message:

2011-01-31 Oliver Hunt <​[email protected]>

Convert markstack to a slot visitor API
​https://bugs.webkit.org/show_bug.cgi?id=53219

rolling r77098, r77099, r77100, r77109, and
r77111 back in, along with a few more Qt fix attempts.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r77113 r77151  
    189189        m_storage->m_length = initialLength;
    190190        m_storage->m_numValuesInVector = 0;
    191         JSValue* vector = m_storage->m_vector;
     191        WriteBarrier<Unknown>* vector = m_storage->m_vector;
    192192        for (size_t i = 0; i < initialCapacity; ++i)
    193             vector[i] = JSValue();
     193            vector[i].clear();
    194194    }
    195195
    … …  
    199199}
    200200
    201 JSArray::JSArray(NonNullPassRefPtr<Structure> structure, const ArgList& list)
     201JSArray::JSArray(JSGlobalData& globalData, NonNullPassRefPtr<Structure> structure, const ArgList& list)
    202202    : JSObject(structure)
    203203{
    … …  
    226226
    227227    size_t i = 0;
    228     JSValue* vector = m_storage->m_vector;
     228    WriteBarrier<Unknown>* vector = m_storage->m_vector;
    229229    ArgList::const_iterator end = list.end();
    230230    for (ArgList::const_iterator it = list.begin(); it != end; ++it, ++i)
    231         vector[i] = *it;
     231        vector[i].set(globalData, this, *it);
    232232    for (; i < initialStorage; i++)
    233         vector[i] = JSValue();
     233        vector[i].clear();
    234234
    235235    checkConsistency();
    … …  
    258258
    259259    if (i < m_vectorLength) {
    260         JSValue& valueSlot = storage->m_vector[i];
     260        WriteBarrier<Unknown>& valueSlot = storage->m_vector[i];
    261261        if (valueSlot) {
    262             slot.setValueSlot(&valueSlot);
     262            slot.setValueSlot(valueSlot.slot());
    263263            return true;
    264264        }
    … …  
    267267            SparseArrayValueMap::iterator it = map->find(i);
    268268            if (it != map->end()) {
    269                 slot.setValueSlot(&it->second);
     269                slot.setValueSlot(it->second.slot());
    270270                return true;
    271271            }
    … …  
    306306            return false;
    307307        if (i < m_vectorLength) {
    308             JSValue& value = storage->m_vector[i];
     308            WriteBarrier<Unknown>& value = storage->m_vector[i];
    309309            if (value) {
    310                 descriptor.setDescriptor(value, 0);
     310                descriptor.setDescriptor(value.get(), 0);
    311311                return true;
    312312            }
    … …  
    315315                SparseArrayValueMap::iterator it = map->find(i);
    316316                if (it != map->end()) {
    317                     descriptor.setDescriptor(it->second, 0);
     317                    descriptor.setDescriptor(it->second.get(), 0);
    318318                    return true;
    319319                }
    … …  
    360360
    361361    if (i < m_vectorLength) {
    362         JSValue& valueSlot = storage->m_vector[i];
     362        WriteBarrier<Unknown>& valueSlot = storage->m_vector[i];
    363363        if (valueSlot) {
    364             valueSlot = value;
     364            valueSlot.set(exec->globalData(), this, value);
    365365            checkConsistency();
    366366            return;
    367367        }
    368         valueSlot = value;
     368        valueSlot.set(exec->globalData(), this, value);
    369369        ++storage->m_numValuesInVector;
    370370        checkConsistency();
    … …  
    396396            }
    397397
    398             pair<SparseArrayValueMap::iterator, bool> result = map->add(i, value);
    399             if (!result.second) { // pre-existing entry
    400                 result.first->second = value;
     398            WriteBarrier<Unknown> temp;
     399            pair<SparseArrayValueMap::iterator, bool> result = map->add(i, temp);
     400            result.first->second.set(exec->globalData(), this, value);
     401            if (!result.second) // pre-existing entry
    401402                return;
    402             }
    403403
    404404            size_t capacity = map->capacity();
    … …  
    416416        if (increaseVectorLength(i + 1)) {
    417417            storage = m_storage;
    418             storage->m_vector[i] = value;
     418            storage->m_vector[i].set(exec->globalData(), this, value);
    419419            ++storage->m_numValuesInVector;
    420420            checkConsistency();
    … …  
    458458   
    459459    unsigned vectorLength = m_vectorLength;
    460     JSValue* vector = storage->m_vector;
     460    WriteBarrier<Unknown>* vector = storage->m_vector;
    461461
    462462    if (newNumValuesInVector == storage->m_numValuesInVector + 1) {
    463463        for (unsigned j = vectorLength; j < newVectorLength; ++j)
    464             vector[j] = JSValue();
     464            vector[j].clear();
    465465        if (i > MIN_SPARSE_ARRAY_INDEX)
    466466            map->remove(i);
    467467    } else {
    468468        for (unsigned j = vectorLength; j < max(vectorLength, MIN_SPARSE_ARRAY_INDEX); ++j)
    469             vector[j] = JSValue();
     469            vector[j].clear();
     470        JSGlobalData& globalData = exec->globalData();
    470471        for (unsigned j = max(vectorLength, MIN_SPARSE_ARRAY_INDEX); j < newVectorLength; ++j)
    471             vector[j] = map->take(j);
     472            vector[j].set(globalData, this, map->take(j).get());
    472473    }
    473474
    … …  
    477478    storage->m_numValuesInVector = newNumValuesInVector;
    478479
    479     storage->m_vector[i] = value;
     480    storage->m_vector[i].set(exec->globalData(), this, value);
    480481
    481482    checkConsistency();
    … …  
    504505   
    505506    if (i < m_vectorLength) {
    506         JSValue& valueSlot = storage->m_vector[i];
     507        WriteBarrier<Unknown>& valueSlot = storage->m_vector[i];
    507508        if (!valueSlot) {
    508509            checkConsistency();
    509510            return false;
    510511        }
    511         valueSlot = JSValue();
     512        valueSlot.clear();
    512513        --storage->m_numValuesInVector;
    513514        checkConsistency();
    … …  
    606607    m_storage->m_allocBase = baseStorage;
    607608
    608     JSValue* vector = storage->m_vector;
     609    WriteBarrier<Unknown>* vector = storage->m_vector;
    609610    for (unsigned i = vectorLength; i < newVectorLength; ++i)
    610         vector[i] = JSValue();
     611        vector[i].clear();
    611612
    612613    m_vectorLength = newVectorLength;
    … …  
    667668        unsigned usedVectorLength = min(length, m_vectorLength);
    668669        for (unsigned i = newLength; i < usedVectorLength; ++i) {
    669             JSValue& valueSlot = storage->m_vector[i];
     670            WriteBarrier<Unknown>& valueSlot = storage->m_vector[i];
    670671            bool hadValue = valueSlot;
    671             valueSlot = JSValue();
     672            valueSlot.clear();
    672673            storage->m_numValuesInVector -= hadValue;
    673674        }
    … …  
    707708
    708709    if (length < m_vectorLength) {
    709         JSValue& valueSlot = storage->m_vector[length];
     710        WriteBarrier<Unknown>& valueSlot = storage->m_vector[length];
    710711        if (valueSlot) {
    711712            --storage->m_numValuesInVector;
    712             result = valueSlot;
    713             valueSlot = JSValue();
     713            result = valueSlot.get();
     714            valueSlot.clear();
    714715        } else
    715716            result = jsUndefined();
    … …  
    719720            SparseArrayValueMap::iterator it = map->find(length);
    720721            if (it != map->end()) {
    721                 result = it->second;
     722                result = it->second.get();
    722723                map->remove(it);
    723724                if (map->isEmpty()) {
    … …  
    743744
    744745    if (storage->m_length < m_vectorLength) {
    745         storage->m_vector[storage->m_length] = value;
     746        storage->m_vector[storage->m_length].set(exec->globalData(), this, value);
    746747        ++storage->m_numValuesInVector;
    747748        ++storage->m_length;
    … …  
    755756            if (increaseVectorLength(storage->m_length + 1)) {
    756757                storage = m_storage;
    757                 storage->m_vector[storage->m_length] = value;
     758                storage->m_vector[storage->m_length].set(exec->globalData(), this, value);
    758759                ++storage->m_numValuesInVector;
    759760                ++storage->m_length;
    … …  
    858859    }
    859860
    860     JSValue* vector = m_storage->m_vector;
     861    WriteBarrier<Unknown>* vector = m_storage->m_vector;
    861862    for (int i = 0; i < count; i++)
    862         vector[i] = JSValue();
     863        vector[i].clear();
    863864}
    864865
    … …  
    942943
    943944    for (size_t i = 0; i < lengthNotIncludingUndefined; i++) {
    944         JSValue value = storage->m_vector[i];
     945        JSValue value = storage->m_vector[i].get();
    945946        ASSERT(!value.isUndefined());
    946947        values[i].first = value;
    … …  
    975976    if (storage->m_length < lengthNotIncludingUndefined)
    976977        storage->m_length = lengthNotIncludingUndefined;
    977        
     978
     979    JSGlobalData& globalData = exec->globalData();
    978980    for (size_t i = 0; i < lengthNotIncludingUndefined; i++)
    979         storage->m_vector[i] = values[i].first;
     981        storage->m_vector[i].set(globalData, this, values[i].first);
    980982
    981983    Heap::heap(this)->popTempSortVector(&values);
    … …  
    11061108    // Iterate over the array, ignoring missing values, counting undefined ones, and inserting all other ones into the tree.
    11071109    for (; numDefined < usedVectorLength; ++numDefined) {
    1108         JSValue v = storage->m_vector[numDefined];
     1110        JSValue v = storage->m_vector[numDefined].get();
    11091111        if (!v || v.isUndefined())
    11101112            break;
    … …  
    11131115    }
    11141116    for (unsigned i = numDefined; i < usedVectorLength; ++i) {
    1115         JSValue v = storage->m_vector[i];
     1117        JSValue v = storage->m_vector[i].get();
    11161118        if (v) {
    11171119            if (v.isUndefined())
    … …  
    11411143        SparseArrayValueMap::iterator end = map->end();
    11421144        for (SparseArrayValueMap::iterator it = map->begin(); it != end; ++it) {
    1143             tree.abstractor().m_nodes[numDefined].value = it->second;
     1145            tree.abstractor().m_nodes[numDefined].value = it->second.get();
    11441146            tree.insert(numDefined);
    11451147            ++numDefined;
    … …  
    11581160    AVLTree<AVLTreeAbstractorForArrayCompare, 44>::Iterator iter;
    11591161    iter.start_iter_least(tree);
     1162    JSGlobalData& globalData = exec->globalData();
    11601163    for (unsigned i = 0; i < numDefined; ++i) {
    1161         storage->m_vector[i] = tree.abstractor().m_nodes[*iter].value;
     1164        storage->m_vector[i].set(globalData, this, tree.abstractor().m_nodes[*iter].value);
    11621165        ++iter;
    11631166    }
    … …  
    11651168    // Put undefined values back in.
    11661169    for (unsigned i = numDefined; i < newUsedVectorLength; ++i)
    1167         storage->m_vector[i] = jsUndefined();
     1170        storage->m_vector[i].setUndefined();
    11681171
    11691172    // Ensure that unused values in the vector are zeroed out.
    11701173    for (unsigned i = newUsedVectorLength; i < usedVectorLength; ++i)
    1171         storage->m_vector[i] = JSValue();
     1174        storage->m_vector[i].clear();
    11721175
    11731176    storage->m_numValuesInVector = newUsedVectorLength;
    … …  
    11801183    ArrayStorage* storage = m_storage;
    11811184
    1182     JSValue* vector = storage->m_vector;
     1185    WriteBarrier<Unknown>* vector = storage->m_vector;
    11831186    unsigned vectorEnd = min(storage->m_length, m_vectorLength);
    11841187    unsigned i = 0;
    11851188    for (; i < vectorEnd; ++i) {
    1186         JSValue& v = vector[i];
     1189        WriteBarrier<Unknown>& v = vector[i];
    11871190        if (!v)
    11881191            break;
    1189         args.append(v);
     1192        args.append(v.get());
    11901193    }
    11911194
    … …  
    11981201    ASSERT(m_storage->m_length >= maxSize);
    11991202    UNUSED_PARAM(maxSize);
    1200     JSValue* vector = m_storage->m_vector;
     1203    WriteBarrier<Unknown>* vector = m_storage->m_vector;
    12011204    unsigned vectorEnd = min(maxSize, m_vectorLength);
    12021205    unsigned i = 0;
    12031206    for (; i < vectorEnd; ++i) {
    1204         JSValue& v = vector[i];
     1207        WriteBarrier<Unknown>& v = vector[i];
    12051208        if (!v)
    12061209            break;
    1207         buffer[i] = v;
     1210        buffer[i] = v.get();
    12081211    }
    12091212
    … …  
    12241227
    12251228    for (; numDefined < usedVectorLength; ++numDefined) {
    1226         JSValue v = storage->m_vector[numDefined];
     1229        JSValue v = storage->m_vector[numDefined].get();
    12271230        if (!v || v.isUndefined())
    12281231            break;
    12291232    }
     1233
    12301234    for (unsigned i = numDefined; i < usedVectorLength; ++i) {
    1231         JSValue v = storage->m_vector[i];
     1235        JSValue v = storage->m_vector[i].get();
    12321236        if (v) {
    12331237            if (v.isUndefined())
    12341238                ++numUndefined;
    12351239            else
    1236                 storage->m_vector[numDefined++] = v;
     1240                storage->m_vector[numDefined++].setWithoutWriteBarrier(v);
    12371241        }
    12381242    }
    … …  
    12531257        SparseArrayValueMap::iterator end = map->end();
    12541258        for (SparseArrayValueMap::iterator it = map->begin(); it != end; ++it)
    1255             storage->m_vector[numDefined++] = it->second;
     1259            storage->m_vector[numDefined++].setWithoutWriteBarrier(it->second.get());
    12561260
    12571261        delete map;
    … …  
    12601264
    12611265    for (unsigned i = numDefined; i < newUsedVectorLength; ++i)
    1262         storage->m_vector[i] = jsUndefined();
     1266        storage->m_vector[i].setUndefined();
    12631267    for (unsigned i = newUsedVectorLength; i < usedVectorLength; ++i)
    1264         storage->m_vector[i] = JSValue();
     1268        storage->m_vector[i].clear();
    12651269
    12661270    storage->m_numValuesInVector = newUsedVectorLength;
Note: See TracChangeset for help on using the changeset viewer.