Update (2023.03.31)

30412: LA port of 8303684: Lift upcall sharing mechanism to AbstractLinker (mainline)
30411: LA port of 8304283: Modernize the switch statements in jdk.internal.foreign
30410: LA port of 8303154: Investigate and improve instruction cache flushing during compilation

Author: loongson-jvm

src/hotspot/cpu/loongarch/sharedRuntime_loongarch_64.cpp

@@ -740,7 +740,6 @@ AdapterHandlerEntry* SharedRuntime::generate_i2c2i_adapters(MacroAssembler *masm
   __ block_comment("gen_c2i_adapter");
   gen_c2i_adapter(masm, total_args_passed, comp_args_on_stack, sig_bt, regs, skip_fixup);
 
-  __ flush();
   return AdapterHandlerLibrary::new_entry(fingerprint, i2c_entry, c2i_entry, c2i_unverified_entry, c2i_no_clinit_check_entry);
 }
 

src/java.base/share/classes/jdk/internal/foreign/abi/loongarch64/LoongArch64Architecture.java

@@ -48,13 +48,12 @@ public boolean isStackType(int cls) {
 
     @Override
     public int typeSize(int cls) {
-        switch (cls) {
-            case StorageType.INTEGER: return INTEGER_REG_SIZE;
-            case StorageType.FLOAT: return FLOAT_REG_SIZE;
+        return switch (cls) {
+            case StorageType.INTEGER -> INTEGER_REG_SIZE;
+            case StorageType.FLOAT   -> FLOAT_REG_SIZE;
             // STACK is deliberately omitted
-        }
-
-        throw new IllegalArgumentException("Invalid Storage Class: " + cls);
+            default -> throw new IllegalArgumentException("Invalid Storage Class: " + cls);
+        };
     }
 
     public interface StorageType {

src/java.base/share/classes/jdk/internal/foreign/abi/loongarch64/linux/LinuxLoongArch64CallArranger.java

@@ -31,6 +31,7 @@
 import java.lang.foreign.MemoryLayout;
 import java.lang.foreign.MemorySegment;
 import jdk.internal.foreign.abi.ABIDescriptor;
+import jdk.internal.foreign.abi.AbstractLinker.UpcallStubFactory;
 import jdk.internal.foreign.abi.Binding;
 import jdk.internal.foreign.abi.CallingSequence;
 import jdk.internal.foreign.abi.CallingSequenceBuilder;
@@ -121,15 +122,11 @@ public static MethodHandle arrangeDowncall(MethodType mt, FunctionDescriptor cDe
         return handle;
     }
 
-    public static MemorySegment arrangeUpcall(MethodHandle target, MethodType mt, FunctionDescriptor cDesc, SegmentScope scope) {
-
+    public static UpcallStubFactory arrangeUpcall(MethodType mt, FunctionDescriptor cDesc) {
         Bindings bindings = getBindings(mt, cDesc, true);
-
-        if (bindings.isInMemoryReturn) {
-            target = SharedUtils.adaptUpcallForIMR(target, true /* drop return, since we don't have bindings for it */);
-        }
-
-        return UpcallLinker.make(CLinux, target, bindings.callingSequence, scope);
+        final boolean dropReturn = true; /* drop return, since we don't have bindings for it */
+        return SharedUtils.arrangeUpcallHelper(mt, bindings.isInMemoryReturn, dropReturn, CLinux,
+                bindings.callingSequence);
     }
 
     private static boolean isInMemoryReturn(Optional<MemoryLayout> returnLayout) {

src/java.base/share/classes/jdk/internal/foreign/abi/loongarch64/linux/LinuxLoongArch64Linker.java

@@ -57,8 +57,8 @@ protected MethodHandle arrangeDowncall(MethodType inferredMethodType, FunctionDe
     }
 
     @Override
-    protected MemorySegment arrangeUpcall(MethodHandle target, MethodType targetType, FunctionDescriptor function, SegmentScope scope) {
-        return LinuxLoongArch64CallArranger.arrangeUpcall(target, targetType, function, scope);
+    protected UpcallStubFactory arrangeUpcall(MethodType targetType, FunctionDescriptor function) {
+        return LinuxLoongArch64CallArranger.arrangeUpcall(targetType, function);
     }
 
     public static VaList newVaList(Consumer<VaList.Builder> actions, SegmentScope scope) {

src/java.base/share/classes/jdk/internal/foreign/abi/loongarch64/linux/TypeClass.java

@@ -82,30 +82,33 @@ private static record FieldCounter(long integerCnt, long floatCnt, long pointerC
         static final FieldCounter SINGLE_POINTER = new FieldCounter(0, 0, 1);
 
         static FieldCounter flatten(MemoryLayout layout) {
-            if (layout instanceof ValueLayout valueLayout) {
-                return switch (classifyValueType(valueLayout)) {
-                    case INTEGER -> FieldCounter.SINGLE_INTEGER;
-                    case FLOAT -> FieldCounter.SINGLE_FLOAT;
-                    case POINTER -> FieldCounter.SINGLE_POINTER;
-                    default -> throw new IllegalStateException("Should not reach here.");
-                };
-            } else if (layout instanceof GroupLayout groupLayout) {
-                FieldCounter currCounter = FieldCounter.EMPTY;
-                for (MemoryLayout memberLayout : groupLayout.memberLayouts()) {
-                    if (memberLayout instanceof PaddingLayout) {
-                        continue;
+            switch (layout) {
+                case ValueLayout valueLayout -> {
+                    return switch (classifyValueType(valueLayout)) {
+                        case INTEGER -> FieldCounter.SINGLE_INTEGER;
+                        case FLOAT   -> FieldCounter.SINGLE_FLOAT;
+                        case POINTER -> FieldCounter.SINGLE_POINTER;
+                        default -> throw new IllegalStateException("Should not reach here.");
+                    };
+                }
+                case GroupLayout groupLayout -> {
+                    FieldCounter currCounter = FieldCounter.EMPTY;
+                    for (MemoryLayout memberLayout : groupLayout.memberLayouts()) {
+                        if (memberLayout instanceof PaddingLayout) {
+                            continue;
+                        }
+                        currCounter = currCounter.add(flatten(memberLayout));
                     }
-                    currCounter = currCounter.add(flatten(memberLayout));
+                    return currCounter;
                 }
-                return currCounter;
-            } else if (layout instanceof SequenceLayout sequenceLayout) {
-                long elementCount = sequenceLayout.elementCount();
-                if (elementCount == 0) {
-                    return FieldCounter.EMPTY;
+                case SequenceLayout sequenceLayout -> {
+                    long elementCount = sequenceLayout.elementCount();
+                    if (elementCount == 0) {
+                        return FieldCounter.EMPTY;
+                    }
+                    return flatten(sequenceLayout.elementLayout()).mul(elementCount);
                 }
-                return flatten(sequenceLayout.elementLayout()).mul(elementCount);
-            } else {
-                throw new IllegalStateException("Cannot get here: " + layout);
+                default -> throw new IllegalStateException("Cannot get here: " + layout);
             }
         }