Changeset 39229 in webkit for trunk/JavaScriptCore/bytecode/CodeBlock.h

Timestamp:

Dec 12, 2008, 12:02:09 AM (16 years ago)

Author:

[email protected]

Message:

2008-12-11 Sam Weinig <​[email protected]>

Reviewed by Geoffrey Garen.

Remove dependancy on having the Instruction buffer in order to
deref Structures used for property access and global resolves.
Instead, we put references to the necessary Structures in axillary
data structures on the CodeBlock. This is not an ideal solution,
as we still pay for having the Structures in two places and we
would like to eventually just hold on to offsets into the machine
code buffer.

• Also removes CodeBlock bloat in non-JIT by #ifdefing the JIT only data structures.

• GNUmakefile.am:
• JavaScriptCore.pri:
• JavaScriptCore.scons:
• JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
• JavaScriptCore.xcodeproj/project.pbxproj:
• JavaScriptCoreSources.bkl:
• bytecode/CodeBlock.cpp: (JSC::isGlobalResolve): (JSC::isPropertyAccess): (JSC::instructionOffsetForNth): (JSC::printGlobalResolveInfo): (JSC::printStructureStubInfo): (JSC::CodeBlock::printStructures): (JSC::CodeBlock::dump): (JSC::CodeBlock::~CodeBlock): (JSC::CodeBlock::shrinkToFit):
• bytecode/CodeBlock.h: (JSC::GlobalResolveInfo::GlobalResolveInfo): (JSC::getNativePC): (JSC::CodeBlock::instructions): (JSC::CodeBlock::getStubInfo): (JSC::CodeBlock::getBytecodeIndex): (JSC::CodeBlock::addPropertyAccessInstruction): (JSC::CodeBlock::addGlobalResolveInstruction): (JSC::CodeBlock::numberOfStructureStubInfos): (JSC::CodeBlock::addStructureStubInfo): (JSC::CodeBlock::structureStubInfo): (JSC::CodeBlock::addGlobalResolveInfo): (JSC::CodeBlock::globalResolveInfo): (JSC::CodeBlock::numberOfCallLinkInfos): (JSC::CodeBlock::addCallLinkInfo): (JSC::CodeBlock::callLinkInfo):
• bytecode/Instruction.h: (JSC::PolymorphicAccessStructureList::PolymorphicStubInfo::set): (JSC::PolymorphicAccessStructureList::PolymorphicAccessStructureList):
• bytecode/Opcode.h: (JSC::):
• bytecode/StructureStubInfo.cpp: Copied from bytecode/CodeBlock.cpp. (JSC::StructureStubInfo::deref):
• bytecode/StructureStubInfo.h: Copied from bytecode/CodeBlock.h. (JSC::StructureStubInfo::StructureStubInfo): (JSC::StructureStubInfo::initGetByIdSelf): (JSC::StructureStubInfo::initGetByIdProto): (JSC::StructureStubInfo::initGetByIdChain): (JSC::StructureStubInfo::initGetByIdSelfList): (JSC::StructureStubInfo::initGetByIdProtoList): (JSC::StructureStubInfo::initPutByIdTransition): (JSC::StructureStubInfo::initPutByIdReplace): (JSC::StructureStubInfo::):
• bytecompiler/BytecodeGenerator.cpp: (JSC::BytecodeGenerator::emitResolve): (JSC::BytecodeGenerator::emitGetById): (JSC::BytecodeGenerator::emitPutById): (JSC::BytecodeGenerator::emitCall): (JSC::BytecodeGenerator::emitConstruct): (JSC::BytecodeGenerator::emitCatch):
• interpreter/Interpreter.cpp: (JSC::Interpreter::tryCTICachePutByID): (JSC::Interpreter::tryCTICacheGetByID): (JSC::Interpreter::cti_op_get_by_id_self_fail): (JSC::getPolymorphicAccessStructureListSlot): (JSC::Interpreter::cti_op_get_by_id_proto_list): (JSC::Interpreter::cti_op_resolve_global):
• jit/JIT.cpp: (JSC::JIT::JIT): (JSC::JIT::privateCompileMainPass): (JSC::JIT::privateCompileSlowCases): (JSC::JIT::privateCompile):
• jit/JITPropertyAccess.cpp: (JSC::JIT::compileGetByIdHotPath): (JSC::JIT::compilePutByIdHotPath): (JSC::JIT::compileGetByIdSlowCase): (JSC::JIT::compilePutByIdSlowCase): (JSC::JIT::privateCompileGetByIdSelfList): (JSC::JIT::privateCompileGetByIdProtoList): (JSC::JIT::privateCompileGetByIdChainList):

