*** old/src/cpu/sparc/vm/c1_LIRAssembler_sparc.cpp	Fri Jul 15 18:49:37 2011
--- new/src/cpu/sparc/vm/c1_LIRAssembler_sparc.cpp	Fri Jul 15 18:49:36 2011

*** 215,227 ****
--- 215,225 ----
  #ifdef ASSERT
        // verify the interpreter's monitor has a non-null object
        {
          Label L;
          __ ld_ptr(OSR_buf, slot_offset + 1*BytesPerWord, O7);
!         __ cmp(G0, O7);
          __ br(Assembler::notEqual, false, Assembler::pt, L);
          __ delayed()->nop();
!         __ cmp_and_br_short(O7, G0, Assembler::notEqual, Assembler::pt, L);
          __ stop("locked object is NULL");
          __ bind(L);
        }
  #endif // ASSERT
        // Copy the lock field into the compiled activation.

*** 2094,2107 ****
--- 2092,2105 ----
  
      if (copyfunc_addr != NULL) {
        __ xor3(O0, -1, tmp);
        __ sub(length, tmp, length);
        __ add(src_pos, tmp, src_pos);
!       __ br_zero(Assembler::less, false, Assembler::pn, O0, *stub->entry());
!       __ cmp_zero_and_br(Assembler::less, O0, *stub->entry());
        __ delayed()->add(dst_pos, tmp, dst_pos);
      } else {
!       __ br_zero(Assembler::less, false, Assembler::pn, O0, *stub->entry());
!       __ cmp_zero_and_br(Assembler::less, O0, *stub->entry());
        __ delayed()->nop();
      }
      __ bind(*stub->continuation());
      return;
    }

