Attachment #217652 for bug #124761

View Details Raw Unified Return to Bug 124761

| Differences between



2013-11-21  Filip Pizlo  <fpizlo@apple.com>

        Combine SymbolTable and SharedSymbolTable
        https://bugs.webkit.org/show_bug.cgi?id=124761

        Reviewed by NOBODY (OOPS!).
        
        SymbolTable was never used directly; we now always used SharedSymbolTable. So, this
        gets rid of SymbolTable and renames SharedSymbolTable to SymbolTable.

        * bytecode/CodeBlock.h:
        (JSC::CodeBlock::symbolTable):
        * bytecode/UnlinkedCodeBlock.h:
        (JSC::UnlinkedFunctionExecutable::symbolTable):
        (JSC::UnlinkedCodeBlock::symbolTable):
        (JSC::UnlinkedCodeBlock::finishCreation):
        * bytecompiler/BytecodeGenerator.h:
        (JSC::BytecodeGenerator::symbolTable):
        * dfg/DFGSpeculativeJIT32_64.cpp:
        (JSC::DFG::SpeculativeJIT::compile):
        * dfg/DFGSpeculativeJIT64.cpp:
        (JSC::DFG::SpeculativeJIT::compile):
        * dfg/DFGStackLayoutPhase.cpp:
        (JSC::DFG::StackLayoutPhase::run):
        * jit/AssemblyHelpers.h:
        (JSC::AssemblyHelpers::symbolTableFor):
        * runtime/Arguments.h:
        (JSC::Arguments::finishCreation):
        * runtime/Executable.h:
        (JSC::FunctionExecutable::symbolTable):
        * runtime/JSActivation.h:
        (JSC::JSActivation::create):
        (JSC::JSActivation::JSActivation):
        (JSC::JSActivation::registersOffset):
        (JSC::JSActivation::allocationSize):
        * runtime/JSSymbolTableObject.h:
        (JSC::JSSymbolTableObject::symbolTable):
        (JSC::JSSymbolTableObject::JSSymbolTableObject):
        (JSC::JSSymbolTableObject::finishCreation):
        * runtime/JSVariableObject.h:
        (JSC::JSVariableObject::JSVariableObject):
        * runtime/SymbolTable.cpp:
        (JSC::SymbolTable::destroy):
        (JSC::SymbolTable::SymbolTable):
        * runtime/SymbolTable.h:
        (JSC::SymbolTable::create):
        (JSC::SymbolTable::createStructure):
        * runtime/VM.cpp:
        (JSC::VM::VM):
        * runtime/VM.h:

2013-11-21  Filip Pizlo  <fpizlo@apple.com>

        Fix a typo (requriements->requirements).

Lines 724-730 public: Source/JavaScriptCore/bytecode/CodeBlock.h_sec1
- Source/JavaScriptCore/bytecode/CodeBlock.h -1 / +1 lines
724	StringJumpTable& stringSwitchJumpTable(int tableIndex) { RELEASE_ASSERT(m_rareData); return m_rareData->m_stringSwitchJumpTables[tableIndex]; }	724	StringJumpTable& stringSwitchJumpTable(int tableIndex) { RELEASE_ASSERT(m_rareData); return m_rareData->m_stringSwitchJumpTables[tableIndex]; }
725		725
726		726
727	SharedSymbolTable* symbolTable() const { return m_unlinkedCode->symbolTable(); }	727	SymbolTable* symbolTable() const { return m_unlinkedCode->symbolTable(); }
728		728
729	EvalCodeCache& evalCodeCache() { createRareDataIfNecessary(); return m_rareData->m_evalCodeCache; }	729	EvalCodeCache& evalCodeCache() { createRareDataIfNecessary(); return m_rareData->m_evalCodeCache; }
730		730



class ScriptExecutable;
class SourceCode;
class SourceProvider;
class SymbolTable;
class UnlinkedCodeBlock;
class UnlinkedFunctionCodeBlock;


    const Identifier& name() const { return m_name; }
    const Identifier& inferredName() const { return m_inferredName; }
    JSString* nameValue() const { return m_nameValue.get(); }
    SymbolTable* symbolTable(CodeSpecializationKind kind)
    {
        return (kind == CodeForCall) ? m_symbolTableForCall.get() : m_symbolTableForConstruct.get();
    }

    Identifier m_name;
    Identifier m_inferredName;
    WriteBarrier<JSString> m_nameValue;
    WriteBarrier<SymbolTable> m_symbolTableForCall;
    WriteBarrier<SymbolTable> m_symbolTableForConstruct;
    RefPtr<FunctionParameters> m_parameters;
    unsigned m_firstLineOffset;
    unsigned m_lineCount;

    void addExceptionHandler(const UnlinkedHandlerInfo& hanler) { createRareDataIfNecessary(); return m_rareData->m_exceptionHandlers.append(hanler); }
    UnlinkedHandlerInfo& exceptionHandler(int index) { ASSERT(m_rareData); return m_rareData->m_exceptionHandlers[index]; }

    SymbolTable* symbolTable() const { return m_symbolTable.get(); }

    VM* vm() const { return m_vm; }


        Base::finishCreation(vm);
        if (codeType() == GlobalCode)
            return;
        m_symbolTable.set(vm, this, SymbolTable::create(vm));
    }

