*** old/src/cpu/sparc/vm/macroAssembler_sparc.cpp	Thu Aug 15 09:45:35 2013
--- new/src/cpu/sparc/vm/macroAssembler_sparc.cpp	Thu Aug 15 09:45:32 2013

*** 1,7 ****
--- 1,7 ----
  /*
!  * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
!  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.

*** 27,36 ****
--- 27,37 ----
  #include "compiler/disassembler.hpp"
  #include "gc_interface/collectedHeap.inline.hpp"
  #include "interpreter/interpreter.hpp"
  #include "memory/cardTableModRefBS.hpp"
  #include "memory/resourceArea.hpp"
+ #include "memory/universe.hpp"
  #include "prims/methodHandles.hpp"
  #include "runtime/biasedLocking.hpp"
  #include "runtime/interfaceSupport.hpp"
  #include "runtime/objectMonitor.hpp"
  #include "runtime/os.hpp"

*** 1143,1153 ****
--- 1144,1154 ----
  
  void  MacroAssembler::set_narrow_klass(Klass* k, Register d) {
    assert(oop_recorder() != NULL, "this assembler needs an OopRecorder");
    int klass_index = oop_recorder()->find_index(k);
    RelocationHolder rspec = metadata_Relocation::spec(klass_index);
!   narrowOop encoded_k = oopDesc::encode_klass(k);
!   narrowOop encoded_k = Klass::encode_klass(k);
  
    assert_not_delayed();
    // Relocation with special format (see relocInfo_sparc.hpp).
    relocate(rspec, 1);
    // Assembler::sethi(encoded_k, d);

*** 1417,1427 ****
--- 1418,1427 ----
    // Check the Klass* of this object for being in the right area of memory.
    // Cannot do the load in the delay above slot in case O0 is null
    load_klass(O0_obj, O0_obj);
    // assert((klass != NULL)
    br_null_short(O0_obj, pn, fail);
    // TODO: Future assert that klass is lower 4g memory for UseCompressedKlassPointers
  
    wrccr( O5_save_flags ); // Restore CCR's
  
    // mark upper end of faulting range
    _verify_oop_implicit_branch[1] = pc();

*** 4087,4143 ****
--- 4087,4182 ----
    if (Universe::narrow_oop_base() != NULL)
      add(dst, G6_heapbase, dst);
  }
  
  void MacroAssembler::encode_klass_not_null(Register r) {
    assert(Metaspace::is_initialized(), "metaspace should be initialized");
    assert (UseCompressedKlassPointers, "must be compressed");
!   assert (LogKlassAlignmentInBytes == Universe::narrow_klass_shift(), "decode alg wrong");
    if (Universe::narrow_klass_base() != NULL)
!   assert(Universe::narrow_klass_base() != NULL, "narrow_klass_base should be initialized");
+   assert(r != G6_heapbase, "bad register choice");
+   set((intptr_t)Universe::narrow_klass_base(), G6_heapbase);
    sub(r, G6_heapbase, r);
+   if (Universe::narrow_klass_shift() != 0) {
+     assert (LogKlassAlignmentInBytes == Universe::narrow_klass_shift(), "decode alg wrong");
      srlx(r, LogKlassAlignmentInBytes, r);
+   }
+   reinit_heapbase();
  }
  
  void MacroAssembler::encode_klass_not_null(Register src, Register dst) {
    assert(Metaspace::is_initialized(), "metaspace should be initialized");
!   assert (UseCompressedKlassPointers, "must be compressed");
    assert (LogKlassAlignmentInBytes == Universe::narrow_klass_shift(), "decode alg wrong");
    if (Universe::narrow_klass_base() == NULL) {
      srlx(src, LogKlassAlignmentInBytes, dst);
+   if (src == dst) {
!     encode_klass_not_null(src);
    } else {
!     sub(src, G6_heapbase, dst);
!     assert (UseCompressedKlassPointers, "must be compressed");
+     assert(Universe::narrow_klass_base() != NULL, "narrow_klass_base should be initialized");
+     set((intptr_t)Universe::narrow_klass_base(), dst);
+     sub(src, dst, dst);
+     if (Universe::narrow_klass_shift() != 0) {
        srlx(dst, LogKlassAlignmentInBytes, dst);
      }
+   }
  }
  
+ // Function instr_size_for_decode_klass_not_null() counts the instructions
+ // generated by decode_klass_not_null() and reinit_heapbase().  Hence, if
+ // the instructions they generate change, then this method needs to be updated.
+ int MacroAssembler::instr_size_for_decode_klass_not_null() {
+   assert (UseCompressedKlassPointers, "only for compressed klass ptrs");
+   // set + add + set
+   int num_instrs = insts_for_internal_set((intptr_t)Universe::narrow_klass_base()) + 1 +
+     insts_for_internal_set((intptr_t)Universe::narrow_ptrs_base());
+   if (Universe::narrow_klass_shift() == 0) {
+     return num_instrs * BytesPerInstWord;
+   } else { // sllx
+     return (num_instrs + 1) * BytesPerInstWord;
+   }
+ }
+ 
+ // !!! If the instructions that get generated here change then function
+ // instr_size_for_decode_klass_not_null() needs to get updated.
  void  MacroAssembler::decode_klass_not_null(Register r) {
    assert(Metaspace::is_initialized(), "metaspace should be initialized");
    // Do not add assert code to this unless you change vtableStubs_sparc.cpp
    // pd_code_size_limit.
    assert (UseCompressedKlassPointers, "must be compressed");
!   assert (LogKlassAlignmentInBytes == Universe::narrow_klass_shift(), "decode alg wrong");
!   assert(Universe::narrow_klass_base() != NULL, "narrow_klass_base should be initialized");
+   assert(r != G6_heapbase, "bad register choice");
+   set((intptr_t)Universe::narrow_klass_base(), G6_heapbase);
+   if (Universe::narrow_klass_shift() != 0)
      sllx(r, LogKlassAlignmentInBytes, r);
    if (Universe::narrow_klass_base() != NULL)
    add(r, G6_heapbase, r);
+   reinit_heapbase();
  }
  
  void  MacroAssembler::decode_klass_not_null(Register src, Register dst) {
    assert(Metaspace::is_initialized(), "metaspace should be initialized");
+   if (src == dst) {
+     decode_klass_not_null(src);
+   } else {
      // Do not add assert code to this unless you change vtableStubs_sparc.cpp
      // pd_code_size_limit.
      assert (UseCompressedKlassPointers, "must be compressed");
!   assert (LogKlassAlignmentInBytes == Universe::narrow_klass_shift(), "decode alg wrong");
!     assert(Universe::narrow_klass_base() != NULL, "narrow_klass_base should be initialized");
+     if (Universe::narrow_klass_shift() != 0) {
+       assert((src != G6_heapbase) && (dst != G6_heapbase), "bad register choice");
+       set((intptr_t)Universe::narrow_klass_base(), G6_heapbase);
        sllx(src, LogKlassAlignmentInBytes, dst);
    if (Universe::narrow_klass_base() != NULL)
        add(dst, G6_heapbase, dst);
+       reinit_heapbase();
+     } else {
+       set((intptr_t)Universe::narrow_klass_base(), dst);
+       add(src, dst, dst);
+     }
+   }
  }
  
  void MacroAssembler::reinit_heapbase() {
    if (UseCompressedOops || UseCompressedKlassPointers) {
+     if (Universe::heap() != NULL) {
+       set((intptr_t)Universe::narrow_ptrs_base(), G6_heapbase);
+     } else {
        AddressLiteral base(Universe::narrow_ptrs_base_addr());
        load_ptr_contents(base, G6_heapbase);
      }
+   }
  }
  
  // Compare char[] arrays aligned to 4 bytes.
  void MacroAssembler::char_arrays_equals(Register ary1, Register ary2,
                                          Register limit, Register result,