Changeset 158901 in webkit


Ignore:
Timestamp:
Nov 7, 2013, 8:05:27 PM (12 years ago)
Author:
mark.lam@apple.com
Message:

Get rid of the regT* definitions in JSInterfaceJIT.h.
​https://bugs.webkit.org/show_bug.cgi?id=123806.

Reviewed by Geoffrey Garen.

JSInterfaceJIT now inherits from GPRInfo and FPRInfo, and relies on them
to provide all the register definitions.

  • jit/GPRInfo.h:

(JSC::GPRInfo::toArgumentRegister):

  • jit/JIT.cpp:

(JSC::JIT::emitEnterOptimizationCheck):
(JSC::JIT::privateCompile):

  • jit/JITArithmetic.cpp:

(JSC::JIT::emit_compareAndJumpSlow):

  • jit/JITArithmetic32_64.cpp:

(JSC::JIT::emit_compareAndJumpSlow):

  • jit/JITCall.cpp:

(JSC::JIT::compileLoadVarargs):

  • jit/JITCall32_64.cpp:

(JSC::JIT::compileLoadVarargs):

  • jit/JITInlines.h:

(JSC::JIT::appendCallWithExceptionCheckSetJSValueResult):
(JSC::JIT::appendCallWithExceptionCheckSetJSValueResultWithProfile):

  • jit/JITOpcodes.cpp:

(JSC::JIT::emit_op_end):
(JSC::JIT::emitSlow_op_new_object):
(JSC::JIT::emit_op_ret):
(JSC::JIT::emit_op_ret_object_or_this):
(JSC::JIT::emit_op_throw):
(JSC::JIT::emit_op_get_pnames):
(JSC::JIT::emit_op_switch_imm):
(JSC::JIT::emit_op_switch_char):
(JSC::JIT::emit_op_switch_string):
(JSC::JIT::emit_op_create_activation):
(JSC::JIT::emit_op_create_arguments):
(JSC::JIT::emitSlow_op_jfalse):
(JSC::JIT::emitSlow_op_jtrue):
(JSC::JIT::emitSlow_op_eq):
(JSC::JIT::emitSlow_op_neq):
(JSC::JIT::emitSlow_op_get_argument_by_val):
(JSC::JIT::emitSlow_op_loop_hint):

  • jit/JITOpcodes32_64.cpp:

(JSC::JIT::privateCompileCTINativeCall):
(JSC::JIT::emit_op_end):
(JSC::JIT::emitSlow_op_new_object):
(JSC::JIT::emitSlow_op_jfalse):
(JSC::JIT::emitSlow_op_jtrue):
(JSC::JIT::emitSlow_op_eq):
(JSC::JIT::emitSlow_op_neq):
(JSC::JIT::emit_op_throw):
(JSC::JIT::emit_op_get_pnames):
(JSC::JIT::emit_op_switch_imm):
(JSC::JIT::emit_op_switch_char):
(JSC::JIT::emit_op_switch_string):
(JSC::JIT::emit_op_create_activation):
(JSC::JIT::emit_op_create_arguments):
(JSC::JIT::emitSlow_op_get_argument_by_val):

  • jit/JSInterfaceJIT.h:

(JSC::JSInterfaceJIT::JSInterfaceJIT):

  • jit/SlowPathCall.h:

(JSC::JITSlowPathCall::call):

  • jit/ThunkGenerators.cpp:
