Changeset 85271 in webkit


Ignore:
Timestamp:
Apr 28, 2011 5:30:34 PM (13 years ago)
Author:
barraclough@apple.com
Message:

https://bugs.webkit.org/show_bug.cgi?id=59763
DFG JIT - Unify FPRReg & FPRegisterID

Reviewed by Oliver Hunt.

(Following on from GPRReg/RegisterID unification).

  • dfg/DFGFPRInfo.h:

(JSC::DFG::FPRInfo::toRegister):
(JSC::DFG::FPRInfo::debugName):

  • dfg/DFGGPRInfo.h:
  • dfg/DFGJITCodeGenerator.cpp:

(JSC::DFG::JITCodeGenerator::fillDouble):
(JSC::DFG::JITCodeGenerator::checkConsistency):

  • dfg/DFGJITCodeGenerator.h:

(JSC::DFG::JITCodeGenerator::boxDouble):
(JSC::DFG::JITCodeGenerator::unboxDouble):
(JSC::DFG::JITCodeGenerator::flushRegisters):
(JSC::DFG::JITCodeGenerator::isFlushed):
(JSC::DFG::JITCodeGenerator::setupTwoStubArgs):
(JSC::DFG::JITCodeGenerator::setupStubArguments):
(JSC::DFG::JITCodeGenerator::callOperation):
(JSC::DFG::GPRResult::lockedResult):
(JSC::DFG::FPRResult::lockedResult):

  • dfg/DFGJITCompiler.cpp:

(JSC::DFG::JITCompiler::fillNumericToDouble):
(JSC::DFG::JITCompiler::jumpFromSpeculativeToNonSpeculative):
(JSC::DFG::JITCompiler::compileFunction):

  • dfg/DFGJITCompiler.h:
  • dfg/DFGNode.h:
  • dfg/DFGNonSpeculativeJIT.cpp:

(JSC::DFG::EntryLocation::EntryLocation):
(JSC::DFG::NonSpeculativeJIT::valueToNumber):
(JSC::DFG::NonSpeculativeJIT::valueToInt32):
(JSC::DFG::NonSpeculativeJIT::numberToInt32):
(JSC::DFG::NonSpeculativeJIT::compile):

  • dfg/DFGNonSpeculativeJIT.h:

(JSC::DFG::NonSpeculativeJIT::silentSpillAllRegisters):
(JSC::DFG::NonSpeculativeJIT::silentFillAllRegisters):

  • dfg/DFGRegisterBank.h:

(JSC::DFG::RegisterBank::iterator::regID):
(JSC::DFG::RegisterBank::iterator::debugName):

  • dfg/DFGSpeculativeJIT.cpp:

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

  • dfg/DFGSpeculativeJIT.h:
