Update (2022.09.14) (openjdk#4)

27793: reduce some CodeBuffer size
27659: Make in_scratch_emit_size a virtual method
27683: Method activation needs more stack words
27583: [C2] Remove reg_class no_Ax_reg and no_T8_reg
27627: Basic type should be 64-bit supported
27751: MacroAssembler::argument_address should not blows arg_slot
25965: Allow larger CodeEntryAlignment
27824: Remove redundant ld_ptr/st_ptr assembler
27898: libsaproc: Fix compile errors on upstream system

Author: loongson-jvm

src/hotspot/cpu/loongarch/abstractInterpreter_loongarch.cpp

@@ -29,6 +29,44 @@
 #include "oops/klass.inline.hpp"
 #include "runtime/frame.inline.hpp"
 
+int AbstractInterpreter::BasicType_as_index(BasicType type) {
+  int i = 0;
+  switch (type) {
+    case T_BOOLEAN: i = 0; break;
+    case T_CHAR   : i = 1; break;
+    case T_BYTE   : i = 2; break;
+    case T_SHORT  : i = 3; break;
+    case T_INT    : i = 4; break;
+    case T_LONG   :
+    case T_VOID   :
+    case T_FLOAT  :
+    case T_DOUBLE : i = 5; break;
+    case T_OBJECT :
+    case T_ARRAY  : i = 6; break;
+    default       : ShouldNotReachHere();
+  }
+  assert(0 <= i && i < AbstractInterpreter::number_of_result_handlers,
+         "index out of bounds");
+  return i;
+}
+
+// How much stack a method activation needs in words.
+int AbstractInterpreter::size_top_interpreter_activation(Method* method) {
+  const int entry_size = frame::interpreter_frame_monitor_size();
+
+  // total overhead size: entry_size + (saved fp thru expr stack
+  // bottom).  be sure to change this if you add/subtract anything
+  // to/from the overhead area
+  const int overhead_size =
+    -(frame::interpreter_frame_initial_sp_offset) + entry_size;
+
+  const int stub_code = frame::entry_frame_after_call_words;
+  assert(method != NULL, "invalid method");
+  const int method_stack = (method->max_locals() + method->max_stack()) *
+                           Interpreter::stackElementWords;
+  return (overhead_size + method_stack + stub_code);
+}
+
 // asm based interpreter deoptimization helpers
 int AbstractInterpreter::size_activation(int max_stack,
                                          int temps,
@@ -55,22 +93,6 @@ int AbstractInterpreter::size_activation(int max_stack,
   return size;
 }
 
-// How much stack a method activation needs in words.
-int AbstractInterpreter::size_top_interpreter_activation(Method* method) {
-
-  const int entry_size    = frame::interpreter_frame_monitor_size();
-
-  // total overhead size: entry_size + (saved ebp thru expr stack bottom).
-  // be sure to change this if you add/subtract anything to/from the overhead area
-  const int overhead_size = -(frame::interpreter_frame_initial_sp_offset) + entry_size;
-
-  const int stub_code = 6;  // see generate_call_stub
-  // return overhead_size + method->max_locals() + method->max_stack() + stub_code;
-  const int method_stack = (method->max_locals() + method->max_stack()) *
-          Interpreter::stackElementWords;
-  return overhead_size + method_stack + stub_code;
-}
-
 void AbstractInterpreter::layout_activation(Method* method,
                                            int tempcount,
                                            int popframe_extra_args,

src/hotspot/cpu/loongarch/c1_CodeStubs_loongarch_64.cpp

@@ -44,7 +44,7 @@ void C1SafepointPollStub::emit_code(LIR_Assembler* ce) {
   __ bind(_entry);
   InternalAddress safepoint_pc(ce->masm()->pc() - ce->masm()->offset() + safepoint_offset());
   __ lea(SCR2, safepoint_pc);
-  __ st_ptr(SCR2, TREG, in_bytes(JavaThread::saved_exception_pc_offset()));
+  __ st_d(SCR2, Address(TREG, JavaThread::saved_exception_pc_offset()));
 
   assert(SharedRuntime::polling_page_return_handler_blob() != NULL,
          "polling page return stub not created yet");

src/hotspot/cpu/loongarch/c1_LIRAssembler_loongarch_64.cpp

@@ -58,7 +58,7 @@ int C1_MacroAssembler::lock_object(Register hdr, Register obj, Register disp_hdr
   verify_oop(obj);
 
   // save object being locked into the BasicObjectLock
-  st_ptr(obj, Address(disp_hdr, BasicObjectLock::obj_offset_in_bytes()));
+  st_d(obj, Address(disp_hdr, BasicObjectLock::obj_offset_in_bytes()));
 
   null_check_offset = offset();
 
@@ -71,11 +71,11 @@ int C1_MacroAssembler::lock_object(Register hdr, Register obj, Register disp_hdr
   }
 
   // Load object header
-  ld_ptr(hdr, Address(obj, hdr_offset));
+  ld_d(hdr, Address(obj, hdr_offset));
   // and mark it as unlocked
   ori(hdr, hdr, markWord::unlocked_value);
   // save unlocked object header into the displaced header location on the stack
-  st_ptr(hdr, Address(disp_hdr, 0));
+  st_d(hdr, Address(disp_hdr, 0));
   // test if object header is still the same (i.e. unlocked), and if so, store the
   // displaced header address in the object header - if it is not the same, get the
   // object header instead
@@ -100,7 +100,7 @@ int C1_MacroAssembler::lock_object(Register hdr, Register obj, Register disp_hdr
   andr(hdr, hdr, SCR1);
   // for recursive locking, the result is zero => save it in the displaced header
   // location (NULL in the displaced hdr location indicates recursive locking)
-  st_ptr(hdr, Address(disp_hdr, 0));
+  st_d(hdr, Address(disp_hdr, 0));
   // otherwise we don't care about the result and handle locking via runtime call
   bnez(hdr, slow_case);
   // done
@@ -116,12 +116,12 @@ void C1_MacroAssembler::unlock_object(Register hdr, Register obj, Register disp_
   Label done;
 
   // load displaced header
-  ld_ptr(hdr, Address(disp_hdr, 0));
+  ld_d(hdr, Address(disp_hdr, 0));
   // if the loaded hdr is NULL we had recursive locking
   // if we had recursive locking, we are done
   beqz(hdr, done);
   // load object
-  ld_ptr(obj, Address(disp_hdr, BasicObjectLock::obj_offset_in_bytes()));
+  ld_d(obj, Address(disp_hdr, BasicObjectLock::obj_offset_in_bytes()));
   verify_oop(obj);
   // test if object header is pointing to the displaced header, and if so, restore
   // the displaced header in the object - if the object header is not pointing to
@@ -155,13 +155,13 @@ void C1_MacroAssembler::initialize_header(Register obj, Register klass, Register
   assert_different_registers(obj, klass, len);
   // This assumes that all prototype bits fit in an int32_t
   li(t1, (int32_t)(intptr_t)markWord::prototype().value());
-  st_ptr(t1, Address(obj, oopDesc::mark_offset_in_bytes()));
+  st_d(t1, Address(obj, oopDesc::mark_offset_in_bytes()));
 
   if (UseCompressedClassPointers) { // Take care not to kill klass
     encode_klass_not_null(t1, klass);
     st_w(t1, Address(obj, oopDesc::klass_offset_in_bytes()));
   } else {
-    st_ptr(klass, Address(obj, oopDesc::klass_offset_in_bytes()));
+    st_d(klass, Address(obj, oopDesc::klass_offset_in_bytes()));
   }
 
   if (len->is_valid()) {
@@ -312,7 +312,7 @@ void C1_MacroAssembler::load_parameter(int offset_in_words, Register reg) {
   //     +  1: argument with offset 1
   //     +  2: ...
 
-  ld_ptr(reg, Address(FP, offset_in_words * BytesPerWord));
+  ld_d(reg, Address(FP, offset_in_words * BytesPerWord));
 }
 
 #ifndef PRODUCT

src/hotspot/cpu/loongarch/c1_MacroAssembler_loongarch_64.cpp

@@ -100,15 +100,15 @@ int StubAssembler::call_RT(Register oop_result1, Register metadata_result, addre
   // check for pending exceptions
   { Label L;
     // check for pending exceptions (java_thread is set upon return)
-    ld_ptr(SCR1, Address(TREG, in_bytes(Thread::pending_exception_offset())));
+    ld_d(SCR1, Address(TREG, Thread::pending_exception_offset()));
     beqz(SCR1, L);
     // exception pending => remove activation and forward to exception handler
     // make sure that the vm_results are cleared
     if (oop_result1->is_valid()) {
-      st_ptr(R0, Address(TREG, JavaThread::vm_result_offset()));
+      st_d(R0, Address(TREG, JavaThread::vm_result_offset()));
     }
     if (metadata_result->is_valid()) {
-      st_ptr(R0, Address(TREG, JavaThread::vm_result_2_offset()));
+      st_d(R0, Address(TREG, JavaThread::vm_result_2_offset()));
     }
     if (frame_size() == no_frame_size) {
       leave();
@@ -161,12 +161,12 @@ int StubAssembler::call_RT(Register oop_result1, Register metadata_result,
       arg2 == A1 || arg2 == A3 ||
       arg3 == A1 || arg3 == A2) {
     addi_d(SP, SP, -4 * wordSize);
-    st_ptr(arg1, Address(SP, 0 * wordSize));
-    st_ptr(arg2, Address(SP, 1 * wordSize));
-    st_ptr(arg3, Address(SP, 2 * wordSize));
-    ld_ptr(arg1, Address(SP, 0 * wordSize));
-    ld_ptr(arg2, Address(SP, 1 * wordSize));
-    ld_ptr(arg3, Address(SP, 2 * wordSize));
+    st_d(arg1, Address(SP, 0 * wordSize));
+    st_d(arg2, Address(SP, 1 * wordSize));
+    st_d(arg3, Address(SP, 2 * wordSize));
+    ld_d(arg1, Address(SP, 0 * wordSize));
+    ld_d(arg2, Address(SP, 1 * wordSize));
+    ld_d(arg3, Address(SP, 2 * wordSize));
     addi_d(SP, SP, 4 * wordSize);
   } else {
     move(A1, arg1);
@@ -294,7 +294,7 @@ static OopMap* save_live_registers(StubAssembler* sasm,
   __ addi_d(SP, SP, -(32 - 4 + 32) * wordSize);
 
   for (int i = 4; i < 32; i++)
-    __ st_ptr(as_Register(i), Address(SP, (32 + i - 4) * wordSize));
+    __ st_d(as_Register(i), Address(SP, (32 + i - 4) * wordSize));
 
   if (save_fpu_registers) {
     for (int i = 0; i < 32; i++)
@@ -311,7 +311,7 @@ static void restore_live_registers(StubAssembler* sasm, bool restore_fpu_registe
   }
 
   for (int i = 4; i < 32; i++)
-    __ ld_ptr(as_Register(i), Address(SP, (32 + i - 4) * wordSize));
+    __ ld_d(as_Register(i), Address(SP, (32 + i - 4) * wordSize));
 
   __ addi_d(SP, SP, (32 - 4 + 32) * wordSize);
 }
@@ -323,7 +323,7 @@ static void restore_live_registers_except_a0(StubAssembler* sasm, bool restore_f
   }
 
   for (int i = 5; i < 32; i++)
-    __ ld_ptr(as_Register(i), Address(SP, (32 + i - 4) * wordSize));
+    __ ld_d(as_Register(i), Address(SP, (32 + i - 4) * wordSize));
 
   __ addi_d(SP, SP, (32 - 4 + 32) * wordSize);
 }
@@ -387,15 +387,15 @@ OopMapSet* Runtime1::generate_handle_exception(StubID id, StubAssembler *sasm) {
     oop_map = generate_oop_map(sasm, 1 /*thread*/);
 
     // load and clear pending exception oop into A0
-    __ ld_ptr(exception_oop, Address(TREG, Thread::pending_exception_offset()));
-    __ st_ptr(R0, Address(TREG, Thread::pending_exception_offset()));
+    __ ld_d(exception_oop, Address(TREG, Thread::pending_exception_offset()));
+    __ st_d(R0, Address(TREG, Thread::pending_exception_offset()));
 
     // load issuing PC (the return address for this stub) into A1
-    __ ld_ptr(exception_pc, Address(FP, frame::return_addr_offset * BytesPerWord));
+    __ ld_d(exception_pc, Address(FP, frame::return_addr_offset * BytesPerWord));
 
     // make sure that the vm_results are cleared (may be unnecessary)
-    __ st_ptr(R0, Address(TREG, JavaThread::vm_result_offset()));
-    __ st_ptr(R0, Address(TREG, JavaThread::vm_result_2_offset()));
+    __ st_d(R0, Address(TREG, JavaThread::vm_result_offset()));
+    __ st_d(R0, Address(TREG, JavaThread::vm_result_2_offset()));
     break;
   case handle_exception_nofpu_id:
   case handle_exception_id:
@@ -422,25 +422,25 @@ OopMapSet* Runtime1::generate_handle_exception(StubID id, StubAssembler *sasm) {
   // check that fields in JavaThread for exception oop and issuing pc are
   // empty before writing to them
   Label oop_empty;
-  __ ld_ptr(SCR1, Address(TREG, JavaThread::exception_oop_offset()));
+  __ ld_d(SCR1, Address(TREG, JavaThread::exception_oop_offset()));
   __ beqz(SCR1, oop_empty);
   __ stop("exception oop already set");
   __ bind(oop_empty);
 
   Label pc_empty;
-  __ ld_ptr(SCR1, Address(TREG, JavaThread::exception_pc_offset()));
+  __ ld_d(SCR1, Address(TREG, JavaThread::exception_pc_offset()));
   __ beqz(SCR1, pc_empty);
   __ stop("exception pc already set");
   __ bind(pc_empty);
 #endif
 
   // save exception oop and issuing pc into JavaThread
   // (exception handler will load it from here)
-  __ st_ptr(exception_oop, Address(TREG, JavaThread::exception_oop_offset()));
-  __ st_ptr(exception_pc, Address(TREG, JavaThread::exception_pc_offset()));
+  __ st_d(exception_oop, Address(TREG, JavaThread::exception_oop_offset()));
+  __ st_d(exception_pc, Address(TREG, JavaThread::exception_pc_offset()));
 
   // patch throwing pc into return address (has bci & oop map)
-  __ st_ptr(exception_pc, Address(FP, frame::return_addr_offset * BytesPerWord));
+  __ st_d(exception_pc, Address(FP, frame::return_addr_offset * BytesPerWord));
 
   // compute the exception handler.
   // the exception oop and the throwing pc are read from the fields in JavaThread
@@ -455,7 +455,7 @@ OopMapSet* Runtime1::generate_handle_exception(StubID id, StubAssembler *sasm) {
   __ invalidate_registers(false, true, true, true, true, true);
 
   // patch the return address, this stub will directly return to the exception handler
-  __ st_ptr(A0, Address(FP, frame::return_addr_offset * BytesPerWord));
+  __ st_d(A0, Address(FP, frame::return_addr_offset * BytesPerWord));
 
   switch (id) {
     case forward_exception_id:
@@ -487,13 +487,13 @@ void Runtime1::generate_unwind_exception(StubAssembler *sasm) {
 #ifdef ASSERT
   // check that fields in JavaThread for exception oop and issuing pc are empty
   Label oop_empty;
-  __ ld_ptr(SCR1, Address(TREG, JavaThread::exception_oop_offset()));
+  __ ld_d(SCR1, Address(TREG, JavaThread::exception_oop_offset()));
   __ beqz(SCR1, oop_empty);
   __ stop("exception oop must be empty");
   __ bind(oop_empty);
 
   Label pc_empty;
-  __ ld_ptr(SCR1, Address(TREG, JavaThread::exception_pc_offset()));
+  __ ld_d(SCR1, Address(TREG, JavaThread::exception_pc_offset()));
   __ beqz(SCR1, pc_empty);
   __ stop("exception pc must be empty");
   __ bind(pc_empty);
@@ -503,8 +503,8 @@ void Runtime1::generate_unwind_exception(StubAssembler *sasm) {
   // exception_handler_for_return_address will destroy it.  We also
   // save exception_oop
   __ addi_d(SP, SP, -2 * wordSize);
-  __ st_ptr(RA, Address(SP, 0 * wordSize));
-  __ st_ptr(exception_oop, Address(SP, 1 * wordSize));
+  __ st_d(RA, Address(SP, 0 * wordSize));
+  __ st_d(exception_oop, Address(SP, 1 * wordSize));
 
   // search the exception handler address of the caller (using the return address)
   __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::exception_handler_for_return_address), TREG, RA);
@@ -519,8 +519,8 @@ void Runtime1::generate_unwind_exception(StubAssembler *sasm) {
 
   // get throwing pc (= return address).
   // RA has been destroyed by the call
-  __ ld_ptr(RA, Address(SP, 0 * wordSize));
-  __ ld_ptr(exception_oop, Address(SP, 1 * wordSize));
+  __ ld_d(RA, Address(SP, 0 * wordSize));
+  __ ld_d(exception_oop, Address(SP, 1 * wordSize));
   __ addi_d(SP, SP, 2 * wordSize);
   __ move(A1, RA);
 
@@ -571,13 +571,13 @@ OopMapSet* Runtime1::generate_patching(StubAssembler* sasm, address target) {
 #ifdef ASSERT
   // check that fields in JavaThread for exception oop and issuing pc are empty
   Label oop_empty;
-  __ ld_ptr(SCR1, Address(TREG, Thread::pending_exception_offset()));
+  __ ld_d(SCR1, Address(TREG, Thread::pending_exception_offset()));
   __ beqz(SCR1, oop_empty);
   __ stop("exception oop must be empty");
   __ bind(oop_empty);
 
   Label pc_empty;
-  __ ld_ptr(SCR1, Address(TREG, JavaThread::exception_pc_offset()));
+  __ ld_d(SCR1, Address(TREG, JavaThread::exception_pc_offset()));
   __ beqz(SCR1, pc_empty);
   __ stop("exception pc must be empty");
   __ bind(pc_empty);
@@ -828,34 +828,34 @@ OopMapSet* Runtime1::generate_code_for(StubID id, StubAssembler* sasm) {
 
         __ set_info("slow_subtype_check", dont_gc_arguments);
         __ addi_d(SP, SP, -4 * wordSize);
-        __ st_ptr(A0, Address(SP, a0_off * VMRegImpl::stack_slot_size));
-        __ st_ptr(A2, Address(SP, a2_off * VMRegImpl::stack_slot_size));
-        __ st_ptr(A4, Address(SP, a4_off * VMRegImpl::stack_slot_size));
-        __ st_ptr(A5, Address(SP, a5_off * VMRegImpl::stack_slot_size));
+        __ st_d(A0, Address(SP, a0_off * VMRegImpl::stack_slot_size));
+        __ st_d(A2, Address(SP, a2_off * VMRegImpl::stack_slot_size));
+        __ st_d(A4, Address(SP, a4_off * VMRegImpl::stack_slot_size));
+        __ st_d(A5, Address(SP, a5_off * VMRegImpl::stack_slot_size));
 
         // This is called by pushing args and not with C abi
-        __ ld_ptr(A4, Address(SP, klass_off * VMRegImpl::stack_slot_size)); // subclass
-        __ ld_ptr(A0, Address(SP, sup_k_off * VMRegImpl::stack_slot_size)); // superclass
+        __ ld_d(A4, Address(SP, klass_off * VMRegImpl::stack_slot_size)); // subclass
+        __ ld_d(A0, Address(SP, sup_k_off * VMRegImpl::stack_slot_size)); // superclass
 
         Label miss;
         __ check_klass_subtype_slow_path<false>(A4, A0, A2, A5, NULL, &miss);
 
         // fallthrough on success:
         __ li(SCR1, 1);
-        __ st_ptr(SCR1, Address(SP, result_off * VMRegImpl::stack_slot_size)); // result
-        __ ld_ptr(A0, Address(SP, a0_off * VMRegImpl::stack_slot_size));
-        __ ld_ptr(A2, Address(SP, a2_off * VMRegImpl::stack_slot_size));
-        __ ld_ptr(A4, Address(SP, a4_off * VMRegImpl::stack_slot_size));
-        __ ld_ptr(A5, Address(SP, a5_off * VMRegImpl::stack_slot_size));
+        __ st_d(SCR1, Address(SP, result_off * VMRegImpl::stack_slot_size)); // result
+        __ ld_d(A0, Address(SP, a0_off * VMRegImpl::stack_slot_size));
+        __ ld_d(A2, Address(SP, a2_off * VMRegImpl::stack_slot_size));
+        __ ld_d(A4, Address(SP, a4_off * VMRegImpl::stack_slot_size));
+        __ ld_d(A5, Address(SP, a5_off * VMRegImpl::stack_slot_size));
         __ addi_d(SP, SP, 4 * wordSize);
         __ jr(RA);
 
         __ bind(miss);
-        __ st_ptr(R0, Address(SP, result_off * VMRegImpl::stack_slot_size)); // result
-        __ ld_ptr(A0, Address(SP, a0_off * VMRegImpl::stack_slot_size));
-        __ ld_ptr(A2, Address(SP, a2_off * VMRegImpl::stack_slot_size));
-        __ ld_ptr(A4, Address(SP, a4_off * VMRegImpl::stack_slot_size));
-        __ ld_ptr(A5, Address(SP, a5_off * VMRegImpl::stack_slot_size));
+        __ st_d(R0, Address(SP, result_off * VMRegImpl::stack_slot_size)); // result
+        __ ld_d(A0, Address(SP, a0_off * VMRegImpl::stack_slot_size));
+        __ ld_d(A2, Address(SP, a2_off * VMRegImpl::stack_slot_size));
+        __ ld_d(A4, Address(SP, a4_off * VMRegImpl::stack_slot_size));
+        __ ld_d(A5, Address(SP, a5_off * VMRegImpl::stack_slot_size));
         __ addi_d(SP, SP, 4 * wordSize);
         __ jr(RA);
       }