Location:
trunk/Source/JavaScriptCore
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r158891 r158901  
     12013-11-07  Mark Lam  <mark.lam@apple.com>
     2
     3        Get rid of the regT* definitions in JSInterfaceJIT.h.
     4        https://bugs.webkit.org/show_bug.cgi?id=123806.
     5
     6        Reviewed by Geoffrey Garen.
     7
     8        JSInterfaceJIT now inherits from GPRInfo and FPRInfo, and relies on them
     9        to provide all the register definitions.
     10
     11        * jit/GPRInfo.h:
     12        (JSC::GPRInfo::toArgumentRegister):
     13        * jit/JIT.cpp:
     14        (JSC::JIT::emitEnterOptimizationCheck):
     15        (JSC::JIT::privateCompile):
     16        * jit/JITArithmetic.cpp:
     17        (JSC::JIT::emit_compareAndJumpSlow):
     18        * jit/JITArithmetic32_64.cpp:
     19        (JSC::JIT::emit_compareAndJumpSlow):
     20        * jit/JITCall.cpp:
     21        (JSC::JIT::compileLoadVarargs):
     22        * jit/JITCall32_64.cpp:
     23        (JSC::JIT::compileLoadVarargs):
     24        * jit/JITInlines.h:
     25        (JSC::JIT::appendCallWithExceptionCheckSetJSValueResult):
     26        (JSC::JIT::appendCallWithExceptionCheckSetJSValueResultWithProfile):
     27        * jit/JITOpcodes.cpp:
     28        (JSC::JIT::emit_op_end):
     29        (JSC::JIT::emitSlow_op_new_object):
     30        (JSC::JIT::emit_op_ret):
     31        (JSC::JIT::emit_op_ret_object_or_this):
     32        (JSC::JIT::emit_op_throw):
     33        (JSC::JIT::emit_op_get_pnames):
     34        (JSC::JIT::emit_op_switch_imm):
     35        (JSC::JIT::emit_op_switch_char):
     36        (JSC::JIT::emit_op_switch_string):
     37        (JSC::JIT::emit_op_create_activation):
     38        (JSC::JIT::emit_op_create_arguments):
     39        (JSC::JIT::emitSlow_op_jfalse):
     40        (JSC::JIT::emitSlow_op_jtrue):
     41        (JSC::JIT::emitSlow_op_eq):
     42        (JSC::JIT::emitSlow_op_neq):
     43        (JSC::JIT::emitSlow_op_get_argument_by_val):
     44        (JSC::JIT::emitSlow_op_loop_hint):
     45        * jit/JITOpcodes32_64.cpp:
     46        (JSC::JIT::privateCompileCTINativeCall):
     47        (JSC::JIT::emit_op_end):
     48        (JSC::JIT::emitSlow_op_new_object):
     49        (JSC::JIT::emitSlow_op_jfalse):
     50        (JSC::JIT::emitSlow_op_jtrue):
     51        (JSC::JIT::emitSlow_op_eq):
     52        (JSC::JIT::emitSlow_op_neq):
     53        (JSC::JIT::emit_op_throw):
     54        (JSC::JIT::emit_op_get_pnames):
     55        (JSC::JIT::emit_op_switch_imm):
     56        (JSC::JIT::emit_op_switch_char):
     57        (JSC::JIT::emit_op_switch_string):
     58        (JSC::JIT::emit_op_create_activation):
     59        (JSC::JIT::emit_op_create_arguments):
     60        (JSC::JIT::emitSlow_op_get_argument_by_val):
     61        * jit/JSInterfaceJIT.h:
     62        (JSC::JSInterfaceJIT::JSInterfaceJIT):
     63        * jit/SlowPathCall.h:
     64        (JSC::JITSlowPathCall::call):
     65        * jit/ThunkGenerators.cpp:
     66
    1672013-11-07  Filip Pizlo  <fpizlo@apple.com>
    268

  • trunk/Source/JavaScriptCore/jit/GPRInfo.h

    r158883 r158901  
    279279#endif
    280280
     281// The baseline JIT requires that regT3 be callee-preserved.
     282
    281283#if CPU(X86)
    282284#define NUMBER_OF_ARGUMENT_REGISTERS 0u
    … …  
    287289    static const unsigned numberOfRegisters = 6;
    288290    static const unsigned numberOfArgumentRegisters = NUMBER_OF_ARGUMENT_REGISTERS;
     291
     292    // Note: regT3 is required to be callee-preserved.
    289293
    290294    // Temporary registers.
    … …  
    344348
    345349#if CPU(X86_64)
     350#if !OS(WINDOWS)
    346351#define NUMBER_OF_ARGUMENT_REGISTERS 6u
     352#else
     353#define NUMBER_OF_ARGUMENT_REGISTERS 4u
     354#endif
    347355
    348356class GPRInfo {
    … …  
    351359    static const unsigned numberOfRegisters = 10;
    352360    static const unsigned numberOfArgumentRegisters = NUMBER_OF_ARGUMENT_REGISTERS;
     361
     362    // Note: regT3 is required to be callee-preserved.
    353363
    354364    // These registers match the baseline JIT.
    … …  
    369379    static const GPRReg regT9 = X86Registers::r13;
    370380    // These constants provide the names for the general purpose argument & return value registers.
     381#if !OS(WINDOWS)
    371382    static const GPRReg argumentGPR0 = X86Registers::edi; // regT4
    372383    static const GPRReg argumentGPR1 = X86Registers::esi; // regT5
    … …  
    375386    static const GPRReg argumentGPR4 = X86Registers::r8;  // regT6
    376387    static const GPRReg argumentGPR5 = X86Registers::r9;  // regT7
     388#else
     389    static const GPRReg argumentGPR0 = X86Registers::ecx;
     390    static const GPRReg argumentGPR1 = X86Registers::edx;
     391    static const GPRReg argumentGPR2 = X86Registers::r8; // regT6
     392    static const GPRReg argumentGPR3 = X86Registers::r9; // regT7
     393#endif
    377394    static const GPRReg nonArgGPR0 = X86Registers::eax; // regT0
    378395    static const GPRReg nonArgGPR1 = X86Registers::ebx; // regT3
    … …  
    392409    {
    393410        ASSERT(index < numberOfArgumentRegisters);
     411#if !OS(WINDOWS)
    394412        static const GPRReg registerForIndex[numberOfArgumentRegisters] = { argumentGPR0, argumentGPR1, argumentGPR2, argumentGPR3, argumentGPR4, argumentGPR5 };
     413#else
     414        static const GPRReg registerForIndex[numberOfArgumentRegisters] = { argumentGPR0, argumentGPR1, argumentGPR2, argumentGPR3 };
     415#endif
    395416        return registerForIndex[index];
    396417    }
    … …  
    433454    static const unsigned numberOfRegisters = 10;
    434455    static const unsigned numberOfArgumentRegisters = NUMBER_OF_ARGUMENT_REGISTERS;
     456
     457    // Note: regT3 is required to be callee-preserved.
    435458
    436459    // Temporary registers.
    … …  
    461484    static const GPRReg nonPreservedNonReturnGPR = ARMRegisters::r2;
    462485
     486#if ENABLE(VALUE_PROFILER)
     487    static const GPRReg bucketCounterRegister = ARMRegisters::r7;
     488#endif
     489
    463490    static GPRReg toRegister(unsigned index)
    464491    {
    … …  
    504531    typedef GPRReg RegisterType;
    505532    static const unsigned numberOfRegisters = 16;
     533
     534    // Note: regT3 is required to be callee-preserved.
    506535
    507536    // These registers match the baseline JIT.
    … …  
    515544    static const GPRReg regT1 = ARM64Registers::x1;
    516545    static const GPRReg regT2 = ARM64Registers::x2;
    517     static const GPRReg regT3 = ARM64Registers::x3;
    518     static const GPRReg regT4 = ARM64Registers::x4;
     546    static const GPRReg regT3 = ARM64Registers::x23;
     547    static const GPRReg regT4 = ARM64Registers::x24;
    519548    static const GPRReg regT5 = ARM64Registers::x5;
    520549    static const GPRReg regT6 = ARM64Registers::x6;
    … …  
    544573    static const GPRReg nonPreservedNonReturnGPR = ARM64Registers::x2;
    545574
     575#if ENABLE(VALUE_PROFILER)
     576    static const GPRReg bucketCounterRegister = ARM64Registers::x7;
     577#endif
     578
    546579    // GPRReg mapping is direct, the machine regsiter numbers can
    547580    // be used directly as indices into the GPR RegisterBank.
    … …  
    598631    static const unsigned numberOfRegisters = 7;
    599632    static const unsigned numberOfArgumentRegisters = NUMBER_OF_ARGUMENT_REGISTERS;
     633
     634    // regT0 must be v0 for returning a 32-bit value.
     635    // regT1 must be v1 for returning a pair of 32-bit value.
     636    // regT3 must be saved in the callee, so use an S register.
    600637
    601638    // Temporary registers.
    … …  
    670707    typedef GPRReg RegisterType;
    671708    static const unsigned numberOfRegisters = 10;
     709
     710    // Note: regT3 is required to be callee-preserved.
    672711
    673712    // Temporary registers.
    … …  
    732771#endif
    733772
     773// The baseline JIT uses "accumulator" style execution with regT0 (for 64-bit)
     774// and regT0 + regT1 (for 32-bit) serving as the accumulator register(s) for
     775// passing results of one opcode to the next. Hence:
     776COMPILE_ASSERT(GPRInfo::regT0 == GPRInfo::returnValueGPR, regT0_must_equal_returnValueGPR);
     777#if USE(JSVALUE32_64)
     778COMPILE_ASSERT(GPRInfo::regT1 == GPRInfo::returnValueGPR2, regT1_must_equal_returnValueGPR2);
     779#endif
     780
    734781} // namespace JSC
    735782

  • trunk/Source/JavaScriptCore/jit/JIT.cpp

    r158586 r158901  
    110110    ASSERT(!m_bytecodeOffset);
    111111    callOperation(operationOptimize, m_bytecodeOffset);
    112     skipOptimize.append(branchTestPtr(Zero, returnValueRegister));
    113     jump(returnValueRegister);
     112    skipOptimize.append(branchTestPtr(Zero, returnValueGPR));
     113    jump(returnValueGPR);
    114114    skipOptimize.link(this);
    115115}
    … …  
    622622
    623623        callOperationWithCallFrameRollbackOnException(m_codeBlock->m_isConstructor ? operationConstructArityCheck : operationCallArityCheck);
    624         if (returnValueRegister != regT0)
    625             move(returnValueRegister, regT0);
     624        if (returnValueGPR != regT0)
     625            move(returnValueGPR, regT0);
    626626        branchTest32(Zero, regT0).linkTo(beginLabel, this);
    627627        emitNakedCall(m_vm->getCTIStub(arityFixup).code());

  • trunk/Source/JavaScriptCore/jit/JITArithmetic.cpp

    r157603 r158901  
    478478        linkSlowCase(iter);
    479479
    480         emitGetVirtualRegister(op1, firstArgumentRegister);
    481         emitGetVirtualRegister(op2, secondArgumentRegister);
    482         callOperation(operation, firstArgumentRegister, secondArgumentRegister);
    483         emitJumpSlowToHot(branchTest32(invert ? Zero : NonZero, returnValueRegister), target);
     480        emitGetVirtualRegister(op1, argumentGPR0);
     481        emitGetVirtualRegister(op2, argumentGPR1);
     482        callOperation(operation, argumentGPR0, argumentGPR1);
     483        emitJumpSlowToHot(branchTest32(invert ? Zero : NonZero, returnValueGPR), target);
    484484        return;
    485485    }
    … …  
    507507        emitGetVirtualRegister(op2, regT1);
    508508        callOperation(operation, regT0, regT1);
    509         emitJumpSlowToHot(branchTest32(invert ? Zero : NonZero, returnValueRegister), target);
     509        emitJumpSlowToHot(branchTest32(invert ? Zero : NonZero, returnValueGPR), target);
    510510    } else if (isOperandConstantImmediateInt(op1)) {
    511511        linkSlowCase(iter);
    … …  
    530530        emitGetVirtualRegister(op1, regT2);
    531531        callOperation(operation, regT2, regT1);
    532         emitJumpSlowToHot(branchTest32(invert ? Zero : NonZero, returnValueRegister), target);
     532        emitJumpSlowToHot(branchTest32(invert ? Zero : NonZero, returnValueGPR), target);
    533533    } else {
    534534        linkSlowCase(iter);
    … …  
    554554        linkSlowCase(iter);
    555555        callOperation(operation, regT0, regT1);
    556         emitJumpSlowToHot(branchTest32(invert ? Zero : NonZero, returnValueRegister), target);
     556        emitJumpSlowToHot(branchTest32(invert ? Zero : NonZero, returnValueGPR), target);
    557557    }
    558558}

  • trunk/Source/JavaScriptCore/jit/JITArithmetic32_64.cpp

    r157603 r158901  
    161161    emitLoad(op2, regT3, regT2);
    162162    callOperation(operation, regT1, regT0, regT3, regT2);
    163     emitJumpSlowToHot(branchTest32(invert ? Zero : NonZero, returnValueRegister), target);
     163    emitJumpSlowToHot(branchTest32(invert ? Zero : NonZero, returnValueGPR), target);
    164164}
    165165

  • trunk/Source/JavaScriptCore/jit/JITCall.cpp

    r158315 r158901  
    122122    emitGetVirtualRegister(arguments, regT1);
    123123    callOperation(operationLoadVarargs, regT0, regT1, firstFreeRegister);
    124     move(returnValueRegister, regT1);
     124    move(returnValueGPR, regT1);
    125125
    126126    if (canOptimize)

  • trunk/Source/JavaScriptCore/jit/JITCall32_64.cpp

    r158672 r158901  
    193193    emitLoad(arguments, regT3, regT2);
    194194    callOperation(operationLoadVarargs, regT1, regT0, regT3, regT2, firstFreeRegister);
    195     move(returnValueRegister, regT3);
     195    move(returnValueGPR, regT3);
    196196
    197197    if (canOptimize)

  • trunk/Source/JavaScriptCore/jit/JITInlines.h

    r158315 r158901  
    150150    MacroAssembler::Call call = appendCallWithExceptionCheck(function);
    151151#if USE(JSVALUE64)
    152     emitPutVirtualRegister(dst, returnValueRegister);
    153 #else
    154     emitStore(dst, returnValue2Register, returnValueRegister);
     152    emitPutVirtualRegister(dst, returnValueGPR);
     153#else
     154    emitStore(dst, returnValueGPR2, returnValueGPR);
    155155#endif
    156156    return call;
    … …  
    162162    emitValueProfilingSite(regT4);
    163163#if USE(JSVALUE64)
    164     emitPutVirtualRegister(dst, returnValueRegister);
    165 #else
    166     emitStore(dst, returnValue2Register, returnValueRegister);
     164    emitPutVirtualRegister(dst, returnValueGPR);
     165#else
     166    emitStore(dst, returnValueGPR2, returnValueGPR);
    167167#endif
    168168    return call;

  • trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp

    r158315 r158901  
    8484void JIT::emit_op_end(Instruction* currentInstruction)
    8585{
    86     RELEASE_ASSERT(returnValueRegister != callFrameRegister);
    87     emitGetVirtualRegister(currentInstruction[1].u.operand, returnValueRegister);
     86    RELEASE_ASSERT(returnValueGPR != callFrameRegister);
     87    emitGetVirtualRegister(currentInstruction[1].u.operand, returnValueGPR);
    8888    restoreReturnAddressBeforeReturn(Address(callFrameRegister, CallFrame::returnPCOffset()));
    8989    ret();
    … …  
    117117    Structure* structure = currentInstruction[3].u.objectAllocationProfile->structure();
    118118    callOperation(operationNewObject, structure);
    119     emitStoreCell(dst, returnValueRegister);
     119    emitStoreCell(dst, returnValueGPR);
    120120}
    121121
    … …  
    269269{
    270270    ASSERT(callFrameRegister != regT1);
    271     ASSERT(regT1 != returnValueRegister);
    272     ASSERT(returnValueRegister != callFrameRegister);
     271    ASSERT(regT1 != returnValueGPR);
     272    ASSERT(returnValueGPR != callFrameRegister);
    273273
    274274    // Return the result in %eax.
    275     emitGetVirtualRegister(currentInstruction[1].u.operand, returnValueRegister);
     275    emitGetVirtualRegister(currentInstruction[1].u.operand, returnValueGPR);
    276276
    277277    // Grab the return address.
    … …  
    289289{
    290290    ASSERT(callFrameRegister != regT1);
    291     ASSERT(regT1 != returnValueRegister);
    292     ASSERT(returnValueRegister != callFrameRegister);
     291    ASSERT(regT1 != returnValueGPR);
     292    ASSERT(returnValueGPR != callFrameRegister);
    293293
    294294    // Return the result in %eax.
    295     emitGetVirtualRegister(currentInstruction[1].u.operand, returnValueRegister);
    296     Jump notJSCell = emitJumpIfNotJSCell(returnValueRegister);
    297     loadPtr(Address(returnValueRegister, JSCell::structureOffset()), regT2);
     295    emitGetVirtualRegister(currentInstruction[1].u.operand, returnValueGPR);
     296    Jump notJSCell = emitJumpIfNotJSCell(returnValueGPR);
     297    loadPtr(Address(returnValueGPR, JSCell::structureOffset()), regT2);
    298298    Jump notObject = emitJumpIfNotObject(regT2);
    299299
    … …  
    311311    notJSCell.link(this);
    312312    notObject.link(this);
    313     emitGetVirtualRegister(currentInstruction[2].u.operand, returnValueRegister);
     313    emitGetVirtualRegister(currentInstruction[2].u.operand, returnValueGPR);
    314314
    315315    // Grab the return address.
    … …  
    484484void JIT::emit_op_throw(Instruction* currentInstruction)
    485485{
    486     ASSERT(regT0 == returnValueRegister);
     486    ASSERT(regT0 == returnValueGPR);
    487487    emitGetVirtualRegister(currentInstruction[1].u.operand, regT0);
    488488    callOperationNoExceptionCheck(operationThrow, regT0);
    … …  
    512512    Label isObject(this);
    513513    callOperation(operationGetPNames, regT0);
    514     emitStoreCell(dst, returnValueRegister);
     514    emitStoreCell(dst, returnValueGPR);
    515515    load32(Address(regT0, OBJECT_OFFSETOF(JSPropertyNameIterator, m_jsStringsSize)), regT3);
    516516    store64(tagTypeNumberRegister, addressFor(i));
    … …  
    683683    emitGetVirtualRegister(scrutinee, regT0);
    684684    callOperation(operationSwitchImmWithUnknownKeyType, regT0, tableIndex);
    685     jump(returnValueRegister);
     685    jump(returnValueGPR);
    686686}
    687687
    … …  
    699699    emitGetVirtualRegister(scrutinee, regT0);
    700700    callOperation(operationSwitchCharWithUnknownKeyType, regT0, tableIndex);
    701     jump(returnValueRegister);
     701    jump(returnValueGPR);
    702702}
    703703
    … …  
    714714    emitGetVirtualRegister(scrutinee, regT0);
    715715    callOperation(operationSwitchStringWithUnknownKeyType, regT0, tableIndex);
    716     jump(returnValueRegister);
     716    jump(returnValueGPR);
    717717}
    718718
    … …  
    822822    Jump activationCreated = branchTest64(NonZero, Address(callFrameRegister, sizeof(Register) * dst));
    823823    callOperation(operationCreateActivation, 0);
    824     emitStoreCell(dst, returnValueRegister);
     824    emitStoreCell(dst, returnValueGPR);
    825825    activationCreated.link(this);
    826826}
    … …  
    833833
    834834    callOperation(operationCreateArguments);
    835     emitStoreCell(dst, returnValueRegister);
    836     emitStoreCell(unmodifiedArgumentsRegister(VirtualRegister(dst)), returnValueRegister);
     835    emitStoreCell(dst, returnValueGPR);
     836    emitStoreCell(unmodifiedArgumentsRegister(VirtualRegister(dst)), returnValueGPR);
    837837
    838838    argsCreated.link(this);
    … …  
    956956    linkSlowCase(iter);
    957957    callOperation(operationConvertJSValueToBoolean, regT0);
    958     emitJumpSlowToHot(branchTest32(Zero, returnValueRegister), currentInstruction[2].u.operand); // inverted!
     958    emitJumpSlowToHot(branchTest32(Zero, returnValueGPR), currentInstruction[2].u.operand); // inverted!
    959959}
    960960
    … …  
    963963    linkSlowCase(iter);
    964964    callOperation(operationConvertJSValueToBoolean, regT0);
    965     emitJumpSlowToHot(branchTest32(NonZero, returnValueRegister), currentInstruction[2].u.operand);
     965    emitJumpSlowToHot(branchTest32(NonZero, returnValueGPR), currentInstruction[2].u.operand);
    966966}
    967967
    … …  
    986986    linkSlowCase(iter);
    987987    callOperation(operationCompareEq, regT0, regT1);
    988     emitTagAsBoolImmediate(returnValueRegister);
    989     emitPutVirtualRegister(currentInstruction[1].u.operand, returnValueRegister);
     988    emitTagAsBoolImmediate(returnValueGPR);
     989    emitPutVirtualRegister(currentInstruction[1].u.operand, returnValueGPR);
    990990}
    991991
    … …  
    995995    callOperation(operationCompareEq, regT0, regT1);
    996996    xor32(TrustedImm32(0x1), regT0);
    997     emitTagAsBoolImmediate(returnValueRegister);
    998     emitPutVirtualRegister(currentInstruction[1].u.operand, returnValueRegister);
     997    emitTagAsBoolImmediate(returnValueGPR);
     998    emitPutVirtualRegister(currentInstruction[1].u.operand, returnValueGPR);
    999999}
    10001000
    … …  
    11071107    linkSlowCase(iter);
    11081108    callOperation(operationCreateArguments);
    1109     emitStoreCell(arguments, returnValueRegister);
    1110     emitStoreCell(unmodifiedArgumentsRegister(VirtualRegister(arguments)), returnValueRegister);
     1109    emitStoreCell(arguments, returnValueGPR);
     1110    emitStoreCell(unmodifiedArgumentsRegister(VirtualRegister(arguments)), returnValueGPR);
    11111111   
    11121112    skipArgumentsCreation.link(this);
    … …  
    11511151       
    11521152        callOperation(operationOptimize, m_bytecodeOffset);
    1153         Jump noOptimizedEntry = branchTestPtr(Zero, returnValueRegister);
    1154         jump(returnValueRegister);
     1153        Jump noOptimizedEntry = branchTestPtr(Zero, returnValueGPR);
     1154        jump(returnValueGPR);
    11551155        noOptimizedEntry.link(this);
    11561156

  • trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp

    r158315 r158901  
    177177    push(callFrameRegister);
    178178#else
    179     move(callFrameRegister, firstArgumentRegister);
     179    move(callFrameRegister, argumentGPR0);
    180180#endif
    181181    move(TrustedImmPtr(FunctionPtr(operationVMHandleException).value()), regT3);
    … …  
    211211void JIT::emit_op_end(Instruction* currentInstruction)
    212212{
    213     ASSERT(returnValueRegister != callFrameRegister);
     213    ASSERT(returnValueGPR != callFrameRegister);
    214214    emitLoad(currentInstruction[1].u.operand, regT1, regT0);
    215215    restoreReturnAddressBeforeReturn(Address(callFrameRegister, CallFrame::returnPCOffset()));
    … …  
    244244    Structure* structure = currentInstruction[3].u.objectAllocationProfile->structure();
    245245    callOperation(operationNewObject, structure);
    246     emitStoreCell(dst, returnValueRegister);
     246    emitStoreCell(dst, returnValueGPR);
    247247}
    248248
    … …  
    509509
    510510    callOperation(operationConvertJSValueToBoolean, regT1, regT0);
    511     emitJumpSlowToHot(branchTest32(Zero, returnValueRegister), target); // Inverted.
     511    emitJumpSlowToHot(branchTest32(Zero, returnValueGPR), target); // Inverted.
    512512}
    513513
    … …  
    543543
    544544    callOperation(operationConvertJSValueToBoolean, regT1, regT0);
    545     emitJumpSlowToHot(branchTest32(NonZero, returnValueRegister), target);
     545    emitJumpSlowToHot(branchTest32(NonZero, returnValueGPR), target);
    546546}
    547547
    … …  
    652652
    653653    storeResult.link(this);
    654     emitStoreBool(dst, returnValueRegister);
     654    emitStoreBool(dst, returnValueGPR);
    655655}
    656656
    … …  
    694694
    695695    storeResult.link(this);
    696     xor32(TrustedImm32(0x1), returnValueRegister);
    697     emitStoreBool(dst, returnValueRegister);
     696    xor32(TrustedImm32(0x1), returnValueGPR);
     697    emitStoreBool(dst, returnValueGPR);
    698698}
    699699
    … …  
    826826void JIT::emit_op_throw(Instruction* currentInstruction)
    827827{
    828     ASSERT(regT0 == returnValueRegister);
     828    ASSERT(regT0 == returnValueGPR);
    829829    emitLoad(currentInstruction[1].u.operand, regT1, regT0);
    830830    callOperationNoExceptionCheck(operationThrow, regT1, regT0);
    … …  
    854854    Label isObject(this);
    855855    callOperation(operationGetPNames, regT0);
    856     emitStoreCell(dst, returnValueRegister);
     856    emitStoreCell(dst, returnValueGPR);
    857857    load32(Address(regT0, OBJECT_OFFSETOF(JSPropertyNameIterator, m_jsStringsSize)), regT3);
    858858    store32(TrustedImm32(Int32Tag), intTagFor(i));
    … …  
    10071007    emitLoad(scrutinee, regT1, regT0);
    10081008    callOperation(operationSwitchImmWithUnknownKeyType, regT1, regT0, tableIndex);
    1009     jump(returnValueRegister);
     1009    jump(returnValueGPR);
    10101010}
    10111011
    … …  
    10231023    emitLoad(scrutinee, regT1, regT0);
    10241024    callOperation(operationSwitchCharWithUnknownKeyType, regT1, regT0, tableIndex);
    1025     jump(returnValueRegister);
     1025    jump(returnValueGPR);
    10261026}
    10271027
    … …  
    10381038    emitLoad(scrutinee, regT1, regT0);
    10391039    callOperation(operationSwitchStringWithUnknownKeyType, regT1, regT0, tableIndex);
    1040     jump(returnValueRegister);
     1040    jump(returnValueGPR);
    10411041}
    10421042
    … …  
    10841084    Jump activationCreated = branch32(NotEqual, tagFor(activation), TrustedImm32(JSValue::EmptyValueTag));
    10851085    callOperation(operationCreateActivation, 0);
    1086     emitStoreCell(activation, returnValueRegister);
     1086    emitStoreCell(activation, returnValueGPR);
    10871087    activationCreated.link(this);
    10881088}
    … …  
    10941094    Jump argsCreated = branch32(NotEqual, tagFor(dst), TrustedImm32(JSValue::EmptyValueTag));
    10951095    callOperation(operationCreateArguments);
    1096     emitStoreCell(dst, returnValueRegister);
    1097     emitStoreCell(unmodifiedArgumentsRegister(VirtualRegister(dst)).offset(), returnValueRegister);
     1096    emitStoreCell(dst, returnValueGPR);
     1097    emitStoreCell(unmodifiedArgumentsRegister(VirtualRegister(dst)).offset(), returnValueGPR);
    10981098    argsCreated.link(this);
    10991099}
    … …  
    12441244
    12451245    callOperation(operationCreateArguments);
    1246     emitStoreCell(arguments, returnValueRegister);
    1247     emitStoreCell(unmodifiedArgumentsRegister(VirtualRegister(arguments)).offset(), returnValueRegister);
     1246    emitStoreCell(arguments, returnValueGPR);
     1247    emitStoreCell(unmodifiedArgumentsRegister(VirtualRegister(arguments)).offset(), returnValueGPR);
    12481248   
    12491249    skipArgumentsCreation.link(this);

  • trunk/Source/JavaScriptCore/jit/JSInterfaceJIT.h

    r158883 r158901  
    2929#include "BytecodeConventions.h"
    3030#include "CCallHelpers.h"
     31#include "FPRInfo.h"
     32#include "GPRInfo.h"
    3133#include "JITCode.h"
    3234#include "JITOperations.h"
    … …  
    4143
    4244namespace JSC {
    43     class JSInterfaceJIT : public CCallHelpers {
     45    class JSInterfaceJIT : public CCallHelpers, public GPRInfo, public FPRInfo {
    4446    public:
    4547        JSInterfaceJIT(VM* vm, CodeBlock* codeBlock = 0)
    … …  
    4749        {
    4850        }
    49        
    50         // NOTES:
    51         //
    52         // regT0 has two special meanings.  The return value from a stub
    53         // call will always be in regT0, and by default (unless
    54         // a register is specified) emitPutVirtualRegister() will store
    55         // the value from regT0.
    56         //
    57         // regT3 is required to be callee-preserved.
    58         //
    59         // tempRegister2 is has no such dependencies.  It is important that
    60         // on x86/x86-64 it is ecx for performance reasons, since the
    61         // MacroAssembler will need to plant register swaps if it is not -
    62         // however the code will still function correctly.
    63 #if CPU(X86_64)
    64         static const RegisterID returnValueRegister = X86Registers::eax;
    65         static const RegisterID returnValue2Register = X86Registers::edx;
    66         static const RegisterID cachedResultRegister = X86Registers::eax;
    67 #if !OS(WINDOWS)
    68         static const RegisterID firstArgumentRegister = X86Registers::edi;
    69         static const RegisterID secondArgumentRegister = X86Registers::esi;
    70 #else
    71         static const RegisterID firstArgumentRegister = X86Registers::ecx;
    72         static const RegisterID secondArgumentRegister = X86Registers::edx;
    73         static const RegisterID thirdArgumentRegister = X86Registers::r8;
    74 #endif
    75 
    76         static const RegisterID callFrameRegister = X86Registers::ebp;
    77         static const RegisterID tagTypeNumberRegister = X86Registers::r14;
    78         static const RegisterID tagMaskRegister = X86Registers::r15;
    79 
    80         static const RegisterID regT0 = X86Registers::eax;
    81         static const RegisterID regT1 = X86Registers::edx;
    82         static const RegisterID regT2 = X86Registers::ecx;
    83         static const RegisterID regT3 = X86Registers::ebx;
    84         static const RegisterID regT4 = X86Registers::r10;
    85 
    86         static const FPRegisterID fpRegT0 = X86Registers::xmm0;
    87         static const FPRegisterID fpRegT1 = X86Registers::xmm1;
    88         static const FPRegisterID fpRegT2 = X86Registers::xmm2;
    89         static const FPRegisterID fpRegT3 = X86Registers::xmm3;
    90 
    91         static const RegisterID nonArgGPR1 = X86Registers::eax; // regT0
    92 #elif CPU(X86)
    93         static const RegisterID returnValueRegister = X86Registers::eax;
    94         static const RegisterID returnValue2Register = X86Registers::edx;
    95         static const RegisterID cachedResultRegister = X86Registers::eax;
    96         // On x86 we always use fastcall conventions = but on
    97         // OS X if might make more sense to just use regparm.
    98         static const RegisterID firstArgumentRegister = X86Registers::ecx;
    99         static const RegisterID secondArgumentRegister = X86Registers::edx;
    100        
    101         static const RegisterID callFrameRegister = X86Registers::ebp;
    102        
    103         static const RegisterID regT0 = X86Registers::eax;
    104         static const RegisterID regT1 = X86Registers::edx;
    105         static const RegisterID regT2 = X86Registers::ecx;
    106         static const RegisterID regT3 = X86Registers::ebx;
    107         static const RegisterID regT4 = X86Registers::esi;
    108        
    109         static const FPRegisterID fpRegT0 = X86Registers::xmm0;
    110         static const FPRegisterID fpRegT1 = X86Registers::xmm1;
    111         static const FPRegisterID fpRegT2 = X86Registers::xmm2;
    112         static const FPRegisterID fpRegT3 = X86Registers::xmm3;
    113 #elif CPU(ARM)
    114         static const RegisterID returnValueRegister = ARMRegisters::r0;
    115         static const RegisterID returnValue2Register = ARMRegisters::r1;
    116         static const RegisterID cachedResultRegister = ARMRegisters::r0;
    117         static const RegisterID firstArgumentRegister = ARMRegisters::r0;
    118         static const RegisterID secondArgumentRegister = ARMRegisters::r1;
    119 
    120         static const RegisterID regT0 = ARMRegisters::r0;
    121         static const RegisterID regT1 = ARMRegisters::r1;
    122         static const RegisterID regT2 = ARMRegisters::r2;
    123         static const RegisterID regT3 = ARMRegisters::r4;
    124         static const RegisterID regT4 = ARMRegisters::r7;
    125         static const RegisterID regT5 = ARMRegisters::r8;
    126 
    127         static const RegisterID callFrameRegister = ARMRegisters::fp;
    128 
    129         static const FPRegisterID fpRegT0 = ARMRegisters::d0;
    130         static const FPRegisterID fpRegT1 = ARMRegisters::d1;
    131         static const FPRegisterID fpRegT2 = ARMRegisters::d2;
    132         static const FPRegisterID fpRegT3 = ARMRegisters::d3;
    133 #elif CPU(ARM64)
    134         static const RegisterID returnValueRegister = ARM64Registers::x0;
    135         static const RegisterID cachedResultRegister = ARM64Registers::x0;
    136         static const RegisterID firstArgumentRegister = ARM64Registers::x0;
    137         static const RegisterID secondArgumentRegister = ARM64Registers::x1;
    138 
    139 #if ENABLE(VALUE_PROFILER)
    140         static const RegisterID bucketCounterRegister = ARM64Registers::x7;
    141 #endif
    142 
    143         static const RegisterID regT0 = ARM64Registers::x0;
    144         static const RegisterID regT1 = ARM64Registers::x1;
    145         static const RegisterID regT2 = ARM64Registers::x2;
    146         static const RegisterID regT3 = ARM64Registers::x23;
    147         static const RegisterID regT4 = ARM64Registers::x24;
    148        
    149         static const RegisterID callFrameRegister = ARM64Registers::fp;
    150         static const RegisterID timeoutCheckRegister = ARM64Registers::x26;
    151         static const RegisterID tagTypeNumberRegister = ARM64Registers::x27;
    152         static const RegisterID tagMaskRegister = ARM64Registers::x28;
    153        
    154         static const FPRegisterID fpRegT0 = ARM64Registers::q0;
    155         static const FPRegisterID fpRegT1 = ARM64Registers::q1;
    156         static const FPRegisterID fpRegT2 = ARM64Registers::q2;
    157         static const FPRegisterID fpRegT3 = ARM64Registers::q3;
    158 
    159         static const RegisterID nonArgGPR1 = ARM64Registers::x9;
    160 #elif CPU(MIPS)
    161         static const RegisterID returnValueRegister = MIPSRegisters::v0;
    162         static const RegisterID returnValue2Register = MIPSRegisters::v1;
    163         static const RegisterID cachedResultRegister = MIPSRegisters::v0;
    164         static const RegisterID firstArgumentRegister = MIPSRegisters::a0;
    165         static const RegisterID secondArgumentRegister = MIPSRegisters::a1;
    166        
    167         // regT0 must be v0 for returning a 32-bit value.
    168         static const RegisterID regT0 = MIPSRegisters::v0;
    169        
    170         // regT1 must be v1 for returning a pair of 32-bit value.
    171         static const RegisterID regT1 = MIPSRegisters::v1;
    172        
    173         static const RegisterID regT2 = MIPSRegisters::t4;
    174        
    175         // regT3 must be saved in the callee, so use an S register.
    176         static const RegisterID regT3 = MIPSRegisters::s2;
    177        
    178         static const RegisterID regT4 = MIPSRegisters::t5;
    179         static const RegisterID regT5 = MIPSRegisters::t6;
    180 
    181         static const RegisterID callFrameRegister = MIPSRegisters::fp;
    182        
    183         static const FPRegisterID fpRegT0 = MIPSRegisters::f4;
    184         static const FPRegisterID fpRegT1 = MIPSRegisters::f6;
    185         static const FPRegisterID fpRegT2 = MIPSRegisters::f8;
    186         static const FPRegisterID fpRegT3 = MIPSRegisters::f10;
    187 #elif CPU(SH4)
    188         static const RegisterID callFrameRegister = SH4Registers::fp;
    189 
    190         static const RegisterID regT0 = SH4Registers::r0;
    191         static const RegisterID regT1 = SH4Registers::r1;
    192         static const RegisterID regT2 = SH4Registers::r2;
    193         static const RegisterID regT3 = SH4Registers::r10;
    194         static const RegisterID regT4 = SH4Registers::r4;
    195         static const RegisterID regT5 = SH4Registers::r5;
    196         static const RegisterID regT6 = SH4Registers::r6;
    197         static const RegisterID regT7 = SH4Registers::r7;
    198         static const RegisterID firstArgumentRegister = regT4;
    199         static const RegisterID secondArgumentRegister = regT5;
    200 
    201         static const RegisterID returnValueRegister = SH4Registers::r0;
    202         static const RegisterID returnValue2Register = SH4Registers::r1;
    203         static const RegisterID cachedResultRegister = SH4Registers::r0;
    204 
    205         static const FPRegisterID fpRegT0 = SH4Registers::dr0;
    206         static const FPRegisterID fpRegT1 = SH4Registers::dr2;
    207         static const FPRegisterID fpRegT2 = SH4Registers::dr4;
    208         static const FPRegisterID fpRegT3 = SH4Registers::dr6;
    209         static const FPRegisterID fpRegT4 = SH4Registers::dr8;
    210         static const FPRegisterID fpRegT5 = SH4Registers::dr10;
    211 #else
    212 #error "JIT not supported on this platform."
    213 #endif
    21451
    21552#if USE(JSVALUE32_64)

  • trunk/Source/JavaScriptCore/jit/SlowPathCall.h

    r157636 r158901  
    5656#elif CPU(X86_64) && OS(WINDOWS)
    5757        m_jit->addPtr(MacroAssembler::TrustedImm32(-16), MacroAssembler::stackPointerRegister);
    58         m_jit->move(MacroAssembler::stackPointerRegister, JIT::firstArgumentRegister);
    59         m_jit->move(JIT::callFrameRegister, JIT::secondArgumentRegister);
    60         m_jit->move(JIT::TrustedImmPtr(m_pc), JIT::thirdArgumentRegister);
     58        m_jit->move(MacroAssembler::stackPointerRegister, JIT::argumentGPR0);
     59        m_jit->move(JIT::callFrameRegister, JIT::argumentGPR1);
     60        m_jit->move(JIT::TrustedImmPtr(m_pc), JIT::argumentGPR2);
    6161#else
    62         m_jit->move(JIT::callFrameRegister, JIT::firstArgumentRegister);
    63         m_jit->move(JIT::TrustedImmPtr(m_pc), JIT::secondArgumentRegister);
     62        m_jit->move(JIT::callFrameRegister, JIT::argumentGPR0);
     63        m_jit->move(JIT::TrustedImmPtr(m_pc), JIT::argumentGPR1);
    6464#endif
    6565        JIT::Call call = m_jit->call();

  • trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp

    r158883 r158901  
    718718    jit.push(JSInterfaceJIT::callFrameRegister);
    719719#else
    720     jit.move(JSInterfaceJIT::callFrameRegister, JSInterfaceJIT::firstArgumentRegister);
     720    jit.move(JSInterfaceJIT::callFrameRegister, JSInterfaceJIT::argumentGPR0);
    721721#endif
    722722    jit.move(JSInterfaceJIT::TrustedImmPtr(FunctionPtr(operationVMHandleException).value()), JSInterfaceJIT::regT3);
Note: See TracChangeset for help on using the changeset viewer.