File:

• trunk/JavaScriptCore/bytecode/CodeBlock.h (modified) (14 diffs)

trunk/JavaScriptCore/bytecode/CodeBlock.h

@@ -41 +41 @@
 #include <wtf/Vector.h>
 
+#if ENABLE(JIT)
+#include "StructureStubInfo.h"
+#endif
+
 namespace JSC {
 
@@ -54 +58 @@
         uint32_t target;
         uint32_t scopeDepth;
+#if ENABLE(JIT)
         void* nativeCode;
+#endif
     };
 
@@ -73 +79 @@
     };
 
-    struct StructureStubInfo {
-        StructureStubInfo(unsigned bytecodeIndex)
-            : bytecodeIndex(bytecodeIndex)
-            , stubRoutine(0)
-            , callReturnLocation(0)
-            , hotPathBegin(0)
-        {
-        }
-    
-        unsigned bytecodeIndex;
-        void* stubRoutine;
-        void* callReturnLocation;
-        void* hotPathBegin;
-    };
-
+#if ENABLE(JIT)
     struct CallLinkInfo {
         CallLinkInfo()
@@ -110 +102 @@
     };
 
-#if ENABLE(JIT)
+    struct GlobalResolveInfo {
+        GlobalResolveInfo()
+            : structure(0)
+            , offset(0)
+        {
+        }
+
+        Structure* structure;
+        unsigned offset;
+    };
+
     struct PC {
         PC(void* nativePC, unsigned bytecodeIndex)
@@ -121 +123 @@
         unsigned bytecodeIndex;
     };
-#endif
 
     // valueAtPosition helpers for the binaryChop algorithm below.
@@ -135 +136 @@
     }
 
-#if ENABLE(JIT)
     inline void* getNativePC(PC* pc)
     {
         return pc->nativePC;
     }
-#endif
 
     // Binary chop algorithm, calls valueAtPosition on pre-sorted elements in array,
@@ -177 +176 @@
         return &array[0];
     }
+#endif
 
     class CodeBlock {
@@ -184 +184 @@
         ~CodeBlock();
 
+        void mark();
+        void refStructures(Instruction* vPC) const;
+        void derefStructures(Instruction* vPC) const;
+#if ENABLE(JIT)
+        void unlinkCallers();
+#endif
+
         static void dumpStatistics();
 
-#if ENABLE(JIT) 
-        void unlinkCallers();
-#endif
-
+#if !defined(NDEBUG) || ENABLE_OPCODE_SAMPLING
+        void dump(ExecState*) const;
+        void printStructures(const Instruction*) const;
+        void printStructure(const char* name, const Instruction*, int operand) const;
+#endif
+
+        inline bool isKnownNotImmediate(int index)
+        {
+            if (index == m_thisRegister)
+                return true;
+
+            if (isConstantRegisterIndex(index))
+                return !JSImmediate::isImmediate(getConstant(index));
+
+            return false;
+        }
+
+        ALWAYS_INLINE bool isConstantRegisterIndex(int index)
+        {
+            return index >= m_numVars && index < m_numVars + m_numConstants;
+        }
+
+        ALWAYS_INLINE JSValue* getConstant(int index)
+        {
+            return m_constantRegisters[index - m_numVars].getJSValue();
+        }
+
+        ALWAYS_INLINE bool isTemporaryRegisterIndex(int index)
+        {
+            return index >= m_numVars + m_numConstants;
+        }
+
+        int expressionRangeForVPC(const Instruction*, int& divot, int& startOffset, int& endOffset);
+        int lineNumberForVPC(const Instruction* vPC);
+        HandlerInfo* handlerForVPC(const Instruction* vPC);
+
+#if ENABLE(JIT)
         void addCaller(CallLinkInfo* caller)
         {
@@ -209 +249 @@
         }
 
-        inline bool isKnownNotImmediate(int index)
-        {
-            if (index == m_thisRegister)
-                return true;
-
-            if (isConstantRegisterIndex(index))
-                return !JSImmediate::isImmediate(getConstant(index));
-
-            return false;
-        }
-
-        ALWAYS_INLINE bool isConstantRegisterIndex(int index)
-        {
-            return index >= m_numVars && index < m_numVars + m_numConstants;
-        }
-
-        ALWAYS_INLINE JSValue* getConstant(int index)
-        {
-            return m_constantRegisters[index - m_numVars].getJSValue();
-        }
-
-        ALWAYS_INLINE bool isTemporaryRegisterIndex(int index)
-        {
-            return index >= m_numVars + m_numConstants;
-        }
-
-#if !defined(NDEBUG) || ENABLE_OPCODE_SAMPLING
-        void dump(ExecState*) const;
-        void printStructures(const Instruction*) const;
-        void printStructure(const char* name, const Instruction*, int operand) const;
-#endif
-        int expressionRangeForVPC(const Instruction*, int& divot, int& startOffset, int& endOffset);
-        int lineNumberForVPC(const Instruction* vPC);
-        HandlerInfo* handlerForVPC(const Instruction* vPC);
-
-        void mark();
-        void refStructures(Instruction* vPC) const;
-        void derefStructures(Instruction* vPC) const;
-
         StructureStubInfo& getStubInfo(void* returnAddress)
         {
-            return *(binaryChop<StructureStubInfo, void*, getStructureStubInfoReturnLocation>(m_propertyAccessInstructions.begin(), m_propertyAccessInstructions.size(), returnAddress));
+            return *(binaryChop<StructureStubInfo, void*, getStructureStubInfoReturnLocation>(m_structureStubInfos.begin(), m_structureStubInfos.size(), returnAddress));
         }
 
@@ -258 +259 @@
         }
 
