jdk-sandbox: comparison src/hotspot/cpu/ppc/macroAssembler

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 #include "gc/shared/barrierSet.hpp"
 #include "gc/shared/barrierSetAssembler.hpp"
 #include "interpreter/interpreter.hpp"
 #include "memory/resourceArea.hpp"
 #include "nativeInst_ppc.hpp"
+#include "oops/klass.inline.hpp"
 #include "prims/methodHandles.hpp"
 #include "runtime/biasedLocking.hpp"
 #include "runtime/icache.hpp"
 #include "runtime/interfaceSupport.inline.hpp"
 #include "runtime/objectMonitor.hpp"
 check_klass_subtype_fast_path(sub_klass, super_klass, temp1_reg, temp2_reg, &L_success, &L_failure);
 check_klass_subtype_slow_path(sub_klass, super_klass, temp1_reg, temp2_reg, &L_success);
 bind(L_failure); // Fallthru if not successful.
 }
-void MacroAssembler::check_method_handle_type(Register mtype_reg, Register mh_reg,
+void MacroAssembler::clinit_barrier(Register klass, Register thread, Label* L_fast_path, Label* L_slow_path) {
-Register temp_reg,
+assert(L_fast_path != NULL || L_slow_path != NULL, "at least one is required");
-Label& wrong_method_type) {
-assert_different_registers(mtype_reg, mh_reg, temp_reg);
+Label L_fallthrough;
-// Compare method type against that of the receiver.
+if (L_fast_path == NULL) {
-load_heap_oop(temp_reg, delayed_value(java_lang_invoke_MethodHandle::type_offset_in_bytes, temp_reg), mh_reg,
+L_fast_path = &L_fallthrough;
-noreg, noreg, false, IS_NOT_NULL);
+} else if (L_slow_path == NULL) {
-cmpd(CCR0, temp_reg, mtype_reg);
+L_slow_path = &L_fallthrough;
-bne(CCR0, wrong_method_type);
+}
+// Fast path check: class is fully initialized
+lbz(R0, in_bytes(InstanceKlass::init_state_offset()), klass);
+cmpwi(CCR0, R0, InstanceKlass::fully_initialized);
+beq(CCR0, *L_fast_path);
+// Fast path check: current thread is initializer thread
+ld(R0, in_bytes(InstanceKlass::init_thread_offset()), klass);
+cmpd(CCR0, thread, R0);
+if (L_slow_path == &L_fallthrough) {
+beq(CCR0, *L_fast_path);
+} else if (L_fast_path == &L_fallthrough) {
+bne(CCR0, *L_slow_path);
+} else {
+Unimplemented();
+}
+bind(L_fallthrough);
 }
 RegisterOrConstant MacroAssembler::argument_offset(RegisterOrConstant arg_slot,
 Register temp_reg,
 int extra_slot_offset) {
 // Biased locking
 // See whether the lock is currently biased toward our thread and
 // whether the epoch is still valid
 // Note that the runtime guarantees sufficient alignment of JavaThread
 // pointers to allow age to be placed into low bits
-assert(markOopDesc::age_shift == markOopDesc::lock_bits + markOopDesc::biased_lock_bits,
+assert(markWord::age_shift == markWord::lock_bits + markWord::biased_lock_bits,
 "biased locking makes assumptions about bit layout");
 if (PrintBiasedLockingStatistics) {
 load_const(temp2_reg, (address) BiasedLocking::total_entry_count_addr(), temp_reg);
 lwzx(temp_reg, temp2_reg);
 addi(temp_reg, temp_reg, 1);
 stwx(temp_reg, temp2_reg);
 }
-andi(temp_reg, mark_reg, markOopDesc::biased_lock_mask_in_place);
+andi(temp_reg, mark_reg, markWord::biased_lock_mask_in_place);
-cmpwi(cr_reg, temp_reg, markOopDesc::biased_lock_pattern);
+cmpwi(cr_reg, temp_reg, markWord::biased_lock_pattern);
 bne(cr_reg, cas_label);
 load_klass(temp_reg, obj_reg);
-load_const_optimized(temp2_reg, ~((int) markOopDesc::age_mask_in_place));
+load_const_optimized(temp2_reg, ~((int) markWord::age_mask_in_place));
 ld(temp_reg, in_bytes(Klass::prototype_header_offset()), temp_reg);
 orr(temp_reg, R16_thread, temp_reg);
 xorr(temp_reg, mark_reg, temp_reg);
 andr(temp_reg, temp_reg, temp2_reg);
 cmpdi(cr_reg, temp_reg, 0);
 // header.
 // If the low three bits in the xor result aren't clear, that means
 // the prototype header is no longer biased and we have to revoke
 // the bias on this object.
-andi(temp2_reg, temp_reg, markOopDesc::biased_lock_mask_in_place);
+andi(temp2_reg, temp_reg, markWord::biased_lock_mask_in_place);
 cmpwi(cr_reg, temp2_reg, 0);
 bne(cr_reg, try_revoke_bias);
 // Biasing is still enabled for this data type. See whether the
 // epoch of the current bias is still valid, meaning that the epoch
 // toward the current thread. Note that we must be absolutely sure
 // that the current epoch is invalid in order to do this because
 // otherwise the manipulations it performs on the mark word are
 // illegal.
-int shift_amount = 64 - markOopDesc::epoch_shift;
+int shift_amount = 64 - markWord::epoch_shift;
 // rotate epoch bits to right (little) end and set other bits to 0
 // [ big part | epoch | little part ] -> [ 0..0 | epoch ]
-rldicl_(temp2_reg, temp_reg, shift_amount, 64 - markOopDesc::epoch_bits);
+rldicl_(temp2_reg, temp_reg, shift_amount, 64 - markWord::epoch_bits);
 // branch if epoch bits are != 0, i.e. they differ, because the epoch has been incremented
 bne(CCR0, try_rebias);
 // The epoch of the current bias is still valid but we know nothing
 // about the owner; it might be set or it might be clear. Try to
 // acquire the bias of the object using an atomic operation. If this
 // fails we will go in to the runtime to revoke the object's bias.
 // Note that we first construct the presumed unbiased header so we
 // don't accidentally blow away another thread's valid bias.
-andi(mark_reg, mark_reg, (markOopDesc::biased_lock_mask_in_place |
+andi(mark_reg, mark_reg, (markWord::biased_lock_mask_in_place |
-markOopDesc::age_mask_in_place |
+markWord::age_mask_in_place |
-markOopDesc::epoch_mask_in_place));
+markWord::epoch_mask_in_place));
 orr(temp_reg, R16_thread, mark_reg);
 assert(oopDesc::mark_offset_in_bytes() == 0, "offset of _mark is not 0");
 // CmpxchgX sets cr_reg to cmpX(temp2_reg, mark_reg).
 // circumstances _only_, we are allowed to use the current header's
 // value as the comparison value when doing the cas to acquire the
 // bias in the current epoch. In other words, we allow transfer of
 // the bias from one thread to another directly in this situation.
 load_klass(temp_reg, obj_reg);
-andi(temp2_reg, mark_reg, markOopDesc::age_mask_in_place);
+andi(temp2_reg, mark_reg, markWord::age_mask_in_place);
 orr(temp2_reg, R16_thread, temp2_reg);
 ld(temp_reg, in_bytes(Klass::prototype_header_offset()), temp_reg);
 orr(temp_reg, temp2_reg, temp_reg);
 assert(oopDesc::mark_offset_in_bytes() == 0, "offset of _mark is not 0");
 // that another thread raced us for the privilege of revoking the
 // bias of this particular object, so it's okay to continue in the
 // normal locking code.
 load_klass(temp_reg, obj_reg);
 ld(temp_reg, in_bytes(Klass::prototype_header_offset()), temp_reg);
-andi(temp2_reg, mark_reg, markOopDesc::age_mask_in_place);
+andi(temp2_reg, mark_reg, markWord::age_mask_in_place);
 orr(temp_reg, temp_reg, temp2_reg);
 assert(oopDesc::mark_offset_in_bytes() == 0, "offset of _mark is not 0");
 // CmpxchgX sets cr_reg to cmpX(temp2_reg, mark_reg).
 /*compare_value=*/mark_reg, /*exchange_value=*/temp_reg,
 /*where=*/obj_reg,
 MacroAssembler::MemBarAcq,
 MacroAssembler::cmpxchgx_hint_acquire_lock());
-// reload markOop in mark_reg before continuing with lightweight locking
+// reload markWord in mark_reg before continuing with lightweight locking
 ld(mark_reg, oopDesc::mark_offset_in_bytes(), obj_reg);
 // Fall through to the normal CAS-based lock, because no matter what
 // the result of the above CAS, some thread must have succeeded in
 // removing the bias bit from the object's header.
 // a higher level. Second, if the bias was revoked while we held the
 // lock, the object could not be rebiased toward another thread, so
 // the bias bit would be clear.
 ld(temp_reg, 0, mark_addr);
-andi(temp_reg, temp_reg, markOopDesc::biased_lock_mask_in_place);
+andi(temp_reg, temp_reg, markWord::biased_lock_mask_in_place);
-cmpwi(cr_reg, temp_reg, markOopDesc::biased_lock_pattern);
+cmpwi(cr_reg, temp_reg, markWord::biased_lock_pattern);
 beq(cr_reg, done);
 }
 // allocation (for C1)
 void MacroAssembler::eden_allocate(
 if (RTMRetryCount > 0) {
 load_const_optimized(retry_on_abort_count_Reg, RTMRetryCount); // Retry on abort
 bind(L_rtm_retry);
 }
-andi_(R0, mark_word, markOopDesc::monitor_value);  // inflated vs stack-locked|neutral|biased
+andi_(R0, mark_word, markWord::monitor_value);  // inflated vs stack-locked|neutral|biased
 bne(CCR0, IsInflated);
 if (PrintPreciseRTMLockingStatistics || profile_rtm) {
 Label L_noincrement;
 if (RTMTotalCountIncrRate > 1) {
 stdx(mark_word, tmp);
 bind(L_noincrement);
 }
 tbegin_();
 beq(CCR0, L_on_abort);
-ld(mark_word, oopDesc::mark_offset_in_bytes(), obj);         // Reload in transaction, conflicts need to be tracked.
+ld(mark_word, oopDesc::mark_offset_in_bytes(), obj);      // Reload in transaction, conflicts need to be tracked.
-andi(R0, mark_word, markOopDesc::biased_lock_mask_in_place); // look at 3 lock bits
+andi(R0, mark_word, markWord::biased_lock_mask_in_place); // look at 3 lock bits
-cmpwi(flag, R0, markOopDesc::unlocked_value);                // bits = 001 unlocked
+cmpwi(flag, R0, markWord::unlocked_value);                // bits = 001 unlocked
-beq(flag, DONE_LABEL);                                       // all done if unlocked
+beq(flag, DONE_LABEL);                                    // all done if unlocked
 if (UseRTMXendForLockBusy) {
 tend_();
 b(L_decrement_retry);
 } else {
 Metadata* method_data, bool profile_rtm,
 Label& DONE_LABEL) {
 assert(UseRTMLocking, "why call this otherwise?");
 Label L_rtm_retry, L_decrement_retry, L_on_abort;
 // Clean monitor_value bit to get valid pointer.
-int owner_offset = ObjectMonitor::owner_offset_in_bytes() - markOopDesc::monitor_value;
+int owner_offset = ObjectMonitor::owner_offset_in_bytes() - markWord::monitor_value;
-// Store non-null, using boxReg instead of (intptr_t)markOopDesc::unused_mark().
+// Store non-null, using boxReg instead of (intptr_t)markWord::unused_mark().
 std(boxReg, BasicLock::displaced_header_offset_in_bytes(), boxReg);
 const Register tmpReg = boxReg;
 const Register owner_addr_Reg = mark_word;
 addi(owner_addr_Reg, mark_word, owner_offset);
 if (PrintPreciseRTMLockingStatistics || profile_rtm) {
 rtm_profiling(abort_status_Reg, /*temp*/ owner_addr_Reg, rtm_counters, method_data, profile_rtm);
 // Restore owner_addr_Reg
 ld(mark_word, oopDesc::mark_offset_in_bytes(), obj);
 #ifdef ASSERT
-andi_(R0, mark_word, markOopDesc::monitor_value);
+andi_(R0, mark_word, markWord::monitor_value);
 asm_assert_ne("must be inflated", 0xa754); // Deflating only allowed at safepoint.
 #endif
 addi(owner_addr_Reg, mark_word, owner_offset);
 }
 if (RTMRetryCount > 0) {
 assert(flag != CCR0, "bad condition register");
 Label cont;
 Label object_has_monitor;
 Label cas_failed;
-// Load markOop from object into displaced_header.
+// Load markWord from object into displaced_header.
 ld(displaced_header, oopDesc::mark_offset_in_bytes(), oop);
 if (try_bias) {
 biased_locking_enter(flag, oop, displaced_header, temp, current_header, cont);
 }
 #endif // INCLUDE_RTM_OPT
 // Handle existing monitor.
 // The object has an existing monitor iff (mark & monitor_value) != 0.
-andi_(temp, displaced_header, markOopDesc::monitor_value);
+andi_(temp, displaced_header, markWord::monitor_value);
 bne(CCR0, object_has_monitor);
-// Set displaced_header to be (markOop of object | UNLOCK_VALUE).
+// Set displaced_header to be (markWord of object | UNLOCK_VALUE).
-ori(displaced_header, displaced_header, markOopDesc::unlocked_value);
+ori(displaced_header, displaced_header, markWord::unlocked_value);
 // Load Compare Value application register.
 // Initialize the box. (Must happen before we update the object mark!)
 std(displaced_header, BasicLock::displaced_header_offset_in_bytes(), box);
 // Must fence, otherwise, preceding store(s) may float below cmpxchg.
-// Compare object markOop with mark and if equal exchange scratch1 with object markOop.
+// Compare object markWord with mark and if equal exchange scratch1 with object markWord.
 cmpxchgd(/*flag=*/flag,
 /*current_value=*/current_header,
 /*compare_value=*/displaced_header,
 /*exchange_value=*/box,
 /*where=*/oop,
 b(cont);
 bind(cas_failed);
 // We did not see an unlocked object so try the fast recursive case.
-// Check if the owner is self by comparing the value in the markOop of object
+// Check if the owner is self by comparing the value in the markWord of object
 // (current_header) with the stack pointer.
 sub(current_header, current_header, R1_SP);
-load_const_optimized(temp, ~(os::vm_page_size()-1) | markOopDesc::lock_mask_in_place);
+load_const_optimized(temp, ~(os::vm_page_size()-1) | markWord::lock_mask_in_place);
 and_(R0/*==0?*/, current_header, temp);
 // If condition is true we are cont and hence we can store 0 as the
 // displaced header in the box, which indicates that it is a recursive lock.
 mcrf(flag,CCR0);
 rtm_counters, method_data, profile_rtm, cont);
 } else {
 #endif // INCLUDE_RTM_OPT
 // Try to CAS m->owner from NULL to current thread.
-addi(temp, displaced_header, ObjectMonitor::owner_offset_in_bytes()-markOopDesc::monitor_value);
+addi(temp, displaced_header, ObjectMonitor::owner_offset_in_bytes()-markWord::monitor_value);
 cmpxchgd(/*flag=*/flag,
 /*current_value=*/current_header,
 /*compare_value=*/(intptr_t)0,
 /*exchange_value=*/R16_thread,
 /*where=*/temp,
 #if INCLUDE_RTM_OPT
 if (UseRTMForStackLocks && use_rtm) {
 assert(!UseBiasedLocking, "Biased locking is not supported with RTM locking");
 Label L_regular_unlock;
-ld(current_header, oopDesc::mark_offset_in_bytes(), oop);         // fetch markword
+ld(current_header, oopDesc::mark_offset_in_bytes(), oop);      // fetch markword
-andi(R0, current_header, markOopDesc::biased_lock_mask_in_place); // look at 3 lock bits
+andi(R0, current_header, markWord::biased_lock_mask_in_place); // look at 3 lock bits
-cmpwi(flag, R0, markOopDesc::unlocked_value);                     // bits = 001 unlocked
+cmpwi(flag, R0, markWord::unlocked_value);                     // bits = 001 unlocked
-bne(flag, L_regular_unlock);                                      // else RegularLock
+bne(flag, L_regular_unlock);                                   // else RegularLock
-tend_();                                                          // otherwise end...
+tend_();                                                       // otherwise end...
-b(cont);                                                          // ... and we're done
+b(cont);                                                       // ... and we're done
 bind(L_regular_unlock);
 }
 #endif
 // Find the lock address and load the displaced header from the stack.
 // Handle existing monitor.
 // The object has an existing monitor iff (mark & monitor_value) != 0.
 RTM_OPT_ONLY( if (!(UseRTMForStackLocks && use_rtm)) ) // skip load if already done
 ld(current_header, oopDesc::mark_offset_in_bytes(), oop);
-andi_(R0, current_header, markOopDesc::monitor_value);
+andi_(R0, current_header, markWord::monitor_value);
 bne(CCR0, object_has_monitor);
 // Check if it is still a light weight lock, this is is true if we see
-// the stack address of the basicLock in the markOop of the object.
+// the stack address of the basicLock in the markWord of the object.
 // Cmpxchg sets flag to cmpd(current_header, box).
 cmpxchgd(/*flag=*/flag,
 /*current_value=*/current_header,
 /*compare_value=*/box,
 /*exchange_value=*/displaced_header,
 // Handle existing monitor.
 b(cont);
 bind(object_has_monitor);
-addi(current_header, current_header, -markOopDesc::monitor_value); // monitor
+STATIC_ASSERT(markWord::monitor_value <= INT_MAX);
+addi(current_header, current_header, -(int)markWord::monitor_value); // monitor
 ld(temp,             ObjectMonitor::owner_offset_in_bytes(), current_header);
 // It's inflated.
 #if INCLUDE_RTM_OPT
 if (use_rtm) {
 void MacroAssembler::load_mirror_from_const_method(Register mirror, Register const_method) {
 ld(mirror, in_bytes(ConstMethod::constants_offset()), const_method);
 ld(mirror, ConstantPool::pool_holder_offset_in_bytes(), mirror);
 ld(mirror, in_bytes(Klass::java_mirror_offset()), mirror);
 resolve_oop_handle(mirror);
+}
+void MacroAssembler::load_method_holder(Register holder, Register method) {
+ld(holder, in_bytes(Method::const_offset()), method);
+ld(holder, in_bytes(ConstMethod::constants_offset()), holder);
+ld(holder, ConstantPool::pool_holder_offset_in_bytes(), holder);
 }
 // Clear Array
 // For very short arrays. tmp == R0 is allowed.
 void MacroAssembler::clear_memory_unrolled(Register base_ptr, int cnt_dwords, Register tmp, int offset) {

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 54825	1b03400e5a8f
child 58679	9c3209ff7550