src/share/vm/c1/c1_LIR.hpp

rev 9434 : 8138952: C1: Distinguish between PPC32 and PPC64
Reviewed-by: twisti

*** 646,671 ****
                                                                               LIR_OprDesc::double_type          |
                                                                               LIR_OprDesc::fpu_register         |
                                                                               LIR_OprDesc::double_size          |
                                                                               LIR_OprDesc::is_xmm_mask); }
  #endif // X86
! #ifdef PPC
    static LIR_Opr double_fpu(int reg)            { return (LIR_Opr)(intptr_t)((reg  << LIR_OprDesc::reg1_shift) |
                                                                               (reg  << LIR_OprDesc::reg2_shift) |
                                                                               LIR_OprDesc::double_type          |
                                                                               LIR_OprDesc::fpu_register         |
                                                                               LIR_OprDesc::double_size); }
    static LIR_Opr single_softfp(int reg)            { return (LIR_Opr)((reg  << LIR_OprDesc::reg1_shift)        |
                                                                               LIR_OprDesc::float_type           |
                                                                               LIR_OprDesc::cpu_register         |
                                                                               LIR_OprDesc::single_size); }
    static LIR_Opr double_softfp(int reg1, int reg2) { return (LIR_Opr)((reg2 << LIR_OprDesc::reg1_shift)        |
                                                                               (reg1 << LIR_OprDesc::reg2_shift) |
                                                                               LIR_OprDesc::double_type          |
                                                                               LIR_OprDesc::cpu_register         |
                                                                               LIR_OprDesc::double_size); }
! #endif // PPC
  
    static LIR_Opr virtual_register(int index, BasicType type) {
      LIR_Opr res;
      switch (type) {
        case T_OBJECT: // fall through
--- 646,673 ----
                                                                               LIR_OprDesc::double_type          |
                                                                               LIR_OprDesc::fpu_register         |
                                                                               LIR_OprDesc::double_size          |
                                                                               LIR_OprDesc::is_xmm_mask); }
  #endif // X86
! #if defined(PPC)
    static LIR_Opr double_fpu(int reg)            { return (LIR_Opr)(intptr_t)((reg  << LIR_OprDesc::reg1_shift) |
                                                                               (reg  << LIR_OprDesc::reg2_shift) |
                                                                               LIR_OprDesc::double_type          |
                                                                               LIR_OprDesc::fpu_register         |
                                                                               LIR_OprDesc::double_size); }
+ #endif
+ #ifdef PPC32
    static LIR_Opr single_softfp(int reg)            { return (LIR_Opr)((reg  << LIR_OprDesc::reg1_shift)        |
                                                                               LIR_OprDesc::float_type           |
                                                                               LIR_OprDesc::cpu_register         |
                                                                               LIR_OprDesc::single_size); }
    static LIR_Opr double_softfp(int reg1, int reg2) { return (LIR_Opr)((reg2 << LIR_OprDesc::reg1_shift)        |
                                                                               (reg1 << LIR_OprDesc::reg2_shift) |
                                                                               LIR_OprDesc::double_type          |
                                                                               LIR_OprDesc::cpu_register         |
                                                                               LIR_OprDesc::double_size); }
