Ignore:
Timestamp:
Aug 19, 2009, 5:02:24 PM (16 years ago)
Author:
[email protected]
Message:

2009-08-19 Yong Li <​[email protected]>

Reviewed by Gavin Barraclough.

Change namespace ARM to ARMRegisters
X86 to X86Registers to avoid conflict with macros
​https://bugs.webkit.org/show_bug.cgi?id=28428

  • assembler/ARMAssembler.cpp:
  • assembler/ARMAssembler.h:
  • assembler/ARMv7Assembler.h:
  • assembler/MacroAssemblerARM.h:
  • assembler/MacroAssemblerARMv7.h:
  • assembler/MacroAssemblerX86Common.h:
  • assembler/MacroAssemblerX86_64.h:
  • assembler/X86Assembler.h:
  • jit/JIT.h:
  • jit/JITArithmetic.cpp:
  • jit/JITInlineMethods.h:
  • jit/JITOpcodes.cpp:
  • wrec/WRECGenerator.cpp:
  • wrec/WRECGenerator.h:
  • yarr/RegexJIT.cpp:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/assembler/ARMAssembler.h

    r47265 r47530  
    3636namespace JSC {
    3737
    38 typedef uint32_t ARMWord;
    39 
    40 namespace ARM {
    41     typedef enum {
    42         r0 = 0,
    43         r1,
    44         r2,
    45         r3,
    46         S0 = r3,
    47         r4,
    48         r5,
    49         r6,
    50         r7,
    51         r8,
    52         S1 = r8,
    53         r9,
    54         r10,
    55         r11,
    56         r12,
    57         r13,
    58         sp = r13,
    59         r14,
    60         lr = r14,
    61         r15,
    62         pc = r15
    63     } RegisterID;
    64 
    65     typedef enum {
    66         d0,
    67         d1,
    68         d2,
    69         d3,
    70         SD0 = d3
    71     } FPRegisterID;
    72 
    73 } // namespace ARM
     38    typedef uint32_t ARMWord;
     39
     40    namespace ARMRegisters {
     41        typedef enum {
     42            r0 = 0,
     43            r1,
     44            r2,
     45            r3,
     46            S0 = r3,
     47            r4,
     48            r5,
     49            r6,
     50            r7,
     51            r8,
     52            S1 = r8,
     53            r9,
     54            r10,
     55            r11,
     56            r12,
     57            r13,
     58            sp = r13,
     59            r14,
     60            lr = r14,
     61            r15,
     62            pc = r15
     63        } RegisterID;
     64
     65        typedef enum {
     66            d0,
     67            d1,
     68            d2,
     69            d3,
     70            SD0 = d3
     71        } FPRegisterID;
     72
     73    } // namespace ARMRegisters
    7474
    7575    class ARMAssembler {
    7676    public:
    77         typedef ARM::RegisterID RegisterID;
    78         typedef ARM::FPRegisterID FPRegisterID;
     77        typedef ARMRegisters::RegisterID RegisterID;
     78        typedef ARMRegisters::FPRegisterID FPRegisterID;
    7979        typedef AssemblerBufferWithConstantPool<2048, 4, 4, ARMAssembler> ARMBuffer;
    8080        typedef SegmentedVector<int, 64> Jumps;
    … …  
    331331        void mov_r(int rd, ARMWord op2, Condition cc = AL)
    332332        {
    333             emitInst(static_cast<ARMWord>(cc) | MOV, rd, ARM::r0, op2);
     333            emitInst(static_cast<ARMWord>(cc) | MOV, rd, ARMRegisters::r0, op2);
    334334        }
    335335
    336336        void movs_r(int rd, ARMWord op2, Condition cc = AL)
    337337        {
    338             emitInst(static_cast<ARMWord>(cc) | MOV | SET_CC, rd, ARM::r0, op2);
     338            emitInst(static_cast<ARMWord>(cc) | MOV | SET_CC, rd, ARMRegisters::r0, op2);
    339339        }
    340340
    … …  
    351351        void mvn_r(int rd, ARMWord op2, Condition cc = AL)
    352352        {
    353             emitInst(static_cast<ARMWord>(cc) | MVN, rd, ARM::r0, op2);
     353            emitInst(static_cast<ARMWord>(cc) | MVN, rd, ARMRegisters::r0, op2);
    354354        }
    355355
    356356        void mvns_r(int rd, ARMWord op2, Condition cc = AL)
    357357        {
    358             emitInst(static_cast<ARMWord>(cc) | MVN | SET_CC, rd, ARM::r0, op2);
     358            emitInst(static_cast<ARMWord>(cc) | MVN | SET_CC, rd, ARMRegisters::r0, op2);
    359359        }
    360360
    … …  
    396396        void ldr_imm(int rd, ARMWord imm, Condition cc = AL)
    397397        {
    398             m_buffer.putIntWithConstantInt(static_cast<ARMWord>(cc) | DTR | DT_LOAD | DT_UP | RN(ARM::pc) | RD(rd), imm, true);
     398            m_buffer.putIntWithConstantInt(static_cast<ARMWord>(cc) | DTR | DT_LOAD | DT_UP | RN(ARMRegisters::pc) | RD(rd), imm, true);
    399399        }
    400400
    401401        void ldr_un_imm(int rd, ARMWord imm, Condition cc = AL)
    402402        {
    403             m_buffer.putIntWithConstantInt(static_cast<ARMWord>(cc) | DTR | DT_LOAD | DT_UP | RN(ARM::pc) | RD(rd), imm);
     403            m_buffer.putIntWithConstantInt(static_cast<ARMWord>(cc) | DTR | DT_LOAD | DT_UP | RN(ARMRegisters::pc) | RD(rd), imm);
    404404        }
    405405
    … …  
    459459        {
    460460            ASSERT(ARMWord(reg) <= 0xf);
    461             m_buffer.putInt(cc | DTR | DT_WB | RN(ARM::sp) | RD(reg) | 0x4);
     461            m_buffer.putInt(cc | DTR | DT_WB | RN(ARMRegisters::sp) | RD(reg) | 0x4);
    462462        }
    463463
    … …  
    465465        {
    466466            ASSERT(ARMWord(reg) <= 0xf);
    467             m_buffer.putInt(cc | (DTR ^ DT_PRE) | DT_LOAD | DT_UP | RN(ARM::sp) | RD(reg) | 0x4);
     467            m_buffer.putInt(cc | (DTR ^ DT_PRE) | DT_LOAD | DT_UP | RN(ARMRegisters::sp) | RD(reg) | 0x4);
    468468        }
    469469
    470470        inline void poke_r(int reg, Condition cc = AL)
    471471        {
    472             dtr_d(false, ARM::sp, 0, reg, cc);
     472            dtr_d(false, ARMRegisters::sp, 0, reg, cc);
    473473        }
    474474
    475475        inline void peek_r(int reg, Condition cc = AL)
    476476        {
    477             dtr_u(true, reg, ARM::sp, 0, cc);
     477            dtr_u(true, reg, ARMRegisters::sp, 0, cc);
    478478        }
    479479
    … …  
    506506#else
    507507            // Cannot access to Zero memory address
    508             dtr_dr(true, ARM::S0, ARM::S0, ARM::S0);
     508            dtr_dr(true, ARMRegisters::S0, ARMRegisters::S0, ARMRegisters::S0);
    509509#endif
    510510        }
    … …  
    512512        static ARMWord lsl(int reg, ARMWord value)
    513513        {
    514             ASSERT(reg <= ARM::pc);
     514            ASSERT(reg <= ARMRegisters::pc);
    515515            ASSERT(value <= 0x1f);
    516516            return reg | (value << 7) | 0x00;
    … …  
    519519        static ARMWord lsr(int reg, ARMWord value)
    520520        {
    521             ASSERT(reg <= ARM::pc);
     521            ASSERT(reg <= ARMRegisters::pc);
    522522            ASSERT(value <= 0x1f);
    523523            return reg | (value << 7) | 0x20;
    … …  
    526526        static ARMWord asr(int reg, ARMWord value)
    527527        {
    528             ASSERT(reg <= ARM::pc);
     528            ASSERT(reg <= ARMRegisters::pc);
    529529            ASSERT(value <= 0x1f);
    530530            return reg | (value << 7) | 0x40;
    … …  
    533533        static ARMWord lsl_r(int reg, int shiftReg)
    534534        {
    535             ASSERT(reg <= ARM::pc);
    536             ASSERT(shiftReg <= ARM::pc);
     535            ASSERT(reg <= ARMRegisters::pc);
     536            ASSERT(shiftReg <= ARMRegisters::pc);
    537537            return reg | (shiftReg << 8) | 0x10;
    538538        }
    … …  
    540540        static ARMWord lsr_r(int reg, int shiftReg)
    541541        {
    542             ASSERT(reg <= ARM::pc);
    543             ASSERT(shiftReg <= ARM::pc);
     542            ASSERT(reg <= ARMRegisters::pc);
     543            ASSERT(shiftReg <= ARMRegisters::pc);
    544544            return reg | (shiftReg << 8) | 0x30;
    545545        }
    … …  
    547547        static ARMWord asr_r(int reg, int shiftReg)
    548548        {
    549             ASSERT(reg <= ARM::pc);
    550             ASSERT(shiftReg <= ARM::pc);
     549            ASSERT(reg <= ARMRegisters::pc);
     550            ASSERT(shiftReg <= ARMRegisters::pc);
    551551            return reg | (shiftReg << 8) | 0x50;
    552552        }
    … …  
    577577        {
    578578            while (!m_buffer.isAligned(alignment))
    579                 mov_r(ARM::r0, ARM::r0);
     579                mov_r(ARMRegisters::r0, ARMRegisters::r0);
    580580
    581581            return label();
    … …  
    586586            ensureSpace(sizeof(ARMWord), sizeof(ARMWord));
    587587            int s = m_buffer.uncheckedSize();
    588             ldr_un_imm(ARM::pc, 0xffffffff, cc);
     588            ldr_un_imm(ARMRegisters::pc, 0xffffffff, cc);
    589589            m_jumps.append(s | (useConstantPool & 0x1));
    590590            return JmpSrc(s);
    … …  
    730730        ARMWord RM(int reg)
    731731        {
    732             ASSERT(reg <= ARM::pc);
     732            ASSERT(reg <= ARMRegisters::pc);
    733733            return reg;
    734734        }
    … …  
    736736        ARMWord RS(int reg)
    737737        {
    738             ASSERT(reg <= ARM::pc);
     738            ASSERT(reg <= ARMRegisters::pc);
    739739            return reg << 8;
    740740        }
    … …  
    742742        ARMWord RD(int reg)
    743743        {
    744             ASSERT(reg <= ARM::pc);
     744            ASSERT(reg <= ARMRegisters::pc);
    745745            return reg << 12;
    746746        }
    … …  
    748748        ARMWord RN(int reg)
    749749        {
    750             ASSERT(reg <= ARM::pc);
     750            ASSERT(reg <= ARMRegisters::pc);
    751751            return reg << 16;
    752752        }
Note: See TracChangeset for help on using the changeset viewer.