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

Timestamp:

Jan 8, 2009, 2:51:19 PM (16 years ago)

Author:

[email protected]

Message:

2009-01-08 Sam Weinig <​[email protected]>

Reviewed by Oliver Hunt.

Fix for ​https://bugs.webkit.org/show_bug.cgi?id=23197
Delay creating the PCVector until an exception is thrown
Part of <rdar://problem/6469060>
Don't store exception information for a CodeBlock until first exception is thrown

• Change the process for re-parsing/re-generating bytecode for exception information to use data from the original CodeBlock (offsets of GlobalResolve instructions) to aid in creating an identical instruction stream on re-parse, instead of padding interchangeable opcodes, which would result in different JITed code.
• Fix bug where the wrong ScopeChainNode was used when re-parsing/regenerating from within some odd modified scope chains.
• Lazily create the pcVector by re-JITing the regenerated CodeBlock and stealing the the pcVector from it.

Saves ~2MB on Membuster head.

• bytecode/CodeBlock.cpp: (JSC::CodeBlock::dump): (JSC::CodeBlock::reparseForExceptionInfoIfNecessary): (JSC::CodeBlock::hasGlobalResolveInstructionAtBytecodeOffset): (JSC::CodeBlock::hasGlobalResolveInfoAtBytecodeOffset):
• bytecode/CodeBlock.h: (JSC::JITCodeRef::JITCodeRef): (JSC::GlobalResolveInfo::GlobalResolveInfo): (JSC::CodeBlock::getBytecodeIndex): (JSC::CodeBlock::addGlobalResolveInstruction): (JSC::CodeBlock::addGlobalResolveInfo): (JSC::CodeBlock::addFunctionRegisterInfo): (JSC::CodeBlock::hasExceptionInfo): (JSC::CodeBlock::pcVector): (JSC::EvalCodeBlock::EvalCodeBlock): (JSC::EvalCodeBlock::baseScopeDepth):
• bytecode/Opcode.h:
• bytecompiler/BytecodeGenerator.cpp: (JSC::BytecodeGenerator::BytecodeGenerator): (JSC::BytecodeGenerator::emitResolve): (JSC::BytecodeGenerator::emitGetScopedVar):
• bytecompiler/BytecodeGenerator.h: (JSC::BytecodeGenerator::setRegeneratingForExceptionInfo):
• interpreter/Interpreter.cpp: (JSC::bytecodeOffsetForPC): (JSC::Interpreter::unwindCallFrame): (JSC::Interpreter::privateExecute): (JSC::Interpreter::retrieveLastCaller): (JSC::Interpreter::cti_op_instanceof): (JSC::Interpreter::cti_op_call_NotJSFunction): (JSC::Interpreter::cti_op_resolve): (JSC::Interpreter::cti_op_construct_NotJSConstruct): (JSC::Interpreter::cti_op_resolve_func): (JSC::Interpreter::cti_op_resolve_skip): (JSC::Interpreter::cti_op_resolve_global): (JSC::Interpreter::cti_op_resolve_with_base): (JSC::Interpreter::cti_op_throw): (JSC::Interpreter::cti_op_in): (JSC::Interpreter::cti_vm_throw):
• jit/JIT.cpp: (JSC::JIT::privateCompile):
• parser/Nodes.cpp: (JSC::EvalNode::generateBytecode): (JSC::EvalNode::bytecodeForExceptionInfoReparse): (JSC::FunctionBodyNode::bytecodeForExceptionInfoReparse):
• parser/Nodes.h:

File:

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

trunk/JavaScriptCore/bytecode/CodeBlock.h

