[GR-40476] Introduce a mechanism for dynamic method address resolution.

PullRequest: graal/12991

Author: Aleksandar Gradinac

compiler/src/org.graalvm.compiler.asm.amd64/src/org/graalvm/compiler/asm/amd64/AMD64Assembler.java

@@ -3702,6 +3702,11 @@ public final void push(Register src) {
         emitByte(0x50 + encode(src));
     }
 
+    public final void push(int imm32) {
+        emitByte(0x68);
+        emitInt(imm32);
+    }
+
     public void pushfq() {
         emitByte(0x9c);
     }

substratevm/src/com.oracle.objectfile/src/com/oracle/objectfile/elf/ELFUserDefinedSection.java

@@ -154,7 +154,7 @@ public void markRelocationSite(int offset, ByteBuffer bb, ObjectFile.RelocationK
         ELFRelocationSection rs = (ELFRelocationSection) getOrCreateRelocationElement(addend);
         assert symbolName != null;
         ELFSymtab.Entry ent = syms.getSymbol(symbolName);
-        assert ent != null;
+        assert ent != null : "Symbol name not defined: " + symbolName;
         rs.addEntry(this, offset, ELFMachine.getRelocation(getOwner().getMachine(), k), ent, addend);
     }
 }

substratevm/src/com.oracle.svm.core.graal.amd64/src/com/oracle/svm/core/graal/amd64/SubstrateAMD64Backend.java

@@ -39,6 +39,8 @@
 
 import java.util.Collection;
 import java.util.EnumSet;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
 
 import org.graalvm.compiler.asm.Label;
 import org.graalvm.compiler.asm.amd64.AMD64Address;
@@ -268,23 +270,29 @@ public static class SubstrateAMD64IndirectCallOp extends AMD64Call.IndirectCallO
 
         private final boolean destroysCallerSavedRegisters;
         @Temp({REG, OperandFlag.ILLEGAL}) private Value exceptionTemp;
+        private final BiConsumer<CompilationResultBuilder, Integer> offsetRecorder;
 
         public SubstrateAMD64IndirectCallOp(ResolvedJavaMethod callTarget, Value result, Value[] parameters, Value[] temps, Value targetAddress,
-                        LIRFrameState state, Value javaFrameAnchor, Value javaFrameAnchorTemp, int newThreadStatus, boolean destroysCallerSavedRegisters, Value exceptionTemp) {
+                        LIRFrameState state, Value javaFrameAnchor, Value javaFrameAnchorTemp, int newThreadStatus, boolean destroysCallerSavedRegisters, Value exceptionTemp,
+                        BiConsumer<CompilationResultBuilder, Integer> offsetRecorder) {
             super(TYPE, callTarget, result, parameters, temps, targetAddress, state);
             this.newThreadStatus = newThreadStatus;
             this.javaFrameAnchor = javaFrameAnchor;
             this.javaFrameAnchorTemp = javaFrameAnchorTemp;
             this.destroysCallerSavedRegisters = destroysCallerSavedRegisters;
             this.exceptionTemp = exceptionTemp;
+            this.offsetRecorder = offsetRecorder;
 
             assert differentRegisters(parameters, temps, targetAddress, javaFrameAnchor, javaFrameAnchorTemp);
         }
 
         @Override
         public void emitCode(CompilationResultBuilder crb, AMD64MacroAssembler masm) {
             maybeTransitionToNative(crb, masm, javaFrameAnchor, javaFrameAnchorTemp, state, newThreadStatus);
-            AMD64Call.indirectCall(crb, masm, asRegister(targetAddress), callTarget, state);
+            int offset = AMD64Call.indirectCall(crb, masm, asRegister(targetAddress), callTarget, state);
+            if (offsetRecorder != null) {
+                offsetRecorder.accept(crb, offset);
+            }
         }
 
         @Override
