Changeset 87343 in webkit


Ignore:
Timestamp:
May 25, 2011 6:01:16 PM (13 years ago)
Author:
oliver@apple.com
Message:

2011-05-25 Oliver Hunt <​oliver@apple.com>

Reviewed by Geoffrey Garen.

Make RegExp GC allocated
​https://bugs.webkit.org/show_bug.cgi?id=61490

Make RegExp GC allocated. Basically mechanical change to replace
most use of [Pass]RefPtr<RegExp> with RegExp* or WriteBarrier<RegExp>
where actual ownership happens.

Made the RegExpCache use Strong<> references currently to avoid any
changes in behaviour.

  • JavaScriptCore.exp:
  • bytecode/CodeBlock.cpp: (JSC::CodeBlock::visitAggregate):
  • bytecode/CodeBlock.h: (JSC::CodeBlock::addRegExp):
  • bytecompiler/BytecodeGenerator.cpp: (JSC::BytecodeGenerator::addRegExp): (JSC::BytecodeGenerator::emitNewRegExp):
  • bytecompiler/BytecodeGenerator.h:
  • runtime/JSCell.h:
  • runtime/JSGlobalData.cpp: (JSC::JSGlobalData::JSGlobalData): (JSC::JSGlobalData::clearBuiltinStructures): (JSC::JSGlobalData::addRegExpToTrace):
  • runtime/JSGlobalData.h:
  • runtime/JSGlobalObject.cpp: (JSC::JSGlobalObject::reset):
  • runtime/RegExp.cpp: (JSC::RegExp::RegExp): (JSC::RegExp::create): (JSC::RegExp::invalidateCode):
  • runtime/RegExp.h: (JSC::RegExp::createStructure):
  • runtime/RegExpCache.cpp: (JSC::RegExpCache::lookupOrCreate): (JSC::RegExpCache::create):
  • runtime/RegExpCache.h:
  • runtime/RegExpConstructor.cpp: (JSC::constructRegExp):
  • runtime/RegExpObject.cpp: (JSC::RegExpObject::RegExpObject): (JSC::RegExpObject::visitChildren):
  • runtime/RegExpObject.h: (JSC::RegExpObject::setRegExp): (JSC::RegExpObject::RegExpObjectData::RegExpObjectData):
  • runtime/RegExpPrototype.cpp: (JSC::RegExpPrototype::RegExpPrototype): (JSC::regExpProtoFuncCompile):
  • runtime/RegExpPrototype.h:
  • runtime/StringPrototype.cpp: (JSC::stringProtoFuncMatch): (JSC::stringProtoFuncSearch):

2011-05-25 Oliver Hunt <​oliver@apple.com>

Reviewed by Geoffrey Garen.

Make RegExp GC allocated
​https://bugs.webkit.org/show_bug.cgi?id=61490

RegExp is GC'd so we don't need the RefPtr shenanigans anymore.

  • bindings/js/SerializedScriptValue.cpp: (WebCore::CloneDeserializer::readTerminal):