! #endif // PPC32
  
    static LIR_Opr virtual_register(int index, BasicType type) {
      LIR_Opr res;
      switch (type) {
        case T_OBJECT: // fall through
*** 1473,1498 ****
   friend class LIR_OpVisitState;
  
   private:
     Bytecodes::Code _bytecode;
     ConversionStub* _stub;
! #ifdef PPC
    LIR_Opr _tmp1;
    LIR_Opr _tmp2;
  #endif
  
   public:
     LIR_OpConvert(Bytecodes::Code code, LIR_Opr opr, LIR_Opr result, ConversionStub* stub)
       : LIR_Op1(lir_convert, opr, result)
       , _stub(stub)
! #ifdef PPC
       , _tmp1(LIR_OprDesc::illegalOpr())
       , _tmp2(LIR_OprDesc::illegalOpr())
  #endif
       , _bytecode(code)                           {}
  
! #ifdef PPC
     LIR_OpConvert(Bytecodes::Code code, LIR_Opr opr, LIR_Opr result, ConversionStub* stub
                   ,LIR_Opr tmp1, LIR_Opr tmp2)
       : LIR_Op1(lir_convert, opr, result)
       , _stub(stub)
       , _tmp1(tmp1)
--- 1475,1500 ----
   friend class LIR_OpVisitState;
  
   private:
     Bytecodes::Code _bytecode;
     ConversionStub* _stub;
! #ifdef PPC32
    LIR_Opr _tmp1;
    LIR_Opr _tmp2;
  #endif
  
   public:
     LIR_OpConvert(Bytecodes::Code code, LIR_Opr opr, LIR_Opr result, ConversionStub* stub)
       : LIR_Op1(lir_convert, opr, result)
       , _stub(stub)
! #ifdef PPC32
       , _tmp1(LIR_OprDesc::illegalOpr())
       , _tmp2(LIR_OprDesc::illegalOpr())
  #endif
       , _bytecode(code)                           {}
  
! #ifdef PPC32
     LIR_OpConvert(Bytecodes::Code code, LIR_Opr opr, LIR_Opr result, ConversionStub* stub
                   ,LIR_Opr tmp1, LIR_Opr tmp2)
       : LIR_Op1(lir_convert, opr, result)
       , _stub(stub)
       , _tmp1(tmp1)
*** 1500,1510 ****
       , _bytecode(code)                           {}
  #endif
  
    Bytecodes::Code bytecode() const               { return _bytecode; }
    ConversionStub* stub() const                   { return _stub; }
! #ifdef PPC
    LIR_Opr tmp1() const                           { return _tmp1; }
    LIR_Opr tmp2() const                           { return _tmp2; }
  #endif
  
    virtual void emit_code(LIR_Assembler* masm);
--- 1502,1512 ----
       , _bytecode(code)                           {}
  #endif
  
    Bytecodes::Code bytecode() const               { return _bytecode; }
    ConversionStub* stub() const                   { return _stub; }
! #ifdef PPC32
    LIR_Opr tmp1() const                           { return _tmp1; }
    LIR_Opr tmp2() const                           { return _tmp2; }
  #endif
  
    virtual void emit_code(LIR_Assembler* masm);
*** 2140,2150 ****
  
    void return_op(LIR_Opr result)                 { append(new LIR_Op1(lir_return, result)); }
  
    void safepoint(LIR_Opr tmp, CodeEmitInfo* info)  { append(new LIR_Op1(lir_safepoint, tmp, info)); }
  
! #ifdef PPC
    void convert(Bytecodes::Code code, LIR_Opr left, LIR_Opr dst, LIR_Opr tmp1, LIR_Opr tmp2) { append(new LIR_OpConvert(code, left, dst, NULL, tmp1, tmp2)); }
  #endif
    void convert(Bytecodes::Code code, LIR_Opr left, LIR_Opr dst, ConversionStub* stub = NULL/*, bool is_32bit = false*/) { append(new LIR_OpConvert(code, left, dst, stub)); }
  
    void logical_and (LIR_Opr left, LIR_Opr right, LIR_Opr dst) { append(new LIR_Op2(lir_logic_and,  left, right, dst)); }
--- 2142,2152 ----
  
    void return_op(LIR_Opr result)                 { append(new LIR_Op1(lir_return, result)); }
  
    void safepoint(LIR_Opr tmp, CodeEmitInfo* info)  { append(new LIR_Op1(lir_safepoint, tmp, info)); }
  
! #ifdef PPC32
    void convert(Bytecodes::Code code, LIR_Opr left, LIR_Opr dst, LIR_Opr tmp1, LIR_Opr tmp2) { append(new LIR_OpConvert(code, left, dst, NULL, tmp1, tmp2)); }
  #endif
    void convert(Bytecodes::Code code, LIR_Opr left, LIR_Opr dst, ConversionStub* stub = NULL/*, bool is_32bit = false*/) { append(new LIR_OpConvert(code, left, dst, stub)); }
  
    void logical_and (LIR_Opr left, LIR_Opr right, LIR_Opr dst) { append(new LIR_Op2(lir_logic_and,  left, right, dst)); }