@@ -635,7 +643,7 @@ protected void emitForeignCallOp(ForeignCallLinkage linkage, Value targetAddress
                 AllocatableValue targetRegister = AMD64.rax.asValue(FrameAccess.getWordStamp().getLIRKind(getLIRKindTool()));
                 emitMove(targetRegister, targetAddress);
                 append(new SubstrateAMD64IndirectCallOp(targetMethod, result, arguments, temps, targetRegister, info,
-                                Value.ILLEGAL, Value.ILLEGAL, StatusSupport.STATUS_ILLEGAL, getDestroysCallerSavedRegisters(targetMethod), Value.ILLEGAL));
+                                Value.ILLEGAL, Value.ILLEGAL, StatusSupport.STATUS_ILLEGAL, getDestroysCallerSavedRegisters(targetMethod), Value.ILLEGAL, null));
             } else {
                 assert targetAddress == null;
                 append(new SubstrateAMD64DirectCallOp(targetMethod, result, arguments, temps, info, Value.ILLEGAL,
@@ -817,10 +825,16 @@ public Register getHeapBaseRegister() {
 
     public final class SubstrateAMD64NodeLIRBuilder extends AMD64NodeLIRBuilder implements SubstrateNodeLIRBuilder {
 
+        private Function<IndirectCallTargetNode, BiConsumer<CompilationResultBuilder, Integer>> indirectCallOffsetRecorderFactory = node -> null;
+
         public SubstrateAMD64NodeLIRBuilder(StructuredGraph graph, LIRGeneratorTool gen, AMD64NodeMatchRules nodeMatchRules) {
             super(graph, gen, nodeMatchRules);
         }
 
+        public void setIndirectCallOffsetRecorderFactory(Function<IndirectCallTargetNode, BiConsumer<CompilationResultBuilder, Integer>> indirectCallOffsetRecorderFactory) {
+            this.indirectCallOffsetRecorderFactory = indirectCallOffsetRecorderFactory;
+        }
+
         @Override
         public void visitSafepointNode(SafepointNode node) {
             throw shouldNotReachHere("handled by lowering");
@@ -943,7 +957,7 @@ protected void emitIndirectCall(IndirectCallTargetNode callTarget, Value result,
             vzeroupperBeforeCall((SubstrateAMD64LIRGenerator) getLIRGeneratorTool(), parameters, callState, (SharedMethod) targetMethod);
             append(new SubstrateAMD64IndirectCallOp(targetMethod, result, parameters, temps, targetAddress, callState,
                             setupJavaFrameAnchor(callTarget), setupJavaFrameAnchorTemp(callTarget), getNewThreadStatus(callTarget),
-                            getDestroysCallerSavedRegisters(targetMethod), getExceptionTemp(callTarget)));
+                            getDestroysCallerSavedRegisters(targetMethod), getExceptionTemp(callTarget), indirectCallOffsetRecorderFactory.apply(callTarget)));
         }
 
         protected void emitComputedIndirectCall(ComputedIndirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) {

substratevm/src/com.oracle.svm.core.graal.amd64/src/com/oracle/svm/core/graal/amd64/SubstrateAMD64RegisterConfig.java

@@ -335,4 +335,8 @@ public RegisterArray filterAllocatableRegisters(PlatformKind kind, RegisterArray
 
         return new RegisterArray(list);
     }
+
+    public RegisterArray getJavaGeneralParameterRegs() {
+        return javaGeneralParameterRegs;
+    }
 }

substratevm/src/com.oracle.svm.core.posix/src/com/oracle/svm/core/posix/headers/Errno.java

@@ -70,6 +70,9 @@ public class Errno {
     @CConstant
     public static native int ENOMEM();
 
+    @CConstant
+    public static native int EEXIST();
+
     @CFunction
     public static native CCharPointer strerror(int errnum);
 }

substratevm/src/com.oracle.svm.core.posix/src/com/oracle/svm/core/posix/headers/Mman.java

@@ -30,6 +30,9 @@
 import org.graalvm.nativeimage.c.constant.CConstant;
 import org.graalvm.nativeimage.c.function.CFunction;
 import org.graalvm.nativeimage.c.function.CFunction.Transition;
+import org.graalvm.nativeimage.c.function.CLibrary;
+import org.graalvm.nativeimage.c.type.CCharPointer;
+import org.graalvm.nativeimage.c.type.CConst;
 import org.graalvm.word.Pointer;
 import org.graalvm.word.PointerBase;
 import org.graalvm.word.UnsignedWord;
@@ -91,5 +94,15 @@ public static class NoTransitions {
 
         @CFunction(transition = Transition.NO_TRANSITION)
         public static native int mprotect(PointerBase addr, UnsignedWord len, int prot);
+
+        @CFunction(transition = Transition.NO_TRANSITION)
+        @Platforms(Platform.LINUX.class)
+        @CLibrary("rt")
+        public static native int shm_open(@CConst CCharPointer name, int oflag, int mode);
+
+        @CFunction(transition = Transition.NO_TRANSITION)
+        @Platforms(Platform.LINUX.class)
+        @CLibrary("rt")
+        public static native int shm_unlink(@CConst CCharPointer name);
     }
 }

substratevm/src/com.oracle.svm.core.posix/src/com/oracle/svm/core/posix/headers/Unistd.java

@@ -134,5 +134,10 @@ public static class NoTransitions {
         @CFunction(transition = Transition.NO_TRANSITION)
         public static native int getpagesize();
 
+        @CFunction(transition = Transition.NO_TRANSITION)
+        public static native int ftruncate(int fd, SignedWord offset);
+
+        @CFunction(transition = Transition.NO_TRANSITION)
+        public static native int getpid();
     }
 }

substratevm/src/com.oracle.svm.core.posix/src/com/oracle/svm/core/posix/linux/LinuxImageHeapProvider.java

@@ -54,6 +54,7 @@
 import com.oracle.svm.core.c.CGlobalData;
 import com.oracle.svm.core.c.CGlobalDataFactory;
 import com.oracle.svm.core.c.function.CEntryPointErrors;
+import com.oracle.svm.core.code.DynamicMethodAddressResolutionHeapSupport;
 import com.oracle.svm.core.config.ConfigurationValues;
 import com.oracle.svm.core.headers.LibC;
 import com.oracle.svm.core.heap.Heap;
@@ -142,13 +143,22 @@ public int initialize(Pointer reservedAddressSpace, UnsignedWord reservedSize, W
             return fallbackCopyingProvider.initialize(reservedAddressSpace, reservedSize, basePointer, endPointer);
         }
 
+        boolean haveDynamicMethodResolution = DynamicMethodAddressResolutionHeapSupport.isEnabled();
+
+        if (haveDynamicMethodResolution) {
+            int res = DynamicMethodAddressResolutionHeapSupport.get().initialize();
+            if (res != CEntryPointErrors.NO_ERROR) {
+                return res;
+            }
+        }
+
         // If we are the first isolate and can use the existing image heap, do it.
         UnsignedWord pageSize = VirtualMemoryProvider.get().getGranularity();
         Word imageHeapBegin = IMAGE_HEAP_BEGIN.get();
         UnsignedWord imageHeapSizeInFile = getImageHeapSizeInFile();
         int imageHeapOffsetInAddressSpace = Heap.getHeap().getImageHeapOffsetInAddressSpace();
         UnsignedWord alignment = WordFactory.unsigned(Heap.getHeap().getPreferredAddressSpaceAlignment());
-        if (firstIsolate && reservedAddressSpace.isNull() && PointerUtils.isAMultiple(imageHeapBegin, alignment) && imageHeapOffsetInAddressSpace == 0) {
+        if (firstIsolate && reservedAddressSpace.isNull() && PointerUtils.isAMultiple(imageHeapBegin, alignment) && imageHeapOffsetInAddressSpace == 0 && !haveDynamicMethodResolution) {
             // Mark the whole image heap as read only.
             if (VirtualMemoryProvider.get().protect(imageHeapBegin, imageHeapSizeInFile, Access.READ) != 0) {
                 return CEntryPointErrors.PROTECT_HEAP_FAILED;
@@ -176,22 +186,40 @@ public int initialize(Pointer reservedAddressSpace, UnsignedWord reservedSize, W
             return CEntryPointErrors.NO_ERROR;
         }
 
+        UnsignedWord preHeapRequiredBytes = WordFactory.zero();
+        if (haveDynamicMethodResolution) {
+            preHeapRequiredBytes = DynamicMethodAddressResolutionHeapSupport.get().getDynamicMethodAddressResolverPreHeapMemoryBytes();
+        }
+
         // Reserve an address space for the image heap if necessary.
         UnsignedWord imageHeapAddressSpaceSize = getImageHeapAddressSpaceSize();
+        UnsignedWord totalAddressSpaceSize = imageHeapAddressSpaceSize.add(preHeapRequiredBytes);
+
         Pointer heapBase;
         Pointer allocatedMemory = WordFactory.nullPointer();
         if (reservedAddressSpace.isNull()) {
-            heapBase = allocatedMemory = VirtualMemoryProvider.get().reserve(imageHeapAddressSpaceSize, alignment, false);
+            heapBase = allocatedMemory = VirtualMemoryProvider.get().reserve(totalAddressSpaceSize, alignment, false);
             if (allocatedMemory.isNull()) {
                 return CEntryPointErrors.RESERVE_ADDRESS_SPACE_FAILED;
             }
         } else {
-            if (reservedSize.belowThan(imageHeapAddressSpaceSize)) {
+            if (reservedSize.belowThan(totalAddressSpaceSize)) {
                 return CEntryPointErrors.INSUFFICIENT_ADDRESS_SPACE;
             }
             heapBase = reservedAddressSpace;
         }
 
+        if (haveDynamicMethodResolution) {
+            heapBase = heapBase.add(preHeapRequiredBytes);
+            Pointer installOffset = heapBase.subtract(DynamicMethodAddressResolutionHeapSupport.get().getRequiredPreHeapMemoryInBytes());
+            int error = DynamicMethodAddressResolutionHeapSupport.get().install(installOffset);
+
+            if (error != CEntryPointErrors.NO_ERROR) {
+                freeImageHeap(allocatedMemory);
+                return error;
+            }
+        }
+
         // Create memory mappings from the image file.
         UnsignedWord fileOffset = CACHED_IMAGE_HEAP_OFFSET.get().read();
         Pointer imageHeap = heapBase.add(imageHeapOffsetInAddressSpace);
@@ -343,7 +371,14 @@ public int freeImageHeap(PointerBase heapBase) {
                     return CEntryPointErrors.MAP_HEAP_FAILED;
                 }
             } else {
-                if (VirtualMemoryProvider.get().free(heapBase, getImageHeapAddressSpaceSize()) != 0) {
+                UnsignedWord totalAddressSpaceSize = getImageHeapAddressSpaceSize();
+                Pointer addressSpaceStart = (Pointer) heapBase;
+                if (DynamicMethodAddressResolutionHeapSupport.isEnabled()) {
+                    totalAddressSpaceSize = totalAddressSpaceSize.add(DynamicMethodAddressResolutionHeapSupport.get().getDynamicMethodAddressResolverPreHeapMemoryBytes());
+                    addressSpaceStart = addressSpaceStart.subtract(DynamicMethodAddressResolutionHeapSupport.get().getDynamicMethodAddressResolverPreHeapMemoryBytes());
+                }
+
+                if (VirtualMemoryProvider.get().free(addressSpaceStart, totalAddressSpaceSize) != 0) {
                     return CEntryPointErrors.MAP_HEAP_FAILED;
                 }
             }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/c/function/CEntryPointErrors.java

@@ -128,6 +128,27 @@ private CEntryPointErrors() {
     @Description("Image page size is incompatible with run-time page size. Rebuild image with -H:PageSize=[pagesize] to set appropriately.") //
     public static final int PAGE_SIZE_CHECK_FAILED = 24;
 
+    @Description("Creating an in-memory file for the GOT failed.") //
+    public static final int DYNAMIC_METHOD_ADDRESS_RESOLUTION_GOT_FD_CREATE_FAILED = 25;
+
+    @Description("Resizing the in-memory file for the GOT failed.") //
+    public static final int DYNAMIC_METHOD_ADDRESS_RESOLUTION_GOT_FD_RESIZE_FAILED = 26;
+
+    @Description("Mapping and populating the in-memory file for the GOT failed.") //
+    public static final int DYNAMIC_METHOD_ADDRESS_RESOLUTION_GOT_FD_MAP_FAILED = 27;
+
+    @Description("Mapping the GOT before an isolate's heap failed (no mapping).") //
+    public static final int DYNAMIC_METHOD_ADDRESS_RESOLUTION_GOT_MMAP_FAILED = 28;
+
+    @Description("Mapping the GOT before an isolate's heap failed (wrong mapping).") //
+    public static final int DYNAMIC_METHOD_ADDRESS_RESOLUTION_GOT_WRONG_MMAP = 29;
+
+    @Description("Mapping the GOT before an isolate's heap failed (invalid file).") //
+    public static final int DYNAMIC_METHOD_ADDRESS_RESOLUTION_GOT_FD_INVALID = 30;
+
+    @Description("Could not create unique GOT file even after retrying.") //
+    public static final int DYNAMIC_METHOD_ADDRESS_RESOLUTION_GOT_UNIQUE_FILE_CREATE_FAILED = 31;
+
     public static String getDescription(int code) {
         String result = null;
         if (code >= 0 && code < DESCRIPTIONS.length) {

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/code/DynamicMethodAddressResolutionHeapSupport.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2022, 2022, Oracle and/or its affiliates. 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.svm.core.code;
+
+import static com.oracle.svm.core.util.PointerUtils.roundUp;
+
+import org.graalvm.compiler.api.replacements.Fold;
+import org.graalvm.nativeimage.CurrentIsolate;
+import org.graalvm.nativeimage.ImageSingletons;
+import org.graalvm.word.Pointer;
+import org.graalvm.word.PointerBase;
+import org.graalvm.word.UnsignedWord;
+import org.graalvm.word.WordFactory;
+
+import com.oracle.svm.core.Isolates;
+import com.oracle.svm.core.Uninterruptible;
+import com.oracle.svm.core.heap.Heap;
+
+public abstract class DynamicMethodAddressResolutionHeapSupport {
+
+    @Fold
+    public static boolean isEnabled() {
+        return ImageSingletons.contains(DynamicMethodAddressResolutionHeapSupport.class);
+    }
+
+    @Fold
+    public static DynamicMethodAddressResolutionHeapSupport get() {
+        return ImageSingletons.lookup(DynamicMethodAddressResolutionHeapSupport.class);
+    }
+
+    public abstract int initialize();
+
+    public abstract UnsignedWord getRequiredPreHeapMemoryInBytes();
+
+    public abstract int install(Pointer address);
+
+    @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
+    public UnsignedWord getDynamicMethodAddressResolverPreHeapMemoryBytes() {
+        UnsignedWord requiredPreHeapMemoryInBytes = getRequiredPreHeapMemoryInBytes();
+        /* Ensure there is enough space to properly align the heap */
+        UnsignedWord heapAlignment = WordFactory.unsigned(Heap.getHeap().getPreferredAddressSpaceAlignment());
+        return roundUp((PointerBase) requiredPreHeapMemoryInBytes, heapAlignment);
+    }
+
+    @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
+    public Pointer getPreHeapMappingStartAddress() {
+        UnsignedWord heapBase = (UnsignedWord) Isolates.getHeapBase(CurrentIsolate.getIsolate());
+        return (Pointer) heapBase.subtract(getRequiredPreHeapMemoryInBytes());
+    }
+
+}