*** old/src/cpu/sparc/vm/c1_Runtime1_sparc.cpp	Fri Jul 15 18:49:38 2011
--- new/src/cpu/sparc/vm/c1_Runtime1_sparc.cpp	Fri Jul 15 18:49:38 2011

*** 69,80 ****
--- 69,79 ----
  
    // check for pending exceptions
    { Label L;
      Address exception_addr(G2_thread, Thread::pending_exception_offset());
      ld_ptr(exception_addr, Gtemp);
!     br_null(Gtemp, false, pt, L);
      delayed()->nop();
!     br_null_short(Gtemp, pt, L);
      Address vm_result_addr(G2_thread, JavaThread::vm_result_offset());
      st_ptr(G0, vm_result_addr);
      Address vm_result_addr_2(G2_thread, JavaThread::vm_result_2_offset());
      st_ptr(G0, vm_result_addr_2);
  

*** 331,343 ****
--- 330,340 ----
    // deoptimization handler entry that will cause re-execution of the current bytecode
    DeoptimizationBlob* deopt_blob = SharedRuntime::deopt_blob();
    assert(deopt_blob != NULL, "deoptimization blob must have been created");
  
    Label no_deopt;
!   __ tst(O0);
    __ brx(Assembler::equal, false, Assembler::pt, no_deopt);
    __ delayed()->nop();
!   __ br_null_short(O0, Assembler::pt, no_deopt);
  
    // return to the deoptimization handler entry for unpacking and rexecute
    // if we simply returned the we'd deopt as if any call we patched had just
    // returned.
  

*** 400,421 ****
--- 397,415 ----
            __ save_frame(0);
  
            if (id == fast_new_instance_init_check_id) {
              // make sure the klass is initialized
              __ ld(G5_klass, instanceKlass::init_state_offset_in_bytes() + sizeof(oopDesc), G3_t1);
!             __ cmp_and_br_short(G3_t1, instanceKlass::fully_initialized, Assembler::notEqual, Assembler::pn, slow_path);
              __ br(Assembler::notEqual, false, Assembler::pn, slow_path);
              __ delayed()->nop();
            }
  #ifdef ASSERT
            // assert object can be fast path allocated
            {
              Label ok, not_ok;
            __ ld(G5_klass, Klass::layout_helper_offset_in_bytes() + sizeof(oopDesc), G1_obj_size);
-           __ cmp(G1_obj_size, 0);  // make sure it's an instance (LH > 0)
!           __ br(Assembler::lessEqual, false, Assembler::pn, not_ok);
            __ delayed()->nop();
!           __ cmp_and_br_short(G1_obj_size, 0, Assembler::lessEqual, Assembler::pn, not_ok);
            __ btst(Klass::_lh_instance_slow_path_bit, G1_obj_size);
            __ br(Assembler::zero, false, Assembler::pn, ok);
            __ delayed()->nop();
            __ bind(not_ok);
            __ stop("assert(can be fast path allocated)");

*** 499,511 ****
--- 493,503 ----
            __ ld(klass_lh, G3_t1);
            __ sra(G3_t1, Klass::_lh_array_tag_shift, G3_t1);
            int tag = ((id == new_type_array_id)
                       ? Klass::_lh_array_tag_type_value
                       : Klass::_lh_array_tag_obj_value);
!           __ cmp_and_brx_short(G3_t1, tag, Assembler::equal, Assembler::pt, ok);
            __ brx(Assembler::equal, false, Assembler::pt, ok);
            __ delayed()->nop();
            __ stop("assert(is an array klass)");
            __ should_not_reach_here();
            __ bind(ok);
          }
  #endif // ASSERT

*** 517,529 ****
--- 509,519 ----
            Register O1_t2 = O1;
            assert_different_registers(G5_klass, G4_length, G1_arr_size, G3_t1, O1_t2);
  
            // check that array length is small enough for fast path
            __ set(C1_MacroAssembler::max_array_allocation_length, G3_t1);
!           __ cmp_and_br_short(G4_length, G3_t1, Assembler::greaterUnsigned, Assembler::pn, slow_path);
            __ br(Assembler::greaterUnsigned, false, Assembler::pn, slow_path);
            __ delayed()->nop();
  
            // if we got here then the TLAB allocation failed, so try
            // refilling the TLAB or allocating directly from eden.
            Label retry_tlab, try_eden;
            __ tlab_refill(retry_tlab, try_eden, slow_path); // preserves G4_length and G5_klass