Location:
trunk/Source
Files:
26 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r87327 r87343  
     12011-05-25  Oliver Hunt  <oliver@apple.com>
     2
     3        Reviewed by Geoffrey Garen.
     4
     5        Make RegExp GC allocated
     6        https://bugs.webkit.org/show_bug.cgi?id=61490
     7
     8        Make RegExp GC allocated.  Basically mechanical change to replace
     9        most use of [Pass]RefPtr<RegExp> with RegExp* or WriteBarrier<RegExp>
     10        where actual ownership happens.
     11
     12        Made the RegExpCache use Strong<> references currently to avoid any
     13        changes in behaviour.
     14
     15        * JavaScriptCore.exp:
     16        * bytecode/CodeBlock.cpp:
     17        (JSC::CodeBlock::visitAggregate):
     18        * bytecode/CodeBlock.h:
     19        (JSC::CodeBlock::addRegExp):
     20        * bytecompiler/BytecodeGenerator.cpp:
     21        (JSC::BytecodeGenerator::addRegExp):
     22        (JSC::BytecodeGenerator::emitNewRegExp):
     23        * bytecompiler/BytecodeGenerator.h:
     24        * runtime/JSCell.h:
     25        * runtime/JSGlobalData.cpp:
     26        (JSC::JSGlobalData::JSGlobalData):
     27        (JSC::JSGlobalData::clearBuiltinStructures):
     28        (JSC::JSGlobalData::addRegExpToTrace):
     29        * runtime/JSGlobalData.h:
     30        * runtime/JSGlobalObject.cpp:
     31        (JSC::JSGlobalObject::reset):
     32        * runtime/RegExp.cpp:
     33        (JSC::RegExp::RegExp):
     34        (JSC::RegExp::create):
     35        (JSC::RegExp::invalidateCode):
     36        * runtime/RegExp.h:
     37        (JSC::RegExp::createStructure):
     38        * runtime/RegExpCache.cpp:
     39        (JSC::RegExpCache::lookupOrCreate):
     40        (JSC::RegExpCache::create):
     41        * runtime/RegExpCache.h:
     42        * runtime/RegExpConstructor.cpp:
     43        (JSC::constructRegExp):
     44        * runtime/RegExpObject.cpp:
     45        (JSC::RegExpObject::RegExpObject):
     46        (JSC::RegExpObject::visitChildren):
     47        * runtime/RegExpObject.h:
     48        (JSC::RegExpObject::setRegExp):
     49        (JSC::RegExpObject::RegExpObjectData::RegExpObjectData):
     50        * runtime/RegExpPrototype.cpp:
     51        (JSC::RegExpPrototype::RegExpPrototype):
     52        (JSC::regExpProtoFuncCompile):
     53        * runtime/RegExpPrototype.h:
     54        * runtime/StringPrototype.cpp:
     55        (JSC::stringProtoFuncMatch):
     56        (JSC::stringProtoFuncSearch):
     57
    1582011-05-25  Oliver Hunt  <oliver@apple.com>
    259

  • trunk/Source/JavaScriptCore/JavaScriptCore.exp

    r87198 r87343  
    138138__ZN3JSC12JSGlobalDataD1Ev
    139139__ZN3JSC12RegExpObject6s_infoE
    140 __ZN3JSC12RegExpObjectC1EPNS_14JSGlobalObjectEPNS_9StructureEN3WTF17NonNullPassRefPtrINS_6RegExpEEE
     140__ZN3JSC12RegExpObjectC1EPNS_14JSGlobalObjectEPNS_9StructureEPNS_6RegExpE
    141141__ZN3JSC12SamplingTool5setupEv
    142142__ZN3JSC12SmallStrings17createEmptyStringEPNS_12JSGlobalDataE

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

    r87184 r87343  
    1919    ??0Mutex@WTF@@QAE@XZ
    2020    ??0RefCountedLeakCounter@WTF@@QAE@PBD@Z
    21     ??0RegExpObject@JSC@@QAE@PAVJSGlobalObject@1@PAVStructure@1@V?$NonNullPassRefPtr@VRegExp@JSC@@@WTF@@@Z
     21    ??0RegExpObject@JSC@@QAE@PAVJSGlobalObject@1@PAVStructure@1@PAVRegExp@1@JSC@@@WTF@@@Z
    2222    ??0SHA1@WTF@@QAE@XZ
    2323    ??0StringObject@JSC@@QAE@PAVExecState@1@PAVStructure@1@ABVUString@1@@Z

  • trunk/Source/JavaScriptCore/bytecode/CodeBlock.cpp

    r87190 r87343  
    14711471    visitor.append(&m_globalObject);
    14721472    visitor.append(&m_ownerExecutable);
    1473     if (m_rareData)
     1473    if (m_rareData) {
    14741474        m_rareData->m_evalCodeCache.visitAggregate(visitor);
     1475        size_t regExpCount = m_rareData->m_regexps.size();
     1476        WriteBarrier<RegExp>* regexps = m_rareData->m_regexps.data();
     1477        for (size_t i = 0; i < regExpCount; i++)
     1478            visitor.append(regexps + i);
     1479    }
    14751480    visitor.appendValues(m_constantRegisters.data(), m_constantRegisters.size());
    14761481    for (size_t i = 0; i < m_functionExprs.size(); ++i)

  • trunk/Source/JavaScriptCore/bytecode/CodeBlock.h

    r85523 r87343  
    3737#include "JumpTable.h"
    3838#include "Nodes.h"
    39 #include "RegExp.h"
     39#include "RegExpObject.h"
    4040#include "UString.h"
    4141#include <wtf/FastAllocBase.h>
    … …  
    452452        FunctionExecutable* functionExpr(int index) { return m_functionExprs[index].get(); }
    453453
    454         unsigned addRegExp(PassRefPtr<RegExp> r) { createRareDataIfNecessary(); unsigned size = m_rareData->m_regexps.size(); m_rareData->m_regexps.append(r); return size; }
     454        unsigned addRegExp(RegExp* r)
     455        {
     456            createRareDataIfNecessary();
     457            unsigned size = m_rareData->m_regexps.size();
     458            m_rareData->m_regexps.append(WriteBarrier<RegExp>(*m_globalData, ownerExecutable(), r));
     459            return size;
     460        }
    455461        RegExp* regexp(int index) const { ASSERT(m_rareData); return m_rareData->m_regexps[index].get(); }
    456462
    … …  
    556562
    557563            // Rare Constants
    558             Vector<RefPtr<RegExp> > m_regexps;
     564            Vector<WriteBarrier<RegExp> > m_regexps;
    559565
    560566            // Jump Tables

  • trunk/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp

    r85523 r87343  
    967967}
    968968
    969 unsigned BytecodeGenerator::addRegExp(PassRefPtr<RegExp> r)
     969unsigned BytecodeGenerator::addRegExp(RegExp* r)
    970970{
    971971    return m_codeBlock->addRegExp(r);
    … …  
    15931593}
    15941594
    1595 RegisterID* BytecodeGenerator::emitNewRegExp(RegisterID* dst, PassRefPtr<RegExp> regExp)
     1595RegisterID* BytecodeGenerator::emitNewRegExp(RegisterID* dst, RegExp* regExp)
    15961596{
    15971597    emitOpcode(op_new_regexp);

  • trunk/Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h

    r87304 r87343  
    292292        RegisterID* emitNewFunctionInternal(RegisterID* dst, unsigned index, bool shouldNullCheck);
    293293        RegisterID* emitNewFunctionExpression(RegisterID* dst, FuncExprNode* func);
    294         RegisterID* emitNewRegExp(RegisterID* dst, PassRefPtr<RegExp> regExp);
     294        RegisterID* emitNewRegExp(RegisterID* dst, RegExp*);
    295295
    296296        RegisterID* emitMove(RegisterID* dst, RegisterID* src);
    … …  
    476476        unsigned addConstant(const Identifier&);
    477477        RegisterID* addConstantValue(JSValue);
    478         unsigned addRegExp(PassRefPtr<RegExp>);
     478        unsigned addRegExp(RegExp*);
    479479
    480480        FunctionExecutable* makeFunction(ExecState* exec, FunctionBodyNode* body)

  • trunk/Source/JavaScriptCore/jit/JITStubs.cpp

    r86699 r87343  
    31643164    CallFrame* callFrame = stackFrame.callFrame;
    31653165
    3166     RegExp* regExp = stackFrame.args[0].regExp();
    3167     if (!regExp->isValid()) {
     3166    RegExpHolder* regExp = stackFrame.args[0].regExp();
     3167    if (!regExp->get()->isValid()) {
    31683168        stackFrame.globalData->exception = createSyntaxError(callFrame, "Invalid flags supplied to RegExp constructor.");
    31693169        VM_THROW_EXCEPTION();

  • trunk/Source/JavaScriptCore/jit/JITStubs.h

    r86510 r87343  
    5858    class PutPropertySlot;
    5959    class RegisterFile;
    60     class RegExp;
     60    class RegExpHolder;
    6161
    6262    template <typename T> class Weak;
    … …  
    7373        CodeBlock* codeBlock() { return static_cast<CodeBlock*>(asPointer); }
    7474        FunctionExecutable* function() { return static_cast<FunctionExecutable*>(asPointer); }
    75         RegExp* regExp() { return static_cast<RegExp*>(asPointer); }
     75        RegExpHolder* regExp() { return static_cast<RegExpHolder*>(asPointer); }
    7676        JSPropertyNameIterator* propertyNameIterator() { return static_cast<JSPropertyNameIterator*>(asPointer); }
    7777        JSGlobalObject* globalObject() { return static_cast<JSGlobalObject*>(asPointer); }

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

    r86974 r87343  
    7272        friend class Structure;
    7373        friend class StructureChain;
     74        friend class RegExp;
    7475        enum CreatingEarlyCellTag { CreatingEarlyCell };
    7576

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

    r86785 r87343  
    5353#include "Parser.h"
    5454#include "RegExpCache.h"
     55#include "RegExpObject.h"
    5556#include "StrictEvalActivation.h"
    5657#include <wtf/WTFThreadData.h>
    … …  
    220221    functionExecutableStructure.set(*this, FunctionExecutable::createStructure(*this, jsNull()));
    221222    dummyMarkableCellStructure.set(*this, JSCell::createDummyStructure(*this));
     223    regExpStructure.set(*this, RegExp::createStructure(*this, jsNull()));
    222224    structureChainStructure.set(*this, StructureChain::createStructure(*this, jsNull()));
    223225
    … …  
    280282    functionExecutableStructure.clear();
    281283    dummyMarkableCellStructure.clear();
     284    regExpStructure.clear();
    282285    structureChainStructure.clear();
    283    
     286
    284287#if ENABLE(JSC_ZOMBIES)
    285288    zombieStructure.clear();
    … …  
    447450
    448451#if ENABLE(REGEXP_TRACING)
    449 void JSGlobalData::addRegExpToTrace(PassRefPtr<RegExp> regExp)
     452void JSGlobalData::addRegExpToTrace(RegExp* regExp)
    450453{
    451454    m_rtTraceList->add(regExp);

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

    r86785 r87343  
    175175        Strong<Structure> functionExecutableStructure;
    176176        Strong<Structure> dummyMarkableCellStructure;
     177        Strong<Structure> regExpStructure;
    177178        Strong<Structure> structureChainStructure;
    178179

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

    r86837 r87343  
    223223    m_dateStructure.set(exec->globalData(), this, DateInstance::createStructure(exec->globalData(), m_datePrototype.get()));
    224224
    225     m_regExpPrototype.set(exec->globalData(), this, new (exec) RegExpPrototype(exec, this, RegExpPrototype::createStructure(exec->globalData(), m_objectPrototype.get())));
     225    RegExp* emptyRegex = RegExp::create(&exec->globalData(), "", NoFlags);
     226   
     227    m_regExpPrototype.set(exec->globalData(), this, new (exec) RegExpPrototype(exec, this, RegExpPrototype::createStructure(exec->globalData(), m_objectPrototype.get()), emptyRegex));
    226228    m_regExpStructure.set(exec->globalData(), this, RegExpObject::createStructure(exec->globalData(), m_regExpPrototype.get()));
    227229

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

    r87327 r87343  
    3535namespace JSC {
    3636
     37const ClassInfo RegExp::s_info = { "RegExp", 0, 0, 0 };
     38
    3739RegExpFlags regExpFlags(const UString& string)
    3840{
    … …  
    7476};
    7577
    76 inline RegExp::RegExp(JSGlobalData*, const UString& patternString, RegExpFlags flags)
    77     : m_state(NotCompiled)
     78inline RegExp::RegExp(JSGlobalData* globalData, const UString& patternString, RegExpFlags flags)
     79    : JSCell(*globalData, globalData->regExpStructure.get())
     80    , m_state(NotCompiled)
    7881    , m_patternString(patternString)
    7982    , m_flags(flags)
    … …  
    9699}
    97100
    98 PassRefPtr<RegExp> RegExp::create(JSGlobalData* globalData, const UString& patternString, RegExpFlags flags)
    99 {
    100     RefPtr<RegExp> res = adoptRef(new RegExp(globalData, patternString, flags));
     101RegExp* RegExp::create(JSGlobalData* globalData, const UString& patternString, RegExpFlags flags)
     102{
     103    RegExp* res = new (globalData) RegExp(globalData, patternString, flags);
    101104#if ENABLE(REGEXP_TRACING)
    102105    globalData->addRegExpToTrace(res);
    103106#endif
    104     return res.release();
     107    return res;
    105108}
    106109
    … …  
    195198}
    196199
     200void RegExp::invalidateCode()
     201{
     202    m_representation.clear();
     203}
    197204
    198205#if ENABLE(YARR_JIT_DEBUG)

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

    r87327 r87343  
    2525#include "UString.h"
    2626#include "ExecutableAllocator.h"
     27#include "Structure.h"
    2728#include "RegExpKey.h"
    2829#include <wtf/Forward.h>
    … …  
    3637    RegExpFlags regExpFlags(const UString&);
    3738
    38     class RegExp : public RefCounted<RegExp> {
     39    class RegExp : public JSCell {
    3940    public:
    40         static PassRefPtr<RegExp> create(JSGlobalData* globalData, const UString& pattern, RegExpFlags);
     41        static RegExp* create(JSGlobalData*, const UString& pattern, RegExpFlags);
    4142        ~RegExp();
    4243
    … …  
    5354        unsigned numSubpatterns() const { return m_numSubpatterns; }
    5455       
     56        void invalidateCode();
     57       
    5558#if ENABLE(REGEXP_TRACING)
    5659        void printTraceData();
    5760#endif
    5861
     62        static Structure* createStructure(JSGlobalData& globalData, JSValue prototype)
     63        {
     64            return Structure::create(globalData, prototype, TypeInfo(LeafType, 0), 0, &s_info);
     65        }
     66       
     67        static JS_EXPORTDATA const ClassInfo s_info;
     68       
    5969    private:
    6070        RegExp(JSGlobalData* globalData, const UString& pattern, RegExpFlags);

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

    r80667 r87343  
    2929
    3030#include "RegExpCache.h"
     31#include "RegExpObject.h"
    3132
    3233namespace JSC {
    3334
    34 PassRefPtr<RegExp> RegExpCache::lookupOrCreate(const UString& patternString, RegExpFlags flags)
     35RegExp* RegExpCache::lookupOrCreate(const UString& patternString, RegExpFlags flags)
    3536{
    3637    if (patternString.length() < maxCacheablePatternLength) {
    37         pair<RegExpCacheMap::iterator, bool> result = m_cacheMap.add(RegExpKey(flags, patternString), 0);
     38        pair<RegExpCacheMap::iterator, bool> result = m_cacheMap.add(RegExpKey(flags, patternString), Strong<RegExp>());
    3839        if (!result.second)
    39             return result.first->second;
     40            return result.first->second.get();
    4041        else
    4142            return create(patternString, flags, result.first);
    … …  
    4445}
    4546
    46 PassRefPtr<RegExp> RegExpCache::create(const UString& patternString, RegExpFlags flags, RegExpCacheMap::iterator iterator)
     47RegExp* RegExpCache::create(const UString& patternString, RegExpFlags flags, RegExpCacheMap::iterator iterator)
    4748{
    48     RefPtr<RegExp> regExp = RegExp::create(m_globalData, patternString, flags);
    49 
     49    RegExp* regExp = RegExp::create(m_globalData, patternString, flags);
    5050    if (patternString.length() >= maxCacheablePatternLength)
    5151        return regExp;
    … …  
    5353    RegExpKey key = RegExpKey(flags, patternString);
    5454    iterator->first = key;
    55     iterator->second = regExp;
     55    iterator->second.set(*m_globalData, regExp);
    5656
    5757    ++m_nextKeyToEvict;

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

    r80667 r87343  
    2828#include "RegExp.h"
    2929#include "RegExpKey.h"
     30#include "Strong.h"
    3031#include "UString.h"
    3132#include <wtf/FixedArray.h>
    … …  
    3940class RegExpCache {
    4041
    41 typedef HashMap<RegExpKey, RefPtr<RegExp> > RegExpCacheMap;
     42typedef HashMap<RegExpKey, Strong<RegExp> > RegExpCacheMap;
    4243
    4344public:
    44     PassRefPtr<RegExp> lookupOrCreate(const UString& patternString, RegExpFlags);
    45     PassRefPtr<RegExp> create(const UString& patternString, RegExpFlags, RegExpCacheMap::iterator);
     45    RegExp* lookupOrCreate(const UString& patternString, RegExpFlags);
     46    RegExp* create(const UString& patternString, RegExpFlags, RegExpCacheMap::iterator);
    4647    RegExpCache(JSGlobalData* globalData);
    4748

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

    r84052 r87343  
    318318    }
    319319
    320     RefPtr<RegExp> regExp = exec->globalData().regExpCache()->lookupOrCreate(pattern, flags);
     320    RegExp* regExp = exec->globalData().regExpCache()->lookupOrCreate(pattern, flags);
    321321    if (!regExp->isValid())
    322322        return throwError(exec, createSyntaxError(exec, regExp->errorMessage()));
    323     return new (exec) RegExpObject(exec->lexicalGlobalObject(), globalObject->regExpStructure(), regExp.release());
     323    return new (exec) RegExpObject(exec->lexicalGlobalObject(), globalObject->regExpStructure(), regExp);
    324324}
    325325

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

    r87327 r87343  
    6262*/
    6363
    64 RegExpObject::RegExpObject(JSGlobalObject* globalObject, Structure* structure, NonNullPassRefPtr<RegExp> regExp)
     64RegExpObject::RegExpObject(JSGlobalObject* globalObject, Structure* structure, RegExp* regExp)
    6565    : JSObjectWithGlobalObject(globalObject, structure)
    66     , d(adoptPtr(new RegExpObjectData(regExp)))
     66    , d(adoptPtr(new RegExpObjectData(globalObject->globalData(), this, regExp)))
    6767{
    6868    ASSERT(inherits(&s_info));
    … …  
    7979    ASSERT(structure()->typeInfo().overridesVisitChildren());
    8080    Base::visitChildren(visitor);
     81    if (d->regExp)
     82        visitor.append(&d->regExp);
    8183    if (UNLIKELY(!d->lastIndex.get().isInt32()))
    8284        visitor.append(&d->lastIndex);

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

    r84556 r87343  
    2626
    2727namespace JSC {
    28 
     28   
    2929    class RegExpObject : public JSObjectWithGlobalObject {
    3030    public:
    3131        typedef JSObjectWithGlobalObject Base;
    3232
    33         RegExpObject(JSGlobalObject*, Structure*, NonNullPassRefPtr<RegExp>);
     33        RegExpObject(JSGlobalObject*, Structure*, RegExp*);
    3434        virtual ~RegExpObject();
    3535
    36         void setRegExp(PassRefPtr<RegExp> r) { d->regExp = r; }
     36        void setRegExp(JSGlobalData& globalData, RegExp* r) { d->regExp.set(globalData, this, r); }
    3737        RegExp* regExp() const { return d->regExp.get(); }
    3838
    … …  
    7575            WTF_MAKE_FAST_ALLOCATED;
    7676        public:
    77             RegExpObjectData(NonNullPassRefPtr<RegExp> regExp)
    78                 : regExp(regExp)
     77            RegExpObjectData(JSGlobalData& globalData, RegExpObject* owner, RegExp* regExp)
     78                : regExp(globalData, owner, regExp)
    7979            {
    8080                lastIndex.setWithoutWriteBarrier(jsNumber(0));
    8181            }
    8282
    83             RefPtr<RegExp> regExp;
     83            WriteBarrier<RegExp> regExp;
    8484            WriteBarrier<Unknown> lastIndex;
    8585        };

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

    r86727 r87343  
    6363ASSERT_CLASS_FITS_IN_CELL(RegExpPrototype);
    6464
    65 RegExpPrototype::RegExpPrototype(ExecState* exec, JSGlobalObject* globalObject, Structure* structure)
    66     : RegExpObject(globalObject, structure, RegExp::create(&exec->globalData(), "", NoFlags))
     65RegExpPrototype::RegExpPrototype(ExecState*, JSGlobalObject* globalObject, Structure* structure, RegExp* regExp)
     66    : RegExpObject(globalObject, structure, regExp)
    6767{
    6868}
    … …  
    102102        return throwVMTypeError(exec);
    103103
    104     RefPtr<RegExp> regExp;
     104    RegExp* regExp;
    105105    JSValue arg0 = exec->argument(0);
    106106    JSValue arg1 = exec->argument(1);
    … …  
    129129        return throwVMError(exec, createSyntaxError(exec, regExp->errorMessage()));
    130130
    131     asRegExpObject(thisValue)->setRegExp(regExp.release());
     131    asRegExpObject(thisValue)->setRegExp(exec->globalData(), regExp);
    132132    asRegExpObject(thisValue)->setLastIndex(0);
    133133    return JSValue::encode(jsUndefined());

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

    r86727 r87343  
    2929    class RegExpPrototype : public RegExpObject {
    3030    public:
    31         RegExpPrototype(ExecState*, JSGlobalObject*, Structure*);
     31        RegExpPrototype(ExecState*, JSGlobalObject*, Structure*, RegExp*);
    3232
    3333        static const ClassInfo s_info;

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

    r87327 r87343  
    607607    JSValue a0 = exec->argument(0);
    608608
    609     RefPtr<RegExp> reg;
     609    RegExp* reg;
    610610    if (a0.inherits(&RegExpObject::s_info))
    611611        reg = asRegExpObject(a0)->regExp();
    … …  
    621621    int pos;
    622622    int matchLength = 0;
    623     regExpConstructor->performMatch(*globalData, reg.get(), s, 0, pos, matchLength);
     623    regExpConstructor->performMatch(*globalData, reg, s, 0, pos, matchLength);
    624624    if (!(reg->global())) {
    625625        // case without 'g' flag is handled like RegExp.prototype.exec
    … …  
    634634        list.append(jsSubstring(exec, s, pos, matchLength));
    635635        pos += matchLength == 0 ? 1 : matchLength;
    636         regExpConstructor->performMatch(*globalData, reg.get(), s, pos, pos, matchLength);
     636        regExpConstructor->performMatch(*globalData, reg, s, pos, pos, matchLength);
    637637    }
    638638    if (list.isEmpty()) {
    … …  
    656656    JSValue a0 = exec->argument(0);
    657657
    658     RefPtr<RegExp> reg;
     658    RegExp* reg;
    659659    if (a0.inherits(&RegExpObject::s_info))
    660660        reg = asRegExpObject(a0)->regExp();
    … …  
    670670    int pos;
    671671    int matchLength = 0;
    672     regExpConstructor->performMatch(*globalData, reg.get(), s, 0, pos, matchLength);
     672    regExpConstructor->performMatch(*globalData, reg, s, 0, pos, matchLength);
    673673    return JSValue::encode(jsNumber(pos));
    674674}

  • trunk/Source/WebCore/ChangeLog

    r87336 r87343  
     12011-05-25  Oliver Hunt  <oliver@apple.com>
     2
     3        Reviewed by Geoffrey Garen.
     4
     5        Make RegExp GC allocated
     6        https://bugs.webkit.org/show_bug.cgi?id=61490
     7
     8        RegExp is GC'd so we don't need the RefPtr shenanigans anymore.
     9
     10        * bindings/js/SerializedScriptValue.cpp:
     11        (WebCore::CloneDeserializer::readTerminal):
     12
    1132011-05-25  Martin Robinson  <mrobinson@igalia.com>
    214

  • trunk/Source/WebCore/bindings/js/SerializedScriptValue.cpp

    r83668 r87343  
    11671167            RegExpFlags reFlags = regExpFlags(flags->ustring());
    11681168            ASSERT(reFlags != InvalidFlags);
    1169             RefPtr<RegExp> regExp = RegExp::create(&m_exec->globalData(), pattern->ustring(), reFlags);
     1169            RegExp* regExp = RegExp::create(&m_exec->globalData(), pattern->ustring(), reFlags);
    11701170            return new (m_exec) RegExpObject(m_exec->lexicalGlobalObject(), m_globalObject->regExpStructure(), regExp);
    11711171        }

  • trunk/Source/WebCore/bridge/qt/qt_runtime.cpp

    r87315 r87343  
    862862            RegExpFlags flags = (re.caseSensitivity() == Qt::CaseInsensitive) ? FlagIgnoreCase : NoFlags;
    863863
    864             RefPtr<JSC::RegExp> regExp = JSC::RegExp::create(&exec->globalData(), pattern, flags);
     864            JSC::RegExp* regExp = JSC::RegExp::create(&exec->globalData(), pattern, flags);
    865865            if (regExp->isValid())
    866                 return new (exec) RegExpObject(exec->lexicalGlobalObject(), exec->lexicalGlobalObject()->regExpStructure(), regExp.release());
     866                return new (exec) RegExpObject(exec->lexicalGlobalObject(), exec->lexicalGlobalObject()->regExpStructure(), regExp);
    867867            return jsNull();
    868868        }
Note: See TracChangeset for help on using the changeset viewer.