Changeset 95840 in webkit

Timestamp:

Sep 23, 2011 11:52:19 AM (13 years ago)

Author:

barraclough@apple.com

Message:

Implement op_resolve_global in the DFG JIT
​https://bugs.webkit.org/show_bug.cgi?id=68704

Reviewed by Oliver Hunt.

This is performance neutral, but increases coverage.

• dfg/DFGByteCodeParser.cpp:

(JSC::DFG::ByteCodeParser::ByteCodeParser):
(JSC::DFG::ByteCodeParser::parseBlock):

• dfg/DFGNode.h:

(JSC::DFG::Node::hasIdentifier):
(JSC::DFG::Node::resolveInfoIndex):

• dfg/DFGOperations.cpp:
• dfg/DFGOperations.h:
• dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::compile):

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• dfg/DFGByteCodeParser.cpp (modified) (3 diffs)
• dfg/DFGNode.h (modified) (3 diffs)
• dfg/DFGOperations.cpp (modified) (1 diff)
• dfg/DFGOperations.h (modified) (2 diffs)
• dfg/DFGSpeculativeJIT.cpp (modified) (1 diff)

trunk/Source/JavaScriptCore/ChangeLog

@@ +1 @@
+2011-09-23  Gavin Barraclough  <barraclough@apple.com>
+
+        Implement op_resolve_global in the DFG JIT
+        https://bugs.webkit.org/show_bug.cgi?id=68704
+
+        Reviewed by Oliver Hunt.
+
+        This is performance neutral, but increases coverage.
+
+        * dfg/DFGByteCodeParser.cpp:
+        (JSC::DFG::ByteCodeParser::ByteCodeParser):
+        (JSC::DFG::ByteCodeParser::parseBlock):
+        * dfg/DFGNode.h:
+        (JSC::DFG::Node::hasIdentifier):
+        (JSC::DFG::Node::resolveInfoIndex):
+        * dfg/DFGOperations.cpp:
+        * dfg/DFGOperations.h:
+        * dfg/DFGSpeculativeJIT.cpp:
+        (JSC::DFG::SpeculativeJIT::compile):
+
 2011-09-23  Mark Rowe  <mrowe@apple.com>
 

trunk/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp

@@ -57 +57 @@
         , m_parameterSlots(0)
         , m_numPassedVarArgs(0)