*** 2121,2146 ****
--- 2119,2141 ----
      __ delayed()->nop();
    }
  
    if (flags & LIR_OpArrayCopy::src_pos_positive_check) {
      // test src_pos register
!     __ tst(src_pos);
      __ br(Assembler::less, false, Assembler::pn, *stub->entry());
!     __ cmp_zero_and_br(Assembler::less, src_pos, *stub->entry());
      __ delayed()->nop();
    }
  
    if (flags & LIR_OpArrayCopy::dst_pos_positive_check) {
      // test dst_pos register
!     __ tst(dst_pos);
      __ br(Assembler::less, false, Assembler::pn, *stub->entry());
!     __ cmp_zero_and_br(Assembler::less, dst_pos, *stub->entry());
      __ delayed()->nop();
    }
  
    if (flags & LIR_OpArrayCopy::length_positive_check) {
      // make sure length isn't negative
!     __ tst(length);
      __ br(Assembler::less, false, Assembler::pn, *stub->entry());
!     __ cmp_zero_and_br(Assembler::less, length, *stub->entry());
      __ delayed()->nop();
    }
  
    if (flags & LIR_OpArrayCopy::src_range_check) {
      __ ld(src, arrayOopDesc::length_offset_in_bytes(), tmp2);

*** 2259,2270 ****
--- 2254,2264 ----
          __ call_VM_leaf(tmp, copyfunc_addr);
  
  #ifndef PRODUCT
          if (PrintC1Statistics) {
            Label failed;
!           __ br_notnull(O0, false, Assembler::pn,  failed);
            __ delayed()->nop();
!           __ br_notnull_short(O0, Assembler::pn, failed);
            __ inc_counter((address)&Runtime1::_arraycopy_checkcast_cnt, G1, G3);
            __ bind(failed);
          }
  #endif
  

*** 2312,2324 ****
--- 2306,2316 ----
        if (basic_type != T_OBJECT) {
          __ cmp(tmp, tmp2);
          __ br(Assembler::notEqual, false, Assembler::pn, halt);
          // load the raw value of the src klass.
          __ delayed()->lduw(src, oopDesc::klass_offset_in_bytes(), tmp2);
!         __ cmp_and_br_short(tmp, tmp2, Assembler::equal, Assembler::pn, known_ok);
          __ br(Assembler::equal, false, Assembler::pn, known_ok);
          __ delayed()->nop();
        } else {
          __ cmp(tmp, tmp2);
          __ br(Assembler::equal, false, Assembler::pn, known_ok);
          __ delayed()->cmp(src, dst);
          __ brx(Assembler::equal, false, Assembler::pn, known_ok);

*** 2328,2340 ****
--- 2320,2330 ----
        __ ld_ptr(dst, oopDesc::klass_offset_in_bytes(), tmp2);
        if (basic_type != T_OBJECT) {
          __ cmp(tmp, tmp2);
          __ brx(Assembler::notEqual, false, Assembler::pn, halt);
          __ delayed()->ld_ptr(src, oopDesc::klass_offset_in_bytes(), tmp2);
!         __ cmp_and_brx_short(tmp, tmp2, Assembler::equal, Assembler::pn, known_ok);
          __ brx(Assembler::equal, false, Assembler::pn, known_ok);
          __ delayed()->nop();
        } else {
          __ cmp(tmp, tmp2);
          __ brx(Assembler::equal, false, Assembler::pn, known_ok);
          __ delayed()->cmp(src, dst);
          __ brx(Assembler::equal, false, Assembler::pn, known_ok);

*** 2528,2546 ****
--- 2518,2534 ----
      // See if the receiver is receiver[n].
      Address receiver_addr(mdo, md->byte_offset_of_slot(data, ReceiverTypeData::receiver_offset(i)) -
                            mdo_offset_bias);
      __ ld_ptr(receiver_addr, tmp1);
      __ verify_oop(tmp1);
!     __ cmp_and_brx_short(recv, tmp1, Assembler::notEqual, Assembler::pt, next_test);
      __ brx(Assembler::notEqual, false, Assembler::pt, next_test);
      __ delayed()->nop();
      Address data_addr(mdo, md->byte_offset_of_slot(data, ReceiverTypeData::receiver_count_offset(i)) -
                        mdo_offset_bias);
      __ ld_ptr(data_addr, tmp1);
      __ add(tmp1, DataLayout::counter_increment, tmp1);
      __ st_ptr(tmp1, data_addr);
-     __ ba(false, *update_done);
      __ delayed()->nop();
      __ bind(next_test);
    }
  
    // Didn't find receiver; find next empty slot and fill it in

*** 2547,2563 ****
--- 2535,2550 ----
    for (i = 0; i < VirtualCallData::row_limit(); i++) {
      Label next_test;
      Address recv_addr(mdo, md->byte_offset_of_slot(data, ReceiverTypeData::receiver_offset(i)) -
                        mdo_offset_bias);
      __ ld_ptr(recv_addr, tmp1);
!     __ br_notnull(tmp1, false, Assembler::pt, next_test);
      __ delayed()->nop();
!     __ br_notnull_short(tmp1, Assembler::pt, next_test);
      __ st_ptr(recv, recv_addr);
      __ set(DataLayout::counter_increment, tmp1);
      __ st_ptr(tmp1, mdo, md->byte_offset_of_slot(data, ReceiverTypeData::receiver_count_offset(i)) -
                mdo_offset_bias);
-     __ ba(false, *update_done);
      __ delayed()->nop();
      __ bind(next_test);
    }
  }
  

*** 2599,2610 ****
--- 2586,2596 ----
      ciMethod* method = op->profiled_method();
      assert(method != NULL, "Should have method");
      setup_md_access(method, op->profiled_bci(), md, data, mdo_offset_bias);
  
      Label not_null;
!     __ br_notnull(obj, false, Assembler::pn, not_null);
      __ delayed()->nop();
!     __ br_notnull_short(obj, Assembler::pn, not_null);
      Register mdo      = k_RInfo;
      Register data_val = Rtmp1;
      jobject2reg(md->constant_encoding(), mdo);
      if (mdo_offset_bias > 0) {
        __ set(mdo_offset_bias, data_val);

*** 2612,2622 ****
--- 2598,2608 ----
      }
      Address flags_addr(mdo, md->byte_offset_of_slot(data, DataLayout::flags_offset()) - mdo_offset_bias);
      __ ldub(flags_addr, data_val);
      __ or3(data_val, BitData::null_seen_byte_constant(), data_val);
      __ stb(data_val, flags_addr);
-     __ ba(false, *obj_is_null);
      __ delayed()->nop();
      __ bind(not_null);
    } else {
      __ br_null(obj, false, Assembler::pn, *obj_is_null);
      __ delayed()->nop();

*** 2680,2690 ****
--- 2666,2676 ----
        __ add(mdo, tmp1, mdo);
      }
      __ load_klass(obj, recv);
      type_profile_helper(mdo, mdo_offset_bias, md, data, recv, tmp1, success);
      // Jump over the failure case
