Mercurial > jdk8-mips64-public > hotspot / changeset

     1.1 --- a/src/cpu/sparc/vm/c1_FrameMap_sparc.cpp	Tue Sep 11 14:59:23 2012 +0200
     1.2 +++ b/src/cpu/sparc/vm/c1_FrameMap_sparc.cpp	Tue Sep 11 16:20:57 2012 +0200
     1.3 @@ -147,6 +147,39 @@
     1.4  LIR_Opr FrameMap::I6_oop_opr;
     1.5  LIR_Opr FrameMap::I7_oop_opr;
     1.6  
     1.7 +LIR_Opr FrameMap::G0_metadata_opr;
     1.8 +LIR_Opr FrameMap::G1_metadata_opr;
     1.9 +LIR_Opr FrameMap::G2_metadata_opr;
    1.10 +LIR_Opr FrameMap::G3_metadata_opr;
    1.11 +LIR_Opr FrameMap::G4_metadata_opr;
    1.12 +LIR_Opr FrameMap::G5_metadata_opr;
    1.13 +LIR_Opr FrameMap::G6_metadata_opr;
    1.14 +LIR_Opr FrameMap::G7_metadata_opr;
    1.15 +LIR_Opr FrameMap::O0_metadata_opr;
    1.16 +LIR_Opr FrameMap::O1_metadata_opr;
    1.17 +LIR_Opr FrameMap::O2_metadata_opr;
    1.18 +LIR_Opr FrameMap::O3_metadata_opr;
    1.19 +LIR_Opr FrameMap::O4_metadata_opr;
    1.20 +LIR_Opr FrameMap::O5_metadata_opr;
    1.21 +LIR_Opr FrameMap::O6_metadata_opr;
    1.22 +LIR_Opr FrameMap::O7_metadata_opr;
    1.23 +LIR_Opr FrameMap::L0_metadata_opr;
    1.24 +LIR_Opr FrameMap::L1_metadata_opr;
    1.25 +LIR_Opr FrameMap::L2_metadata_opr;
    1.26 +LIR_Opr FrameMap::L3_metadata_opr;
    1.27 +LIR_Opr FrameMap::L4_metadata_opr;
    1.28 +LIR_Opr FrameMap::L5_metadata_opr;
    1.29 +LIR_Opr FrameMap::L6_metadata_opr;
    1.30 +LIR_Opr FrameMap::L7_metadata_opr;
    1.31 +LIR_Opr FrameMap::I0_metadata_opr;
    1.32 +LIR_Opr FrameMap::I1_metadata_opr;
    1.33 +LIR_Opr FrameMap::I2_metadata_opr;
    1.34 +LIR_Opr FrameMap::I3_metadata_opr;
    1.35 +LIR_Opr FrameMap::I4_metadata_opr;
    1.36 +LIR_Opr FrameMap::I5_metadata_opr;
    1.37 +LIR_Opr FrameMap::I6_metadata_opr;
    1.38 +LIR_Opr FrameMap::I7_metadata_opr;
    1.39 +
    1.40  LIR_Opr FrameMap::SP_opr;
    1.41  LIR_Opr FrameMap::FP_opr;
    1.42  
    1.43 @@ -310,6 +343,39 @@
    1.44    I6_oop_opr = as_oop_opr(I6);
    1.45    I7_oop_opr = as_oop_opr(I7);
    1.46  
    1.47 +  G0_metadata_opr = as_metadata_opr(G0);
    1.48 +  G1_metadata_opr = as_metadata_opr(G1);
    1.49 +  G2_metadata_opr = as_metadata_opr(G2);
    1.50 +  G3_metadata_opr = as_metadata_opr(G3);
    1.51 +  G4_metadata_opr = as_metadata_opr(G4);
    1.52 +  G5_metadata_opr = as_metadata_opr(G5);
    1.53 +  G6_metadata_opr = as_metadata_opr(G6);
    1.54 +  G7_metadata_opr = as_metadata_opr(G7);
    1.55 +  O0_metadata_opr = as_metadata_opr(O0);
    1.56 +  O1_metadata_opr = as_metadata_opr(O1);
    1.57 +  O2_metadata_opr = as_metadata_opr(O2);
    1.58 +  O3_metadata_opr = as_metadata_opr(O3);
    1.59 +  O4_metadata_opr = as_metadata_opr(O4);
    1.60 +  O5_metadata_opr = as_metadata_opr(O5);
    1.61 +  O6_metadata_opr = as_metadata_opr(O6);
    1.62 +  O7_metadata_opr = as_metadata_opr(O7);
    1.63 +  L0_metadata_opr = as_metadata_opr(L0);
    1.64 +  L1_metadata_opr = as_metadata_opr(L1);
    1.65 +  L2_metadata_opr = as_metadata_opr(L2);
    1.66 +  L3_metadata_opr = as_metadata_opr(L3);
    1.67 +  L4_metadata_opr = as_metadata_opr(L4);
    1.68 +  L5_metadata_opr = as_metadata_opr(L5);
    1.69 +  L6_metadata_opr = as_metadata_opr(L6);
    1.70 +  L7_metadata_opr = as_metadata_opr(L7);
    1.71 +  I0_metadata_opr = as_metadata_opr(I0);
    1.72 +  I1_metadata_opr = as_metadata_opr(I1);
    1.73 +  I2_metadata_opr = as_metadata_opr(I2);
    1.74 +  I3_metadata_opr = as_metadata_opr(I3);
    1.75 +  I4_metadata_opr = as_metadata_opr(I4);
    1.76 +  I5_metadata_opr = as_metadata_opr(I5);
    1.77 +  I6_metadata_opr = as_metadata_opr(I6);
    1.78 +  I7_metadata_opr = as_metadata_opr(I7);
    1.79 +
    1.80    FP_opr = as_pointer_opr(FP);
    1.81    SP_opr = as_pointer_opr(SP);
    1.82  

     2.1 --- a/src/cpu/sparc/vm/c1_FrameMap_sparc.hpp	Tue Sep 11 14:59:23 2012 +0200
     2.2 +++ b/src/cpu/sparc/vm/c1_FrameMap_sparc.hpp	Tue Sep 11 16:20:57 2012 +0200
     2.3 @@ -104,6 +104,39 @@
     2.4    static LIR_Opr I6_oop_opr;
     2.5    static LIR_Opr I7_oop_opr;
     2.6  
     2.7 +  static LIR_Opr G0_metadata_opr;
     2.8 +  static LIR_Opr G1_metadata_opr;
     2.9 +  static LIR_Opr G2_metadata_opr;
    2.10 +  static LIR_Opr G3_metadata_opr;
    2.11 +  static LIR_Opr G4_metadata_opr;
    2.12 +  static LIR_Opr G5_metadata_opr;
    2.13 +  static LIR_Opr G6_metadata_opr;
    2.14 +  static LIR_Opr G7_metadata_opr;
    2.15 +  static LIR_Opr O0_metadata_opr;
    2.16 +  static LIR_Opr O1_metadata_opr;
    2.17 +  static LIR_Opr O2_metadata_opr;
    2.18 +  static LIR_Opr O3_metadata_opr;
    2.19 +  static LIR_Opr O4_metadata_opr;
    2.20 +  static LIR_Opr O5_metadata_opr;
    2.21 +  static LIR_Opr O6_metadata_opr;
    2.22 +  static LIR_Opr O7_metadata_opr;
    2.23 +  static LIR_Opr L0_metadata_opr;
    2.24 +  static LIR_Opr L1_metadata_opr;
    2.25 +  static LIR_Opr L2_metadata_opr;
    2.26 +  static LIR_Opr L3_metadata_opr;
    2.27 +  static LIR_Opr L4_metadata_opr;
    2.28 +  static LIR_Opr L5_metadata_opr;
    2.29 +  static LIR_Opr L6_metadata_opr;
    2.30 +  static LIR_Opr L7_metadata_opr;
    2.31 +  static LIR_Opr I0_metadata_opr;
    2.32 +  static LIR_Opr I1_metadata_opr;
    2.33 +  static LIR_Opr I2_metadata_opr;
    2.34 +  static LIR_Opr I3_metadata_opr;
    2.35 +  static LIR_Opr I4_metadata_opr;
    2.36 +  static LIR_Opr I5_metadata_opr;
    2.37 +  static LIR_Opr I6_metadata_opr;
    2.38 +  static LIR_Opr I7_metadata_opr;
    2.39 +
    2.40    static LIR_Opr in_long_opr;
    2.41    static LIR_Opr out_long_opr;
    2.42    static LIR_Opr g1_long_single_opr;

     3.1 --- a/src/cpu/sparc/vm/c1_LIRAssembler_sparc.cpp	Tue Sep 11 14:59:23 2012 +0200
     3.2 +++ b/src/cpu/sparc/vm/c1_LIRAssembler_sparc.cpp	Tue Sep 11 16:20:57 2012 +0200
     3.3 @@ -447,9 +447,12 @@
     3.4  
     3.5    if (compilation()->env()->dtrace_method_probes()) {
     3.6      __ mov(G2_thread, O0);
     3.7 +    __ save_thread(I1); // need to preserve thread in G2 across
     3.8 +                        // runtime call
     3.9      metadata2reg(method()->constant_encoding(), O1);
    3.10      __ call(CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_exit), relocInfo::runtime_call_type);
    3.11      __ delayed()->nop();
    3.12 +    __ restore_thread(I1);
    3.13    }
    3.14  
    3.15    if (method()->is_synchronized() || compilation()->env()->dtrace_method_probes()) {
    3.16 @@ -843,6 +846,7 @@
    3.17  #endif
    3.18          break;
    3.19        case T_ADDRESS:
    3.20 +      case T_METADATA:
    3.21          __ st_ptr(from_reg->as_register(), base, offset);
    3.22          break;
    3.23        case T_ARRAY : // fall through
    3.24 @@ -965,6 +969,7 @@
    3.25  #endif
    3.26          }
    3.27          break;
    3.28 +      case T_METADATA:
    3.29        case T_ADDRESS:  __ ld_ptr(base, offset, to_reg->as_register()); break;
    3.30        case T_ARRAY : // fall through
    3.31        case T_OBJECT:
    3.32 @@ -1366,6 +1371,7 @@
    3.33  void LIR_Assembler::mem2reg(LIR_Opr src_opr, LIR_Opr dest, BasicType type,
    3.34                              LIR_PatchCode patch_code, CodeEmitInfo* info, bool wide, bool unaligned) {
    3.35  
    3.36 +  assert(type != T_METADATA, "load of metadata ptr not supported");
    3.37    LIR_Address* addr = src_opr->as_address_ptr();
    3.38    LIR_Opr to_reg = dest;
    3.39  
    3.40 @@ -1513,6 +1519,7 @@
    3.41  void LIR_Assembler::reg2mem(LIR_Opr from_reg, LIR_Opr dest, BasicType type,
    3.42                              LIR_PatchCode patch_code, CodeEmitInfo* info, bool pop_fpu_stack,
    3.43                              bool wide, bool unaligned) {
    3.44 +  assert(type != T_METADATA, "store of metadata ptr not supported");
    3.45    LIR_Address* addr = dest->as_address_ptr();
    3.46  
    3.47    Register src = addr->base()->as_pointer_register();

     4.1 --- a/src/cpu/sparc/vm/c1_LIRGenerator_sparc.cpp	Tue Sep 11 14:59:23 2012 +0200
     4.2 +++ b/src/cpu/sparc/vm/c1_LIRGenerator_sparc.cpp	Tue Sep 11 16:20:57 2012 +0200
     4.3 @@ -884,7 +884,7 @@
     4.4    LIR_Opr tmp2 = FrameMap::G3_oop_opr;
     4.5    LIR_Opr tmp3 = FrameMap::G4_oop_opr;
     4.6    LIR_Opr tmp4 = FrameMap::O1_oop_opr;
     4.7 -  LIR_Opr klass_reg = FrameMap::G5_oop_opr;
     4.8 +  LIR_Opr klass_reg = FrameMap::G5_metadata_opr;
     4.9    new_instance(reg, x->klass(), tmp1, tmp2, tmp3, tmp4, klass_reg, info);
    4.10    LIR_Opr result = rlock_result(x);
    4.11    __ move(reg, result);
    4.12 @@ -903,11 +903,11 @@
    4.13    LIR_Opr tmp2 = FrameMap::G3_oop_opr;
    4.14    LIR_Opr tmp3 = FrameMap::G4_oop_opr;
    4.15    LIR_Opr tmp4 = FrameMap::O1_oop_opr;
    4.16 -  LIR_Opr klass_reg = FrameMap::G5_oop_opr;
    4.17 +  LIR_Opr klass_reg = FrameMap::G5_metadata_opr;
    4.18    LIR_Opr len = length.result();
    4.19    BasicType elem_type = x->elt_type();
    4.20  
    4.21 -  __ oop2reg(ciTypeArrayKlass::make(elem_type)->constant_encoding(), klass_reg);
    4.22 +  __ metadata2reg(ciTypeArrayKlass::make(elem_type)->constant_encoding(), klass_reg);
    4.23  
    4.24    CodeStub* slow_path = new NewTypeArrayStub(klass_reg, len, reg, info);
    4.25    __ allocate_array(reg, len, tmp1, tmp2, tmp3, tmp4, elem_type, klass_reg, slow_path);
    4.26 @@ -935,7 +935,7 @@
    4.27    LIR_Opr tmp2 = FrameMap::G3_oop_opr;
    4.28    LIR_Opr tmp3 = FrameMap::G4_oop_opr;
    4.29    LIR_Opr tmp4 = FrameMap::O1_oop_opr;
    4.30 -  LIR_Opr klass_reg = FrameMap::G5_oop_opr;
    4.31 +  LIR_Opr klass_reg = FrameMap::G5_metadata_opr;
    4.32    LIR_Opr len = length.result();
    4.33  
    4.34    CodeStub* slow_path = new NewObjectArrayStub(klass_reg, len, reg, info);
    4.35 @@ -985,8 +985,8 @@
    4.36  
    4.37    // This instruction can be deoptimized in the slow path : use
    4.38    // O0 as result register.
    4.39 -  const LIR_Opr reg = result_register_for(x->type());
    4.40 -  klass2reg_with_patching(reg, x->klass(), patching_info);
    4.41 +  const LIR_Opr klass_reg = FrameMap::O0_metadata_opr;
    4.42 +  klass2reg_with_patching(klass_reg, x->klass(), patching_info);
    4.43    LIR_Opr rank = FrameMap::O1_opr;
    4.44    __ move(LIR_OprFact::intConst(x->rank()), rank);
    4.45    LIR_Opr varargs = FrameMap::as_pointer_opr(O2);
    4.46 @@ -995,9 +995,10 @@
    4.47           LIR_OprFact::intptrConst(offset_from_sp),
    4.48           varargs);
    4.49    LIR_OprList* args = new LIR_OprList(3);
    4.50 -  args->append(reg);
    4.51 +  args->append(klass_reg);
    4.52    args->append(rank);
    4.53    args->append(varargs);
    4.54 +  const LIR_Opr reg = result_register_for(x->type());
    4.55    __ call_runtime(Runtime1::entry_for(Runtime1::new_multi_array_id),
    4.56                    LIR_OprFact::illegalOpr,
    4.57                    reg, args, info);

     5.1 --- a/src/cpu/sparc/vm/sharedRuntime_sparc.cpp	Tue Sep 11 14:59:23 2012 +0200
     5.2 +++ b/src/cpu/sparc/vm/sharedRuntime_sparc.cpp	Tue Sep 11 16:20:57 2012 +0200
     5.3 @@ -1340,6 +1340,7 @@
     5.4        case T_ADDRESS: // raw pointers, like current thread, for VM calls
     5.5        case T_ARRAY:
     5.6        case T_OBJECT:
     5.7 +      case T_METADATA:
     5.8          regs[i].set2( int_stk_helper( j ) );
     5.9          break;
    5.10        case T_FLOAT:
    5.11 @@ -1388,6 +1389,7 @@
    5.12        case T_FLOAT:
    5.13        case T_INT:
    5.14        case T_OBJECT:
    5.15 +      case T_METADATA:
    5.16        case T_SHORT:
    5.17          regs[i].set1( int_stk_helper( i ) );
    5.18          break;

     6.1 --- a/src/cpu/x86/vm/c1_FrameMap_x86.cpp	Tue Sep 11 14:59:23 2012 +0200
     6.2 +++ b/src/cpu/x86/vm/c1_FrameMap_x86.cpp	Tue Sep 11 16:20:57 2012 +0200
     6.3 @@ -96,6 +96,13 @@
     6.4  LIR_Opr FrameMap::rdx_oop_opr;
     6.5  LIR_Opr FrameMap::rcx_oop_opr;
     6.6  
     6.7 +LIR_Opr FrameMap::rsi_metadata_opr;
     6.8 +LIR_Opr FrameMap::rdi_metadata_opr;
     6.9 +LIR_Opr FrameMap::rbx_metadata_opr;
    6.10 +LIR_Opr FrameMap::rax_metadata_opr;
    6.11 +LIR_Opr FrameMap::rdx_metadata_opr;
    6.12 +LIR_Opr FrameMap::rcx_metadata_opr;
    6.13 +
    6.14  LIR_Opr FrameMap::long0_opr;
    6.15  LIR_Opr FrameMap::long1_opr;
    6.16  LIR_Opr FrameMap::fpu0_float_opr;
    6.17 @@ -122,6 +129,13 @@
    6.18  LIR_Opr FrameMap::r12_oop_opr;
    6.19  LIR_Opr FrameMap::r13_oop_opr;
    6.20  LIR_Opr FrameMap::r14_oop_opr;
    6.21 +
    6.22 +LIR_Opr  FrameMap::r8_metadata_opr;
    6.23 +LIR_Opr  FrameMap::r9_metadata_opr;
    6.24 +LIR_Opr FrameMap::r11_metadata_opr;
    6.25 +LIR_Opr FrameMap::r12_metadata_opr;
    6.26 +LIR_Opr FrameMap::r13_metadata_opr;
    6.27 +LIR_Opr FrameMap::r14_metadata_opr;
    6.28  #endif // _LP64
    6.29  
    6.30  LIR_Opr FrameMap::_caller_save_cpu_regs[] = { 0, };
    6.31 @@ -236,6 +250,13 @@
    6.32    rdx_oop_opr = as_oop_opr(rdx);
    6.33    rcx_oop_opr = as_oop_opr(rcx);
    6.34  
    6.35 +  rsi_metadata_opr = as_metadata_opr(rsi);
    6.36 +  rdi_metadata_opr = as_metadata_opr(rdi);
    6.37 +  rbx_metadata_opr = as_metadata_opr(rbx);
    6.38 +  rax_metadata_opr = as_metadata_opr(rax);
    6.39 +  rdx_metadata_opr = as_metadata_opr(rdx);
    6.40 +  rcx_metadata_opr = as_metadata_opr(rcx);
    6.41 +
    6.42    rsp_opr = as_pointer_opr(rsp);
    6.43    rbp_opr = as_pointer_opr(rbp);
    6.44  
    6.45 @@ -246,6 +267,13 @@
    6.46    r12_oop_opr = as_oop_opr(r12);
    6.47    r13_oop_opr = as_oop_opr(r13);
    6.48    r14_oop_opr = as_oop_opr(r14);
    6.49 +
    6.50 +  r8_metadata_opr = as_metadata_opr(r8);
    6.51 +  r9_metadata_opr = as_metadata_opr(r9);
    6.52 +  r11_metadata_opr = as_metadata_opr(r11);
    6.53 +  r12_metadata_opr = as_metadata_opr(r12);
    6.54 +  r13_metadata_opr = as_metadata_opr(r13);
    6.55 +  r14_metadata_opr = as_metadata_opr(r14);
    6.56  #endif // _LP64
    6.57  
    6.58    VMRegPair regs;

     7.1 --- a/src/cpu/x86/vm/c1_FrameMap_x86.hpp	Tue Sep 11 14:59:23 2012 +0200
     7.2 +++ b/src/cpu/x86/vm/c1_FrameMap_x86.hpp	Tue Sep 11 16:20:57 2012 +0200
     7.3 @@ -73,6 +73,14 @@
     7.4    static LIR_Opr rax_oop_opr;
     7.5    static LIR_Opr rdx_oop_opr;
     7.6    static LIR_Opr rcx_oop_opr;
     7.7 +
     7.8 +  static LIR_Opr rsi_metadata_opr;
     7.9 +  static LIR_Opr rdi_metadata_opr;
    7.10 +  static LIR_Opr rbx_metadata_opr;
    7.11 +  static LIR_Opr rax_metadata_opr;
    7.12 +  static LIR_Opr rdx_metadata_opr;
    7.13 +  static LIR_Opr rcx_metadata_opr;
    7.14 +
    7.15  #ifdef _LP64
    7.16  
    7.17    static LIR_Opr  r8_opr;
    7.18 @@ -92,6 +100,14 @@
    7.19    static LIR_Opr r13_oop_opr;
    7.20    static LIR_Opr r14_oop_opr;
    7.21  
    7.22 +  static LIR_Opr  r8_metadata_opr;
    7.23 +  static LIR_Opr  r9_metadata_opr;
    7.24 +
    7.25 +  static LIR_Opr r11_metadata_opr;
    7.26 +  static LIR_Opr r12_metadata_opr;
    7.27 +  static LIR_Opr r13_metadata_opr;
    7.28 +  static LIR_Opr r14_metadata_opr;
    7.29 +
    7.30  #endif // _LP64
    7.31  
    7.32    static LIR_Opr long0_opr;

     8.1 --- a/src/cpu/x86/vm/c1_LIRAssembler_x86.cpp	Tue Sep 11 14:59:23 2012 +0200
     8.2 +++ b/src/cpu/x86/vm/c1_LIRAssembler_x86.cpp	Tue Sep 11 16:20:57 2012 +0200
     8.3 @@ -950,6 +950,8 @@
     8.4      if (type == T_OBJECT || type == T_ARRAY) {
     8.5        __ verify_oop(src->as_register());
     8.6        __ movptr (dst, src->as_register());
     8.7 +    } else if (type == T_METADATA) {
     8.8 +      __ movptr (dst, src->as_register());
     8.9      } else {
    8.10        __ movl (dst, src->as_register());
    8.11      }
    8.12 @@ -1041,6 +1043,14 @@
    8.13          __ movptr(as_Address(to_addr), src->as_register());
    8.14        }
    8.15        break;
    8.16 +    case T_METADATA:
    8.17 +      // We get here to store a method pointer to the stack to pass to
    8.18 +      // a dtrace runtime call. This can't work on 64 bit with
    8.19 +      // compressed klass ptrs: T_METADATA can be a compressed klass
    8.20 +      // ptr or a 64 bit method pointer.
    8.21 +      LP64_ONLY(ShouldNotReachHere());
    8.22 +      __ movptr(as_Address(to_addr), src->as_register());
    8.23 +      break;
    8.24      case T_ADDRESS:
    8.25        __ movptr(as_Address(to_addr), src->as_register());
    8.26        break;
    8.27 @@ -1118,6 +1128,8 @@
    8.28      if (type == T_ARRAY || type == T_OBJECT) {
    8.29        __ movptr(dest->as_register(), frame_map()->address_for_slot(src->single_stack_ix()));
    8.30        __ verify_oop(dest->as_register());
    8.31 +    } else if (type == T_METADATA) {
    8.32 +      __ movptr(dest->as_register(), frame_map()->address_for_slot(src->single_stack_ix()));
    8.33      } else {
    8.34        __ movl(dest->as_register(), frame_map()->address_for_slot(src->single_stack_ix()));
    8.35      }

     9.1 --- a/src/cpu/x86/vm/c1_LIRGenerator_x86.cpp	Tue Sep 11 14:59:23 2012 +0200
     9.2 +++ b/src/cpu/x86/vm/c1_LIRGenerator_x86.cpp	Tue Sep 11 16:20:57 2012 +0200
     9.3 @@ -1002,13 +1002,12 @@
     9.4  #endif
     9.5    CodeEmitInfo* info = state_for(x, x->state());
     9.6    LIR_Opr reg = result_register_for(x->type());
     9.7 -  LIR_Opr klass_reg = new_register(objectType);
     9.8    new_instance(reg, x->klass(),
     9.9                         FrameMap::rcx_oop_opr,
    9.10                         FrameMap::rdi_oop_opr,
    9.11                         FrameMap::rsi_oop_opr,
    9.12                         LIR_OprFact::illegalOpr,
    9.13 -                       FrameMap::rdx_oop_opr, info);
    9.14 +                       FrameMap::rdx_metadata_opr, info);
    9.15    LIR_Opr result = rlock_result(x);
    9.16    __ move(reg, result);
    9.17  }
    9.18 @@ -1025,11 +1024,11 @@
    9.19    LIR_Opr tmp2 = FrameMap::rsi_oop_opr;
    9.20    LIR_Opr tmp3 = FrameMap::rdi_oop_opr;
    9.21    LIR_Opr tmp4 = reg;
    9.22 -  LIR_Opr klass_reg = FrameMap::rdx_oop_opr;
    9.23 +  LIR_Opr klass_reg = FrameMap::rdx_metadata_opr;
    9.24    LIR_Opr len = length.result();
    9.25    BasicType elem_type = x->elt_type();
    9.26  
    9.27 -  __ oop2reg(ciTypeArrayKlass::make(elem_type)->constant_encoding(), klass_reg);
    9.28 +  __ metadata2reg(ciTypeArrayKlass::make(elem_type)->constant_encoding(), klass_reg);
    9.29  
    9.30    CodeStub* slow_path = new NewTypeArrayStub(klass_reg, len, reg, info);
    9.31    __ allocate_array(reg, len, tmp1, tmp2, tmp3, tmp4, elem_type, klass_reg, slow_path);
    9.32 @@ -1055,7 +1054,7 @@
    9.33    LIR_Opr tmp2 = FrameMap::rsi_oop_opr;
    9.34    LIR_Opr tmp3 = FrameMap::rdi_oop_opr;
    9.35    LIR_Opr tmp4 = reg;
    9.36 -  LIR_Opr klass_reg = FrameMap::rdx_oop_opr;
    9.37 +  LIR_Opr klass_reg = FrameMap::rdx_metadata_opr;
    9.38  
    9.39    length.load_item_force(FrameMap::rbx_opr);
    9.40    LIR_Opr len = length.result();
    9.41 @@ -1103,17 +1102,18 @@
    9.42      store_stack_parameter(size->result(), in_ByteSize(i*4));
    9.43    }
    9.44  
    9.45 -  LIR_Opr reg = result_register_for(x->type());
    9.46 -  klass2reg_with_patching(reg, x->klass(), patching_info);
    9.47 +  LIR_Opr klass_reg = FrameMap::rax_metadata_opr;
    9.48 +  klass2reg_with_patching(klass_reg, x->klass(), patching_info);
    9.49  
    9.50    LIR_Opr rank = FrameMap::rbx_opr;
    9.51    __ move(LIR_OprFact::intConst(x->rank()), rank);
    9.52    LIR_Opr varargs = FrameMap::rcx_opr;
    9.53    __ move(FrameMap::rsp_opr, varargs);
    9.54    LIR_OprList* args = new LIR_OprList(3);
    9.55 -  args->append(reg);
    9.56 +  args->append(klass_reg);
    9.57    args->append(rank);
    9.58    args->append(varargs);
    9.59 +  LIR_Opr reg = result_register_for(x->type());
    9.60    __ call_runtime(Runtime1::entry_for(Runtime1::new_multi_array_id),
    9.61                    LIR_OprFact::illegalOpr,
    9.62                    reg, args, info);

    10.1 --- a/src/cpu/x86/vm/sharedRuntime_x86_32.cpp	Tue Sep 11 14:59:23 2012 +0200
    10.2 +++ b/src/cpu/x86/vm/sharedRuntime_x86_32.cpp	Tue Sep 11 16:20:57 2012 +0200
    10.3 @@ -938,6 +938,7 @@
    10.4      case T_OBJECT:
    10.5      case T_ARRAY:
    10.6      case T_ADDRESS:
    10.7 +    case T_METADATA:
    10.8        regs[i].set1(VMRegImpl::stack2reg(stack++));
    10.9        break;
   10.10      case T_LONG:

    11.1 --- a/src/cpu/x86/vm/sharedRuntime_x86_64.cpp	Tue Sep 11 14:59:23 2012 +0200
    11.2 +++ b/src/cpu/x86/vm/sharedRuntime_x86_64.cpp	Tue Sep 11 16:20:57 2012 +0200
    11.3 @@ -903,6 +903,7 @@
    11.4        case T_OBJECT:
    11.5        case T_ARRAY:
    11.6        case T_ADDRESS:
    11.7 +      case T_METADATA:
    11.8          if (int_args < Argument::n_int_register_parameters_c) {
    11.9            regs[i].set2(INT_ArgReg[int_args++]->as_VMReg());
   11.10  #ifdef _WIN64

    12.1 --- a/src/share/vm/c1/c1_FrameMap.hpp	Tue Sep 11 14:59:23 2012 +0200
    12.2 +++ b/src/share/vm/c1/c1_FrameMap.hpp	Tue Sep 11 16:20:57 2012 +0200
    12.3 @@ -194,6 +194,10 @@
    12.4      return LIR_OprFact::single_cpu_oop(cpu_reg2rnr(r));
    12.5    }
    12.6  
    12.7 +  static LIR_Opr as_metadata_opr(Register r) {
    12.8 +    return LIR_OprFact::single_cpu_metadata(cpu_reg2rnr(r));
    12.9 +  }
   12.10 +
   12.11    FrameMap(ciMethod* method, int monitors, int reserved_argument_area_size);
   12.12    bool finalize_frame(int nof_slots);
   12.13  

    13.1 --- a/src/share/vm/c1/c1_LIR.cpp	Tue Sep 11 14:59:23 2012 +0200
    13.2 +++ b/src/share/vm/c1/c1_LIR.cpp	Tue Sep 11 16:20:57 2012 +0200
    13.3 @@ -89,8 +89,12 @@
    13.4      ClassConstant* c = type->as_ClassConstant();
    13.5      if (c != NULL && !c->value()->is_loaded()) {
    13.6        return LIR_OprFact::metadataConst(NULL);
    13.7 +    } else if (c != NULL) {
    13.8 +      return LIR_OprFact::metadataConst(c->value()->constant_encoding());
    13.9      } else {
   13.10 -      return LIR_OprFact::metadataConst(c->value()->constant_encoding());
   13.11 +      MethodConstant* m = type->as_MethodConstant();
   13.12 +      assert (m != NULL, "not a class or a method?");
   13.13 +      return LIR_OprFact::metadataConst(m->value()->constant_encoding());
   13.14      }
   13.15    }
   13.16    case objectTag : {
   13.17 @@ -1166,10 +1170,12 @@
   13.18  
   13.19  
   13.20  void LIR_List::oop2reg_patch(jobject o, LIR_Opr reg, CodeEmitInfo* info) {
   13.21 +  assert(reg->type() == T_OBJECT, "bad reg");
   13.22    append(new LIR_Op1(lir_move, LIR_OprFact::oopConst(o),  reg, T_OBJECT, lir_patch_normal, info));
   13.23  }
   13.24  
   13.25  void LIR_List::klass2reg_patch(Metadata* o, LIR_Opr reg, CodeEmitInfo* info) {
   13.26 +  assert(reg->type() == T_METADATA, "bad reg");
   13.27    append(new LIR_Op1(lir_move, LIR_OprFact::metadataConst(o), reg, T_METADATA, lir_patch_normal, info));
   13.28  }
   13.29  

    14.1 --- a/src/share/vm/c1/c1_LIR.hpp	Tue Sep 11 14:59:23 2012 +0200
    14.2 +++ b/src/share/vm/c1/c1_LIR.hpp	Tue Sep 11 16:20:57 2012 +0200
    14.3 @@ -299,6 +299,7 @@
    14.4      , address_type  = 4 << type_shift
    14.5      , float_type    = 5 << type_shift
    14.6      , double_type   = 6 << type_shift
    14.7 +    , metadata_type = 7 << type_shift
    14.8    };
    14.9    friend OprType as_OprType(BasicType t);
   14.10    friend BasicType as_BasicType(OprType t);
   14.11 @@ -322,6 +323,7 @@
   14.12        case T_ADDRESS:
   14.13        case T_OBJECT:
   14.14        case T_ARRAY:
   14.15 +      case T_METADATA:
   14.16          return single_size;
   14.17          break;
   14.18  
   14.19 @@ -474,6 +476,7 @@
   14.20    case T_OBJECT:
   14.21    case T_ARRAY:    return LIR_OprDesc::object_type;
   14.22    case T_ADDRESS:  return LIR_OprDesc::address_type;
   14.23 +  case T_METADATA: return LIR_OprDesc::metadata_type;
   14.24    case T_ILLEGAL:  // fall through
   14.25    default: ShouldNotReachHere(); return LIR_OprDesc::unknown_type;
   14.26    }
   14.27 @@ -487,6 +490,7 @@
   14.28    case LIR_OprDesc::double_type:  return T_DOUBLE;
   14.29    case LIR_OprDesc::object_type:  return T_OBJECT;
   14.30    case LIR_OprDesc::address_type: return T_ADDRESS;
   14.31 +  case LIR_OprDesc::metadata_type:return T_METADATA;
   14.32    case LIR_OprDesc::unknown_type: // fall through
   14.33    default: ShouldNotReachHere();  return T_ILLEGAL;
   14.34    }
   14.35 @@ -587,6 +591,12 @@
   14.36                                 LIR_OprDesc::cpu_register         |
   14.37                                 LIR_OprDesc::single_size);
   14.38    }
   14.39 +  static LIR_Opr single_cpu_metadata(int reg) {
   14.40 +    return (LIR_Opr)(intptr_t)((reg  << LIR_OprDesc::reg1_shift) |
   14.41 +                               LIR_OprDesc::metadata_type        |
   14.42 +                               LIR_OprDesc::cpu_register         |
   14.43 +                               LIR_OprDesc::single_size);
   14.44 +  }
   14.45    static LIR_Opr double_cpu(int reg1, int reg2) {
   14.46      LP64_ONLY(assert(reg1 == reg2, "must be identical"));
   14.47      return (LIR_Opr)(intptr_t)((reg1 << LIR_OprDesc::reg1_shift) |
   14.48 @@ -660,6 +670,14 @@
   14.49                                              LIR_OprDesc::virtual_mask);
   14.50          break;
   14.51  
   14.52 +      case T_METADATA:
   14.53 +        res = (LIR_Opr)(intptr_t)((index << LIR_OprDesc::data_shift)  |
   14.54 +                                            LIR_OprDesc::metadata_type|
   14.55 +                                            LIR_OprDesc::cpu_register |
   14.56 +                                            LIR_OprDesc::single_size  |
   14.57 +                                            LIR_OprDesc::virtual_mask);
   14.58 +        break;
   14.59 +
   14.60        case T_INT:
   14.61          res = (LIR_Opr)(intptr_t)((index << LIR_OprDesc::data_shift) |
   14.62                                    LIR_OprDesc::int_type              |
   14.63 @@ -757,6 +775,12 @@
   14.64                                    LIR_OprDesc::single_size);
   14.65          break;
   14.66  
   14.67 +      case T_METADATA:
   14.68 +        res = (LIR_Opr)(intptr_t)((index << LIR_OprDesc::data_shift) |
   14.69 +                                  LIR_OprDesc::metadata_type         |
   14.70 +                                  LIR_OprDesc::stack_value           |
   14.71 +                                  LIR_OprDesc::single_size);
   14.72 +        break;
   14.73        case T_INT:
   14.74          res = (LIR_Opr)(intptr_t)((index << LIR_OprDesc::data_shift) |
   14.75                                    LIR_OprDesc::int_type              |
   14.76 @@ -2006,10 +2030,10 @@
   14.77    }
   14.78    void volatile_move(LIR_Opr src, LIR_Opr dst, BasicType type, CodeEmitInfo* info = NULL, LIR_PatchCode patch_code = lir_patch_none) { append(new LIR_Op1(lir_move, src, dst, type, patch_code, info, lir_move_volatile)); }
   14.79  
   14.80 -  void oop2reg  (jobject o, LIR_Opr reg)         { append(new LIR_Op1(lir_move, LIR_OprFact::oopConst(o),    reg));   }
   14.81 +  void oop2reg  (jobject o, LIR_Opr reg)         { assert(reg->type() == T_OBJECT, "bad reg"); append(new LIR_Op1(lir_move, LIR_OprFact::oopConst(o),    reg));   }
   14.82    void oop2reg_patch(jobject o, LIR_Opr reg, CodeEmitInfo* info);
   14.83  
   14.84 -  void oop2reg  (Metadata* o, LIR_Opr reg)       { append(new LIR_Op1(lir_move, LIR_OprFact::metadataConst(o), reg));   }
   14.85 +  void metadata2reg  (Metadata* o, LIR_Opr reg)  { assert(reg->type() == T_METADATA, "bad reg"); append(new LIR_Op1(lir_move, LIR_OprFact::metadataConst(o), reg));   }
   14.86    void klass2reg_patch(Metadata* o, LIR_Opr reg, CodeEmitInfo* info);
   14.87  
   14.88    void return_op(LIR_Opr result)                 { append(new LIR_Op1(lir_return, result)); }

    15.1 --- a/src/share/vm/c1/c1_LIRGenerator.cpp	Tue Sep 11 14:59:23 2012 +0200
    15.2 +++ b/src/share/vm/c1/c1_LIRGenerator.cpp	Tue Sep 11 16:20:57 2012 +0200
    15.3 @@ -467,7 +467,7 @@
    15.4      __ klass2reg_patch(NULL, r, info);
    15.5    } else {
    15.6      // no patching needed
    15.7 -    __ oop2reg(obj->constant_encoding(), r);
    15.8 +    __ metadata2reg(obj->constant_encoding(), r);
    15.9    }
   15.10  }
   15.11  
   15.12 @@ -955,8 +955,8 @@
   15.13        not_taken_count_offset = t;
   15.14      }
   15.15  
   15.16 -    LIR_Opr md_reg = new_register(T_OBJECT);
   15.17 -    __ oop2reg(md->constant_encoding(), md_reg);
   15.18 +    LIR_Opr md_reg = new_register(T_METADATA);
   15.19 +    __ metadata2reg(md->constant_encoding(), md_reg);
   15.20  
   15.21      LIR_Opr data_offset_reg = new_pointer_register();
   15.22      __ cmove(lir_cond(cond),
   15.23 @@ -1192,8 +1192,8 @@
   15.24      signature.append(T_OBJECT); // Method*
   15.25      LIR_OprList* args = new LIR_OprList();
   15.26      args->append(getThreadPointer());
   15.27 -    LIR_Opr meth = new_register(T_OBJECT);
   15.28 -    __ oop2reg(method()->constant_encoding(), meth);
   15.29 +    LIR_Opr meth = new_register(T_METADATA);
   15.30 +    __ metadata2reg(method()->constant_encoding(), meth);
   15.31      args->append(meth);
   15.32      call_runtime(&signature, args, CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_exit), voidType, NULL);
   15.33    }
   15.34 @@ -2553,8 +2553,8 @@
   15.35        assert(data->is_JumpData(), "need JumpData for branches");
   15.36        offset = md->byte_offset_of_slot(data, JumpData::taken_offset());
   15.37      }
   15.38 -    LIR_Opr md_reg = new_register(T_OBJECT);
   15.39 -    __ oop2reg(md->constant_encoding(), md_reg);
   15.40 +    LIR_Opr md_reg = new_register(T_METADATA);
   15.41 +    __ metadata2reg(md->constant_encoding(), md_reg);
   15.42  
   15.43      increment_counter(new LIR_Address(md_reg, offset,
   15.44                                        NOT_LP64(T_INT) LP64_ONLY(T_LONG)), DataLayout::counter_increment);
   15.45 @@ -2611,8 +2611,8 @@
   15.46      signature.append(T_OBJECT); // Method*
   15.47      LIR_OprList* args = new LIR_OprList();
   15.48      args->append(getThreadPointer());
   15.49 -    LIR_Opr meth = new_register(T_OBJECT);
   15.50 -    __ oop2reg(method()->constant_encoding(), meth);
   15.51 +    LIR_Opr meth = new_register(T_METADATA);
   15.52 +    __ metadata2reg(method()->constant_encoding(), meth);
   15.53      args->append(meth);
   15.54      call_runtime(&signature, args, CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_entry), voidType, NULL);
   15.55    }
   15.56 @@ -3032,21 +3032,21 @@
   15.57    assert(level > CompLevel_simple, "Shouldn't be here");
   15.58  
   15.59    int offset = -1;
   15.60 -  LIR_Opr counter_holder = new_register(T_OBJECT);
   15.61 +  LIR_Opr counter_holder = new_register(T_METADATA);
   15.62    LIR_Opr meth;
   15.63    if (level == CompLevel_limited_profile) {
   15.64      offset = in_bytes(backedge ? Method::backedge_counter_offset() :
   15.65                                   Method::invocation_counter_offset());
   15.66 -    __ oop2reg(method->constant_encoding(), counter_holder);
   15.67 +    __ metadata2reg(method->constant_encoding(), counter_holder);
   15.68      meth = counter_holder;
   15.69    } else if (level == CompLevel_full_profile) {
   15.70      offset = in_bytes(backedge ? MethodData::backedge_counter_offset() :
   15.71                                   MethodData::invocation_counter_offset());
   15.72      ciMethodData* md = method->method_data_or_null();
   15.73      assert(md != NULL, "Sanity");
   15.74 -    __ oop2reg(md->constant_encoding(), counter_holder);
   15.75 -    meth = new_register(T_OBJECT);
   15.76 -    __ oop2reg(method->constant_encoding(), meth);
   15.77 +    __ metadata2reg(md->constant_encoding(), counter_holder);
   15.78 +    meth = new_register(T_METADATA);
   15.79 +    __ metadata2reg(method->constant_encoding(), meth);
   15.80    } else {
   15.81      ShouldNotReachHere();
   15.82    }

    16.1 --- a/src/share/vm/c1/c1_LinearScan.cpp	Tue Sep 11 14:59:23 2012 +0200
    16.2 +++ b/src/share/vm/c1/c1_LinearScan.cpp	Tue Sep 11 16:20:57 2012 +0200
    16.3 @@ -2067,6 +2067,12 @@
    16.4          return LIR_OprFact::single_cpu_address(assigned_reg);
    16.5        }
    16.6  
    16.7 +      case T_METADATA: {
    16.8 +        assert(assigned_reg >= pd_first_cpu_reg && assigned_reg <= pd_last_cpu_reg, "no cpu register");
    16.9 +        assert(interval->assigned_regHi() == any_reg, "must not have hi register");
   16.10 +        return LIR_OprFact::single_cpu_metadata(assigned_reg);
   16.11 +      }
   16.12 +
   16.13  #ifdef __SOFTFP__
   16.14        case T_FLOAT:  // fall through
   16.15  #endif // __SOFTFP__

    17.1 --- a/src/share/vm/c1/c1_ValueType.cpp	Tue Sep 11 14:59:23 2012 +0200
    17.2 +++ b/src/share/vm/c1/c1_ValueType.cpp	Tue Sep 11 16:20:57 2012 +0200
    17.3 @@ -168,6 +168,7 @@
    17.4      case floatTag:   return T_FLOAT;
    17.5      case doubleTag:  return T_DOUBLE;
    17.6      case objectTag:  return T_OBJECT;
    17.7 +    case metaDataTag:return T_METADATA;
    17.8      case addressTag: return T_ADDRESS;
    17.9      case illegalTag: return T_ILLEGAL;
   17.10    }

    18.1 --- a/src/share/vm/opto/runtime.cpp	Tue Sep 11 14:59:23 2012 +0200
    18.2 +++ b/src/share/vm/opto/runtime.cpp	Tue Sep 11 16:20:57 2012 +0200
    18.3 @@ -1148,7 +1148,7 @@
    18.4    // create input type (domain)
    18.5    const Type **fields = TypeTuple::fields(2);
    18.6    fields[TypeFunc::Parms+0] = TypeRawPtr::BOTTOM; // Thread-local storage
    18.7 -  fields[TypeFunc::Parms+1] = TypeInstPtr::NOTNULL;  // Method*;    Method we are entering
    18.8 +  fields[TypeFunc::Parms+1] = TypeMetadataPtr::BOTTOM;  // Method*;    Method we are entering
    18.9    const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2,fields);
   18.10  
   18.11    // create result type (range)

    19.1 --- a/src/share/vm/utilities/globalDefinitions.cpp	Tue Sep 11 14:59:23 2012 +0200
    19.2 +++ b/src/share/vm/utilities/globalDefinitions.cpp	Tue Sep 11 16:20:57 2012 +0200
    19.3 @@ -213,7 +213,7 @@
    19.4  
    19.5  
    19.6  // Map BasicType to size in words
    19.7 -int type2size[T_CONFLICT+1]={ -1, 0, 0, 0, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 0, 1, 1, -1};
    19.8 +int type2size[T_CONFLICT+1]={ -1, 0, 0, 0, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, -1};
    19.9  
   19.10  BasicType type2field[T_CONFLICT+1] = {
   19.11    (BasicType)0,            // 0,