-#if ENABLE(JIT)
         unsigned getBytecodeIndex(void* nativePC)
         {
@@ -266 +266 @@
 
         Vector<Instruction>& instructions() { return m_instructions; }
+
 #if ENABLE(JIT)
         void setJITCode(void* jitCode) { m_jitCode = jitCode; }
@@ -292 +293 @@
         unsigned sourceOffset() const { return m_sourceOffset; }
 
-        void addGlobalResolveInstruction(unsigned globalResolveInstructions) { m_globalResolveInstructions.append(globalResolveInstructions); }
-
-        size_t numberOfPropertyAccessInstructions() const { return m_propertyAccessInstructions.size(); }
-        void addPropertyAccessInstruction(unsigned propertyAccessInstructions) { m_propertyAccessInstructions.append(StructureStubInfo(propertyAccessInstructions)); }
-        StructureStubInfo& propertyAccessInstruction(int index) { return m_propertyAccessInstructions[index]; }
-
-        size_t numberOfCallLinkInfos() const { return m_callLinkInfos.size(); }
-        void addCallLinkInfo() { m_callLinkInfos.append(CallLinkInfo()); }
-        CallLinkInfo& callLinkInfo(int index) { return m_callLinkInfos[index]; }
-
         size_t numberOfJumpTargets() const { return m_jumpTargets.size(); }
         void addJumpTarget(unsigned jumpTarget) { m_jumpTargets.append(jumpTarget); }
@@ -317 +308 @@
         LineInfo& lastLineInfo() { return m_lineInfo.last(); }
 
-#if ENABLE(JIT)
+#if !ENABLE(JIT)
+        void addPropertyAccessInstruction(unsigned propertyAccessInstruction) { m_propertyAccessInstructions.append(propertyAccessInstruction); }
+        void addGlobalResolveInstruction(unsigned globalResolveInstructions) { m_globalResolveInstructions.append(globalResolveInstructions); }
+#else
+        size_t numberOfStructureStubInfos() const { return m_structureStubInfos.size(); }
+        void addStructureStubInfo(const StructureStubInfo& stubInfo) { m_structureStubInfos.append(stubInfo); }
+        StructureStubInfo& structureStubInfo(int index) { return m_structureStubInfos[index]; }
+
+        void addGlobalResolveInfo() { m_globalResolveInfos.append(GlobalResolveInfo()); }
+        GlobalResolveInfo& globalResolveInfo(int index) { return m_globalResolveInfos[index]; }
+
+        size_t numberOfCallLinkInfos() const { return m_callLinkInfos.size(); }
+        void addCallLinkInfo() { m_callLinkInfos.append(CallLinkInfo()); }
+        CallLinkInfo& callLinkInfo(int index) { return m_callLinkInfos[index]; }
+
         Vector<PC>& pcVector() { return m_pcVector; }
 #endif
@@ -408 +413 @@
         unsigned m_sourceOffset;
 
+#if !ENABLE(JIT)
+        Vector<unsigned> m_propertyAccessInstructions;
         Vector<unsigned> m_globalResolveInstructions;
-        Vector<StructureStubInfo> m_propertyAccessInstructions;
+#else
+        Vector<StructureStubInfo> m_structureStubInfos;
+        Vector<GlobalResolveInfo> m_globalResolveInfos;
         Vector<CallLinkInfo> m_callLinkInfos;
         Vector<CallLinkInfo*> m_linkedCallerList;
+#endif
 
         Vector<unsigned> m_jumpTargets;