Update (2023.05.17, 2nd)

30554: LA port of 8301995: Move invokedynamic resolution information out of ConstantPoolCacheEntry
30553: LA port of 8304301: Remove the global option SuperWordMaxVectorSize
30552: LA port of 8231349: Move intrinsic stubs generation to compiler runtime initialization code

Author: loongson-jvm

src/hotspot/cpu/loongarch/globals_loongarch.hpp

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2015, 2022, Loongson Technology. All rights reserved.
+ * Copyright (c) 2015, 2023, Loongson Technology. 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
@@ -36,6 +36,8 @@ define_pd_global(bool, ImplicitNullChecks,       true);  // Generate code for im
 define_pd_global(bool, TrapBasedNullChecks,      false);
 define_pd_global(bool, UncommonNullCast,         true);  // Uncommon-trap NULLs passed to check cast
 
+define_pd_global(bool, DelayCompilerStubsGeneration, COMPILER2_OR_JVMCI);
+
 define_pd_global(uintx, CodeCacheSegmentSize,    64 COMPILER1_AND_COMPILER2_PRESENT(+64)); // Tiered compilation has large code-entry alignment.
 
 // Ideally, this should be cache line size,

src/hotspot/cpu/loongarch/interp_masm_loongarch.hpp

@@ -120,6 +120,8 @@ class InterpreterMacroAssembler: public MacroAssembler {
   void get_cache_index_at_bcp(Register index, int bcp_offset, size_t index_size = sizeof(u2));
   void get_method_counters(Register method, Register mcs, Label& skip);
 
+  void load_resolved_indy_entry(Register cache, Register index);
+
   // load cpool->resolved_references(index);
   void load_resolved_reference_at_index(Register result, Register index, Register tmp);
 

src/hotspot/cpu/loongarch/interp_masm_loongarch_64.cpp

@@ -323,6 +323,18 @@ void InterpreterMacroAssembler::get_method_counters(Register method,
   bind(has_counters);
 }
 
+void InterpreterMacroAssembler::load_resolved_indy_entry(Register cache, Register index) {
+  // Get index out of bytecode pointer, get_cache_entry_pointer_at_bcp
+  get_cache_index_at_bcp(index, 1, sizeof(u4));
+  // Get address of invokedynamic array
+  ld_d(cache, FP, frame::interpreter_frame_cache_offset * wordSize);
+  ld_d(cache, Address(cache, in_bytes(ConstantPoolCache::invokedynamic_entries_offset())));
+  // Scale the index to be the entry index * sizeof(ResolvedInvokeDynamicInfo)
+  slli_d(index, index, log2i_exact(sizeof(ResolvedIndyEntry)));
+  addi_d(cache, cache, Array<ResolvedIndyEntry>::base_offset_in_bytes());
+  add_d(cache, cache, index);
+}
+
 // Load object from cpool->resolved_references(index)
 void InterpreterMacroAssembler::load_resolved_reference_at_index(
                                            Register result, Register index, Register tmp) {

src/hotspot/cpu/loongarch/loongarch_64.ad

@@ -1103,6 +1103,10 @@ const int Matcher::scalable_vector_reg_size(const BasicType bt) {
   return -1;
 }
 
+const int Matcher::superword_max_vector_size(const BasicType bt) {
+  return Matcher::max_vector_size(bt);
+}
+
 // Vector ideal reg
 const uint Matcher::vector_ideal_reg(int size) {
   assert(MaxVectorSize == 16 || MaxVectorSize == 32, "");

src/hotspot/cpu/loongarch/stubGenerator_loongarch_64.cpp

@@ -5505,7 +5505,7 @@ class StubGenerator: public StubCodeGenerator {
   };
 
   // Initialization
-  void generate_initial() {
+  void generate_initial_stubs() {
     // Generates all stubs and initializes the entry points
 
     //-------------------------------------------------------------
@@ -5529,6 +5529,11 @@ class StubGenerator: public StubCodeGenerator {
                                CAST_FROM_FN_PTR(address,
                                  SharedRuntime::throw_delayed_StackOverflowError));
 
+    // Initialize table for copy memory (arraycopy) check.
+    if (UnsafeCopyMemory::_table == nullptr) {
+      UnsafeCopyMemory::create_table(8);
+    }
+
     if (UseCRC32Intrinsics) {
       // set table address before stub generation which use it
       StubRoutines::_crc_table_adr = (address)StubRoutines::la::_crc_table;
@@ -5540,7 +5545,7 @@ class StubGenerator: public StubCodeGenerator {
     }
  }
 
-  void generate_phase1() {
+  void generate_continuation_stubs() {
     // Continuation stubs:
     StubRoutines::_cont_thaw             = generate_cont_thaw();
     StubRoutines::_cont_returnBarrier    = generate_cont_returnBarrier();
@@ -5550,7 +5555,7 @@ class StubGenerator: public StubCodeGenerator {
     JFR_ONLY(StubRoutines::_jfr_write_checkpoint = StubRoutines::_jfr_write_checkpoint_stub->entry_point();)
   }
 
-  void generate_all() {
+  void generate_final_stubs() {
     // Generates all stubs and initializes the entry points
 
     // These entry points require SharedInfo::stack0 to be set up in
@@ -5571,10 +5576,6 @@ class StubGenerator: public StubCodeGenerator {
                                CAST_FROM_FN_PTR(address,
                                  SharedRuntime::throw_NullPointerException_at_call));
 
-    StubRoutines::la::_vector_iota_indices = generate_iota_indices("iota_indices");
-
-    // entry points that are platform specific
-
     // support for verify_oop (must happen after universe_init)
     if (VerifyOops) {
       StubRoutines::_verify_oop_subroutine_entry   = generate_verify_oop();
@@ -5591,10 +5592,14 @@ class StubGenerator: public StubCodeGenerator {
       StubRoutines::_dcos = generate_dsin_dcos(/* isCos = */ true);
     }
 
-    if (UseBigIntegerShiftIntrinsic) {
-      StubRoutines::_bigIntegerLeftShiftWorker = generate_bigIntegerLeftShift();
+    BarrierSetNMethod* bs_nm = BarrierSet::barrier_set()->barrier_set_nmethod();
+    if (bs_nm != NULL) {
+      StubRoutines::la::_method_entry_barrier = generate_method_entry_barrier();
     }
+  }
 
+  void generate_compiler_stubs() {
+#if COMPILER2_OR_JVMCI
 #ifdef COMPILER2
     if (UseMulAddIntrinsic) {
       StubRoutines::_mulAdd = generate_mulAdd();
@@ -5613,8 +5618,14 @@ class StubGenerator: public StubCodeGenerator {
       // because it's faster for the sizes of modulus we care about.
       StubRoutines::_montgomerySquare = g.generate_multiply();
     }
+
+    if (UseBigIntegerShiftIntrinsic) {
+      StubRoutines::_bigIntegerLeftShiftWorker = generate_bigIntegerLeftShift();
+    }
 #endif
 
+    StubRoutines::la::_vector_iota_indices = generate_iota_indices("iota_indices");
+
     if (UseAESIntrinsics) {
       StubRoutines::_aescrypt_encryptBlock = generate_aescrypt_encryptBlock(false);
       StubRoutines::_aescrypt_decryptBlock = generate_aescrypt_decryptBlock(false);
@@ -5640,28 +5651,31 @@ class StubGenerator: public StubCodeGenerator {
 
     generate_string_indexof_stubs();
 
-    BarrierSetNMethod* bs_nm = BarrierSet::barrier_set()->barrier_set_nmethod();
-    if (bs_nm != NULL) {
-      StubRoutines::la::_method_entry_barrier = generate_method_entry_barrier();
-    }
+#endif // COMPILER2_OR_JVMCI
   }
 
  public:
-  StubGenerator(CodeBuffer* code, int phase) : StubCodeGenerator(code) {
-    if (phase == 0) {
-      generate_initial();
-    } else if (phase == 1) {
-      generate_phase1(); // stubs that must be available for the interpreter
-    } else {
-      generate_all();
-    }
+  StubGenerator(CodeBuffer* code, StubsKind kind) : StubCodeGenerator(code) {
+    switch(kind) {
+    case Initial_stubs:
+      generate_initial_stubs();
+      break;
+     case Continuation_stubs:
+      generate_continuation_stubs();
+      break;
+    case Compiler_stubs:
+      generate_compiler_stubs();
+      break;
+    case Final_stubs:
+      generate_final_stubs();
+      break;
+    default:
+      fatal("unexpected stubs kind: %d", kind);
+      break;
+    };
   }
 }; // end class declaration
 
-#define UCM_TABLE_MAX_ENTRIES 7
-void StubGenerator_generate(CodeBuffer* code, int phase) {
-  if (UnsafeCopyMemory::_table == NULL) {
-    UnsafeCopyMemory::create_table(UCM_TABLE_MAX_ENTRIES);
-  }
-  StubGenerator g(code, phase);
+void StubGenerator_generate(CodeBuffer* code, StubCodeGenerator::StubsKind kind) {
+  StubGenerator g(code, kind);
 }

src/hotspot/cpu/loongarch/stubRoutines_loongarch.hpp

@@ -35,8 +35,11 @@ static bool returns_to_call_stub(address return_pc){
 }
 
 enum platform_dependent_constants {
-  code_size1 = 20000,    // simply increase if too small (assembler will crash if too small)
-  code_size2 = 60000    // simply increase if too small (assembler will crash if too small)
+  // simply increase sizes if too small (assembler will crash if too small)
+  _initial_stubs_code_size      = 20000,
+  _continuation_stubs_code_size =  2000,
+  _compiler_stubs_code_size     = 60000,
+  _final_stubs_code_size        = 60000
 };
 
 class la {

src/hotspot/cpu/loongarch/templateInterpreterGenerator_loongarch.cpp

@@ -585,13 +585,17 @@ address TemplateInterpreterGenerator::generate_return_entry_for(TosState state,
 
   const Register cache = T4;
   const Register index = T3;
-  __ get_cache_and_index_at_bcp(cache, index, 1, index_size);
-
-  const Register flags = cache;
-  __ alsl_d(AT, index, cache, Address::times_ptr - 1);
-  __ ld_w(flags, AT, in_bytes(ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::flags_offset()));
-  __ andi(flags, flags, ConstantPoolCacheEntry::parameter_size_mask);
-  __ alsl_d(SP, flags, SP, Interpreter::logStackElementSize - 1);
+  if (index_size == sizeof(u4)) {
+    __ load_resolved_indy_entry(cache, index);
+    __ ld_hu(cache, Address(cache, in_bytes(ResolvedIndyEntry::num_parameters_offset())));
+    __ alsl_d(SP, cache, SP, Interpreter::logStackElementSize - 1);
+  } else {
+    __ get_cache_and_index_at_bcp(cache, index, 1, index_size);
+    __ alsl_d(AT, index, cache, Address::times_ptr - 1);
+    __ ld_d(cache, AT, in_bytes(ConstantPoolCache::base_offset() + ConstantPoolCacheEntry::flags_offset()));
+    __ andi(cache, cache, ConstantPoolCacheEntry::parameter_size_mask);
+    __ alsl_d(SP, cache, SP, Interpreter::logStackElementSize - 1);
+  }
 
   __ check_and_handle_popframe(TREG);
   __ check_and_handle_earlyret(TREG);

src/hotspot/cpu/loongarch/templateTable_loongarch_64.cpp

@@ -2256,14 +2256,82 @@ void TemplateTable::load_field_cp_cache_entry(Register obj,
   }
 }
 
+// The Rmethod register is input and overwritten to be the adapter method for the
+// indy call. Return address (ra) is set to the return address for the adapter and
+// an appendix may be pushed to the stack. Registers A0-A3 are clobbered.
+void TemplateTable::load_invokedynamic_entry(Register method) {
+  // setup registers
+  const Register appendix = A0;
+  const Register cache = A2;
+  const Register index = A3;
+  assert_different_registers(method, appendix, cache, index);
+
+  __ save_bcp();
+
+  Label resolved;
+
+  __ load_resolved_indy_entry(cache, index);
+  __ ld_d(method, Address(cache, in_bytes(ResolvedIndyEntry::method_offset())));
+  __ membar(Assembler::Membar_mask_bits(Assembler::LoadLoad | Assembler::LoadStore));
+
+  // Compare the method to zero
+  __ bnez(method, resolved);
+
+  Bytecodes::Code code = bytecode();
+
+  // Call to the interpreter runtime to resolve invokedynamic
+  address entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_from_cache);
+  __ li(method, code); // this is essentially Bytecodes::_invokedynamic
+  __ call_VM(noreg, entry, method);
+  // Update registers with resolved info
+  __ load_resolved_indy_entry(cache, index);
+  __ ld_d(method, Address(cache, in_bytes(ResolvedIndyEntry::method_offset())));
+  __ membar(Assembler::Membar_mask_bits(Assembler::LoadLoad | Assembler::LoadStore));
+
+#ifdef ASSERT
+  __ bnez(method, resolved);
+  __ stop("Should be resolved by now");
+#endif // ASSERT
+  __ bind(resolved);
+
+  Label L_no_push;
+  // Check if there is an appendix
+  __ ld_bu(index, Address(cache, in_bytes(ResolvedIndyEntry::flags_offset())));
+  __ andi(AT, index, 1UL << ResolvedIndyEntry::has_appendix_shift);
+  __ beqz(AT, L_no_push);
+
+  // Get appendix
+  __ ld_hu(index, Address(cache, in_bytes(ResolvedIndyEntry::resolved_references_index_offset())));
+  // Push the appendix as a trailing parameter
+  // since the parameter_size includes it.
+  __ push(method);
+  __ move(method, index);
+  __ load_resolved_reference_at_index(appendix, method, A1);
+  __ verify_oop(appendix);
+  __ pop(method);
+  __ push(appendix);  // push appendix (MethodType, CallSite, etc.)
+  __ bind(L_no_push);
+
+  // compute return type
+  __ ld_bu(index, Address(cache, in_bytes(ResolvedIndyEntry::result_type_offset())));
+  // load return address
+  // Return address is loaded into ra and not pushed to the stack like x86
+  {
+    const address table_addr = (address) Interpreter::invoke_return_entry_table_for(code);
+    __ li(AT, table_addr);
+    __ alsl_d(AT, index, AT, 3-1);
+    __ ld_d(RA, AT, 0);
+  }
+}
+
 // get the method, itable_index and flags of the current invoke
 void TemplateTable::load_invoke_cp_cache_entry(int byte_no,
                                                Register method,
                                                Register itable_index,
                                                Register flags,
                                                bool is_invokevirtual,
                                                bool is_invokevfinal, /*unused*/
-                                               bool is_invokedynamic) {
+                                               bool is_invokedynamic /*unused*/) {
   // setup registers
   const Register cache = T3;
   const Register index = T1;
@@ -2284,7 +2352,7 @@ void TemplateTable::load_invoke_cp_cache_entry(int byte_no,
   const int index_offset = in_bytes(ConstantPoolCache::base_offset() +
                                     ConstantPoolCacheEntry::f2_offset());
 
-  size_t index_size = (is_invokedynamic ? sizeof(u4): sizeof(u2));
+  size_t index_size = sizeof(u2);
   resolve_cache_and_index(byte_no, cache, index, index_size);
 
   __ alsl_d(AT, index, cache, Address::times_ptr - 1);
@@ -3172,7 +3240,7 @@ void TemplateTable::prepare_invoke(int byte_no,
 
   load_invoke_cp_cache_entry(byte_no, method, index, flags, is_invokevirtual, false, is_invokedynamic);
 
-  if (is_invokedynamic || is_invokehandle) {
+  if (is_invokehandle) {
    Label L_no_push;
      __ li(AT, (1 << ConstantPoolCacheEntry::has_appendix_shift));
      __ andr(AT, AT, flags);
@@ -3497,32 +3565,32 @@ void TemplateTable::invokehandle(int byte_no) {
   __ jump_from_interpreted(T2_method);
 }
 
- void TemplateTable::invokedynamic(int byte_no) {
-   transition(vtos, vtos);
-   assert(byte_no == f1_byte, "use this argument");
+void TemplateTable::invokedynamic(int byte_no) {
+  transition(vtos, vtos);
+  assert(byte_no == f1_byte, "use this argument");
 
-   const Register T2_callsite = T2;
+  const Register T2_callsite = T2;
 
-   prepare_invoke(byte_no, Rmethod, T2_callsite);
+  load_invokedynamic_entry(Rmethod);
 
-   // T2: CallSite object (from cpool->resolved_references[f1])
-   // Rmethod: MH.linkToCallSite method (from f2)
+  // T2: CallSite object (from cpool->resolved_references[f1])
+  // Rmethod: MH.linkToCallSite method (from f2)
 
-   // Note:  T2_callsite is already pushed by prepare_invoke
-   // %%% should make a type profile for any invokedynamic that takes a ref argument
-   // profile this call
-   __ profile_call(T4);
+  // Note:  T2_callsite is already pushed by prepare_invoke
+  // %%% should make a type profile for any invokedynamic that takes a ref argument
+  // profile this call
+  __ profile_call(T4);
 
-   // T8: tmp, used for mdp
-   // Rmethod: callee
-   // T4: tmp
-   // is_virtual: false
-   __ profile_arguments_type(T8, Rmethod, T4, false);
+  // T8: tmp, used for mdp
+  // Rmethod: callee
+  // T4: tmp
+  // is_virtual: false
+  __ profile_arguments_type(T8, Rmethod, T4, false);
 
-   __ verify_oop(T2_callsite);
+  __ verify_oop(T2_callsite);
 
-   __ jump_from_interpreted(Rmethod);
- }
+  __ jump_from_interpreted(Rmethod);
+}
 
 //-----------------------------------------------------------------------------
 // Allocation