@@ -67 +67 @@
     struct JITCodeRef {
         void* code;
+#ifndef NDEBUG
+        unsigned codeSize;
+#endif
         RefPtr<ExecutablePool> executablePool;
-        
+
         JITCodeRef()
             : code(0)
+#ifndef NDEBUG
+            , codeSize(0)
+#endif
         {
         }
@@ -76 +82 @@
         JITCodeRef(void* code, PassRefPtr<ExecutablePool> executablePool)
             : code(code)
+#ifndef NDEBUG
+            , codeSize(0)
+#endif
             , executablePool(executablePool)
         {
@@ -141 +150 @@
 
     struct GlobalResolveInfo {
-        GlobalResolveInfo()
+        GlobalResolveInfo(unsigned bytecodeOffset)
             : structure(0)
             , offset(0)
+            , bytecodeOffset(bytecodeOffset)
         {
         }
@@ -149 +159 @@
         Structure* structure;
         unsigned offset;
+        unsigned bytecodeOffset;
     };
 
@@ -298 +309 @@
         }
 
-        unsigned getBytecodeIndex(void* nativePC)
-        {
+        unsigned getBytecodeIndex(CallFrame* callFrame, void* nativePC)
+        {
+            reparseForExceptionInfoIfNecessary(callFrame);
             ptrdiff_t nativePCOffset = reinterpret_cast<void**>(nativePC) - reinterpret_cast<void**>(m_jitCode.code);
-            return binaryChop<PC, ptrdiff_t, getNativePCOffset>(m_pcVector.begin(), m_pcVector.size(), nativePCOffset)->bytecodeIndex;
+            return binaryChop<PC, ptrdiff_t, getNativePCOffset>(m_exceptionInfo->m_pcVector.begin(), m_exceptionInfo->m_pcVector.size(), nativePCOffset)->bytecodeIndex;
         }
 
@@ -344 +356 @@
 #if !ENABLE(JIT)
         void addPropertyAccessInstruction(unsigned propertyAccessInstruction) { m_propertyAccessInstructions.append(propertyAccessInstruction); }
-        void addGlobalResolveInstruction(unsigned globalResolveInstructions) { m_globalResolveInstructions.append(globalResolveInstructions); }
+        void addGlobalResolveInstruction(unsigned globalResolveInstruction) { m_globalResolveInstructions.append(globalResolveInstruction); }
+        bool hasGlobalResolveInstructionAtBytecodeOffset(unsigned bytecodeOffset);
 #else
         size_t numberOfStructureStubInfos() const { return m_structureStubInfos.size(); }
@@ -350 +363 @@
         StructureStubInfo& structureStubInfo(int index) { return m_structureStubInfos[index]; }
 
-        void addGlobalResolveInfo() { m_globalResolveInfos.append(GlobalResolveInfo()); }
+        void addGlobalResolveInfo(unsigned globalResolveInstruction) { m_globalResolveInfos.append(GlobalResolveInfo(globalResolveInstruction)); }
         GlobalResolveInfo& globalResolveInfo(int index) { return m_globalResolveInfos[index]; }
+        bool hasGlobalResolveInfoAtBytecodeOffset(unsigned bytecodeOffset);
 
         size_t numberOfCallLinkInfos() const { return m_callLinkInfos.size(); }
@@ -358 +372 @@
 
         void addFunctionRegisterInfo(unsigned bytecodeOffset, int functionIndex) { createRareDataIfNecessary(); m_rareData->m_functionRegisterInfos.append(FunctionRegisterInfo(bytecodeOffset, functionIndex)); }
-
-        Vector<PC>& pcVector() { return m_pcVector; }
 #endif
 
@@ -368 +380 @@
         HandlerInfo& exceptionHandler(int index) { ASSERT(m_rareData); return m_rareData->m_exceptionHandlers[index]; }
 
+        bool hasExceptionInfo() const { return m_exceptionInfo; }
         void clearExceptionInfo() { m_exceptionInfo.clear(); }
 
@@ -376 +389 @@
         void addLineInfo(const LineInfo& lineInfo) { ASSERT(m_exceptionInfo); m_exceptionInfo->m_lineInfo.append(lineInfo); }
         LineInfo& lastLineInfo() { ASSERT(m_exceptionInfo); return m_exceptionInfo->m_lineInfo.last(); }
+
+#if ENABLE(JIT)
+        Vector<PC>& pcVector() { ASSERT(m_exceptionInfo); return m_exceptionInfo->m_pcVector; }
+#endif
 
         // Constant Pool
@@ -475 +492 @@
         Vector<CallLinkInfo> m_callLinkInfos;
         Vector<CallLinkInfo*> m_linkedCallerList;
-
-        Vector<PC> m_pcVector;
 #endif
 
@@ -492 +507 @@
             Vector<LineInfo> m_lineInfo;
             Vector<GetByIdExceptionInfo> m_getByIdExceptionInfo;
+
+#if ENABLE(JIT)
+            Vector<PC> m_pcVector;
+#endif
         };
         OwnPtr<ExceptionInfo> m_exceptionInfo;
@@ -543 +562 @@
     class EvalCodeBlock : public ProgramCodeBlock {
     public:
-        EvalCodeBlock(ScopeNode* ownerNode, JSGlobalObject* globalObject, PassRefPtr<SourceProvider> sourceProvider)
+        EvalCodeBlock(ScopeNode* ownerNode, JSGlobalObject* globalObject, PassRefPtr<SourceProvider> sourceProvider, int baseScopeDepth)
             : ProgramCodeBlock(ownerNode, EvalCode, globalObject, sourceProvider)
-        {
-        }
+            , m_baseScopeDepth(baseScopeDepth)
+        {
+        }
+
+        int baseScopeDepth() const { return m_baseScopeDepth; }
+
+    private:
+        int m_baseScopeDepth;
     };