private:

    FunctionExpressionVector m_functionDecls;
    FunctionExpressionVector m_functionExprs;

    WriteBarrier<SymbolTable> m_symbolTable;

    Vector<unsigned> m_propertyAccessInstructions;





        Vector<UnlinkedInstruction, 0, UnsafeVectorOverflow>& instructions() { return m_instructions; }

        SymbolTable& symbolTable() { return *m_symbolTable; }

        bool shouldOptimizeLocals()
        {

        bool m_shouldEmitDebugHooks;
        bool m_shouldEmitProfileHooks;

        SymbolTable* m_symbolTable;

        ScopeNode* m_scopeNode;
        Strong<UnlinkedCodeBlock> m_codeBlock;

Lines 4350-4356 void SpeculativeJIT::compile(Node* node) Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp_sec1
- Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp -1 / +1 lines
4350		4350
4351	JITCompiler::Jump notCreated = m_jit.branch32(JITCompiler::Equal, activationValueTagGPR, TrustedImm32(JSValue::EmptyValueTag));	4351	JITCompiler::Jump notCreated = m_jit.branch32(JITCompiler::Equal, activationValueTagGPR, TrustedImm32(JSValue::EmptyValueTag));
4352		4352
4353	SharedSymbolTable* symbolTable = m_jit.symbolTableFor(node->codeOrigin);	4353	SymbolTable* symbolTable = m_jit.symbolTableFor(node->codeOrigin);
4354	int registersOffset = JSActivation::registersOffset(symbolTable);	4354	int registersOffset = JSActivation::registersOffset(symbolTable);
4355		4355
4356	int bytecodeCaptureStart = symbolTable->captureStart();	4356	int bytecodeCaptureStart = symbolTable->captureStart();

Lines 4630-4636 void SpeculativeJIT::compile(Node* node) Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp_sec1
- Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp -1 / +1 lines
4630		4630
4631	JITCompiler::Jump notCreated = m_jit.branchTest64(JITCompiler::Zero, activationValueGPR);	4631	JITCompiler::Jump notCreated = m_jit.branchTest64(JITCompiler::Zero, activationValueGPR);
4632		4632
4633	SharedSymbolTable* symbolTable = m_jit.symbolTableFor(node->codeOrigin);	4633	SymbolTable* symbolTable = m_jit.symbolTableFor(node->codeOrigin);
4634	int registersOffset = JSActivation::registersOffset(symbolTable);	4634	int registersOffset = JSActivation::registersOffset(symbolTable);
4635		4635
4636	int bytecodeCaptureStart = symbolTable->captureStart();	4636	int bytecodeCaptureStart = symbolTable->captureStart();

Lines 46-52 public: Source/JavaScriptCore/dfg/DFGStackLayoutPhase.cpp_sec1
- Source/JavaScriptCore/dfg/DFGStackLayoutPhase.cpp -1 / +1 lines
46		46
47	bool run()	47	bool run()
48	{	48	{
49	SharedSymbolTable* symbolTable = codeBlock()->symbolTable();	49	SymbolTable* symbolTable = codeBlock()->symbolTable();
50		50
51	// This enumerates the locals that we actually care about and packs them. So for example	51	// This enumerates the locals that we actually care about and packs them. So for example
52	// if we use local 1, 3, 4, 5, 7, then we remap them: 1->0, 3->1, 4->2, 5->3, 7->4. We	52	// if we use local 1, 3, 4, 5, 7, then we remap them: 1->0, 3->1, 4->2, 5->3, 7->4. We

Lines 435-441 public: Source/JavaScriptCore/jit/AssemblyHelpers.h_sec1
- Source/JavaScriptCore/jit/AssemblyHelpers.h -1 / +1 lines
435	return baselineArgumentsRegisterFor(codeOrigin.inlineCallFrame);	435	return baselineArgumentsRegisterFor(codeOrigin.inlineCallFrame);
436	}	436	}
437		437
438	SharedSymbolTable* symbolTableFor(const CodeOrigin& codeOrigin)	438	SymbolTable* symbolTableFor(const CodeOrigin& codeOrigin)
439	{	439	{
440	return baselineCodeBlockFor(codeOrigin)->symbolTable();	440	return baselineCodeBlockFor(codeOrigin)->symbolTable();
441	}	441	}

Lines 251-257 inline void Arguments::finishCreation(Ca Source/JavaScriptCore/runtime/Arguments.h_sec1
- Source/JavaScriptCore/runtime/Arguments.h -1 / +1 lines
251		251
252	CodeBlock* codeBlock = callFrame->codeBlock();	252	CodeBlock* codeBlock = callFrame->codeBlock();
253	if (codeBlock->hasSlowArguments()) {	253	if (codeBlock->hasSlowArguments()) {
254	SharedSymbolTable* symbolTable = codeBlock->symbolTable();	254	SymbolTable* symbolTable = codeBlock->symbolTable();
255	const SlowArgument* slowArguments = codeBlock->machineSlowArguments();	255	const SlowArgument* slowArguments = codeBlock->machineSlowArguments();
256	allocateSlowArguments();	256	allocateSlowArguments();
257	size_t count = std::min<unsigned>(m_numArguments, symbolTable->parameterCount());	257	size_t count = std::min<unsigned>(m_numArguments, symbolTable->parameterCount());

Lines 639-645 public: Source/JavaScriptCore/runtime/Executable.h_sec1
- Source/JavaScriptCore/runtime/Executable.h -1 / +1 lines
639	JSString* nameValue() const { return m_unlinkedExecutable->nameValue(); }	639	JSString* nameValue() const { return m_unlinkedExecutable->nameValue(); }
640	size_t parameterCount() const { return m_unlinkedExecutable->parameterCount(); } // Excluding 'this'!	640	size_t parameterCount() const { return m_unlinkedExecutable->parameterCount(); } // Excluding 'this'!
641	String paramString() const;	641	String paramString() const;
642	SharedSymbolTable* symbolTable(CodeSpecializationKind kind) const { return m_unlinkedExecutable->symbolTable(kind); }	642	SymbolTable* symbolTable(CodeSpecializationKind kind) const { return m_unlinkedExecutable->symbolTable(kind); }
643		643
644	void clearCodeIfNotCompiling();	644	void clearCodeIfNotCompiling();
645	void clearUnlinkedCodeForRecompilationIfNotCompiling();	645	void clearUnlinkedCodeForRecompilationIfNotCompiling();



    
class JSActivation : public JSVariableObject {
private:
    JSActivation(VM&, CallFrame*, Register*, SymbolTable*);
    
public:
    typedef JSVariableObject Base;

    static JSActivation* create(VM& vm, CallFrame* callFrame, Register* registers, CodeBlock* codeBlock)
    {
        SymbolTable* symbolTable = codeBlock->symbolTable();
        JSActivation* activation = new (
            NotNull,
            allocateCell<JSActivation>(

    bool isValid(const SymbolTableEntry&) const;
    bool isTornOff();
    int registersOffset();
    static int registersOffset(SymbolTable*);

protected:
    static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesVisitChildren | OverridesGetPropertyNames | Base::StructureFlags;


    static JSValue argumentsGetter(ExecState*, JSValue, PropertyName);

    static size_t allocationSize(SymbolTable*);
    static size_t storageOffset();

    WriteBarrier<Unknown>* storage(); // captureCount() number of registers.

extern int activationCount;
extern int allTheThingsCount;

inline JSActivation::JSActivation(VM& vm, CallFrame* callFrame, Register* registers, SymbolTable* symbolTable)
    : Base(
        vm,
        callFrame->lexicalGlobalObject()->activationStructure(),

    return asActivation(jsValue());
}

inline int JSActivation::registersOffset(SymbolTable* symbolTable)
{
    return storageOffset() + ((symbolTable->captureCount() - symbolTable->captureStart()  - 1) * sizeof(WriteBarrier<Unknown>));
}

        reinterpret_cast<char*>(this) + storageOffset());
}

inline size_t JSActivation::allocationSize(SymbolTable* symbolTable)
{
    size_t objectSizeInBytes = WTF::roundUpToMultipleOf<sizeof(WriteBarrier<Unknown>)>(sizeof(JSActivation));
    size_t storageSizeInBytes = symbolTable->captureCount() * sizeof(WriteBarrier<Unknown>);



public:
    typedef JSScope Base;
    
    SymbolTable* symbolTable() const { return m_symbolTable.get(); }
    
    JS_EXPORT_PRIVATE static bool deleteProperty(JSCell*, ExecState*, PropertyName);
    JS_EXPORT_PRIVATE static void getOwnNonIndexPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);

protected:
    static const unsigned StructureFlags = IsEnvironmentRecord | OverridesVisitChildren | OverridesGetPropertyNames | Base::StructureFlags;
    
    JSSymbolTableObject(VM& vm, Structure* structure, JSScope* scope, SymbolTable* symbolTable = 0)
        : Base(vm, structure, scope)
    {
        if (symbolTable)

    {
        Base::finishCreation(vm);
        if (!m_symbolTable)
            m_symbolTable.set(vm, this, SymbolTable::create(vm));
    }

    static void visitChildren(JSCell*, SlotVisitor&);

    WriteBarrier<SymbolTable> m_symbolTable;
};

template<typename SymbolTableObjectType>

Lines 61-67 protected: Source/JavaScriptCore/runtime/JSVariableObject.h_sec1
- Source/JavaScriptCore/runtime/JSVariableObject.h -1 / +1 lines
61	Structure* structure,	61	Structure* structure,
62	Register* registers,	62	Register* registers,
63	JSScope* scope,	63	JSScope* scope,
64	SharedSymbolTable* symbolTable = 0)	64	SymbolTable* symbolTable = 0)
65	: Base(vm, structure, scope, symbolTable)	65	: Base(vm, structure, scope, symbolTable)
66	, m_registers(reinterpret_cast<WriteBarrierBase<Unknown>*>(registers))	66	, m_registers(reinterpret_cast<WriteBarrierBase<Unknown>*>(registers))
67	{	67	{




namespace JSC {

const ClassInfo SymbolTable::s_info = { "SymbolTable", 0, 0, 0, CREATE_METHOD_TABLE(SymbolTable) };

SymbolTableEntry& SymbolTableEntry::copySlow(const SymbolTableEntry& other)
{

    return *this;
}

void SymbolTable::destroy(JSCell* cell)
{
    SymbolTable* thisObject = jsCast<SymbolTable*>(cell);
    thisObject->SymbolTable::~SymbolTable();
}

void SymbolTableEntry::freeFatEntrySlow()

    return entry;
}

SymbolTable::SymbolTable(VM& vm)
    : JSCell(vm, vm.symbolTableStructure.get())
    , m_parameterCountIncludingThis(0)
    , m_usesNonStrictEval(false)
    , m_captureStart(0)
    , m_captureEnd(0)
{
}

SymbolTable::~SymbolTable() { }

} // namespace JSC



    static const bool needsDestruction = true;
};

class SymbolTable : public JSCell {
public:
    typedef JSCell Base;

    typedef HashMap<RefPtr<StringImpl>, SymbolTableEntry, IdentifierRepHash, HashTraits<RefPtr<StringImpl>>, SymbolTableIndexHashTraits> Map;

    static SymbolTable* create(VM& vm)
    {
        SymbolTable* symbolTable = new (NotNull, allocateCell<SymbolTable>(vm.heap)) SymbolTable(vm);
        symbolTable->finishCreation(vm);
        return symbolTable;
    }
    static const bool needsDestruction = true;
    static const bool hasImmortalStructure = true;
    static void destroy(JSCell*);

    static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
    {
        return Structure::create(vm, globalObject, prototype, TypeInfo(LeafType, StructureFlags), info());
    }

    // You must hold the lock until after you're done with the iterator.
    Map::iterator find(const ConcurrentJITLocker&, StringImpl* key)
    {

        return contains(locker, key);
    }
    
private:
    Map m_map;
public:
    mutable ConcurrentJITLock m_lock;
};


class SharedSymbolTable : public JSCell, public SymbolTable {
public:
    typedef JSCell Base;

    static SharedSymbolTable* create(VM& vm)
    {
        SharedSymbolTable* sharedSymbolTable = new (NotNull, allocateCell<SharedSymbolTable>(vm.heap)) SharedSymbolTable(vm);
        sharedSymbolTable->finishCreation(vm);
        return sharedSymbolTable;
    }
    static const bool needsDestruction = true;
    static const bool hasImmortalStructure = true;
    static void destroy(JSCell*);

    static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
    {
        return Structure::create(vm, globalObject, prototype, TypeInfo(LeafType, StructureFlags), info());
    }

    bool usesNonStrictEval() { return m_usesNonStrictEval; }
    void setUsesNonStrictEval(bool usesNonStrictEval) { m_usesNonStrictEval = usesNonStrictEval; }


    DECLARE_EXPORT_INFO;

private:
    JS_EXPORT_PRIVATE SymbolTable(VM&);
    ~SymbolTable();
        , m_parameterCountIncludingThis(0)
        , m_usesNonStrictEval(false)
        , m_captureStart(0)
        , m_captureEnd(0)
    {
    }

    Map m_map;
    
    int m_parameterCountIncludingThis;
    bool m_usesNonStrictEval;


    int m_captureEnd;

    std::unique_ptr<SlowArgument[]> m_slowArguments;

public:
    mutable ConcurrentJITLock m_lock;
};

} // namespace JSC

Lines 245-251 VM::VM(VMType vmType, HeapType heapType) Source/JavaScriptCore/runtime/VM.cpp_sec1
- Source/JavaScriptCore/runtime/VM.cpp -1 / +1 lines
245	programExecutableStructure.set(this, ProgramExecutable::createStructure(this, 0, jsNull()));	245	programExecutableStructure.set(this, ProgramExecutable::createStructure(this, 0, jsNull()));
246	functionExecutableStructure.set(this, FunctionExecutable::createStructure(this, 0, jsNull()));	246	functionExecutableStructure.set(this, FunctionExecutable::createStructure(this, 0, jsNull()));
247	regExpStructure.set(this, RegExp::createStructure(this, 0, jsNull()));	247	regExpStructure.set(this, RegExp::createStructure(this, 0, jsNull()));
248	sharedSymbolTableStructure.set(this, SharedSymbolTable::createStructure(this, 0, jsNull()));	248	symbolTableStructure.set(this, SymbolTable::createStructure(this, 0, jsNull()));
249	structureChainStructure.set(this, StructureChain::createStructure(this, 0, jsNull()));	249	structureChainStructure.set(this, StructureChain::createStructure(this, 0, jsNull()));
250	sparseArrayValueMapStructure.set(this, SparseArrayValueMap::createStructure(this, 0, jsNull()));	250	sparseArrayValueMapStructure.set(this, SparseArrayValueMap::createStructure(this, 0, jsNull()));
251	withScopeStructure.set(this, JSWithScope::createStructure(this, 0, jsNull()));	251	withScopeStructure.set(this, JSWithScope::createStructure(this, 0, jsNull()));

Lines 264-270 namespace JSC { Source/JavaScriptCore/runtime/VM.h_sec1
- Source/JavaScriptCore/runtime/VM.h -1 / +1 lines
264	Strong<Structure> programExecutableStructure;	264	Strong<Structure> programExecutableStructure;
265	Strong<Structure> functionExecutableStructure;	265	Strong<Structure> functionExecutableStructure;
266	Strong<Structure> regExpStructure;	266	Strong<Structure> regExpStructure;
267	Strong<Structure> sharedSymbolTableStructure;	267	Strong<Structure> symbolTableStructure;
268	Strong<Structure> structureChainStructure;	268	Strong<Structure> structureChainStructure;
269	Strong<Structure> sparseArrayValueMapStructure;	269	Strong<Structure> sparseArrayValueMapStructure;
270	Strong<Structure> withScopeStructure;	270	Strong<Structure> withScopeStructure;

Return to Bug 124761

Lines 55-61 struct ParserError; Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h_sec1
- Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h -7 / +7 lines
55	class ScriptExecutable;	55	class ScriptExecutable;
56	class SourceCode;	56	class SourceCode;
57	class SourceProvider;	57	class SourceProvider;
58	class SharedSymbolTable;	58	class SymbolTable;
59	class UnlinkedCodeBlock;	59	class UnlinkedCodeBlock;
60	class UnlinkedFunctionCodeBlock;	60	class UnlinkedFunctionCodeBlock;
61		61
Lines 93-99 public: Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h_sec2
93	const Identifier& name() const { return m_name; }	93	const Identifier& name() const { return m_name; }
94	const Identifier& inferredName() const { return m_inferredName; }	94	const Identifier& inferredName() const { return m_inferredName; }
95	JSString* nameValue() const { return m_nameValue.get(); }	95	JSString* nameValue() const { return m_nameValue.get(); }
96	SharedSymbolTable* symbolTable(CodeSpecializationKind kind)	96	SymbolTable* symbolTable(CodeSpecializationKind kind)
97	{	97	{
98	return (kind == CodeForCall) ? m_symbolTableForCall.get() : m_symbolTableForConstruct.get();	98	return (kind == CodeForCall) ? m_symbolTableForCall.get() : m_symbolTableForConstruct.get();
99	}	99	}
Lines 156-163 private: Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h_sec3
156	Identifier m_name;	156	Identifier m_name;
157	Identifier m_inferredName;	157	Identifier m_inferredName;
158	WriteBarrier<JSString> m_nameValue;	158	WriteBarrier<JSString> m_nameValue;
159	WriteBarrier<SharedSymbolTable> m_symbolTableForCall;	159	WriteBarrier<SymbolTable> m_symbolTableForCall;
160	WriteBarrier<SharedSymbolTable> m_symbolTableForConstruct;	160	WriteBarrier<SymbolTable> m_symbolTableForConstruct;
161	RefPtr<FunctionParameters> m_parameters;	161	RefPtr<FunctionParameters> m_parameters;
162	unsigned m_firstLineOffset;	162	unsigned m_firstLineOffset;
163	unsigned m_lineCount;	163	unsigned m_lineCount;
Lines 383-389 public: Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h_sec4
383	void addExceptionHandler(const UnlinkedHandlerInfo& hanler) { createRareDataIfNecessary(); return m_rareData->m_exceptionHandlers.append(hanler); }	383	void addExceptionHandler(const UnlinkedHandlerInfo& hanler) { createRareDataIfNecessary(); return m_rareData->m_exceptionHandlers.append(hanler); }
384	UnlinkedHandlerInfo& exceptionHandler(int index) { ASSERT(m_rareData); return m_rareData->m_exceptionHandlers[index]; }	384	UnlinkedHandlerInfo& exceptionHandler(int index) { ASSERT(m_rareData); return m_rareData->m_exceptionHandlers[index]; }
385		385
386	SharedSymbolTable* symbolTable() const { return m_symbolTable.get(); }	386	SymbolTable* symbolTable() const { return m_symbolTable.get(); }
387		387
388	VM* vm() const { return m_vm; }	388	VM* vm() const { return m_vm; }
389		389
Lines 469-475 protected: Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h_sec5
469	Base::finishCreation(vm);	469	Base::finishCreation(vm);
470	if (codeType() == GlobalCode)	470	if (codeType() == GlobalCode)
471	return;	471	return;
472	m_symbolTable.set(vm, this, SharedSymbolTable::create(vm));	472	m_symbolTable.set(vm, this, SymbolTable::create(vm));
473	}	473	}
474		474
475	private:	475	private:
Lines 512-518 private: Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h_sec6
512	FunctionExpressionVector m_functionDecls;	512	FunctionExpressionVector m_functionDecls;
513	FunctionExpressionVector m_functionExprs;	513	FunctionExpressionVector m_functionExprs;
514		514
515	WriteBarrier<SharedSymbolTable> m_symbolTable;	515	WriteBarrier<SymbolTable> m_symbolTable;
516		516
517	Vector<unsigned> m_propertyAccessInstructions;	517	Vector<unsigned> m_propertyAccessInstructions;
518		518

Lines 534-540 namespace JSC { Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h_sec1
- Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h -2 / +2 lines
534		534
535	Vector<UnlinkedInstruction, 0, UnsafeVectorOverflow>& instructions() { return m_instructions; }	535	Vector<UnlinkedInstruction, 0, UnsafeVectorOverflow>& instructions() { return m_instructions; }
536		536
537	SharedSymbolTable& symbolTable() { return *m_symbolTable; }	537	SymbolTable& symbolTable() { return *m_symbolTable; }
538		538
539	bool shouldOptimizeLocals()	539	bool shouldOptimizeLocals()
540	{	540	{
Lines 577-583 namespace JSC { Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h_sec2
577	bool m_shouldEmitDebugHooks;	577	bool m_shouldEmitDebugHooks;
578	bool m_shouldEmitProfileHooks;	578	bool m_shouldEmitProfileHooks;
579		579
580	SharedSymbolTable* m_symbolTable;	580	SymbolTable* m_symbolTable;
581		581
582	ScopeNode* m_scopeNode;	582	ScopeNode* m_scopeNode;
583	Strong<UnlinkedCodeBlock> m_codeBlock;	583	Strong<UnlinkedCodeBlock> m_codeBlock;

Lines 334-346 struct SymbolTableIndexHashTraits : Hash Source/JavaScriptCore/runtime/SymbolTable.h_sec1
- Source/JavaScriptCore/runtime/SymbolTable.h -38 / +25 lines
334	static const bool needsDestruction = true;	334	static const bool needsDestruction = true;
335	};	335	};
336		336
337	class SymbolTable {	337	class SymbolTable : public JSCell {
338	public:	338	public:
		339	typedef JSCell Base;
		340
339	typedef HashMap<RefPtr<StringImpl>, SymbolTableEntry, IdentifierRepHash, HashTraits<RefPtr<StringImpl>>, SymbolTableIndexHashTraits> Map;	341	typedef HashMap<RefPtr<StringImpl>, SymbolTableEntry, IdentifierRepHash, HashTraits<RefPtr<StringImpl>>, SymbolTableIndexHashTraits> Map;
340		342
341	JS_EXPORT_PRIVATE SymbolTable();	343	static SymbolTable* create(VM& vm)
342	JS_EXPORT_PRIVATE ~SymbolTable();	344	{
343		345	SymbolTable* symbolTable = new (NotNull, allocateCell<SymbolTable>(vm.heap)) SymbolTable(vm);
		346	symbolTable->finishCreation(vm);
		347	return symbolTable;
		348	}
		349	static const bool needsDestruction = true;
		350	static const bool hasImmortalStructure = true;
		351	static void destroy(JSCell*);
		352
		353	static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
		354	{
		355	return Structure::create(vm, globalObject, prototype, TypeInfo(LeafType, StructureFlags), info());
		356	}
		357
344	// You must hold the lock until after you're done with the iterator.	358	// You must hold the lock until after you're done with the iterator.
345	Map::iterator find(const ConcurrentJITLocker&, StringImpl* key)	359	Map::iterator find(const ConcurrentJITLocker&, StringImpl* key)
346	{	360	{
Lines 433-464 public: Source/JavaScriptCore/runtime/SymbolTable.h_sec2
433	return contains(locker, key);	447	return contains(locker, key);
434	}	448	}
435		449
436	private:
437	Map m_map;
438	public:
439	mutable ConcurrentJITLock m_lock;
440	};
441
442
443	class SharedSymbolTable : public JSCell, public SymbolTable {
444	public:
445	typedef JSCell Base;
446
447	static SharedSymbolTable* create(VM& vm)
448	{
449	SharedSymbolTable* sharedSymbolTable = new (NotNull, allocateCell<SharedSymbolTable>(vm.heap)) SharedSymbolTable(vm);
450	sharedSymbolTable->finishCreation(vm);
451	return sharedSymbolTable;
452	}
453	static const bool needsDestruction = true;
454	static const bool hasImmortalStructure = true;
455	static void destroy(JSCell*);
456
457	static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
458	{
459	return Structure::create(vm, globalObject, prototype, TypeInfo(LeafType, StructureFlags), info());
460	}
461
462	bool usesNonStrictEval() { return m_usesNonStrictEval; }	450	bool usesNonStrictEval() { return m_usesNonStrictEval; }
463	void setUsesNonStrictEval(bool usesNonStrictEval) { m_usesNonStrictEval = usesNonStrictEval; }	451	void setUsesNonStrictEval(bool usesNonStrictEval) { m_usesNonStrictEval = usesNonStrictEval; }
464		452
Lines 481-495 public: Source/JavaScriptCore/runtime/SymbolTable.h_sec3
481	DECLARE_EXPORT_INFO;	469	DECLARE_EXPORT_INFO;
482		470
483	private:	471	private:
484	SharedSymbolTable(VM& vm)	472	JS_EXPORT_PRIVATE SymbolTable(VM&);
485	: JSCell(vm, vm.sharedSymbolTableStructure.get())	473	~SymbolTable();
486	, m_parameterCountIncludingThis(0)
487	, m_usesNonStrictEval(false)
488	, m_captureStart(0)
489	, m_captureEnd(0)
490	{
491	}
492		474
		475	Map m_map;
		476
493	int m_parameterCountIncludingThis;	477	int m_parameterCountIncludingThis;
494	bool m_usesNonStrictEval;	478	bool m_usesNonStrictEval;
495		479
Lines 497-502 private: Source/JavaScriptCore/runtime/SymbolTable.h_sec4
497	int m_captureEnd;	481	int m_captureEnd;
498		482
499	std::unique_ptr<SlowArgument[]> m_slowArguments;	483	std::unique_ptr<SlowArgument[]> m_slowArguments;
		484
		485	public:
		486	mutable ConcurrentJITLock m_lock;
500	};	487	};
501		488
502	} // namespace JSC	489	} // namespace JSC

Lines 1-3 Source/JavaScriptCore/ChangeLog_sec1
- Source/JavaScriptCore/ChangeLog +51 lines
		1	2013-11-21 Filip Pizlo <fpizlo@apple.com>
		2
		3	Combine SymbolTable and SharedSymbolTable
		4	https://bugs.webkit.org/show_bug.cgi?id=124761
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	SymbolTable was never used directly; we now always used SharedSymbolTable. So, this
		9	gets rid of SymbolTable and renames SharedSymbolTable to SymbolTable.
		10
		11	* bytecode/CodeBlock.h:
		12	(JSC::CodeBlock::symbolTable):
		13	* bytecode/UnlinkedCodeBlock.h:
		14	(JSC::UnlinkedFunctionExecutable::symbolTable):
		15	(JSC::UnlinkedCodeBlock::symbolTable):
		16	(JSC::UnlinkedCodeBlock::finishCreation):
		17	* bytecompiler/BytecodeGenerator.h:
		18	(JSC::BytecodeGenerator::symbolTable):
		19	* dfg/DFGSpeculativeJIT32_64.cpp:
		20	(JSC::DFG::SpeculativeJIT::compile):
		21	* dfg/DFGSpeculativeJIT64.cpp:
		22	(JSC::DFG::SpeculativeJIT::compile):
		23	* dfg/DFGStackLayoutPhase.cpp:
		24	(JSC::DFG::StackLayoutPhase::run):
		25	* jit/AssemblyHelpers.h:
		26	(JSC::AssemblyHelpers::symbolTableFor):
		27	* runtime/Arguments.h:
		28	(JSC::Arguments::finishCreation):
		29	* runtime/Executable.h:
		30	(JSC::FunctionExecutable::symbolTable):
		31	* runtime/JSActivation.h:
		32	(JSC::JSActivation::create):
		33	(JSC::JSActivation::JSActivation):
		34	(JSC::JSActivation::registersOffset):
		35	(JSC::JSActivation::allocationSize):
		36	* runtime/JSSymbolTableObject.h:
		37	(JSC::JSSymbolTableObject::symbolTable):
		38	(JSC::JSSymbolTableObject::JSSymbolTableObject):
		39	(JSC::JSSymbolTableObject::finishCreation):
		40	* runtime/JSVariableObject.h:
		41	(JSC::JSVariableObject::JSVariableObject):
		42	* runtime/SymbolTable.cpp:
		43	(JSC::SymbolTable::destroy):
		44	(JSC::SymbolTable::SymbolTable):
		45	* runtime/SymbolTable.h:
		46	(JSC::SymbolTable::create):
		47	(JSC::SymbolTable::createStructure):
		48	* runtime/VM.cpp:
		49	(JSC::VM::VM):
		50	* runtime/VM.h:
		51
1	2013-11-21 Filip Pizlo <fpizlo@apple.com>	52	2013-11-21 Filip Pizlo <fpizlo@apple.com>
2		53
3	Fix a typo (requriements->requirements).	54	Fix a typo (requriements->requirements).

Lines 41-54 class Register; Source/JavaScriptCore/runtime/JSActivation.h_sec1
- Source/JavaScriptCore/runtime/JSActivation.h -7 / +7 lines
41		41
42	class JSActivation : public JSVariableObject {	42	class JSActivation : public JSVariableObject {
43	private:	43	private:
44	JSActivation(VM&, CallFrame, Register, SharedSymbolTable*);	44	JSActivation(VM&, CallFrame, Register, SymbolTable*);
45		45
46	public:	46	public:
47	typedef JSVariableObject Base;	47	typedef JSVariableObject Base;
48		48
49	static JSActivation* create(VM& vm, CallFrame* callFrame, Register* registers, CodeBlock* codeBlock)	49	static JSActivation* create(VM& vm, CallFrame* callFrame, Register* registers, CodeBlock* codeBlock)
50	{	50	{
51	SharedSymbolTable* symbolTable = codeBlock->symbolTable();	51	SymbolTable* symbolTable = codeBlock->symbolTable();
52	JSActivation* activation = new (	52	JSActivation* activation = new (
53	NotNull,	53	NotNull,
54	allocateCell<JSActivation>(	54	allocateCell<JSActivation>(
Lines 87-93 public: Source/JavaScriptCore/runtime/JSActivation.h_sec2
87	bool isValid(const SymbolTableEntry&) const;	87	bool isValid(const SymbolTableEntry&) const;
88	bool isTornOff();	88	bool isTornOff();
89	int registersOffset();	89	int registersOffset();
90	static int registersOffset(SharedSymbolTable*);	90	static int registersOffset(SymbolTable*);
91		91
92	protected:	92	protected:
93	static const unsigned StructureFlags = OverridesGetOwnPropertySlot \| OverridesVisitChildren \| OverridesGetPropertyNames \| Base::StructureFlags;	93	static const unsigned StructureFlags = OverridesGetOwnPropertySlot \| OverridesVisitChildren \| OverridesGetPropertyNames \| Base::StructureFlags;
Lines 101-107 private: Source/JavaScriptCore/runtime/JSActivation.h_sec3
101		101
102	static JSValue argumentsGetter(ExecState*, JSValue, PropertyName);	102	static JSValue argumentsGetter(ExecState*, JSValue, PropertyName);
103		103
104	static size_t allocationSize(SharedSymbolTable*);	104	static size_t allocationSize(SymbolTable*);
105	static size_t storageOffset();	105	static size_t storageOffset();
106		106
107	WriteBarrier<Unknown>* storage(); // captureCount() number of registers.	107	WriteBarrier<Unknown>* storage(); // captureCount() number of registers.
Lines 110-116 private: Source/JavaScriptCore/runtime/JSActivation.h_sec4
110	extern int activationCount;	110	extern int activationCount;
111	extern int allTheThingsCount;	111	extern int allTheThingsCount;
112		112
113	inline JSActivation::JSActivation(VM& vm, CallFrame* callFrame, Register* registers, SharedSymbolTable* symbolTable)	113	inline JSActivation::JSActivation(VM& vm, CallFrame* callFrame, Register* registers, SymbolTable* symbolTable)
114	: Base(	114	: Base(
115	vm,	115	vm,
116	callFrame->lexicalGlobalObject()->activationStructure(),	116	callFrame->lexicalGlobalObject()->activationStructure(),
Lines 137-143 ALWAYS_INLINE JSActivation* Register::ac Source/JavaScriptCore/runtime/JSActivation.h_sec5
137	return asActivation(jsValue());	137	return asActivation(jsValue());
138	}	138	}
139		139
140	inline int JSActivation::registersOffset(SharedSymbolTable* symbolTable)	140	inline int JSActivation::registersOffset(SymbolTable* symbolTable)
141	{	141	{
142	return storageOffset() + ((symbolTable->captureCount() - symbolTable->captureStart() - 1) * sizeof(WriteBarrier<Unknown>));	142	return storageOffset() + ((symbolTable->captureCount() - symbolTable->captureStart() - 1) * sizeof(WriteBarrier<Unknown>));
143	}	143	}
Lines 175-181 inline WriteBarrier<Unknown>* JSActivati Source/JavaScriptCore/runtime/JSActivation.h_sec6
175	reinterpret_cast<char*>(this) + storageOffset());	175	reinterpret_cast<char*>(this) + storageOffset());
176	}	176	}
177		177
178	inline size_t JSActivation::allocationSize(SharedSymbolTable* symbolTable)	178	inline size_t JSActivation::allocationSize(SymbolTable* symbolTable)
179	{	179	{
180	size_t objectSizeInBytes = WTF::roundUpToMultipleOf<sizeof(WriteBarrier<Unknown>)>(sizeof(JSActivation));	180	size_t objectSizeInBytes = WTF::roundUpToMultipleOf<sizeof(WriteBarrier<Unknown>)>(sizeof(JSActivation));
181	size_t storageSizeInBytes = symbolTable->captureCount() * sizeof(WriteBarrier<Unknown>);	181	size_t storageSizeInBytes = symbolTable->captureCount() * sizeof(WriteBarrier<Unknown>);

Lines 39-45 class JSSymbolTableObject : public JSSco Source/JavaScriptCore/runtime/JSSymbolTableObject.h_sec1
- Source/JavaScriptCore/runtime/JSSymbolTableObject.h -4 / +4 lines
39	public:	39	public:
40	typedef JSScope Base;	40	typedef JSScope Base;
41		41
42	SharedSymbolTable* symbolTable() const { return m_symbolTable.get(); }	42	SymbolTable* symbolTable() const { return m_symbolTable.get(); }
43		43
44	JS_EXPORT_PRIVATE static bool deleteProperty(JSCell, ExecState, PropertyName);	44	JS_EXPORT_PRIVATE static bool deleteProperty(JSCell, ExecState, PropertyName);
45	JS_EXPORT_PRIVATE static void getOwnNonIndexPropertyNames(JSObject, ExecState, PropertyNameArray&, EnumerationMode);	45	JS_EXPORT_PRIVATE static void getOwnNonIndexPropertyNames(JSObject, ExecState, PropertyNameArray&, EnumerationMode);
Lines 47-53 public: Source/JavaScriptCore/runtime/JSSymbolTableObject.h_sec2
47	protected:	47	protected:
48	static const unsigned StructureFlags = IsEnvironmentRecord \| OverridesVisitChildren \| OverridesGetPropertyNames \| Base::StructureFlags;	48	static const unsigned StructureFlags = IsEnvironmentRecord \| OverridesVisitChildren \| OverridesGetPropertyNames \| Base::StructureFlags;
49		49
50	JSSymbolTableObject(VM& vm, Structure* structure, JSScope* scope, SharedSymbolTable* symbolTable = 0)	50	JSSymbolTableObject(VM& vm, Structure* structure, JSScope* scope, SymbolTable* symbolTable = 0)
51	: Base(vm, structure, scope)	51	: Base(vm, structure, scope)
52	{	52	{
53	if (symbolTable)	53	if (symbolTable)
Lines 58-69 protected: Source/JavaScriptCore/runtime/JSSymbolTableObject.h_sec3
58	{	58	{
59	Base::finishCreation(vm);	59	Base::finishCreation(vm);
60	if (!m_symbolTable)	60	if (!m_symbolTable)
61	m_symbolTable.set(vm, this, SharedSymbolTable::create(vm));	61	m_symbolTable.set(vm, this, SymbolTable::create(vm));
62	}	62	}
63		63
64	static void visitChildren(JSCell*, SlotVisitor&);	64	static void visitChildren(JSCell*, SlotVisitor&);
65		65
66	WriteBarrier<SharedSymbolTable> m_symbolTable;	66	WriteBarrier<SymbolTable> m_symbolTable;
67	};	67	};
68		68
69	template<typename SymbolTableObjectType>	69	template<typename SymbolTableObjectType>

Lines 35-41 Source/JavaScriptCore/runtime/SymbolTable.cpp_sec1
- Source/JavaScriptCore/runtime/SymbolTable.cpp -5 / +13 lines
35		35
36	namespace JSC {	36	namespace JSC {
37		37
38	const ClassInfo SharedSymbolTable::s_info = { "SharedSymbolTable", 0, 0, 0, CREATE_METHOD_TABLE(SharedSymbolTable) };	38	const ClassInfo SymbolTable::s_info = { "SymbolTable", 0, 0, 0, CREATE_METHOD_TABLE(SymbolTable) };
39		39
40	SymbolTableEntry& SymbolTableEntry::copySlow(const SymbolTableEntry& other)	40	SymbolTableEntry& SymbolTableEntry::copySlow(const SymbolTableEntry& other)
41	{	41	{
Lines 46-55 SymbolTableEntry& SymbolTableEntry::copy Source/JavaScriptCore/runtime/SymbolTable.cpp_sec2
46	return *this;	46	return *this;
47	}	47	}
48		48
49	void SharedSymbolTable::destroy(JSCell* cell)	49	void SymbolTable::destroy(JSCell* cell)
50	{	50	{
51	SharedSymbolTable* thisObject = jsCast<SharedSymbolTable*>(cell);	51	SymbolTable* thisObject = jsCast<SymbolTable*>(cell);
52	thisObject->SharedSymbolTable::~SharedSymbolTable();	52	thisObject->SymbolTable::~SymbolTable();
53	}	53	}
54		54
55	void SymbolTableEntry::freeFatEntrySlow()	55	void SymbolTableEntry::freeFatEntrySlow()
Lines 98-104 SymbolTableEntry::FatEntry* SymbolTableE Source/JavaScriptCore/runtime/SymbolTable.cpp_sec3
98	return entry;	98	return entry;
99	}	99	}
100		100
101	SymbolTable::SymbolTable() { }	101	SymbolTable::SymbolTable(VM& vm)
		102	: JSCell(vm, vm.symbolTableStructure.get())
		103	, m_parameterCountIncludingThis(0)
		104	, m_usesNonStrictEval(false)
		105	, m_captureStart(0)
		106	, m_captureEnd(0)
		107	{
		108	}
		109
102	SymbolTable::~SymbolTable() { }	110	SymbolTable::~SymbolTable() { }
103		111
104	} // namespace JSC	112	} // namespace JSC