+        , m_globalResolveNumber(0)
     {
         ASSERT(m_profiledBlock);
@@ -616 +617 @@
     // The number of var args passed to the next var arg node.
     unsigned m_numPassedVarArgs;
+    // The index in the global resolve info.
+    unsigned m_globalResolveNumber;
 
     struct PhiStackEntry {
@@ -1428 +1431 @@
         }
             
+        case op_resolve_global: {
+            unsigned identifier = currentInstruction[2].u.operand;
+
+            NodeIndex resolve = addToGraph(ResolveGlobal, OpInfo(identifier), OpInfo(m_globalResolveNumber++));
+            set(currentInstruction[1].u.operand, resolve);
+
+            NEXT_OPCODE(op_resolve_global);
+        }
+
         case op_loop_hint: {
             // Baseline->DFG OSR jumps between loop hints. The DFG assumes that Baseline->DFG

trunk/Source/JavaScriptCore/dfg/DFGNode.h

@@ -291 +291 @@
     macro(ResolveBase, NodeResultJS | NodeMustGenerate | NodeClobbersWorld) \
     macro(ResolveBaseStrictPut, NodeResultJS | NodeMustGenerate | NodeClobbersWorld) \
+    macro(ResolveGlobal, NodeResultJS | NodeMustGenerate | NodeClobbersWorld) \
     \
     /* Nodes for misc operations. */\
@@ -467 +468 @@
         case ResolveBase:
         case ResolveBaseStrictPut:
+        case ResolveGlobal:
             return true;
         default:
@@ -480 +482 @@
     }
     
+    unsigned resolveInfoIndex()
+    {
+        ASSERT(op == ResolveGlobal);
+        return m_opInfo2;
+    }
+
     bool hasArithNodeFlags()
     {

trunk/Source/JavaScriptCore/dfg/DFGOperations.cpp

@@ -675 +675 @@
 }
 
+EncodedJSValue operationResolveGlobal(ExecState* exec, GlobalResolveInfo* resolveInfo, Identifier* propertyName)
+{
+    JSGlobalObject* globalObject = exec->lexicalGlobalObject();
+
+    PropertySlot slot(globalObject);
+    if (globalObject->getPropertySlot(exec, *propertyName, slot)) {
+        JSValue result = slot.getValue(exec, *propertyName);
+
+        if (slot.isCacheableValue() && !globalObject->structure()->isUncacheableDictionary() && slot.slotBase() == globalObject) {
+            resolveInfo->structure.set(exec->globalData(), exec->codeBlock()->ownerExecutable(), globalObject->structure());
+            resolveInfo->offset = slot.cachedOffset();
+        }
+
+        return JSValue::encode(result);
+    }
+
+    return throwVMError(exec, createUndefinedVariableError(exec, *propertyName));
+}
+
 EncodedJSValue operationToPrimitive(ExecState* exec, EncodedJSValue value)
 {

trunk/Source/JavaScriptCore/dfg/DFGOperations.h

@@ -31 +31 @@
 #include <dfg/DFGJITCompiler.h>
 
-namespace JSC { namespace DFG {
+namespace JSC {
+
+struct GlobalResolveInfo;
+
+namespace DFG {
 
 enum PutKind { Direct, NotDirect };
@@ -76 +80 @@
 EncodedJSValue operationResolveBase(ExecState*, Identifier*);
 EncodedJSValue operationResolveBaseStrictPut(ExecState*, Identifier*);
+EncodedJSValue operationResolveGlobal(ExecState*, GlobalResolveInfo*, Identifier*);
 EncodedJSValue operationToPrimitive(ExecState*, EncodedJSValue);
 EncodedJSValue operationStrCat(ExecState*, void* start, size_t);

trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp

@@ -2044 +2044 @@
         break;
     }
-        
+
+    case ResolveGlobal: {
+        GPRTemporary globalObject(this);
+        GPRTemporary resolveInfo(this);
+        GPRTemporary result(this);
+
+        GPRReg globalObjectGPR = globalObject.gpr();
+        GPRReg resolveInfoGPR = resolveInfo.gpr();
+        GPRReg resultGPR = result.gpr();
+
+        GlobalResolveInfo* resolveInfoAddress = &(m_jit.codeBlock()->globalResolveInfo(node.resolveInfoIndex()));
+
+        // Check Structure of global object
+        m_jit.move(JITCompiler::TrustedImmPtr(m_jit.codeBlock()->globalObject()), globalObjectGPR);
+        m_jit.move(JITCompiler::TrustedImmPtr(resolveInfoAddress), resolveInfoGPR);
+        m_jit.loadPtr(JITCompiler::Address(resolveInfoGPR, OBJECT_OFFSETOF(GlobalResolveInfo, structure)), resultGPR);
+        JITCompiler::Jump structuresMatch = m_jit.branchPtr(JITCompiler::Equal, resultGPR, JITCompiler::Address(globalObjectGPR, JSCell::structureOffset()));
+
+        silentSpillAllRegisters(resultGPR);
+        m_jit.move(resolveInfoGPR, GPRInfo::argumentGPR1);
+        m_jit.move(JITCompiler::TrustedImmPtr(&m_jit.codeBlock()->identifier(node.identifierNumber())), GPRInfo::argumentGPR2);
+        m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
+        JITCompiler::Call functionCall = appendCallWithExceptionCheck(operationResolveGlobal);
+        m_jit.move(GPRInfo::returnValueGPR, resultGPR);
+        silentFillAllRegisters(resultGPR);
+
+        JITCompiler::Jump wasSlow = m_jit.jump();
+
+        // Fast case
+        structuresMatch.link(&m_jit);
+        m_jit.loadPtr(JITCompiler::Address(globalObjectGPR, JSObject::offsetOfPropertyStorage()), resultGPR);
+        m_jit.load32(JITCompiler::Address(resolveInfoGPR, OBJECT_OFFSETOF(GlobalResolveInfo, offset)), resolveInfoGPR);
+        m_jit.loadPtr(JITCompiler::BaseIndex(resultGPR, resolveInfoGPR, JITCompiler::ScalePtr), resultGPR);
+
+        wasSlow.link(&m_jit);
+
+        jsValueResult(resultGPR, m_compileIndex);
+        break;
+    }
+
     case Phantom:
         // This is a no-op.