Location:
trunk/Source/JavaScriptCore
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/JavaScriptCore/ChangeLog

    r85265 r85271  
     12011-04-28  Gavin Barraclough  <barraclough@apple.com>
     2
     3        Reviewed by Oliver Hunt.
     4
     5        https://bugs.webkit.org/show_bug.cgi?id=59763
     6        DFG JIT - Unify FPRReg & FPRegisterID
     7
     8        (Following on from GPRReg/RegisterID unification).
     9
     10        * dfg/DFGFPRInfo.h:
     11        (JSC::DFG::FPRInfo::toRegister):
     12        (JSC::DFG::FPRInfo::debugName):
     13        * dfg/DFGGPRInfo.h:
     14        * dfg/DFGJITCodeGenerator.cpp:
     15        (JSC::DFG::JITCodeGenerator::fillDouble):
     16        (JSC::DFG::JITCodeGenerator::checkConsistency):
     17        * dfg/DFGJITCodeGenerator.h:
     18        (JSC::DFG::JITCodeGenerator::boxDouble):
     19        (JSC::DFG::JITCodeGenerator::unboxDouble):
     20        (JSC::DFG::JITCodeGenerator::flushRegisters):
     21        (JSC::DFG::JITCodeGenerator::isFlushed):
     22        (JSC::DFG::JITCodeGenerator::setupTwoStubArgs):
     23        (JSC::DFG::JITCodeGenerator::setupStubArguments):
     24        (JSC::DFG::JITCodeGenerator::callOperation):
     25        (JSC::DFG::GPRResult::lockedResult):
     26        (JSC::DFG::FPRResult::lockedResult):
     27        * dfg/DFGJITCompiler.cpp:
     28        (JSC::DFG::JITCompiler::fillNumericToDouble):
     29        (JSC::DFG::JITCompiler::jumpFromSpeculativeToNonSpeculative):
     30        (JSC::DFG::JITCompiler::compileFunction):
     31        * dfg/DFGJITCompiler.h:
     32        * dfg/DFGNode.h:
     33        * dfg/DFGNonSpeculativeJIT.cpp:
     34        (JSC::DFG::EntryLocation::EntryLocation):
     35        (JSC::DFG::NonSpeculativeJIT::valueToNumber):
     36        (JSC::DFG::NonSpeculativeJIT::valueToInt32):
     37        (JSC::DFG::NonSpeculativeJIT::numberToInt32):
     38        (JSC::DFG::NonSpeculativeJIT::compile):
     39        * dfg/DFGNonSpeculativeJIT.h:
     40        (JSC::DFG::NonSpeculativeJIT::silentSpillAllRegisters):
     41        (JSC::DFG::NonSpeculativeJIT::silentFillAllRegisters):
     42        * dfg/DFGRegisterBank.h:
     43        (JSC::DFG::RegisterBank::iterator::regID):
     44        (JSC::DFG::RegisterBank::iterator::debugName):
     45        * dfg/DFGSpeculativeJIT.cpp:
     46        (JSC::DFG::SpeculationCheck::SpeculationCheck):
     47        (JSC::DFG::SpeculativeJIT::compile):
     48        * dfg/DFGSpeculativeJIT.h:
     49
    1502011-04-28  David Kilzer  <ddkilzer@apple.com>
    251
  • trunk/Source/JavaScriptCore/dfg/DFGFPRInfo.h

    r85249 r85271  
    3434namespace JSC { namespace DFG {
    3535
    36 // Abstracted sequential numbering of available machine registers (as opposed to GPRReg,
    37 // which are non-sequential, and not abstracted from the register numbering used by the underlying processor).
    38 enum FPRReg { fpr0, fpr1, fpr2, fpr3, fpr4, fpr5, numberOfFPRs, InvalidFPRReg = 0xFFFFFFFF };
     36typedef MacroAssembler::FPRegisterID FPRReg;
     37#define InvalidFPRReg ((FPRReg)-1)
    3938
    40 inline FPRReg next(FPRReg& reg)
    41 {
    42     ASSERT(reg < numberOfFPRs);
    43     return reg = static_cast<FPRReg>(reg + 1);
    44 }
    45 
    46 class FPRBankInfo {
     39class FPRInfo {
    4740public:
    4841    typedef FPRReg RegisterType;
    4942    static const unsigned numberOfRegisters = 6;
    5043
     44    // Temporary registers.
     45    static const FPRReg fpRegT0 = X86Registers::xmm0;
     46    static const FPRReg fpRegT1 = X86Registers::xmm1;
     47    static const FPRReg fpRegT2 = X86Registers::xmm2;
     48    static const FPRReg fpRegT3 = X86Registers::xmm3;
     49    static const FPRReg fpRegT4 = X86Registers::xmm4;
     50    static const FPRReg fpRegT5 = X86Registers::xmm5;
     51    // These constants provide the names for the general purpose argument & return value registers.
     52    static const FPRReg argumentFPR0 = X86Registers::xmm0; // fpRegT0
     53    static const FPRReg argumentFPR1 = X86Registers::xmm1; // fpRegT1
     54    static const FPRReg argumentFPR2 = X86Registers::xmm2; // fpRegT2
     55    static const FPRReg argumentFPR3 = X86Registers::xmm3; // fpRegT3
     56    static const FPRReg returnValueFPR = X86Registers::xmm0; // fpRegT0
     57
     58    // FPRReg mapping is direct, the machine regsiter numbers can
     59    // be used directly as indices into the FPR RegisterBank.
     60    COMPILE_ASSERT(X86Registers::xmm0 == 0, xmm0_is_0);
     61    COMPILE_ASSERT(X86Registers::xmm1 == 1, xmm1_is_1);
     62    COMPILE_ASSERT(X86Registers::xmm2 == 2, xmm2_is_2);
     63    COMPILE_ASSERT(X86Registers::xmm3 == 3, xmm3_is_3);
     64    COMPILE_ASSERT(X86Registers::xmm4 == 4, xmm4_is_4);
     65    COMPILE_ASSERT(X86Registers::xmm5 == 5, xmm5_is_5);
    5166    static FPRReg toRegister(unsigned index)
    5267    {
    5368        return (FPRReg)index;
    5469    }
    55 
    5670    static unsigned toIndex(FPRReg reg)
    5771    {
    5872        return (unsigned)reg;
    5973    }
     74
     75#ifndef NDEBUG
     76    static const char* debugName(FPRReg reg)
     77    {
     78        ASSERT(reg != InvalidFPRReg);
     79        ASSERT(reg < 16);
     80        static const char* nameForRegister[16] = {
     81            "xmm0", "xmm1", "xmm2", "xmm3",
     82            "xmm4", "xmm5", "xmm6", "xmm7",
     83            "xmm8", "xmm9", "xmm10", "xmm11",
     84            "xmm12", "xmm13", "xmm14", "xmm15"
     85        };
     86        return nameForRegister[reg];
     87    }
     88#endif
    6089};
    6190
    62 typedef RegisterBank<FPRBankInfo>::iterator fpr_iterator;
     91typedef RegisterBank<FPRInfo>::iterator fpr_iterator;
    6392
    6493} } // namespace JSC::DFG
  • trunk/Source/JavaScriptCore/dfg/DFGGPRInfo.h

    r85249 r85271  
    5858    static const GPRReg regT8 = X86Registers::r10;
    5959    // These constants provide the names for the general purpose argument & return value registers.
    60     static const GPRReg argumentRegister0 = X86Registers::edi; // regT4
    61     static const GPRReg argumentRegister1 = X86Registers::esi; // regT5
    62     static const GPRReg argumentRegister2 = X86Registers::edx; // regT1
    63     static const GPRReg argumentRegister3 = X86Registers::ecx; // regT2
    64     static const GPRReg returnValueRegister = X86Registers::eax; // regT0
    65     static const GPRReg returnValueRegister2 = X86Registers::edx; // regT1
     60    static const GPRReg argumentGPR0 = X86Registers::edi; // regT4
     61    static const GPRReg argumentGPR1 = X86Registers::esi; // regT5
     62    static const GPRReg argumentGPR2 = X86Registers::edx; // regT1
     63    static const GPRReg argumentGPR3 = X86Registers::ecx; // regT2
     64    static const GPRReg returnValueGPR = X86Registers::eax; // regT0
     65    static const GPRReg returnValueGPR2 = X86Registers::edx; // regT1
    6666
    6767    static GPRReg toRegister(unsigned index)
  • trunk/Source/JavaScriptCore/dfg/DFGJITCodeGenerator.cpp

    r85249 r85271  
    124124                FPRReg fpr = fprAllocate();
    125125                m_jit.move(MacroAssembler::ImmPtr(reinterpret_cast<void*>(reinterpretDoubleToIntptr(valueOfDoubleConstant(nodeIndex)))), gpr);
    126                 m_jit.movePtrToDouble(gpr, JITCompiler::fprToRegisterID(fpr));
     126                m_jit.movePtrToDouble(gpr, fpr);
    127127                unlock(gpr);
    128128
     
    163163        GPRReg tempGpr = allocate(); // FIXME: can we skip this allocation on the last use of the virtual register?
    164164
    165         JITCompiler::FPRegisterID fpReg = JITCompiler::fprToRegisterID(fpr);
    166 
    167165        JITCompiler::Jump isInteger = m_jit.branchPtr(MacroAssembler::AboveOrEqual, jsValueGpr, GPRInfo::tagTypeNumberRegister);
    168166
     
    172170        m_jit.move(jsValueGpr, tempGpr);
    173171        m_jit.addPtr(GPRInfo::tagTypeNumberRegister, tempGpr);
    174         m_jit.movePtrToDouble(tempGpr, fpReg);
     172        m_jit.movePtrToDouble(tempGpr, fpr);
    175173        JITCompiler::Jump hasUnboxedDouble = m_jit.jump();
    176174
    177175        // Finally, handle integers.
    178176        isInteger.link(&m_jit);
    179         m_jit.convertInt32ToDouble(jsValueGpr, fpReg);
     177        m_jit.convertInt32ToDouble(jsValueGpr, fpr);
    180178        hasUnboxedDouble.link(&m_jit);
    181179
     
    193191        GPRReg gpr = info.gpr();
    194192        m_gprs.lock(gpr);
    195         GPRReg reg = gpr;
    196         JITCompiler::FPRegisterID fpReg = JITCompiler::fprToRegisterID(fpr);
    197 
    198         m_jit.convertInt32ToDouble(reg, fpReg);
     193
     194        m_jit.convertInt32ToDouble(gpr, fpr);
    199195
    200196        m_gprs.release(gpr);
     
    396392        }
    397393    }
    398     for (FPRReg i = fpr0; i < numberOfFPRs; next(i)) {
    399         if (m_fprs.isLocked(i)) {
    400             fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: fpr %d is locked.\n", i);
     394    for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
     395        if (iter.isLocked()) {
     396            fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: fpr %s is locked.\n", iter.debugName());
    401397            failed = true;
    402398        }
    403399    }
    404400
    405     VirtualRegister fprContents[numberOfFPRs];
    406 
    407     for (unsigned i = 0; i < numberOfFPRs; ++i)
    408         fprContents[i] = InvalidVirtualRegister;
    409401    for (unsigned i = 0; i < m_generationInfo.size(); ++i) {
    410402        VirtualRegister virtualRegister = (VirtualRegister)i;
     
    432424            FPRReg fpr = info.fpr();
    433425            ASSERT(fpr != InvalidFPRReg);
    434             fprContents[fpr] = virtualRegister;
     426            if (m_fprs.name(fpr) != virtualRegister) {
     427                fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: name mismatch for virtual register %d (fpr %s).\n", virtualRegister, FPRInfo::debugName(fpr));
     428                failed = true;
     429            }
    435430            break;
    436431        }
     
    444439
    445440        GenerationInfo& info = m_generationInfo[virtualRegister];
    446         if (iter.gpr() != info.gpr()) {
     441        if (iter.regID() != info.gpr()) {
    447442            fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: name mismatch for gpr %s (virtual register %d).\n", iter.debugName(), virtualRegister);
    448443            failed = true;
    449444        }
    450445    }
    451     for (FPRReg i = fpr0; i < numberOfFPRs; next(i)) {
    452         if (m_fprs.name(i) != fprContents[i]) {
    453             fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: name mismatch for fpr %d (%d != %d).\n", i, m_fprs.name(i), fprContents[i]);
     446
     447    for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
     448        VirtualRegister virtualRegister = iter.name();
     449        if (virtualRegister == InvalidVirtualRegister)
     450            continue;
     451
     452        GenerationInfo& info = m_generationInfo[virtualRegister];
     453        if (iter.regID() != info.fpr()) {
     454            fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: name mismatch for fpr %s (virtual register %d).\n", iter.debugName(), virtualRegister);
    454455            failed = true;
    455456        }
  • trunk/Source/JavaScriptCore/dfg/DFGJITCodeGenerator.h

    r85249 r85271  
    5353    typedef MacroAssembler::TrustedImm32 TrustedImm32;
    5454    typedef MacroAssembler::Imm32 Imm32;
    55     typedef MacroAssembler::FPRegisterID FPRegisterID;
    5655
    5756    // These constants are used to set priorities for spill order for
     
    158157    GPRReg boxDouble(FPRReg fpr, GPRReg gpr)
    159158    {
    160         JITCompiler::FPRegisterID fpReg = JITCompiler::fprToRegisterID(fpr);
    161         m_jit.moveDoubleToPtr(fpReg, gpr);
     159        m_jit.moveDoubleToPtr(fpr, gpr);
    162160        m_jit.subPtr(GPRInfo::tagTypeNumberRegister, gpr);
    163161        return gpr;
     
    165163    FPRReg unboxDouble(GPRReg gpr, FPRReg fpr)
    166164    {
    167         JITCompiler::FPRegisterID fpReg = JITCompiler::fprToRegisterID(fpr);
    168165        m_jit.addPtr(GPRInfo::tagTypeNumberRegister, gpr);
    169         m_jit.movePtrToDouble(gpr, fpReg);
     166        m_jit.movePtrToDouble(gpr, fpr);
    170167        return fpr;
    171168    }
     
    257254            }
    258255        }
    259         for (FPRReg fpr = fpr0; fpr < numberOfFPRs; next(fpr)) {
    260             VirtualRegister name = m_fprs.name(fpr);
    261             if (name != InvalidVirtualRegister) {
    262                 spill(name);
    263                 m_fprs.release(fpr);
     256        for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
     257            if (iter.name() != InvalidVirtualRegister) {
     258                spill(iter.name());
     259                iter.release();
    264260            }
    265261        }
     
    275271                return false;
    276272        }
    277         for (FPRReg fpr = fpr0; fpr < numberOfFPRs; next(fpr)) {
    278             VirtualRegister name = m_fprs.name(fpr);
    279             if (name != InvalidVirtualRegister)
     273        for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
     274            if (iter.name() != InvalidVirtualRegister)
    280275                return false;
    281276        }
     
    486481        if (srcB != destA) {
    487482            // Handle the easy cases - two simple moves.
    488             m_jit.moveDouble(JITCompiler::fprToRegisterID(srcA), JITCompiler::fprToRegisterID(destA));
    489             m_jit.moveDouble(JITCompiler::fprToRegisterID(srcB), JITCompiler::fprToRegisterID(destB));
     483            m_jit.moveDouble(srcA, destA);
     484            m_jit.moveDouble(srcB, destB);
    490485            return;
    491486        }
     
    493488        if (srcA != destB) {
    494489            // Handle the non-swap case - just put srcB in place first.
    495             m_jit.moveDouble(JITCompiler::fprToRegisterID(srcB), JITCompiler::fprToRegisterID(destB));
    496             m_jit.moveDouble(JITCompiler::fprToRegisterID(srcA), JITCompiler::fprToRegisterID(destA));
     490            m_jit.moveDouble(srcB, destB);
     491            m_jit.moveDouble(srcA, destA);
    497492            return;
    498493        }
     
    501496        // Need to swap; pick a temporary register.
    502497        FPRReg temp;
    503         if (destA != JITCompiler::argumentFPR3 && destA != JITCompiler::argumentFPR3)
    504             temp = JITCompiler::argumentFPR3;
    505         else if (destA != JITCompiler::argumentFPR2 && destA != JITCompiler::argumentFPR2)
    506             temp = JITCompiler::argumentFPR2;
     498        if (destA != FPRInfo::argumentFPR3 && destA != FPRInfo::argumentFPR3)
     499            temp = FPRInfo::argumentFPR3;
     500        else if (destA != FPRInfo::argumentFPR2 && destA != FPRInfo::argumentFPR2)
     501            temp = FPRInfo::argumentFPR2;
    507502        else {
    508             ASSERT(destA != JITCompiler::argumentFPR1 && destA != JITCompiler::argumentFPR1);
    509             temp = JITCompiler::argumentFPR1;
    510         }
    511         m_jit.moveDouble(JITCompiler::fprToRegisterID(destA), JITCompiler::fprToRegisterID(temp));
    512         m_jit.moveDouble(JITCompiler::fprToRegisterID(destB), JITCompiler::fprToRegisterID(destA));
    513         m_jit.moveDouble(JITCompiler::fprToRegisterID(temp), JITCompiler::fprToRegisterID(destB));
     503            ASSERT(destA != FPRInfo::argumentFPR1 && destA != FPRInfo::argumentFPR1);
     504            temp = FPRInfo::argumentFPR1;
     505        }
     506        m_jit.moveDouble(destA, temp);
     507        m_jit.moveDouble(destB, destA);
     508        m_jit.moveDouble(temp, destB);
    514509    }
    515510    void setupStubArguments(GPRReg arg1, GPRReg arg2)
    516511    {
    517         setupTwoStubArgs<GPRInfo::argumentRegister1, GPRInfo::argumentRegister2>(arg1, arg2);
     512        setupTwoStubArgs<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2>(arg1, arg2);
    518513    }
    519514    void setupStubArguments(GPRReg arg1, GPRReg arg2, GPRReg arg3)
     
    521516        // If neither of arg2/arg3 are in our way, then we can move arg1 into place.
    522517        // Then we can use setupTwoStubArgs to fix arg2/arg3.
    523         if (arg2 != GPRInfo::argumentRegister1 && arg3 != GPRInfo::argumentRegister1) {
    524             m_jit.move(arg1, GPRInfo::argumentRegister1);
    525             setupTwoStubArgs<GPRInfo::argumentRegister2, GPRInfo::argumentRegister3>(arg2, arg3);
     518        if (arg2 != GPRInfo::argumentGPR1 && arg3 != GPRInfo::argumentGPR1) {
     519            m_jit.move(arg1, GPRInfo::argumentGPR1);
     520            setupTwoStubArgs<GPRInfo::argumentGPR2, GPRInfo::argumentGPR3>(arg2, arg3);
    526521            return;
    527522        }
     
    529524        // If neither of arg1/arg3 are in our way, then we can move arg2 into place.
    530525        // Then we can use setupTwoStubArgs to fix arg1/arg3.
    531         if (arg1 != GPRInfo::argumentRegister2 && arg3 != GPRInfo::argumentRegister2) {
    532             m_jit.move(arg2, GPRInfo::argumentRegister2);
    533             setupTwoStubArgs<GPRInfo::argumentRegister1, GPRInfo::argumentRegister3>(arg1, arg3);
     526        if (arg1 != GPRInfo::argumentGPR2 && arg3 != GPRInfo::argumentGPR2) {
     527            m_jit.move(arg2, GPRInfo::argumentGPR2);
     528            setupTwoStubArgs<GPRInfo::argumentGPR1, GPRInfo::argumentGPR3>(arg1, arg3);
    534529            return;
    535530        }
     
    537532        // If neither of arg1/arg2 are in our way, then we can move arg3 into place.
    538533        // Then we can use setupTwoStubArgs to fix arg1/arg2.
    539         if (arg1 != GPRInfo::argumentRegister3 && arg2 != GPRInfo::argumentRegister3) {
    540             m_jit.move(arg3, GPRInfo::argumentRegister3);
    541             setupTwoStubArgs<GPRInfo::argumentRegister1, GPRInfo::argumentRegister2>(arg1, arg2);
     534        if (arg1 != GPRInfo::argumentGPR3 && arg2 != GPRInfo::argumentGPR3) {
     535            m_jit.move(arg3, GPRInfo::argumentGPR3);
     536            setupTwoStubArgs<GPRInfo::argumentGPR1, GPRInfo::argumentGPR2>(arg1, arg2);
    542537            return;
    543538        }
     
    548543
    549544        // First, ensure arg1 is in place.
    550         if (arg1 != GPRInfo::argumentRegister1) {
    551             m_jit.swap(arg1, GPRInfo::argumentRegister1);
    552 
    553             // If arg1 wasn't in argumentRegister1, one of arg2/arg3 must be.
    554             ASSERT(arg2 == GPRInfo::argumentRegister1 || arg3 == GPRInfo::argumentRegister1);
    555             // If arg2 was in argumentRegister1 it no longer is (due to the swap).
     545        if (arg1 != GPRInfo::argumentGPR1) {
     546            m_jit.swap(arg1, GPRInfo::argumentGPR1);
     547
     548            // If arg1 wasn't in argumentGPR1, one of arg2/arg3 must be.
     549            ASSERT(arg2 == GPRInfo::argumentGPR1 || arg3 == GPRInfo::argumentGPR1);
     550            // If arg2 was in argumentGPR1 it no longer is (due to the swap).
    556551            // Otherwise arg3 must have been. Mark him as moved.
    557             if (arg2 == GPRInfo::argumentRegister1)
     552            if (arg2 == GPRInfo::argumentGPR1)
    558553                arg2 = arg1;
    559554            else
     
    562557
    563558        // Either arg2 & arg3 need swapping, or we're all done.
    564         ASSERT((arg2 == GPRInfo::argumentRegister2 || arg3 == GPRInfo::argumentRegister3)
    565             || (arg2 == GPRInfo::argumentRegister3 || arg3 == GPRInfo::argumentRegister2));
    566 
    567         if (arg2 != GPRInfo::argumentRegister2)
    568             m_jit.swap(GPRInfo::argumentRegister2, GPRInfo::argumentRegister3);
     559        ASSERT((arg2 == GPRInfo::argumentGPR2 || arg3 == GPRInfo::argumentGPR3)
     560            || (arg2 == GPRInfo::argumentGPR3 || arg3 == GPRInfo::argumentGPR2));
     561
     562        if (arg2 != GPRInfo::argumentGPR2)
     563            m_jit.swap(GPRInfo::argumentGPR2, GPRInfo::argumentGPR3);
    569564    }
    570565
     
    574569        ASSERT(isFlushed());
    575570
    576         m_jit.move(arg1, GPRInfo::argumentRegister1);
    577         m_jit.move(JITCompiler::TrustedImmPtr(pointer), GPRInfo::argumentRegister2);
    578         m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentRegister0);
     571        m_jit.move(arg1, GPRInfo::argumentGPR1);
     572        m_jit.move(JITCompiler::TrustedImmPtr(pointer), GPRInfo::argumentGPR2);
     573        m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
    579574
    580575        appendCallWithExceptionCheck(operation);
    581         m_jit.move(GPRInfo::returnValueRegister, result);
     576        m_jit.move(GPRInfo::returnValueGPR, result);
    582577    }
    583578    void callOperation(J_DFGOperation_EJI operation, GPRReg result, GPRReg arg1, Identifier* identifier)
     
    589584        ASSERT(isFlushed());
    590585
    591         m_jit.move(arg1, GPRInfo::argumentRegister1);
    592         m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentRegister0);
     586        m_jit.move(arg1, GPRInfo::argumentGPR1);
     587        m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
    593588
    594589        appendCallWithExceptionCheck(operation);
    595         m_jit.move(GPRInfo::returnValueRegister, result);
     590        m_jit.move(GPRInfo::returnValueGPR, result);
    596591    }
    597592    void callOperation(Z_DFGOperation_EJ operation, GPRReg result, GPRReg arg1)
     
    599594        ASSERT(isFlushed());
    600595
    601         m_jit.move(arg1, GPRInfo::argumentRegister1);
    602         m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentRegister0);
     596        m_jit.move(arg1, GPRInfo::argumentGPR1);
     597        m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
    603598
    604599        appendCallWithExceptionCheck(operation);
    605         m_jit.move(GPRInfo::returnValueRegister, result);
     600        m_jit.move(GPRInfo::returnValueGPR, result);
    606601    }
    607602    void callOperation(Z_DFGOperation_EJJ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
     
    610605
    611606        setupStubArguments(arg1, arg2);
    612         m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentRegister0);
     607        m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
    613608
    614609        appendCallWithExceptionCheck(operation);
    615         m_jit.move(GPRInfo::returnValueRegister, result);
     610        m_jit.move(GPRInfo::returnValueGPR, result);
    616611    }
    617612    void callOperation(J_DFGOperation_EJJ operation, GPRReg result, GPRReg arg1, GPRReg arg2)
     
    620615
    621616        setupStubArguments(arg1, arg2);
    622         m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentRegister0);
     617        m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
    623618
    624619        appendCallWithExceptionCheck(operation);
    625         m_jit.move(GPRInfo::returnValueRegister, result);
     620        m_jit.move(GPRInfo::returnValueGPR, result);
    626621    }
    627622    void callOperation(V_DFGOperation_EJJP operation, GPRReg arg1, GPRReg arg2, void* pointer)
     
    630625
    631626        setupStubArguments(arg1, arg2);
    632         m_jit.move(JITCompiler::TrustedImmPtr(pointer), GPRInfo::argumentRegister3);
    633         m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentRegister0);
     627        m_jit.move(JITCompiler::TrustedImmPtr(pointer), GPRInfo::argumentGPR3);
     628        m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
    634629
    635630        appendCallWithExceptionCheck(operation);
     
    644639
    645640        setupStubArguments(arg1, arg2, arg3);
    646         m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentRegister0);
     641        m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
    647642
    648643        appendCallWithExceptionCheck(operation);
     
    652647        ASSERT(isFlushed());
    653648
    654         setupTwoStubArgs<JITCompiler::argumentFPR0, JITCompiler::argumentFPR1>(arg1, arg2);
     649        setupTwoStubArgs<FPRInfo::argumentFPR0, FPRInfo::argumentFPR1>(arg1, arg2);
    655650
    656651        m_jit.appendCall(operation);
    657         m_jit.moveDouble(JITCompiler::fpReturnValueRegister, JITCompiler::fprToRegisterID(result));
     652        m_jit.moveDouble(FPRInfo::returnValueFPR, result);
    658653    }
    659654
     
    705700    Vector<GenerationInfo, 32> m_generationInfo;
    706701    RegisterBank<GPRInfo> m_gprs;
    707     RegisterBank<FPRBankInfo> m_fprs;
     702    RegisterBank<FPRInfo> m_fprs;
    708703
    709704    Vector<MacroAssembler::Label> m_blockHeads;
     
    809804    }
    810805
    811     MacroAssembler::FPRegisterID gpr()
    812     {
    813         return JITCompiler::fprToRegisterID(fpr());
    814     }
    815 
    816806private:
    817807    JITCodeGenerator* m_jit;
     
    914904    }
    915905
    916     MacroAssembler::FPRegisterID gpr()
    917     {
    918         ASSERT(m_fpr != InvalidFPRReg);
    919         return JITCompiler::fprToRegisterID(m_fpr);
    920     }
    921 
    922906protected:
    923907    FPRTemporary(JITCodeGenerator* jit, FPRReg lockedFPR)
     
    947931    static GPRReg lockedResult(JITCodeGenerator* jit)
    948932    {
    949         jit->lock(GPRInfo::returnValueRegister);
    950         return GPRInfo::returnValueRegister;
     933        jit->lock(GPRInfo::returnValueGPR);
     934        return GPRInfo::returnValueGPR;
    951935    }
    952936};
     
    962946    static FPRReg lockedResult(JITCodeGenerator* jit)
    963947    {
    964         jit->lock(JITCompiler::returnValueFPR);
    965         return JITCompiler::returnValueFPR;
     948        jit->lock(FPRInfo::returnValueFPR);
     949        return FPRInfo::returnValueFPR;
    966950    }
    967951};
  • trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp

    r85249 r85271  
    4848        ASSERT(node.op == DoubleConstant);
    4949        move(MacroAssembler::ImmPtr(reinterpret_cast<void*>(reinterpretDoubleToIntptr(valueOfDoubleConstant(nodeIndex)))), temporary);
    50         movePtrToDouble(temporary, fprToRegisterID(fpr));
     50        movePtrToDouble(temporary, fpr);
    5151    } else {
    5252        loadPtr(addressFor(node.virtualRegister()), temporary);
     
    5454        jitAssertIsJSDouble(temporary);
    5555        addPtr(GPRInfo::tagTypeNumberRegister, temporary);
    56         movePtrToDouble(temporary, fprToRegisterID(fpr));
     56        movePtrToDouble(temporary, fpr);
    5757        Jump hasUnboxedDouble = jump();
    5858        isInteger.link(this);
    59         convertInt32ToDouble(temporary, fprToRegisterID(fpr));
     59        convertInt32ToDouble(temporary, fpr);
    6060        hasUnboxedDouble.link(this);
    6161    }
     
    143143
    144144    // Spill all FPRs in use by the speculative path.
    145     for (FPRReg fpr = fpr0; fpr < numberOfFPRs; next(fpr)) {
    146         NodeIndex nodeIndex = check.m_fprInfo[fpr];
     145    for (unsigned index = 0; index < FPRInfo::numberOfRegisters; ++index) {
     146        NodeIndex nodeIndex = check.m_fprInfo[index];
    147147        if (nodeIndex == NoNode)
    148148            continue;
     
    150150        VirtualRegister virtualRegister = graph()[nodeIndex].virtualRegister();
    151151
    152         moveDoubleToPtr(fprToRegisterID(fpr), GPRInfo::regT0);
     152        moveDoubleToPtr(FPRInfo::toRegister(index), GPRInfo::regT0);
    153153        subPtr(GPRInfo::tagTypeNumberRegister, GPRInfo::regT0);
    154154        storePtr(GPRInfo::regT0, addressFor(virtualRegister));
     
    156156
    157157    // Fill all FPRs in use by the non-speculative path.
    158     for (FPRReg fpr = fpr0; fpr < numberOfFPRs; next(fpr)) {
    159         NodeIndex nodeIndex = entry.m_fprInfo[fpr];
     158    for (unsigned index = 0; index < FPRInfo::numberOfRegisters; ++index) {
     159        NodeIndex nodeIndex = entry.m_fprInfo[index];
    160160        if (nodeIndex == NoNode)
    161161            continue;
    162162
    163         fillNumericToDouble(nodeIndex, fpr, GPRInfo::regT0);
     163        fillNumericToDouble(nodeIndex, FPRInfo::toRegister(index), GPRInfo::regT0);
    164164    }
    165165
     
    314314        // of the call out from JIT code that threw the exception; this is still
    315315        // available on the stack, just below the stack pointer!
    316         move(GPRInfo::callFrameRegister, GPRInfo::argumentRegister0);
    317         peek(GPRInfo::argumentRegister1, -1);
     316        move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
     317        peek(GPRInfo::argumentGPR1, -1);
    318318        m_calls.append(CallRecord(call(), lookupExceptionHandler));
    319         // lookupExceptionHandler leaves the handler CallFrame* in the returnValueRegister,
    320         // and the address of the handler in returnValueRegister2.
    321         jump(GPRInfo::returnValueRegister2);
     319        // lookupExceptionHandler leaves the handler CallFrame* in the returnValueGPR,
     320        // and the address of the handler in returnValueGPR2.
     321        jump(GPRInfo::returnValueGPR2);
    322322    }
    323323
     
    326326    // FIXME: change this from a cti call to a DFG style operation (normal C calling conventions).
    327327    registerFileCheck.link(this);
    328     move(stackPointerRegister, GPRInfo::argumentRegister0);
     328    move(stackPointerRegister, GPRInfo::argumentGPR0);
    329329    poke(GPRInfo::callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));
    330330    Call callRegisterFileCheck = call();
     
    340340    emitPutToCallFrameHeader(GPRInfo::regT2, RegisterFile::ReturnPC);
    341341    branch32(Equal, GPRInfo::regT1, Imm32(m_codeBlock->m_numParameters)).linkTo(fromArityCheck, this);
    342     move(stackPointerRegister, GPRInfo::argumentRegister0);
     342    move(stackPointerRegister, GPRInfo::argumentGPR0);
    343343    poke(GPRInfo::callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));
    344344    Call callArityCheck = call();
  • trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.h

    r85249 r85271  
    109109
    110110#if CPU(X86_64)
    111     // Temporary registers.
    112     static const FPRegisterID fpRegT0 = X86Registers::xmm0;
    113     static const FPRegisterID fpRegT1 = X86Registers::xmm1;
    114     static const FPRegisterID fpRegT2 = X86Registers::xmm2;
    115     static const FPRegisterID fpRegT3 = X86Registers::xmm3;
    116     static const FPRegisterID fpRegT4 = X86Registers::xmm4;
    117     static const FPRegisterID fpRegT5 = X86Registers::xmm5;
    118 
    119     // These constants provide both FPRegisterID & FPRReg style names for the
    120     // floating point argument & return value register.
    121     static const FPRReg argumentFPR0 = fpr0;
    122     static const FPRReg argumentFPR1 = fpr1;
    123     static const FPRReg argumentFPR2 = fpr2;
    124     static const FPRReg argumentFPR3 = fpr3;
    125     static const FPRegisterID fpArgumentRegister0 = fpRegT0;
    126     static const FPRegisterID fpArgumentRegister1 = fpRegT1;
    127     static const FPRegisterID fpArgumentRegister2 = fpRegT2;
    128     static const FPRegisterID fpArgumentRegister3 = fpRegT3;
    129     static const FPRReg returnValueFPR = fpr0;
    130     static const FPRegisterID fpReturnValueRegister = fpRegT0;
    131 
    132 
    133111    void preserveReturnAddressAfterCall(GPRReg reg)
    134112    {
     
    179157    {
    180158        return Address(GPRInfo::callFrameRegister, virtualRegister * sizeof(Register) + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload));
    181     }
    182 
    183     static FPRegisterID fprToRegisterID(FPRReg reg)
    184     {
    185         ASSERT(reg < numberOfFPRs);
    186         static const FPRegisterID idForRegister[numberOfFPRs] = { fpRegT0, fpRegT1, fpRegT2, fpRegT3, fpRegT4, fpRegT5 };
    187         return idForRegister[reg];
    188159    }
    189160
  • trunk/Source/JavaScriptCore/dfg/DFGNonSpeculativeJIT.cpp

    r85249 r85271  
    4747            m_gprInfo[iter.index()].nodeIndex = NoNode;
    4848    }
    49     for (FPRReg fpr = fpr0; fpr < numberOfFPRs; next(fpr)) {
    50         VirtualRegister virtualRegister = jit->m_fprs.name(fpr);
    51         if (virtualRegister != InvalidVirtualRegister) {
    52             GenerationInfo& info =  jit->m_generationInfo[virtualRegister];
     49    for (fpr_iterator iter = jit->m_fprs.begin(); iter != jit->m_fprs.end(); ++iter) {
     50        if (iter.name() != InvalidVirtualRegister) {
     51            GenerationInfo& info =  jit->m_generationInfo[iter.name()];
    5352            ASSERT(info.registerFormat() == DataFormatDouble);
    54             m_fprInfo[fpr] = info.nodeIndex();
     53            m_fprInfo[iter.index()] = info.nodeIndex();
    5554        } else
    56             m_fprInfo[fpr] = NoNode;
     55            m_fprInfo[iter.index()] = NoNode;
    5756    }
    5857}
     
    6261    GPRReg jsValueGpr = operand.gpr();
    6362    GPRReg tempGpr = allocate(); // FIXME: can we skip this allocation on the last use of the virtual register?
    64 
    65     JITCompiler::FPRegisterID fpReg = JITCompiler::fprToRegisterID(fpr);
    6663
    6764    JITCompiler::Jump isInteger = m_jit.branchPtr(MacroAssembler::AboveOrEqual, jsValueGpr, GPRInfo::tagTypeNumberRegister);
     
    7168    m_jit.move(jsValueGpr, tempGpr);
    7269    m_jit.addPtr(GPRInfo::tagTypeNumberRegister, tempGpr);
    73     m_jit.movePtrToDouble(tempGpr, fpReg);
     70    m_jit.movePtrToDouble(tempGpr, fpr);
    7471    JITCompiler::Jump hasUnboxedDouble = m_jit.jump();
    7572
     
    7774    nonNumeric.link(&m_jit);
    7875    silentSpillAllRegisters(fpr, jsValueGpr);
    79     m_jit.move(jsValueGpr, GPRInfo::argumentRegister1);
    80     m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentRegister0);
     76    m_jit.move(jsValueGpr, GPRInfo::argumentGPR1);
     77    m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
    8178    appendCallWithExceptionCheck(dfgConvertJSValueToNumber);
    82     m_jit.moveDouble(JITCompiler::fpReturnValueRegister, fpReg);
     79    m_jit.moveDouble(FPRInfo::returnValueFPR, fpr);
    8380    silentFillAllRegisters(fpr);
    8481    JITCompiler::Jump hasCalledToNumber = m_jit.jump();
     
    8683    // Finally, handle integers.
    8784    isInteger.link(&m_jit);
    88     m_jit.convertInt32ToDouble(jsValueGpr, fpReg);
     85    m_jit.convertInt32ToDouble(jsValueGpr, fpr);
    8986    hasUnboxedDouble.link(&m_jit);
    9087    hasCalledToNumber.link(&m_jit);
     
    10198    // First handle non-integers
    10299    silentSpillAllRegisters(result, jsValueGpr);
    103     m_jit.move(jsValueGpr, GPRInfo::argumentRegister1);
    104     m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentRegister0);
     100    m_jit.move(jsValueGpr, GPRInfo::argumentGPR1);
     101    m_jit.move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
    105102    appendCallWithExceptionCheck(dfgConvertJSValueToInt32);
    106     m_jit.zeroExtend32ToPtr(GPRInfo::returnValueRegister, result);
     103    m_jit.zeroExtend32ToPtr(GPRInfo::returnValueGPR, result);
    107104    silentFillAllRegisters(result);
    108105    JITCompiler::Jump hasCalledToInt32 = m_jit.jump();
     
    116113void NonSpeculativeJIT::numberToInt32(FPRReg fpr, GPRReg gpr)
    117114{
    118     JITCompiler::FPRegisterID fpReg = JITCompiler::fprToRegisterID(fpr);
    119 
    120     JITCompiler::Jump truncatedToInteger = m_jit.branchTruncateDoubleToInt32(fpReg, gpr, JITCompiler::BranchIfTruncateSuccessful);
     115    JITCompiler::Jump truncatedToInteger = m_jit.branchTruncateDoubleToInt32(fpr, gpr, JITCompiler::BranchIfTruncateSuccessful);
    121116
    122117    silentSpillAllRegisters(gpr);
    123118
    124     m_jit.moveDouble(fpReg, JITCompiler::fpArgumentRegister0);
     119    m_jit.moveDouble(fpr, FPRInfo::argumentFPR0);
    125120    appendCallWithExceptionCheck(toInt32);
    126     m_jit.zeroExtend32ToPtr(GPRInfo::returnValueRegister, gpr);
     121    m_jit.zeroExtend32ToPtr(GPRInfo::returnValueGPR, gpr);
    127122
    128123    silentFillAllRegisters(gpr);
     
    275270        IntegerOperand op1(this, node.child1);
    276271        FPRTemporary result(this);
    277         m_jit.convertInt32ToDouble(op1.gpr(), result.gpr());
     272        m_jit.convertInt32ToDouble(op1.gpr(), result.fpr());
    278273
    279274        MacroAssembler::Jump positive = m_jit.branch32(MacroAssembler::GreaterThanOrEqual, op1.gpr(), TrustedImm32(0));
    280         m_jit.addDouble(JITCompiler::AbsoluteAddress(&twoToThe32), result.gpr());
     275        m_jit.addDouble(JITCompiler::AbsoluteAddress(&twoToThe32), result.fpr());
    281276        positive.link(&m_jit);
    282277
     
    288283        IntegerOperand op1(this, node.child1);
    289284        FPRTemporary result(this);
    290         m_jit.convertInt32ToDouble(op1.gpr(), result.gpr());
     285        m_jit.convertInt32ToDouble(op1.gpr(), result.fpr());
    291286        doubleResult(result.fpr(), m_compileIndex);
    292287        break;
     
    330325            IntegerOperand op1(this, node.child1);
    331326            FPRTemporary result(this);
    332             m_jit.convertInt32ToDouble(op1.gpr(), result.gpr());
     327            m_jit.convertInt32ToDouble(op1.gpr(), result.fpr());
    333328            doubleResult(result.fpr(), m_compileIndex);
    334329            break;
     
    338333            DoubleOperand op1(this, node.child1);
    339334            FPRTemporary result(this, op1);
    340             m_jit.moveDouble(op1.gpr(), result.gpr());
     335            m_jit.moveDouble(op1.fpr(), result.fpr());
    341336            doubleResult(result.fpr(), m_compileIndex);
    342337            break;
     
    369364        FPRTemporary result(this, op1, op2);
    370365
    371         MacroAssembler::FPRegisterID reg1 = op1.gpr();
    372         MacroAssembler::FPRegisterID reg2 = op2.gpr();
    373         m_jit.addDouble(reg1, reg2, result.gpr());
     366        FPRReg reg1 = op1.fpr();
     367        FPRReg reg2 = op2.fpr();
     368        m_jit.addDouble(reg1, reg2, result.fpr());
    374369
    375370        doubleResult(result.fpr(), m_compileIndex);
     
    382377        FPRTemporary result(this, op1);
    383378
    384         MacroAssembler::FPRegisterID reg1 = op1.gpr();
    385         MacroAssembler::FPRegisterID reg2 = op2.gpr();
    386         m_jit.subDouble(reg1, reg2, result.gpr());
     379        FPRReg reg1 = op1.fpr();
     380        FPRReg reg2 = op2.fpr();
     381        m_jit.subDouble(reg1, reg2, result.fpr());
    387382
    388383        doubleResult(result.fpr(), m_compileIndex);
     
    395390        FPRTemporary result(this, op1, op2);
    396391
    397         MacroAssembler::FPRegisterID reg1 = op1.gpr();
    398         MacroAssembler::FPRegisterID reg2 = op2.gpr();
    399         m_jit.mulDouble(reg1, reg2, result.gpr());
     392        FPRReg reg1 = op1.fpr();
     393        FPRReg reg2 = op2.fpr();
     394        m_jit.mulDouble(reg1, reg2, result.fpr());
    400395
    401396        doubleResult(result.fpr(), m_compileIndex);
     
    408403        FPRTemporary result(this, op1);
    409404
    410         MacroAssembler::FPRegisterID reg1 = op1.gpr();
    411         MacroAssembler::FPRegisterID reg2 = op2.gpr();
    412         m_jit.divDouble(reg1, reg2, result.gpr());
     405        FPRReg reg1 = op1.fpr();
     406        FPRReg reg2 = op2.fpr();
     407        m_jit.divDouble(reg1, reg2, result.fpr());
    413408
    414409        doubleResult(result.fpr(), m_compileIndex);
     
    622617    case Return: {
    623618        ASSERT(GPRInfo::callFrameRegister != GPRInfo::regT1);
    624         ASSERT(GPRInfo::regT1 != GPRInfo::returnValueRegister);
    625         ASSERT(GPRInfo::returnValueRegister != GPRInfo::callFrameRegister);
     619        ASSERT(GPRInfo::regT1 != GPRInfo::returnValueGPR);
     620        ASSERT(GPRInfo::returnValueGPR != GPRInfo::callFrameRegister);
    626621
    627622#if DFG_SUCCESS_STATS
     
    630625#endif
    631626
    632         // Return the result in returnValueRegister.
     627        // Return the result in returnValueGPR.
    633628        JSValueOperand op1(this, node.child1);
    634         m_jit.move(op1.gpr(), GPRInfo::returnValueRegister);
     629        m_jit.move(op1.gpr(), GPRInfo::returnValueGPR);
    635630
    636631        // Grab the return address.
  • trunk/Source/JavaScriptCore/dfg/DFGNonSpeculativeJIT.h

    r85249 r85271  
    5555    };
    5656    RegisterInfo m_gprInfo[GPRInfo::numberOfRegisters];
    57     NodeIndex m_fprInfo[numberOfFPRs];
     57    NodeIndex m_fprInfo[FPRInfo::numberOfRegisters];
    5858};
    5959
     
    100100
    101101        DataFormat registerFormat = info.registerFormat();
    102         GPRReg reg = info.gpr();
    103102
    104103        if (registerFormat == DataFormatInteger) {
    105             m_jit.orPtr(GPRInfo::tagTypeNumberRegister, reg);
    106             m_jit.storePtr(reg, JITCompiler::addressFor(spillMe));
     104            m_jit.orPtr(GPRInfo::tagTypeNumberRegister, info.gpr());
     105            m_jit.storePtr(info.gpr(), JITCompiler::addressFor(spillMe));
    107106        } else {
    108107            ASSERT(registerFormat & DataFormatJS || registerFormat == DataFormatCell);
    109             m_jit.storePtr(reg, JITCompiler::addressFor(spillMe));
     108            m_jit.storePtr(info.gpr(), JITCompiler::addressFor(spillMe));
    110109        }
    111110    }
     
    132131        ASSERT(info.registerFormat() != DataFormatNone && info.registerFormat() != DataFormatDouble);
    133132        DataFormat registerFormat = info.registerFormat();
    134         GPRReg reg = info.gpr();
    135133
    136134        if (registerFormat == DataFormatInteger) {
    137135            if (node.isConstant()) {
    138136                ASSERT(isInt32Constant(nodeIndex));
    139                 m_jit.move(Imm32(valueOfInt32Constant(nodeIndex)), reg);
     137                m_jit.move(Imm32(valueOfInt32Constant(nodeIndex)), info.gpr());
    140138            } else
    141                 m_jit.load32(JITCompiler::addressFor(spillMe), reg);
     139                m_jit.load32(JITCompiler::addressFor(spillMe), info.gpr());
    142140            return;
    143141        }
    144142
    145143        if (node.isConstant())
    146             m_jit.move(constantAsJSValueAsImmPtr(nodeIndex), reg);
     144            m_jit.move(constantAsJSValueAsImmPtr(nodeIndex), info.gpr());
    147145        else {
    148146            ASSERT(registerFormat & DataFormatJS || registerFormat == DataFormatCell);
    149             m_jit.loadPtr(JITCompiler::addressFor(spillMe), reg);
     147            m_jit.loadPtr(JITCompiler::addressFor(spillMe), info.gpr());
    150148        }
    151149    }
     
    160158        ASSERT(info.registerFormat() == DataFormatDouble);
    161159
    162         if (node.isConstant()) {
    163             GPRReg reg = info.gpr();
    164             m_jit.move(constantAsJSValueAsImmPtr(nodeIndex), reg);
    165         } else {
     160        if (node.isConstant())
     161            m_jit.move(constantAsJSValueAsImmPtr(nodeIndex), info.gpr());
     162        else {
    166163            m_jit.loadPtr(JITCompiler::addressFor(spillMe), canTrample);
    167164            unboxDouble(canTrample, info.fpr());
     
    179176                silentSpillGPR(iter.name(), exclude);
    180177        }
    181         for (FPRReg fpr = fpr0; fpr < numberOfFPRs; next(fpr)) {
    182             VirtualRegister name = m_fprs.name(fpr);
    183             if (name != InvalidVirtualRegister)
    184                 silentSpillFPR(name, canTrample);
     178        for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
     179            if (iter.name() != InvalidVirtualRegister)
     180                silentSpillFPR(iter.name(), canTrample);
    185181        }
    186182    }
     
    195191                silentSpillGPR(iter.name());
    196192        }
    197         for (FPRReg fpr = fpr0; fpr < numberOfFPRs; next(fpr)) {
    198             VirtualRegister name = m_fprs.name(fpr);
    199             if (name != InvalidVirtualRegister)
    200                 silentSpillFPR(name, canTrample, exclude);
     193        for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
     194            if (iter.name() != InvalidVirtualRegister)
     195                silentSpillFPR(iter.name(), canTrample, exclude);
    201196        }
    202197    }
     
    207202            canTrample = GPRInfo::regT1;
    208203       
    209         for (FPRReg fpr = fpr0; fpr < numberOfFPRs; next(fpr)) {
    210             VirtualRegister name = m_fprs.name(fpr);
    211             if (name != InvalidVirtualRegister)
    212                 silentFillFPR(name, canTrample);
     204        for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
     205            if (iter.name() != InvalidVirtualRegister)
     206                silentFillFPR(iter.name(), canTrample);
    213207        }
    214208        for (gpr_iterator iter = m_gprs.begin(); iter != m_gprs.end(); ++iter) {
     
    221215        GPRReg canTrample = GPRInfo::regT0;
    222216       
    223         for (FPRReg fpr = fpr0; fpr < numberOfFPRs; next(fpr)) {
    224             VirtualRegister name = m_fprs.name(fpr);
    225             if (name != InvalidVirtualRegister) {
    226 #ifndef NDEBUG
    227                 ASSERT(fpr != exclude);
    228 #else
    229                 UNUSED_PARAM(exclude);
    230 #endif
    231                 silentFillFPR(name, canTrample, exclude);
     217        for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
     218            if (iter.name() != InvalidVirtualRegister) {
     219                ASSERT_UNUSED(exclude, iter.regID() != exclude);
     220                silentFillFPR(iter.name(), canTrample, exclude);
    232221            }
    233222        }
  • trunk/Source/JavaScriptCore/dfg/DFGRegisterBank.h

    r85249 r85271  
    226226        }
    227227
    228         RegID gpr() const
     228        RegID regID() const
    229229        {
    230230            return BankInfo::toRegister(m_index);
     
    234234        const char* debugName() const
    235235        {
    236             return BankInfo::debugName(gpr());
     236            return BankInfo::debugName(regID());
    237237        }
    238238#endif
  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp

    r85249 r85271  
    152152            m_gprInfo[iter.index()].nodeIndex = NoNode;
    153153    }
    154     for (FPRReg fpr = fpr0; fpr < numberOfFPRs; next(fpr)) {
    155         VirtualRegister virtualRegister = jit->m_fprs.name(fpr);
    156         if (virtualRegister != InvalidVirtualRegister) {
    157             GenerationInfo& info =  jit->m_generationInfo[virtualRegister];
     154    for (fpr_iterator iter = jit->m_fprs.begin(); iter != jit->m_fprs.end(); ++iter) {
     155        if (iter.name() != InvalidVirtualRegister) {
     156            GenerationInfo& info =  jit->m_generationInfo[iter.name()];
    158157            ASSERT(info.registerFormat() == DataFormatDouble);
    159             m_fprInfo[fpr] = info.nodeIndex();
     158            m_fprInfo[iter.index()] = info.nodeIndex();
    160159        } else
    161             m_fprInfo[fpr] = NoNode;
     160            m_fprInfo[iter.index()] = NoNode;
    162161    }
    163162}
     
    432431            GPRTemporary result(this);
    433432
    434             GPRReg reg = op2.gpr();
    435             speculationCheck(m_jit.branchAdd32(MacroAssembler::Overflow, reg, Imm32(imm1), result.gpr()));
     433            speculationCheck(m_jit.branchAdd32(MacroAssembler::Overflow, op2.gpr(), Imm32(imm1), result.gpr()));
    436434
    437435            integerResult(result.gpr(), m_compileIndex);
     
    444442            GPRTemporary result(this);
    445443
    446             GPRReg reg = op1.gpr();
    447             speculationCheck(m_jit.branchAdd32(MacroAssembler::Overflow, reg, Imm32(imm2), result.gpr()));
     444            speculationCheck(m_jit.branchAdd32(MacroAssembler::Overflow, op1.gpr(), Imm32(imm2), result.gpr()));
    448445
    449446            integerResult(result.gpr(), m_compileIndex);
     
    477474            GPRTemporary result(this);
    478475
    479             GPRReg reg = op1.gpr();
    480             speculationCheck(m_jit.branchSub32(MacroAssembler::Overflow, reg, Imm32(imm2), result.gpr()));
     476            speculationCheck(m_jit.branchSub32(MacroAssembler::Overflow, op1.gpr(), Imm32(imm2), result.gpr()));
    481477
    482478            integerResult(result.gpr(), m_compileIndex);
     
    488484        GPRTemporary result(this);
    489485
    490         GPRReg reg1 = op1.gpr();
    491         GPRReg reg2 = op2.gpr();
    492         speculationCheck(m_jit.branchSub32(MacroAssembler::Overflow, reg1, reg2, result.gpr()));
     486        speculationCheck(m_jit.branchSub32(MacroAssembler::Overflow, op1.gpr(), op2.gpr(), result.gpr()));
    493487
    494488        integerResult(result.gpr(), m_compileIndex);
     
    776770    case Return: {
    777771        ASSERT(GPRInfo::callFrameRegister != GPRInfo::regT1);
    778         ASSERT(GPRInfo::regT1 != GPRInfo::returnValueRegister);
    779         ASSERT(GPRInfo::returnValueRegister != GPRInfo::callFrameRegister);
     772        ASSERT(GPRInfo::regT1 != GPRInfo::returnValueGPR);
     773        ASSERT(GPRInfo::returnValueGPR != GPRInfo::callFrameRegister);
    780774
    781775#if DFG_SUCCESS_STATS
     
    784778#endif
    785779
    786         // Return the result in returnValueRegister.
     780        // Return the result in returnValueGPR.
    787781        JSValueOperand op1(this, node.child1);
    788         m_jit.move(op1.gpr(), GPRInfo::returnValueRegister);
     782        m_jit.move(op1.gpr(), GPRInfo::returnValueGPR);
    789783
    790784        // Grab the return address.
  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h

    r85249 r85271  
    8787    };
    8888    RegisterInfo m_gprInfo[GPRInfo::numberOfRegisters];
    89     NodeIndex m_fprInfo[numberOfFPRs];
     89    NodeIndex m_fprInfo[FPRInfo::numberOfRegisters];
    9090};
    9191typedef SegmentedVector<SpeculationCheck, 16> SpeculationCheckVector;
Note: See TracChangeset for help on using the changeset viewer.