*** old/src/share/vm/c1/c1_LIRGenerator.cpp	Thu Nov 25 07:06:09 2010
--- new/src/share/vm/c1/c1_LIRGenerator.cpp	Thu Nov 25 07:06:09 2010

*** 862,876 ****
--- 862,876 ----
               data_offset_reg);
  
      // MDO cells are intptr_t, so the data_reg width is arch-dependent.
      LIR_Opr data_reg = new_pointer_register();
      LIR_Address* data_addr = new LIR_Address(md_reg, data_offset_reg, data_reg->type());
!     __ move(LIR_OprFact::address(data_addr), data_reg);
      // Use leal instead of add to avoid destroying condition codes on x86
      LIR_Address* fake_incr_value = new LIR_Address(data_reg, DataLayout::counter_increment, T_INT);
      __ leal(LIR_OprFact::address(fake_incr_value), data_reg);
!     __ move(data_reg, LIR_OprFact::address(data_addr));
    }
  }
  
  // Phi technique:
  // This is about passing live values from one basic block to the other.

*** 1007,1021 ****
--- 1007,1021 ----
    // handlers, so assign operands manually here
    for_each_phi_fun(block(), phi,
                     operand_for_instruction(phi));
  
    LIR_Opr thread_reg = getThreadPointer();
!   __ move_wide(new LIR_Address(thread_reg, in_bytes(JavaThread::exception_oop_offset()), T_OBJECT),
                 exceptionOopOpr());
!   __ move_wide(LIR_OprFact::oopConst(NULL),
                 new LIR_Address(thread_reg, in_bytes(JavaThread::exception_oop_offset()), T_OBJECT));
!   __ move_wide(LIR_OprFact::oopConst(NULL),
                 new LIR_Address(thread_reg, in_bytes(JavaThread::exception_pc_offset()), T_OBJECT));
  
    LIR_Opr result = new_register(T_OBJECT);
    __ move(exceptionOopOpr(), result);
    set_result(x, result);

*** 1083,1093 ****
--- 1083,1093 ----
  
  
  void LIRGenerator::do_Return(Return* x) {
    if (compilation()->env()->dtrace_method_probes()) {
      BasicTypeList signature;
!     signature.append(LP64_ONLY(T_LONG) NOT_LP64(T_INT));    // thread
      signature.append(T_OBJECT); // methodOop
      LIR_OprList* args = new LIR_OprList();
      args->append(getThreadPointer());
      LIR_Opr meth = new_register(T_OBJECT);
      __ oop2reg(method()->constant_encoding(), meth);

*** 1120,1139 ****
--- 1120,1139 ----
    CodeEmitInfo* info = NULL;
    if (x->needs_null_check()) {
      info = state_for(x);
    }
    __ move(new LIR_Address(rcvr.result(), oopDesc::klass_offset_in_bytes(), T_OBJECT), result, info);
!   __ move_wide(new LIR_Address(result, Klass::java_mirror_offset_in_bytes() +
                                 klassOopDesc::klass_part_offset_in_bytes(), T_OBJECT), result);
  }
  
  
  // Example: Thread.currentThread()
  void LIRGenerator::do_currentThread(Intrinsic* x) {
    assert(x->number_of_arguments() == 0, "wrong type");
    LIR_Opr reg = rlock_result(x);
!   __ load(new LIR_Address(getThreadPointer(), in_bytes(JavaThread::threadObj_offset()), T_OBJECT), reg);
!   __ move_wide(new LIR_Address(getThreadPointer(), in_bytes(JavaThread::threadObj_offset()), T_OBJECT), reg);
  }
  
  
  void LIRGenerator::do_RegisterFinalizer(Intrinsic* x) {
    assert(x->number_of_arguments() == 1, "wrong type");

*** 1906,1917 ****
--- 1906,1921 ----
    }
  
    if (x->may_be_unaligned() && (dst_type == T_LONG || dst_type == T_DOUBLE)) {
      __ unaligned_move(addr, reg);
    } else {
+     if (dst_type == T_OBJECT && x->is_wide()) {
+       __ move_wide(addr, reg);
+     } else {
        __ move(addr, reg);
      }
+   }
  }
  
  
  void LIRGenerator::do_UnsafePutRaw(UnsafePutRaw* x) {
    int  log2_scale = 0;

*** 2285,2295 ****
--- 2289,2299 ----
      java_index += type2size[t];
    }
  
    if (compilation()->env()->dtrace_method_probes()) {
      BasicTypeList signature;
!     signature.append(LP64_ONLY(T_LONG) NOT_LP64(T_INT));    // thread
      signature.append(T_OBJECT); // methodOop
      LIR_OprList* args = new LIR_OprList();
      args->append(getThreadPointer());
      LIR_Opr meth = new_register(T_OBJECT);
      __ oop2reg(method()->constant_encoding(), meth);

*** 2350,2359 ****
--- 2354,2366 ----
      if (loc->is_register()) {
        param->load_item_force(loc);
      } else {
        LIR_Address* addr = loc->as_address_ptr();
        param->load_for_store(addr->type());
+       if (addr->type() == T_OBJECT) {
+         __ move_wide(param->result(), addr);
+       } else
          if (addr->type() == T_LONG || addr->type() == T_DOUBLE) {
            __ unaligned_move(param->result(), addr);
          } else {
            __ move(param->result(), addr);
          }

*** 2366,2376 ****
--- 2373,2383 ----
      if (loc->is_register()) {
        receiver->load_item_force(loc);
      } else {
        assert(loc->is_address(), "just checking");
        receiver->load_for_store(T_OBJECT);
!       __ move_wide(receiver->result(), loc->as_address_ptr());
      }
    }
  }