Changeset 245026 in webkit


Ignore:
Timestamp:
May 7, 2019 12:57:10 PM (5 years ago)
Author:
commit-queue@webkit.org
Message:

Unreviewed, rolling out r244978.
​https://bugs.webkit.org/show_bug.cgi?id=197671

TemplateObject map should use start/end offsets (Requested by
yusukesuzuki on #webkit).

Reverted changeset:

"TemplateObject passed to template literal tags are not always
identical for the same source location."
​https://bugs.webkit.org/show_bug.cgi?id=190756
​https://trac.webkit.org/changeset/244978

Location:
trunk
Files:
10 deleted
38 edited

Legend:

Unmodified
Added
Removed

  • trunk/JSTests/ChangeLog

    r245018 r245026  
     12019-05-07  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r244978.
     4        https://bugs.webkit.org/show_bug.cgi?id=197671
     5
     6        TemplateObject map should use start/end offsets (Requested by
     7        yusukesuzuki on #webkit).
     8
     9        Reverted changeset:
     10
     11        "TemplateObject passed to template literal tags are not always
     12        identical for the same source location."
     13        https://bugs.webkit.org/show_bug.cgi?id=190756
     14        https://trac.webkit.org/changeset/244978
     15
    1162019-05-07  Tadeu Zagallo  <tzagallo@apple.com>
    217

  • trunk/JSTests/complex.yaml

    r244978 r245026  
    2626- path: complex/generator-regeneration.js
    2727  cmd: runComplexTest [], ["generator-regeneration-after.js"], "--useDollarVM=1"
    28 
    29 - path: complex/tagged-template-regeneration.js
    30   cmd: runComplexTest [], ["tagged-template-regeneration-after.js"], "--useDollarVM=1"

  • trunk/Source/JavaScriptCore/ChangeLog

    r245018 r245026  
     12019-05-07  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r244978.
     4        https://bugs.webkit.org/show_bug.cgi?id=197671
     5
     6        TemplateObject map should use start/end offsets (Requested by
     7        yusukesuzuki on #webkit).
     8
     9        Reverted changeset:
     10
     11        "TemplateObject passed to template literal tags are not always
     12        identical for the same source location."
     13        https://bugs.webkit.org/show_bug.cgi?id=190756
     14        https://trac.webkit.org/changeset/244978
     15
    1162019-05-07  Tadeu Zagallo  <tzagallo@apple.com>
    217

  • trunk/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-Builtin.Promise-Combined.js-result

    r244978 r245026  
    142142JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
    143143{\
    144     return vm.builtinExecutables()->codeName##Executable()->link(vm, nullptr, vm.builtinExecutables()->codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); }
     144    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); }
    145145JSC_FOREACH_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
    146146#undef DEFINE_BUILTIN_GENERATOR

  • trunk/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-Builtin.Promise-Separate.js-result

    r244978 r245026  
    159159JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
    160160{\
    161     return vm.builtinExecutables()->codeName##Executable()->link(vm, nullptr, vm.builtinExecutables()->codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); }
     161    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); }
    162162JSC_FOREACH_BUILTIN.PROMISE_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
    163163#undef DEFINE_BUILTIN_GENERATOR

  • trunk/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-Builtin.prototype-Combined.js-result

    r244978 r245026  
    168168JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
    169169{\
    170     return vm.builtinExecutables()->codeName##Executable()->link(vm, nullptr, vm.builtinExecutables()->codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); }
     170    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); }
    171171JSC_FOREACH_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
    172172#undef DEFINE_BUILTIN_GENERATOR

  • trunk/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-Builtin.prototype-Separate.js-result

    r244978 r245026  
    283283JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
    284284{\
    285     return vm.builtinExecutables()->codeName##Executable()->link(vm, nullptr, vm.builtinExecutables()->codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); }
     285    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); }
    286286JSC_FOREACH_BUILTIN.PROTOTYPE_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
    287287#undef DEFINE_BUILTIN_GENERATOR

  • trunk/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-BuiltinConstructor-Combined.js-result

    r244978 r245026  
    140140JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
    141141{\
    142     return vm.builtinExecutables()->codeName##Executable()->link(vm, nullptr, vm.builtinExecutables()->codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); }
     142    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); }
    143143JSC_FOREACH_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
    144144#undef DEFINE_BUILTIN_GENERATOR

  • trunk/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-BuiltinConstructor-Separate.js-result

    r244978 r245026  
    213213JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
    214214{\
    215     return vm.builtinExecutables()->codeName##Executable()->link(vm, nullptr, vm.builtinExecutables()->codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); }
     215    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); }
    216216JSC_FOREACH_BUILTINCONSTRUCTOR_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
    217217#undef DEFINE_BUILTIN_GENERATOR

  • trunk/Source/JavaScriptCore/Scripts/tests/builtins/expected/JavaScriptCore-InternalClashingNames-Combined.js-result

    r244978 r245026  
    141141JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \
    142142{\
    143     return vm.builtinExecutables()->codeName##Executable()->link(vm, nullptr, vm.builtinExecutables()->codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); }
     143    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); }
    144144JSC_FOREACH_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
    145145#undef DEFINE_BUILTIN_GENERATOR

  • trunk/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-AnotherGuardedInternalBuiltin-Separate.js-result

    r244978 r245026  
    221221{\
    222222    JSVMClientData* clientData = static_cast<JSVMClientData*>(vm.clientData); \
    223     return clientData->builtinFunctions().anotherGuardedInternalBuiltinBuiltins().codeName##Executable()->link(vm, nullptr, clientData->builtinFunctions().anotherGuardedInternalBuiltinBuiltins().codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); \
     223    return clientData->builtinFunctions().anotherGuardedInternalBuiltinBuiltins().codeName##Executable()->link(vm, clientData->builtinFunctions().anotherGuardedInternalBuiltinBuiltins().codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); \
    224224}
    225225WEBCORE_FOREACH_ANOTHERGUARDEDINTERNALBUILTIN_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)

  • trunk/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-ArbitraryConditionalGuard-Separate.js-result

    r244978 r245026  
    191191{\
    192192    JSVMClientData* clientData = static_cast<JSVMClientData*>(vm.clientData); \
    193     return clientData->builtinFunctions().arbitraryConditionalGuardBuiltins().codeName##Executable()->link(vm, nullptr, clientData->builtinFunctions().arbitraryConditionalGuardBuiltins().codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); \
     193    return clientData->builtinFunctions().arbitraryConditionalGuardBuiltins().codeName##Executable()->link(vm, clientData->builtinFunctions().arbitraryConditionalGuardBuiltins().codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); \
    194194}
    195195WEBCORE_FOREACH_ARBITRARYCONDITIONALGUARD_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)

  • trunk/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-GuardedBuiltin-Separate.js-result

    r244978 r245026  
    191191{\
    192192    JSVMClientData* clientData = static_cast<JSVMClientData*>(vm.clientData); \
    193     return clientData->builtinFunctions().guardedBuiltinBuiltins().codeName##Executable()->link(vm, nullptr, clientData->builtinFunctions().guardedBuiltinBuiltins().codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); \
     193    return clientData->builtinFunctions().guardedBuiltinBuiltins().codeName##Executable()->link(vm, clientData->builtinFunctions().guardedBuiltinBuiltins().codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); \
    194194}
    195195WEBCORE_FOREACH_GUARDEDBUILTIN_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)

  • trunk/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-GuardedInternalBuiltin-Separate.js-result

    r244978 r245026  
    223223{\
    224224    JSVMClientData* clientData = static_cast<JSVMClientData*>(vm.clientData); \
    225     return clientData->builtinFunctions().guardedInternalBuiltinBuiltins().codeName##Executable()->link(vm, nullptr, clientData->builtinFunctions().guardedInternalBuiltinBuiltins().codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); \
     225    return clientData->builtinFunctions().guardedInternalBuiltinBuiltins().codeName##Executable()->link(vm, clientData->builtinFunctions().guardedInternalBuiltinBuiltins().codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); \
    226226}
    227227WEBCORE_FOREACH_GUARDEDINTERNALBUILTIN_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)

  • trunk/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-UnguardedBuiltin-Separate.js-result

    r244978 r245026  
    185185{\
    186186    JSVMClientData* clientData = static_cast<JSVMClientData*>(vm.clientData); \
    187     return clientData->builtinFunctions().unguardedBuiltinBuiltins().codeName##Executable()->link(vm, nullptr, clientData->builtinFunctions().unguardedBuiltinBuiltins().codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); \
     187    return clientData->builtinFunctions().unguardedBuiltinBuiltins().codeName##Executable()->link(vm, clientData->builtinFunctions().unguardedBuiltinBuiltins().codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); \
    188188}
    189189WEBCORE_FOREACH_UNGUARDEDBUILTIN_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)

  • trunk/Source/JavaScriptCore/Scripts/tests/builtins/expected/WebCore-xmlCasingTest-Separate.js-result

    r244978 r245026  
    276276{\
    277277    JSVMClientData* clientData = static_cast<JSVMClientData*>(vm.clientData); \
    278     return clientData->builtinFunctions().xmlCasingTestBuiltins().codeName##Executable()->link(vm, nullptr, clientData->builtinFunctions().xmlCasingTestBuiltins().codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); \
     278    return clientData->builtinFunctions().xmlCasingTestBuiltins().codeName##Executable()->link(vm, clientData->builtinFunctions().xmlCasingTestBuiltins().codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); \
    279279}
    280280WEBCORE_FOREACH_XMLCASINGTEST_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)

  • trunk/Source/JavaScriptCore/Scripts/wkbuiltins/builtins_templates.py

    r244978 r245026  
    8686JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \\
    8787{\\
    88     return vm.builtinExecutables()->codeName##Executable()->link(vm, nullptr, vm.builtinExecutables()->codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); \
     88    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); \
    8989}
    9090${macroPrefix}_FOREACH_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
    … …  
    9797JSC::FunctionExecutable* codeName##Generator(JSC::VM& vm) \\
    9898{\\
    99     return vm.builtinExecutables()->codeName##Executable()->link(vm, nullptr, vm.builtinExecutables()->codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); \
     99    return vm.builtinExecutables()->codeName##Executable()->link(vm, vm.builtinExecutables()->codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); \
    100100}
    101101${macroPrefix}_FOREACH_${objectMacro}_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
    … …  
    109109{\\
    110110    JSVMClientData* clientData = static_cast<JSVMClientData*>(vm.clientData); \\
    111     return clientData->builtinFunctions().${objectNameLC}Builtins().codeName##Executable()->link(vm, nullptr, clientData->builtinFunctions().${objectNameLC}Builtins().codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); \\
     111    return clientData->builtinFunctions().${objectNameLC}Builtins().codeName##Executable()->link(vm, clientData->builtinFunctions().${objectNameLC}Builtins().codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); \\
    112112}
    113113${macroPrefix}_FOREACH_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)
    … …  
    121121{\\
    122122    JSVMClientData* clientData = static_cast<JSVMClientData*>(vm.clientData); \\
    123     return clientData->builtinFunctions().${objectNameLC}Builtins().codeName##Executable()->link(vm, nullptr, clientData->builtinFunctions().${objectNameLC}Builtins().codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); \\
     123    return clientData->builtinFunctions().${objectNameLC}Builtins().codeName##Executable()->link(vm, clientData->builtinFunctions().${objectNameLC}Builtins().codeName##Source(), WTF::nullopt, s_##codeName##Intrinsic); \\
    124124}
    125125${macroPrefix}_FOREACH_${objectMacro}_BUILTIN_CODE(DEFINE_BUILTIN_GENERATOR)

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

    r244978 r245026  
    396396        vm.functionHasExecutedCache()->removeUnexecutedRange(ownerExecutable->sourceID(), ownerExecutable->typeProfilingStartOffset(vm), ownerExecutable->typeProfilingEndOffset(vm));
    397397
    398     ScriptExecutable* topLevelExecutable = ownerExecutable->topLevelExecutable();
    399     setConstantRegisters(unlinkedCodeBlock->constantRegisters(), unlinkedCodeBlock->constantsSourceCodeRepresentation(), topLevelExecutable);
     398    setConstantRegisters(unlinkedCodeBlock->constantRegisters(), unlinkedCodeBlock->constantsSourceCodeRepresentation());
    400399    RETURN_IF_EXCEPTION(throwScope, false);
    401400
    … …  
    423422        if (shouldUpdateFunctionHasExecutedCache)
    424423            vm.functionHasExecutedCache()->insertUnexecutedRange(ownerExecutable->sourceID(), unlinkedExecutable->typeProfilingStartOffset(), unlinkedExecutable->typeProfilingEndOffset());
    425         m_functionDecls[i].set(vm, this, unlinkedExecutable->link(vm, topLevelExecutable, ownerExecutable->source()));
     424        m_functionDecls[i].set(vm, this, unlinkedExecutable->link(vm, ownerExecutable->source()));
    426425    }
    427426
    … …  
    431430        if (shouldUpdateFunctionHasExecutedCache)
    432431            vm.functionHasExecutedCache()->insertUnexecutedRange(ownerExecutable->sourceID(), unlinkedExecutable->typeProfilingStartOffset(), unlinkedExecutable->typeProfilingEndOffset());
    433         m_functionExprs[i].set(vm, this, unlinkedExecutable->link(vm, topLevelExecutable, ownerExecutable->source()));
     432        m_functionExprs[i].set(vm, this, unlinkedExecutable->link(vm, ownerExecutable->source()));
    434433    }
    435434
    … …  
    872871}
    873872
    874 void CodeBlock::setConstantRegisters(const Vector<WriteBarrier<Unknown>>& constants, const Vector<SourceCodeRepresentation>& constantsSourceCodeRepresentation, ScriptExecutable* topLevelExecutable)
     873void CodeBlock::setConstantRegisters(const Vector<WriteBarrier<Unknown>>& constants, const Vector<SourceCodeRepresentation>& constantsSourceCodeRepresentation)
    875874{
    876875    VM& vm = *m_vm;
    … …  
    900899                    constant = clone;
    901900                } else if (auto* descriptor = jsDynamicCast<JSTemplateObjectDescriptor*>(vm, cell)) {
    902                     auto* templateObject = topLevelExecutable->createTemplateObject(exec, descriptor);
     901                    auto* templateObject = descriptor->createTemplateObject(exec);
    903902                    RETURN_IF_EXCEPTION(scope, void());
    904903                    constant = templateObject;

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

    r244978 r245026  
    912912    void setConstantIdentifierSetRegisters(VM&, const Vector<ConstantIdentifierSetEntry>& constants);
    913913
    914     void setConstantRegisters(const Vector<WriteBarrier<Unknown>>& constants, const Vector<SourceCodeRepresentation>& constantsSourceCodeRepresentation, ScriptExecutable* topLevelExecutable);
     914    void setConstantRegisters(const Vector<WriteBarrier<Unknown>>& constants, const Vector<SourceCodeRepresentation>& constantsSourceCodeRepresentation);
    915915
    916916    void replaceConstant(int index, JSValue value)

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

    r244978 r245026  
    159159}
    160160
    161 FunctionExecutable* UnlinkedFunctionExecutable::link(VM& vm, ScriptExecutable* topLevelExecutable, const SourceCode& passedParentSource, Optional<int> overrideLineNumber, Intrinsic intrinsic)
     161FunctionExecutable* UnlinkedFunctionExecutable::link(VM& vm, const SourceCode& passedParentSource, Optional<int> overrideLineNumber, Intrinsic intrinsic)
    162162{
    163163    SourceCode source = linkedSourceCode(passedParentSource);
    … …  
    167167        hasFunctionOverride = FunctionOverrides::initializeOverrideFor(source, overrideInfo);
    168168
    169     FunctionExecutable* result = FunctionExecutable::create(vm, topLevelExecutable, source, this, intrinsic);
     169    FunctionExecutable* result = FunctionExecutable::create(vm, source, this, intrinsic);
    170170    if (overrideLineNumber)
    171171        result->setOverrideLineNumber(*overrideLineNumber);

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

    r244978 r245026  
    127127
    128128    SourceCode linkedSourceCode(const SourceCode&) const;
    129     JS_EXPORT_PRIVATE FunctionExecutable* link(VM&, ScriptExecutable* topLevelExecutable, const SourceCode& parentSource, Optional<int> overrideLineNumber = WTF::nullopt, Intrinsic = NoIntrinsic);
     129    JS_EXPORT_PRIVATE FunctionExecutable* link(VM&, const SourceCode& parentSource, Optional<int> overrideLineNumber = WTF::nullopt, Intrinsic = NoIntrinsic);
    130130
    131131    void clearCode(VM& vm)

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

    r244978 r245026  
    29492949}
    29502950
    2951 RegisterID* BytecodeGenerator::addTemplateObjectConstant(Ref<TemplateObjectDescriptor>&& descriptor, int startOffset)
    2952 {
    2953     auto result = m_templateObjectDescriptorSet.add(WTFMove(descriptor));
    2954     JSTemplateObjectDescriptor* descriptorValue = m_templateDescriptorMap.ensure(startOffset, [&] {
    2955         return JSTemplateObjectDescriptor::create(*vm(), result.iterator->copyRef(), startOffset);
     2951RegisterID* BytecodeGenerator::addTemplateObjectConstant(Ref<TemplateObjectDescriptor>&& descriptor)
     2952{
     2953    JSTemplateObjectDescriptor* descriptorValue = m_templateObjectDescriptorMap.ensure(descriptor.copyRef(), [&] {
     2954        return JSTemplateObjectDescriptor::create(*vm(), WTFMove(descriptor));
    29562955    }).iterator->value;
     2956
    29572957    int index = addConstantIndex();
    29582958    m_codeBlock->addConstant(descriptorValue);
    … …  
    41424142            cookedStrings.append(string->cooked()->impl());
    41434143    }
    4144     RefPtr<RegisterID> constant = addTemplateObjectConstant(TemplateObjectDescriptor::create(WTFMove(rawStrings), WTFMove(cookedStrings)), taggedTemplate->startOffset());
     4144    RefPtr<RegisterID> constant = addTemplateObjectConstant(TemplateObjectDescriptor::create(WTFMove(rawStrings), WTFMove(cookedStrings)));
    41454145    if (!dst)
    41464146        return constant.get();

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

    r244978 r245026  
    10611061        using IdentifierStringMap = HashMap<UniquedStringImpl*, JSString*, IdentifierRepHash>;
    10621062        using IdentifierBigIntMap = HashMap<BigIntMapEntry, JSBigInt*>;
    1063         using TemplateObjectDescriptorSet = HashSet<Ref<TemplateObjectDescriptor>>;
    1064         using TemplateDescriptorMap = HashMap<uint64_t, JSTemplateObjectDescriptor*, WTF::IntHash<uint64_t>, WTF::UnsignedWithZeroKeyHashTraits<uint64_t>>;
     1063        using TemplateObjectDescriptorMap = HashMap<Ref<TemplateObjectDescriptor>, JSTemplateObjectDescriptor*>;
    10651064
    10661065        // Helper for emitCall() and emitConstruct(). This works because the set of
    … …  
    11541153        JSString* addStringConstant(const Identifier&);
    11551154        JSValue addBigIntConstant(const Identifier&, uint8_t radix, bool sign);
    1156         RegisterID* addTemplateObjectConstant(Ref<TemplateObjectDescriptor>&&, int);
     1155        RegisterID* addTemplateObjectConstant(Ref<TemplateObjectDescriptor>&&);
    11571156
    11581157        const InstructionStream& instructions() const { return m_writer; }
    … …  
    12721271        IdentifierStringMap m_stringMap;
    12731272        IdentifierBigIntMap m_bigIntMap;
    1274         TemplateObjectDescriptorSet m_templateObjectDescriptorSet;
    1275         TemplateDescriptorMap m_templateDescriptorMap;
     1273        TemplateObjectDescriptorMap m_templateObjectDescriptorMap;
    12761274
    12771275        StaticPropertyAnalyzer m_staticPropertyAnalyzer;

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

    r244978 r245026  
    11531153class CachedTemplateObjectDescriptor : public CachedObject<TemplateObjectDescriptor> {
    11541154public:
    1155     void encode(Encoder& encoder, const JSTemplateObjectDescriptor& descriptor)
    1156     {
    1157         m_rawStrings.encode(encoder, descriptor.descriptor().rawStrings());
    1158         m_cookedStrings.encode(encoder, descriptor.descriptor().cookedStrings());
    1159         m_startOffset = descriptor.startOffset();
    1160     }
    1161 
    1162     JSTemplateObjectDescriptor* decode(Decoder& decoder) const
     1155    void encode(Encoder& encoder, const TemplateObjectDescriptor& templateObjectDescriptor)
     1156    {
     1157        m_rawStrings.encode(encoder, templateObjectDescriptor.rawStrings());
     1158        m_cookedStrings.encode(encoder, templateObjectDescriptor.cookedStrings());
     1159    }
     1160
     1161    Ref<TemplateObjectDescriptor> decode(Decoder& decoder) const
    11631162    {
    11641163        TemplateObjectDescriptor::StringVector decodedRawStrings;
    … …  
    11661165        m_rawStrings.decode(decoder, decodedRawStrings);
    11671166        m_cookedStrings.decode(decoder, decodedCookedStrings);
    1168         return JSTemplateObjectDescriptor::create(decoder.vm(), TemplateObjectDescriptor::create(WTFMove(decodedRawStrings), WTFMove(decodedCookedStrings)), m_startOffset);
     1167        return TemplateObjectDescriptor::create(WTFMove(decodedRawStrings), WTFMove(decodedCookedStrings));
    11691168    }
    11701169
    … …  
    11721171    CachedVector<CachedString, 4> m_rawStrings;
    11731172    CachedVector<CachedOptional<CachedString>, 4> m_cookedStrings;
    1174     int m_startOffset;
    11751173};
    11761174
    … …  
    12461244        if (auto* templateObjectDescriptor = jsDynamicCast<JSTemplateObjectDescriptor*>(vm, cell)) {
    12471245            m_type = EncodedType::TemplateObjectDescriptor;
    1248             this->allocate<CachedTemplateObjectDescriptor>(encoder)->encode(encoder, *templateObjectDescriptor);
     1246            this->allocate<CachedTemplateObjectDescriptor>(encoder)->encode(encoder, templateObjectDescriptor->descriptor());
    12491247            return;
    12501248        }
    … …  
    12811279            break;
    12821280        case EncodedType::TemplateObjectDescriptor:
    1283             v = this->buffer<CachedTemplateObjectDescriptor>()->decode(decoder);
     1281            v = JSTemplateObjectDescriptor::create(decoder.vm(), this->buffer<CachedTemplateObjectDescriptor>()->decode(decoder));
    12841282            break;
    12851283        case EncodedType::BigInt:

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

    r244978 r245026  
    4545}
    4646
    47 auto EvalExecutable::ensureTemplateObjectMap(VM&) -> TemplateObjectMap&
    48 {
    49     return ensureTemplateObjectMapImpl(m_templateObjectMap);
    50 }
    51 
    5247void EvalExecutable::visitChildren(JSCell* cell, SlotVisitor& visitor)
    5348{
    … …  
    5752    visitor.append(thisObject->m_unlinkedEvalCodeBlock);
    5853    visitor.append(thisObject->m_evalCodeBlock);
    59     if (TemplateObjectMap* map = thisObject->m_templateObjectMap.get()) {
    60         auto locker = holdLock(thisObject->cellLock());
    61         for (auto& entry : *map)
    62             visitor.append(entry.value);
    63     }
    6454}
    6555

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

    r244978 r245026  
    7070    bool allowDirectEvalCache() const { return m_unlinkedEvalCodeBlock->allowDirectEvalCache(); }
    7171
    72     TemplateObjectMap& ensureTemplateObjectMap(VM&);
    73 
    7472protected:
    7573    friend class ExecutableBase;
    … …  
    8381    WriteBarrier<ExecutableToCodeBlockEdge> m_evalCodeBlock;
    8482    WriteBarrier<UnlinkedEvalCodeBlock> m_unlinkedEvalCodeBlock;
    85     std::unique_ptr<TemplateObjectMap> m_templateObjectMap;
    8683};
    8784

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

    r244978 r245026  
    5555}
    5656
    57 void FunctionExecutable::finishCreation(VM& vm, ScriptExecutable* topLevelExecutable)
     57void FunctionExecutable::finishCreation(VM& vm)
    5858{
    5959    Base::finishCreation(vm);
    60     m_topLevelExecutable.set(vm, this, topLevelExecutable ? topLevelExecutable : this);
    6160    if (VM::canUseJIT())
    6261        m_singletonFunction.set(vm, this, InferredValue::create(vm));
    … …  
    8786    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
    8887    Base::visitChildren(thisObject, visitor);
    89     visitor.append(thisObject->m_topLevelExecutable);
    9088    visitor.append(thisObject->m_codeBlockForCall);
    9189    visitor.append(thisObject->m_codeBlockForConstruct);
    … …  
    9391    if (VM::canUseJIT())
    9492        visitor.append(thisObject->m_singletonFunction);
    95     if (RareData* rareData = thisObject->m_rareData.get()) {
    96         visitor.append(rareData->m_cachedPolyProtoStructure);
    97         if (TemplateObjectMap* map = rareData->m_templateObjectMap.get()) {
    98             auto locker = holdLock(thisObject->cellLock());
    99             for (auto& entry : *map)
    100                 visitor.append(entry.value);
    101         }
    102     }
     93    visitor.append(thisObject->m_cachedPolyProtoStructure);
    10394}
    10495
    … …  
    113104        return nullptr;
    114105
    115     return unlinkedExecutable->link(exec.vm(), nullptr, source, overrideLineNumber);
     106    return unlinkedExecutable->link(exec.vm(), source, overrideLineNumber);
    116107}
    117108
    … …  
    125116    rareData->m_typeProfilingStartOffset = typeProfilingStartOffset();
    126117    rareData->m_typeProfilingEndOffset = typeProfilingEndOffset();
    127     WTF::storeStoreFence();
    128118    m_rareData = WTFMove(rareData);
    129119    return *m_rareData;
    … …  
    141131}
    142132
    143 auto FunctionExecutable::ensureTemplateObjectMap(VM&) -> TemplateObjectMap&
    144 {
    145     RareData& rareData = ensureRareData();
    146     return ensureTemplateObjectMapImpl(rareData.m_templateObjectMap);
    147 }
    148 
    149133} // namespace JSC

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

    r244978 r245026  
    4949    }
    5050
    51     static FunctionExecutable* create(VM& vm, ScriptExecutable* topLevelExecutable, const SourceCode& source, UnlinkedFunctionExecutable* unlinkedExecutable, Intrinsic intrinsic)
     51    static FunctionExecutable* create(VM& vm, const SourceCode& source, UnlinkedFunctionExecutable* unlinkedExecutable, Intrinsic intrinsic)
    5252    {
    5353        FunctionExecutable* executable = new (NotNull, allocateCell<FunctionExecutable>(vm.heap)) FunctionExecutable(vm, source, unlinkedExecutable, intrinsic);
    54         executable->finishCreation(vm, topLevelExecutable);
     54        executable->finishCreation(vm);
    5555        return executable;
    5656    }
    … …  
    283283
    284284    // Cached poly proto structure for the result of constructing this executable.
    285     Structure* cachedPolyProtoStructure()
    286     {
    287         if (UNLIKELY(m_rareData))
    288             return m_rareData->m_cachedPolyProtoStructure.get();
    289         return nullptr;
    290     }
    291     void setCachedPolyProtoStructure(VM& vm, Structure* structure)
    292     {
    293         ensureRareData().m_cachedPolyProtoStructure.set(vm, this, structure);
    294     }
     285    Structure* cachedPolyProtoStructure() { return m_cachedPolyProtoStructure.get(); }
     286    void setCachedPolyProtoStructure(VM& vm, Structure* structure) { m_cachedPolyProtoStructure.set(vm, this, structure); }
    295287
    296288    InlineWatchpointSet& ensurePolyProtoWatchpoint()
    … …  
    302294
    303295    Box<InlineWatchpointSet> sharedPolyProtoWatchpoint() const { return m_polyProtoWatchpoint; }
    304 
    305     ScriptExecutable* topLevelExecutable() const { return m_topLevelExecutable.get(); }
    306 
    307     TemplateObjectMap& ensureTemplateObjectMap(VM&);
    308296
    309297private:
    … …  
    311299    FunctionExecutable(VM&, const SourceCode&, UnlinkedFunctionExecutable*, Intrinsic);
    312300   
    313     void finishCreation(VM&, ScriptExecutable* topLevelExecutable);
     301    void finishCreation(VM&);
    314302
    315303    friend class ScriptExecutable;
    … …  
    324312        unsigned m_typeProfilingStartOffset { UINT_MAX };
    325313        unsigned m_typeProfilingEndOffset { UINT_MAX };
    326         std::unique_ptr<TemplateObjectMap> m_templateObjectMap;
    327         WriteBarrier<Structure> m_cachedPolyProtoStructure;
    328314    };
    329315
    … …  
    336322    RareData& ensureRareDataSlow();
    337323
    338     // FIXME: We can merge rareData pointer and top-level executable pointer. First time, setting parent.
    339     // If RareData is required, materialize RareData, swap it, and store top-level executable pointer inside RareData.
    340     // https://bugs.webkit.org/show_bug.cgi?id=197625
    341324    std::unique_ptr<RareData> m_rareData;
    342     WriteBarrier<ScriptExecutable> m_topLevelExecutable;
    343325    WriteBarrier<UnlinkedFunctionExecutable> m_unlinkedExecutable;
    344326    WriteBarrier<ExecutableToCodeBlockEdge> m_codeBlockForCall;
    … …  
    348330        WatchpointState m_singletonFunctionState;
    349331    };
     332    WriteBarrier<Structure> m_cachedPolyProtoStructure;
    350333    Box<InlineWatchpointSet> m_polyProtoWatchpoint;
    351334};

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

    r244978 r245026  
    201201                    unlinkedFunctionExecutable->typeProfilingEndOffset());
    202202            }
    203             JSFunction* function = JSFunction::create(vm, unlinkedFunctionExecutable->link(vm, moduleProgramExecutable, moduleProgramExecutable->source()), moduleEnvironment);
     203            JSFunction* function = JSFunction::create(vm, unlinkedFunctionExecutable->link(vm, moduleProgramExecutable->source()), moduleEnvironment);
    204204            bool putResult = false;
    205205            symbolTablePutTouchWatchpointSet(moduleEnvironment, exec, unlinkedFunctionExecutable->name(), function, /* shouldThrowReadOnlyError */ false, /* ignoreReadOnlyErrors */ true, putResult);

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

    r244978 r245026  
    3737
    3838
    39 JSTemplateObjectDescriptor::JSTemplateObjectDescriptor(VM& vm, Ref<TemplateObjectDescriptor>&& descriptor, int startOffset)
     39JSTemplateObjectDescriptor::JSTemplateObjectDescriptor(VM& vm, Ref<TemplateObjectDescriptor>&& descriptor)
    4040    : Base(vm, vm.templateObjectDescriptorStructure.get())
    4141    , m_descriptor(WTFMove(descriptor))
    42     , m_startOffset(startOffset)
    4342{
    4443}
    4544
    46 JSTemplateObjectDescriptor* JSTemplateObjectDescriptor::create(VM& vm, Ref<TemplateObjectDescriptor>&& descriptor, int startOffset)
     45JSTemplateObjectDescriptor* JSTemplateObjectDescriptor::create(VM& vm, Ref<TemplateObjectDescriptor>&& descriptor)
    4746{
    48     JSTemplateObjectDescriptor* result = new (NotNull, allocateCell<JSTemplateObjectDescriptor>(vm.heap)) JSTemplateObjectDescriptor(vm, WTFMove(descriptor), startOffset);
     47    JSTemplateObjectDescriptor* result = new (NotNull, allocateCell<JSTemplateObjectDescriptor>(vm.heap)) JSTemplateObjectDescriptor(vm, WTFMove(descriptor));
    4948    result->finishCreation(vm);
    5049    return result;

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

    r244978 r245026  
    3939    DECLARE_INFO;
    4040
    41     static JSTemplateObjectDescriptor* create(VM&, Ref<TemplateObjectDescriptor>&&, int);
     41    static JSTemplateObjectDescriptor* create(VM&, Ref<TemplateObjectDescriptor>&&);
    4242
    4343    static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
    … …  
    5050    JSArray* createTemplateObject(ExecState*);
    5151
    52     int startOffset() const { return m_startOffset; }
    53 
    5452protected:
    5553    static void destroy(JSCell*);
    5654
    5755private:
    58     JSTemplateObjectDescriptor(VM&, Ref<TemplateObjectDescriptor>&&, int);
     56    JSTemplateObjectDescriptor(VM&, Ref<TemplateObjectDescriptor>&&);
    5957
    6058    Ref<TemplateObjectDescriptor> m_descriptor;
    61     int m_startOffset { 0 };
    6259};
    6360

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

    r244978 r245026  
    8686}
    8787
    88 auto ModuleProgramExecutable::ensureTemplateObjectMap(VM&) -> TemplateObjectMap&
    89 {
    90     return ensureTemplateObjectMapImpl(m_templateObjectMap);
    91 }
    92 
    9388void ModuleProgramExecutable::visitChildren(JSCell* cell, SlotVisitor& visitor)
    9489{
    … …  
    9994    visitor.append(thisObject->m_moduleEnvironmentSymbolTable);
    10095    visitor.append(thisObject->m_moduleProgramCodeBlock);
    101     if (TemplateObjectMap* map = thisObject->m_templateObjectMap.get()) {
    102         auto locker = holdLock(thisObject->cellLock());
    103         for (auto& entry : *map)
    104             visitor.append(entry.value);
    105     }
    10696}
    10797

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

    r244978 r245026  
    7070    SymbolTable* moduleEnvironmentSymbolTable() { return m_moduleEnvironmentSymbolTable.get(); }
    7171
    72     TemplateObjectMap& ensureTemplateObjectMap(VM&);
    73 
    7472private:
    7573    friend class ExecutableBase;
    … …  
    8381    WriteBarrier<SymbolTable> m_moduleEnvironmentSymbolTable;
    8482    WriteBarrier<ExecutableToCodeBlockEdge> m_moduleProgramCodeBlock;
    85     std::unique_ptr<TemplateObjectMap> m_templateObjectMap;
    8683};
    8784

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

    r244978 r245026  
    217217}
    218218
    219 auto ProgramExecutable::ensureTemplateObjectMap(VM&) -> TemplateObjectMap&
    220 {
    221     return ensureTemplateObjectMapImpl(m_templateObjectMap);
    222 }
    223 
    224219void ProgramExecutable::visitChildren(JSCell* cell, SlotVisitor& visitor)
    225220{
    … …  
    229224    visitor.append(thisObject->m_unlinkedProgramCodeBlock);
    230225    visitor.append(thisObject->m_programCodeBlock);
    231     if (TemplateObjectMap* map = thisObject->m_templateObjectMap.get()) {
    232         auto locker = holdLock(thisObject->cellLock());
    233         for (auto& entry : *map)
    234             visitor.append(entry.value);
    235     }
    236226}
    237227

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

    r244978 r245026  
    7474    ExecutableInfo executableInfo() const { return ExecutableInfo(usesEval(), isStrictMode(), false, false, ConstructorKind::None, JSParserScriptMode::Classic, SuperBinding::NotNeeded, SourceParseMode::ProgramMode, derivedContextType(), isArrowFunctionContext(), false, EvalContextType::None); }
    7575
    76     TemplateObjectMap& ensureTemplateObjectMap(VM&);
    77 
    7876private:
    7977    friend class ExecutableBase;
    … …  
    8684    WriteBarrier<UnlinkedProgramCodeBlock> m_unlinkedProgramCodeBlock;
    8785    WriteBarrier<ExecutableToCodeBlockEdge> m_programCodeBlock;
    88     std::unique_ptr<TemplateObjectMap> m_templateObjectMap;
    8986};
    9087

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

    r244978 r245026  
    3535#include "JIT.h"
    3636#include "JSCInlines.h"
    37 #include "JSTemplateObjectDescriptor.h"
    3837#include "LLIntEntrypoint.h"
    3938#include "ModuleProgramCodeBlock.h"
    … …  
    437436}
    438437
    439 ScriptExecutable* ScriptExecutable::topLevelExecutable()
    440 {
    441     switch (type()) {
    442     case FunctionExecutableType:
    443         return jsCast<FunctionExecutable*>(this)->topLevelExecutable();
    444     default:
    445         return this;
    446     }
    447 }
    448 
    449 JSArray* ScriptExecutable::createTemplateObject(ExecState* exec, JSTemplateObjectDescriptor* descriptor)
    450 {
    451     VM& vm = exec->vm();
    452     auto scope = DECLARE_THROW_SCOPE(vm);
    453 
    454     TemplateObjectMap& templateObjectMap = ensureTemplateObjectMap(vm);
    455     TemplateObjectMap::AddResult result;
    456     {
    457         auto locker = holdLock(cellLock());
    458         result = templateObjectMap.add(descriptor->startOffset(), WriteBarrier<JSArray>());
    459     }
    460     if (JSArray* array = result.iterator->value.get())
    461         return array;
    462     JSArray* templateObject = descriptor->createTemplateObject(exec);
    463     RETURN_IF_EXCEPTION(scope, nullptr);
    464     result.iterator->value.set(vm, this, templateObject);
    465     return templateObject;
    466 }
    467 
    468 auto ScriptExecutable::ensureTemplateObjectMapImpl(std::unique_ptr<TemplateObjectMap>& dest) -> TemplateObjectMap&
    469 {
    470     if (dest)
    471         return *dest;
    472     auto result = std::make_unique<TemplateObjectMap>();
    473     WTF::storeStoreFence();
    474     dest = WTFMove(result);
    475     return *dest;
    476 }
    477 
    478 auto ScriptExecutable::ensureTemplateObjectMap(VM& vm) -> TemplateObjectMap&
    479 {
    480     switch (type()) {
    481     case FunctionExecutableType:
    482         return static_cast<FunctionExecutable*>(this)->ensureTemplateObjectMap(vm);
    483     case EvalExecutableType:
    484         return static_cast<EvalExecutable*>(this)->ensureTemplateObjectMap(vm);
    485     case ProgramExecutableType:
    486         return static_cast<ProgramExecutable*>(this)->ensureTemplateObjectMap(vm);
    487     case ModuleProgramExecutableType:
    488     default:
    489         ASSERT(type() == ModuleProgramExecutableType);
    490         return static_cast<ModuleProgramExecutable*>(this)->ensureTemplateObjectMap(vm);
    491     }
    492 }
    493 
    494438CodeBlockHash ScriptExecutable::hashFor(CodeSpecializationKind kind) const
    495439{

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

    r244978 r245026  
    3030namespace JSC {
    3131
    32 class JSArray;
    33 class JSTemplateObjectDescriptor;
    3432class IsoCellSet;
    3533
    … …  
    4038
    4139    static void destroy(JSCell*);
    42 
    43     using TemplateObjectMap = HashMap<uint64_t, WriteBarrier<JSArray>, WTF::IntHash<uint64_t>, WTF::UnsignedWithZeroKeyHashTraits<uint64_t>>;
    4440       
    4541    CodeBlockHash hashFor(CodeSpecializationKind) const;
    … …  
    117113    Exception* prepareForExecution(VM&, JSFunction*, JSScope*, CodeSpecializationKind, CodeBlock*& resultCodeBlock);
    118114
    119     ScriptExecutable* topLevelExecutable();
    120     JSArray* createTemplateObject(ExecState*, JSTemplateObjectDescriptor*);
    121 
    122115private:
    123116    friend class ExecutableBase;
    … …  
    125118
    126119    bool hasClearableCode(VM&) const;
    127 
    128     TemplateObjectMap& ensureTemplateObjectMap(VM&);
    129120
    130121protected:
    … …  
    147138    }
    148139
    149     static TemplateObjectMap& ensureTemplateObjectMapImpl(std::unique_ptr<TemplateObjectMap>& dest);
    150 
    151140    SourceCode m_source;
    152141    Intrinsic m_intrinsic { NoIntrinsic };

  • trunk/Source/JavaScriptCore/tools/JSDollarVM.cpp

    r244978 r245026  
    18471847
    18481848    const SourceCode& source = makeSource(functionText, { });
    1849     JSFunction* func = JSFunction::create(vm, createBuiltinExecutable(vm, source, Identifier::fromString(&vm, "foo"), ConstructorKind::None, ConstructAbility::CannotConstruct)->link(vm, nullptr, source), exec->lexicalGlobalObject());
     1849    JSFunction* func = JSFunction::create(vm, createBuiltinExecutable(vm, source, Identifier::fromString(&vm, "foo"), ConstructorKind::None, ConstructAbility::CannotConstruct)->link(vm, source), exec->lexicalGlobalObject());
    18501850
    18511851    return JSValue::encode(func);
    … …  
    20862086{
    20872087    return changeDebuggerModeWhenIdle(exec, { });
    2088 }
    2089 
    2090 static EncodedJSValue JSC_HOST_CALL functionDeleteAllCodeWhenIdle(ExecState* exec)
    2091 {
    2092     VM* vm = &exec->vm();
    2093     vm->whenIdle([=] () {
    2094         vm->deleteAllCode(PreventCollectionAndDeleteAllCode);
    2095     });
    2096     return JSValue::encode(jsUndefined());
    20972088}
    20982089
    … …  
    22862277    addFunction(vm, "disableDebuggerModeWhenIdle", functionDisableDebuggerModeWhenIdle, 0);
    22872278
    2288     addFunction(vm, "deleteAllCodeWhenIdle", functionDeleteAllCodeWhenIdle, 0);
    2289 
    22902279    addFunction(vm, "globalObjectCount", functionGlobalObjectCount, 0);
    22912280    addFunction(vm, "globalObjectForObject", functionGlobalObjectForObject, 1);
Note: See TracChangeset for help on using the changeset viewer.