-     __ ba(false, *success);
      __ delayed()->nop();
      // Cast failure case
      __ bind(profile_cast_failure);
      jobject2reg(md->constant_encoding(), mdo);
      if (mdo_offset_bias > 0) {

*** 2693,2706 ****
--- 2679,2692 ----
      }
      Address data_addr(mdo, md->byte_offset_of_slot(data, CounterData::count_offset()) - mdo_offset_bias);
      __ ld_ptr(data_addr, tmp1);
      __ sub(tmp1, DataLayout::counter_increment, tmp1);
      __ st_ptr(tmp1, data_addr);
-     __ ba(false, *failure);
      __ delayed()->nop();
    }
-   __ ba(false, *success);
    __ delayed()->nop();
  }
  
  void LIR_Assembler::emit_opTypeCheck(LIR_OpTypeCheck* op) {
    LIR_Code code = op->code();

*** 2726,2737 ****
--- 2712,2722 ----
      Label *success_target = op->should_profile() ? &profile_cast_success : &done;
      Label *failure_target = op->should_profile() ? &profile_cast_failure : stub->entry();
  
      if (op->should_profile()) {
        Label not_null;
!       __ br_notnull(value, false, Assembler::pn, not_null);
        __ delayed()->nop();
!       __ br_notnull_short(value, Assembler::pn, not_null);
        Register mdo      = k_RInfo;
        Register data_val = Rtmp1;
        jobject2reg(md->constant_encoding(), mdo);
        if (mdo_offset_bias > 0) {
          __ set(mdo_offset_bias, data_val);

*** 2739,2754 ****
--- 2724,2737 ----
        }
        Address flags_addr(mdo, md->byte_offset_of_slot(data, DataLayout::flags_offset()) - mdo_offset_bias);
        __ ldub(flags_addr, data_val);
        __ or3(data_val, BitData::null_seen_byte_constant(), data_val);
        __ stb(data_val, flags_addr);
!       __ ba(false, done);
        __ delayed()->nop();
!       __ ba_short(done);
        __ bind(not_null);
      } else {
!       __ br_null(value, false, Assembler::pn, done);
        __ delayed()->nop();
!       __ br_null_short(value, Assembler::pn, done);
      }
      add_debug_info_for_null_check_here(op->info_for_exception());
      __ load_klass(array, k_RInfo);
      __ load_klass(value, klass_RInfo);
  

*** 2775,2786 ****
--- 2758,2768 ----
          __ set(mdo_offset_bias, tmp1);
          __ add(mdo, tmp1, mdo);
        }
        __ load_klass(value, recv);
        type_profile_helper(mdo, mdo_offset_bias, md, data, recv, tmp1, &done);
!       __ ba(false, done);
        __ delayed()->nop();
!       __ ba_short(done);
        // Cast failure case
        __ bind(profile_cast_failure);
        jobject2reg(md->constant_encoding(), mdo);
        if (mdo_offset_bias > 0) {
          __ set(mdo_offset_bias, tmp1);

*** 2788,2798 ****
--- 2770,2780 ----
        }
        Address data_addr(mdo, md->byte_offset_of_slot(data, CounterData::count_offset()) - mdo_offset_bias);
        __ ld_ptr(data_addr, tmp1);
        __ sub(tmp1, DataLayout::counter_increment, tmp1);
        __ st_ptr(tmp1, data_addr);
-       __ ba(false, *stub->entry());
        __ delayed()->nop();
      }
      __ bind(done);
    } else if (code == lir_checkcast) {
      Register obj = op->object()->as_register();

*** 2806,2817 ****
--- 2788,2798 ----
      Register dst = op->result_opr()->as_register();
      Label success, failure, done;
      emit_typecheck_helper(op, &success, &failure, &failure);
      __ bind(failure);
      __ set(0, dst);
!     __ ba(false, done);
      __ delayed()->nop();
!     __ ba_short(done);
      __ bind(success);
      __ set(1, dst);
      __ bind(done);
    } else {
      ShouldNotReachHere();