Do another merge using nifty new merge script (CL for that coming soon).

third_party/WebKit/JavaScriptCore/VM/CTI.cpp

 /*
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 569 matching lines @@
 void CTI::compileOpCallInitializeCallFrame(unsigned, unsigned argCount)
 {
     m_jit.movl_mr(OBJECT_OFFSET(JSFunction, m_scopeChain) + OBJECT_OFFSET(ScopeChain, m_node), X86::ecx, X86::ebx); // newScopeChain
 
     m_jit.movl_i32m(asInteger(noValue()), RegisterFile::OptionalCalleeArguments * static_cast<int>(sizeof(Register)), X86::edi);
     m_jit.movl_rm(X86::ecx, RegisterFile::Callee * static_cast<int>(sizeof(Register)), X86::edi);
     m_jit.movl_i32m(argCount, RegisterFile::ArgumentCount * static_cast<int>(sizeof(Register)), X86::edi);
     m_jit.movl_rm(X86::ebx, RegisterFile::ScopeChain * static_cast<int>(sizeof(Register)), X86::edi);
 }
 
-void CTI::compileOpCallSetupArgs(Instruction* instruction, bool isConstruct, bool isEval)
+void CTI::compileOpCallSetupArgs(Instruction* instruction)
 {
-    int firstArg = instruction[4].u.operand;
-    int argCount = instruction[5].u.operand;
-    int registerOffset = instruction[6].u.operand;
+    int argCount = instruction[3].u.operand;
+    int registerOffset = instruction[4].u.operand;
 
+    // ecx holds func
     emitPutArg(X86::ecx, 0);
     emitPutArgConstant(registerOffset, 4);
     emitPutArgConstant(argCount, 8);
     emitPutArgConstant(reinterpret_cast<unsigned>(instruction), 12);
-    if (isConstruct) {
-        emitGetPutArg(instruction[3].u.operand, 16, X86::eax);
-        emitPutArgConstant(firstArg, 20);
-    } else if (isEval)
-        emitGetPutArg(instruction[3].u.operand, 16, X86::eax);
+}
+
+void CTI::compileOpCallEvalSetupArgs(Instruction* instruction)
+{
+    int argCount = instruction[3].u.operand;
+    int registerOffset = instruction[4].u.operand;
+
+    // ecx holds func
+    emitPutArg(X86::ecx, 0);
+    emitPutArgConstant(registerOffset, 4);
+    emitPutArgConstant(argCount, 8);
+    emitPutArgConstant(reinterpret_cast<unsigned>(instruction), 12);
+}
+
+void CTI::compileOpConstructSetupArgs(Instruction* instruction)
+{
+    int argCount = instruction[3].u.operand;
+    int registerOffset = instruction[4].u.operand;
+    int proto = instruction[5].u.operand;
+    int thisRegister = instruction[6].u.operand;
+
+    // ecx holds func
+    emitPutArg(X86::ecx, 0);
+    emitPutArgConstant(registerOffset, 4);
+    emitPutArgConstant(argCount, 8);
+    emitGetPutArg(proto, 12, X86::eax);
+    emitPutArgConstant(thisRegister, 16);
+    emitPutArgConstant(reinterpret_cast<unsigned>(instruction), 20);
 }
 
 void CTI::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned i, unsigned callLinkInfoIndex)
 {
     int dst = instruction[1].u.operand;
     int callee = instruction[2].u.operand;
-    int firstArg = instruction[4].u.operand;
-    int argCount = instruction[5].u.operand;
-    int registerOffset = instruction[6].u.operand;
-
-    // Setup this value as the first argument (does not apply to constructors)
-    if (opcodeID != op_construct) {
-        int thisVal = instruction[3].u.operand;
-        if (thisVal == missingThisObjectMarker())
-            m_jit.movl_i32m(asInteger(jsNull()), firstArg * sizeof(Register), X86::edi);
-        else {
-            emitGetArg(thisVal, X86::eax);
-            emitPutResult(firstArg);
-        }
-    }
+    int argCount = instruction[3].u.operand;
+    int registerOffset = instruction[4].u.operand;
 
     // Handle eval
     X86Assembler::JmpSrc wasEval;
     if (opcodeID == op_call_eval) {
         emitGetArg(callee, X86::ecx);
-        compileOpCallSetupArgs(instruction, false, true);
+        compileOpCallEvalSetupArgs(instruction);
 
         emitCTICall(instruction, i, Machine::cti_op_call_eval);
         m_jit.cmpl_i32r(asInteger(JSImmediate::impossibleValue()), X86::eax);
         wasEval = m_jit.emitUnlinkedJne();
     }
 
     // This plants a check for a cached JSFunction value, so we can plant a fast link to the callee.
     // This deliberately leaves the callee in ecx, used when setting up the stack frame below
     emitGetArg(callee, X86::ecx);
     m_jit.cmpl_i32r(asInteger(JSImmediate::impossibleValue()), X86::ecx);
     X86Assembler::JmpDst addressOfLinkedFunctionCheck = m_jit.label();
     m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJne(), i));
     ASSERT(X86Assembler::getDifferenceBetweenLabels(addressOfLinkedFunctionCheck, m_jit.label()) == repatchOffsetOpCallCall);
     m_callStructureStubCompilationInfo[callLinkInfoIndex].hotPathBegin = addressOfLinkedFunctionCheck;
 
     // The following is the fast case, only used whan a callee can be linked.
 
     // In the case of OpConstruct, call out to a cti_ function to create the new object.
     if (opcodeID == op_construct) {
+        int proto = instruction[5].u.operand;
+        int thisRegister = instruction[6].u.operand;
+
         emitPutArg(X86::ecx, 0);
-        emitGetPutArg(instruction[3].u.operand, 16, X86::eax);
+        emitGetPutArg(proto, 12, X86::eax);
         emitCTICall(instruction, i, Machine::cti_op_construct_JSConstruct);
-        emitPutResult(firstArg);
+        emitPutResult(thisRegister);
         emitGetArg(callee, X86::ecx);
     }
 
     // Fast version of stack frame initialization, directly relative to edi.
     // Note that this omits to set up RegisterFile::CodeBlock, which is set in the callee
     m_jit.movl_i32m(asInteger(noValue()), (registerOffset + RegisterFile::OptionalCalleeArguments) * static_cast<int>(sizeof(Register)), X86::edi);
     m_jit.movl_rm(X86::ecx, (registerOffset + RegisterFile::Callee) * static_cast<int>(sizeof(Register)), X86::edi);
     m_jit.movl_mr(OBJECT_OFFSET(JSFunction, m_scopeChain) + OBJECT_OFFSET(ScopeChain, m_node), X86::ecx, X86::edx); // newScopeChain
     m_jit.movl_i32m(argCount, (registerOffset + RegisterFile::ArgumentCount) * static_cast<int>(sizeof(Register)), X86::edi);
     m_jit.movl_rm(X86::edi, (registerOffset + RegisterFile::CallerFrame) * static_cast<int>(sizeof(Register)), X86::edi);
@@ skipping 614 matching lines @@
             break;
         }
         case op_new_func: {
             FuncDeclNode* func = (m_codeBlock->functions[instruction[i + 2].u.operand]).get();
             emitPutArgConstant(reinterpret_cast<unsigned>(func), 0);
             emitCTICall(instruction + i, i, Machine::cti_op_new_func);
             emitPutResult(instruction[i + 1].u.operand);
             i += 3;
             break;
         }
-        case op_call: {
+        case op_call:
+        case op_call_eval:
+        case op_construct: {
             compileOpCall(opcodeID, instruction + i, i, callLinkInfoIndex++);
-            i += 7;
+            i += (opcodeID == op_construct ? 7 : 5);
             break;
         }
         case op_get_global_var: {
             JSVariableObject* globalObject = static_cast<JSVariableObject*>(instruction[i + 2].u.jsCell);
             m_jit.movl_i32r(asInteger(globalObject), X86::eax);
             emitGetVariableObjectRegister(X86::eax, instruction[i + 3].u.operand, X86::eax);
             emitPutResult(instruction[i + 1].u.operand);
             i += 4;
             break;
         }
@@ skipping 73 matching lines @@
             break;
         }
         case op_resolve: {
             Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 2].u.operand]);
             emitPutArgConstant(reinterpret_cast<unsigned>(ident), 0);
             emitCTICall(instruction + i, i, Machine::cti_op_resolve);
             emitPutResult(instruction[i + 1].u.operand);
             i += 3;
             break;
         }
-        case op_construct: {
-            compileOpCall(opcodeID, instruction + i, i, callLinkInfoIndex++);
-            i += 7;
-            break;
-        }
         case op_construct_verify: {
             emitGetArg(instruction[i + 1].u.operand, X86::eax);
             
             m_jit.testl_i32r(JSImmediate::TagMask, X86::eax);
             X86Assembler::JmpSrc isImmediate = m_jit.emitUnlinkedJne();
             m_jit.movl_mr(OBJECT_OFFSET(JSCell, m_structureID), X86::eax, X86::ecx);
             m_jit.cmpl_i32m(ObjectType, OBJECT_OFFSET(StructureID, m_typeInfo) + OBJECT_OFFSET(TypeInfo, m_type), X86::ecx);
             X86Assembler::JmpSrc isObject = m_jit.emitUnlinkedJe();
 
             m_jit.link(isImmediate, m_jit.label());
@@ skipping 507 matching lines @@
         }
         case op_bitor: {
             emitGetArg(instruction[i + 2].u.operand, X86::eax);
             emitGetArg(instruction[i + 3].u.operand, X86::edx);
             emitJumpSlowCaseIfNotImmNums(X86::eax, X86::edx, i);
             m_jit.orl_rr(X86::edx, X86::eax);
             emitPutResult(instruction[i + 1].u.operand);
             i += 5;
             break;
         }
-        case op_call_eval: {
-            compileOpCall(opcodeID, instruction + i, i, callLinkInfoIndex++);
-            i += 7;
-            break;
-        }
         case op_throw: {
             emitGetPutArg(instruction[i + 1].u.operand, 0, X86::ecx);
             emitCTICall(instruction + i, i, Machine::cti_op_throw);
             m_jit.addl_i8r(0x20, X86::esp);
             m_jit.popl_r(X86::ebx);
             m_jit.popl_r(X86::edi);
             m_jit.popl_r(X86::esi);
             m_jit.ret();
             i += 2;
             break;
@@ skipping 829 matching lines @@
                 compileBinaryArithOpSlowCase(instruction + i, op_mul, iter, dst, src1, src2, OperandTypes::fromInt(instruction[i + 4].u.operand), i);
             i += 5;
             break;
         }
 
         case op_call:
         case op_call_eval:
         case op_construct: {
             int dst = instruction[i + 1].u.operand;
             int callee = instruction[i + 2].u.operand;
-            int firstArg = instruction[i + 4].u.operand;
-            int argCount = instruction[i + 5].u.operand;
-            int registerOffset = instruction[i + 6].u.operand;
+            int argCount = instruction[i + 3].u.operand;
+            int registerOffset = instruction[i + 4].u.operand;
 
             m_jit.link(iter->from, m_jit.label());
 
             // The arguments have been set up on the hot path for op_call_eval
-            if (opcodeID != op_call_eval)
-                compileOpCallSetupArgs(instruction + i, (opcodeID == op_construct), false);
+            if (opcodeID == op_call)
+                compileOpCallSetupArgs(instruction + i);
+            else if (opcodeID == op_construct)
+                compileOpConstructSetupArgs(instruction + i);
 
             // Fast check for JS function.
             m_jit.testl_i32r(JSImmediate::TagMask, X86::ecx);
             X86Assembler::JmpSrc callLinkFailNotObject = m_jit.emitUnlinkedJne();
             m_jit.cmpl_i32m(reinterpret_cast<unsigned>(m_machine->m_jsFunctionVptr), X86::ecx);
             X86Assembler::JmpSrc callLinkFailNotJSFunction = m_jit.emitUnlinkedJne();
 
-            // First, in the cale of a construct, allocate the new object.
+            // First, in the case of a construct, allocate the new object.
             if (opcodeID == op_construct) {
                 emitCTICall(instruction, i, Machine::cti_op_construct_JSConstruct);
-                emitPutResult(firstArg);
+                emitPutResult(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
                 emitGetArg(callee, X86::ecx);
             }
 
             // Load the callee CodeBlock* into eax
             m_jit.movl_mr(OBJECT_OFFSET(JSFunction, m_body), X86::ecx, X86::eax);
             m_jit.movl_mr(OBJECT_OFFSET(FunctionBodyNode, m_code), X86::eax, X86::eax);
             m_jit.testl_rr(X86::eax, X86::eax);
             X86Assembler::JmpSrc hasCodeBlockForLink = m_jit.emitUnlinkedJne();
             emitCTICall(instruction + i, i, Machine::cti_op_call_JSFunction);
             emitGetArg(callee, X86::ecx);
@@ skipping 20 matching lines @@
             emitPutArgConstant(reinterpret_cast<unsigned>(info), 4);
             m_callStructureStubCompilationInfo[callLinkInfoIndex].callReturnLocation =
                 emitCTICall(instruction + i, i, Machine::cti_vm_lazyLinkCall);
             emitNakedCall(i, X86::eax);
             X86Assembler::JmpSrc storeResultForFirstRun = m_jit.emitUnlinkedJmp();
 
             // This is the address for the cold path *after* the first run (which tries to link the call).
             m_callStructureStubCompilationInfo[callLinkInfoIndex].coldPathOther = m_jit.label();
 
             // The arguments have been set up on the hot path for op_call_eval
-            if (opcodeID != op_call_eval)
-                compileOpCallSetupArgs(instruction + i, (opcodeID == op_construct), false);
+            if (opcodeID == op_call)
+                compileOpCallSetupArgs(instruction + i);
+            else if (opcodeID == op_construct)
+                compileOpConstructSetupArgs(instruction + i);
 
             // Check for JSFunctions.
             m_jit.testl_i32r(JSImmediate::TagMask, X86::ecx);
             X86Assembler::JmpSrc isNotObject = m_jit.emitUnlinkedJne();
             m_jit.cmpl_i32m(reinterpret_cast<unsigned>(m_machine->m_jsFunctionVptr), X86::ecx);
             X86Assembler::JmpSrc isJSFunction = m_jit.emitUnlinkedJe();
 
             // This handles host functions
             X86Assembler::JmpDst notJSFunctionlabel = m_jit.label();
             m_jit.link(isNotObject, notJSFunctionlabel);
             m_jit.link(callLinkFailNotObject, notJSFunctionlabel);
             m_jit.link(callLinkFailNotJSFunction, notJSFunctionlabel);
             emitCTICall(instruction + i, i, ((opcodeID == op_construct) ? Machine::cti_op_construct_NotJSConstruct : Machine::cti_op_call_NotJSFunction));
             X86Assembler::JmpSrc wasNotJSFunction = m_jit.emitUnlinkedJmp();
 
             // Next, handle JSFunctions...
             m_jit.link(isJSFunction, m_jit.label());
 
-            // First, in the cale of a construct, allocate the new object.
+            // First, in the case of a construct, allocate the new object.
             if (opcodeID == op_construct) {
                 emitCTICall(instruction, i, Machine::cti_op_construct_JSConstruct);
-                emitPutResult(firstArg);
+                emitPutResult(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
                 emitGetArg(callee, X86::ecx);
             }
 
             // Load the callee CodeBlock* into eax
             m_jit.movl_mr(OBJECT_OFFSET(JSFunction, m_body), X86::ecx, X86::eax);
             m_jit.movl_mr(OBJECT_OFFSET(FunctionBodyNode, m_code), X86::eax, X86::eax);
             m_jit.testl_rr(X86::eax, X86::eax);
             X86Assembler::JmpSrc hasCodeBlock = m_jit.emitUnlinkedJne();
             emitCTICall(instruction + i, i, Machine::cti_op_call_JSFunction);
             emitGetArg(callee, X86::ecx);
@@ skipping 24 matching lines @@
             X86Assembler::JmpDst storeResult = m_jit.label();
             m_jit.link(wasNotJSFunction, storeResult);
             m_jit.link(storeResultForFirstRun, storeResult);
             emitPutResult(dst);
 
 #if ENABLE(CODEBLOCK_SAMPLING)
             m_jit.movl_i32m(reinterpret_cast<unsigned>(m_codeBlock), m_machine->sampler()->codeBlockSlot());
 #endif
             ++callLinkInfoIndex;
 
-            i += 7;
+            i += (opcodeID == op_construct ? 7 : 5);
             break;
         }
         case op_to_jsnumber: {
             m_jit.link(iter->from, m_jit.label());
             m_jit.link(iter->from, m_jit.label());
 
             emitPutArg(X86::eax, 0);
             emitCTICall(instruction + i, i, Machine::cti_op_to_jsnumber);
 
             emitPutResult(instruction[i + 1].u.operand);
@@ skipping 652 matching lines @@
     void* code = jit.copy();
     ASSERT(code);
     return code;
 }
 
 #endif // ENABLE(WREC)
 
 } // namespace JSC
 
 #endif // ENABLE(CTI)