*** old/src/cpu/x86/vm/assembler_x86_64.cpp	Mon May 19 21:11:09 2008
--- new/src/cpu/x86/vm/assembler_x86_64.cpp	Mon May 19 21:11:08 2008

*** 681,691 ****
--- 681,692 ----
      }
      break;
  
    case REP8(0xB8): // movl/q r, #32/#64(oop?)
      if (which == end_pc_operand)  return ip + (is_64bit ? 8 : 4);
!     assert((which == call32_operand || which == imm64_operand) && is_64bit, "");
!     assert((which == call32_operand || which == imm64_operand) && is_64bit ||
+            which == narrow_oop_operand && !is_64bit, "");
      return ip;
  
    case 0x69: // imul r, a, #32
    case 0xC7: // movl a, #32(oop?)
      tail_size = 4;

*** 907,917 ****
--- 908,919 ----
    if (r->type() == relocInfo::none) {
      return;
    } else if (r->is_call() || format == call32_operand) {
      opnd = locate_operand(inst, call32_operand);
    } else if (r->is_data()) {
!     assert(format == imm64_operand || format == disp32_operand, "format ok");
!     assert(format == imm64_operand || format == disp32_operand ||
+            format == narrow_oop_operand, "format ok");
      opnd = locate_operand(inst, (WhichOperand) format);
    } else {
      assert(format == 0, "cannot specify a format");
      return;
    }

*** 5155,5170 ****
--- 5157,5169 ----
  }
  
  void MacroAssembler::store_klass(Register dst, Register src) {
    if (UseCompressedOops) {
      encode_heap_oop_not_null(src);
!     // zero the entire klass field first as the gap needs to be zeroed too.
      movptr(Address(dst, oopDesc::klass_offset_in_bytes()), NULL_WORD);
      movl(Address(dst, oopDesc::klass_offset_in_bytes()), src);
    } else {
      movq(Address(dst, oopDesc::klass_offset_in_bytes()), src);
!     // Store to the wide klass field to zero the gap.
    }
+   movq(Address(dst, oopDesc::klass_offset_in_bytes()), src);
  }
  
  void MacroAssembler::load_heap_oop(Register dst, Address src) {
    if (UseCompressedOops) {
      movl(dst, src);

*** 5186,5202 ****
--- 5185,5203 ----
  
  // Algorithm must match oop.inline.hpp encode_heap_oop.
  void MacroAssembler::encode_heap_oop(Register r) {
    assert (UseCompressedOops, "should be compressed");
  #ifdef ASSERT
+   if (CheckCompressedOops) {
      Label ok;
      pushq(rscratch1); // cmpptr trashes rscratch1
      cmpptr(r12_heapbase, ExternalAddress((address)Universe::heap_base_addr()));
      jcc(Assembler::equal, ok);
      stop("MacroAssembler::encode_heap_oop: heap base corrupted?");
      bind(ok);
      popq(rscratch1);
+   }
  #endif
    verify_oop(r, "broken oop in encode_heap_oop");
    testq(r, r);
    cmovq(Assembler::equal, r, r12_heapbase);
    subq(r, r12_heapbase);

*** 5204,5232 ****
--- 5205,5237 ----
  }
  
  void MacroAssembler::encode_heap_oop_not_null(Register r) {
    assert (UseCompressedOops, "should be compressed");
  #ifdef ASSERT
+   if (CheckCompressedOops) {
      Label ok;
      testq(r, r);
      jcc(Assembler::notEqual, ok);
      stop("null oop passed to encode_heap_oop_not_null");
      bind(ok);
+   }
  #endif
    verify_oop(r, "broken oop in encode_heap_oop_not_null");
    subq(r, r12_heapbase);
    shrq(r, LogMinObjAlignmentInBytes);
  }
  
  void MacroAssembler::encode_heap_oop_not_null(Register dst, Register src) {
    assert (UseCompressedOops, "should be compressed");
  #ifdef ASSERT
+   if (CheckCompressedOops) {
      Label ok;
      testq(src, src);
      jcc(Assembler::notEqual, ok);
      stop("null oop passed to encode_heap_oop_not_null2");
      bind(ok);
+   }
  #endif
    verify_oop(src, "broken oop in encode_heap_oop_not_null2");
    if (dst != src) {
      movq(dst, src);
    }

*** 5235,5252 ****
--- 5240,5259 ----
  }
  
  void  MacroAssembler::decode_heap_oop(Register r) {
    assert (UseCompressedOops, "should be compressed");
  #ifdef ASSERT
+   if (CheckCompressedOops) {
      Label ok;
      pushq(rscratch1);
      cmpptr(r12_heapbase,
             ExternalAddress((address)Universe::heap_base_addr()));
      jcc(Assembler::equal, ok);
      stop("MacroAssembler::decode_heap_oop: heap base corrupted?");
      bind(ok);
      popq(rscratch1);
+   }
  #endif
  
    Label done;
    shlq(r, LogMinObjAlignmentInBytes);
    jccb(Assembler::equal, done);

*** 5275,5284 ****
--- 5282,5304 ----
    // vtableStubs also counts instructions in pd_code_size_limit.
    assert(Address::times_8 == LogMinObjAlignmentInBytes, "decode alg wrong");
    leaq(dst, Address(r12_heapbase, src, Address::times_8, 0));
  }
  
+ void  MacroAssembler::set_narrow_oop(Register dst, jobject obj) {
+   assert(oop_recorder() != NULL, "this assembler needs an OopRecorder");
+   int oop_index = oop_recorder()->find_index(obj);
+   RelocationHolder rspec = oop_Relocation::spec(oop_index);
+ 
+   // movl dst,obj
+   InstructionMark im(this);
+   int encode = prefix_and_encode(dst->encoding());
+   emit_byte(0xB8 | encode);
+   emit_data(oop_index, rspec, narrow_oop_operand);
+ }
+ 
+ 
  Assembler::Condition MacroAssembler::negate_condition(Assembler::Condition cond) {
    switch (cond) {
      // Note some conditions are synonyms for others
      case Assembler::zero:         return Assembler::notZero;
      case Assembler::notZero:      return Assembler::zero;