[GR-60631] Always copy over relocatable section for layered images.

PullRequest: graal/19654

Author: teshull

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

@@ -33,7 +33,6 @@
 import static com.oracle.svm.core.Isolates.IMAGE_HEAP_WRITABLE_END;
 import static com.oracle.svm.core.Isolates.IMAGE_HEAP_WRITABLE_PATCHED_BEGIN;
 import static com.oracle.svm.core.Isolates.IMAGE_HEAP_WRITABLE_PATCHED_END;
-import static com.oracle.svm.core.imagelayer.ImageLayerSection.SectionEntries.HEAP_ANY_RELOCATABLE_POINTER;
 import static com.oracle.svm.core.imagelayer.ImageLayerSection.SectionEntries.HEAP_BEGIN;
 import static com.oracle.svm.core.imagelayer.ImageLayerSection.SectionEntries.HEAP_END;
 import static com.oracle.svm.core.imagelayer.ImageLayerSection.SectionEntries.HEAP_RELOCATABLE_BEGIN;
@@ -187,7 +186,8 @@ protected int initializeLayeredImage(Pointer firstHeapStart, Pointer selfReserve
             Word heapEnd = currentSection.readWord(ImageLayerSection.getEntryOffset(HEAP_END));
             Word heapRelocBegin = currentSection.readWord(ImageLayerSection.getEntryOffset(HEAP_RELOCATABLE_BEGIN));
             Word heapRelocEnd = currentSection.readWord(ImageLayerSection.getEntryOffset(HEAP_RELOCATABLE_END));
-            Word heapAnyRelocPointer = currentSection.readWord(ImageLayerSection.getEntryOffset(HEAP_ANY_RELOCATABLE_POINTER));
+            /* This value is not used for layered images. */
+            Word heapAnyRelocPointer = Word.nullPointer();
             Word heapWritableBegin = currentSection.readWord(ImageLayerSection.getEntryOffset(HEAP_WRITEABLE_BEGIN));
             Word heapWritableEnd = currentSection.readWord(ImageLayerSection.getEntryOffset(HEAP_WRITEABLE_END));
             Word heapWritablePatchedBegin = currentSection.readWord(ImageLayerSection.getEntryOffset(HEAP_WRITEABLE_PATCHED_BEGIN));
@@ -284,7 +284,7 @@ private static int initializeImageHeap(Pointer imageHeap, UnsignedWord reservedS
                     Word heapWritablePatchedEndSym, Word heapWritableSym, Word heapWritableEndSym) {
         assert heapBeginSym.belowOrEqual(heapWritableSym) && heapWritableSym.belowOrEqual(heapWritableEndSym) && heapWritableEndSym.belowOrEqual(heapEndSym);
         assert heapBeginSym.belowOrEqual(heapRelocsSym) && heapRelocsSym.belowOrEqual(heapRelocsEndSym) && heapRelocsEndSym.belowOrEqual(heapEndSym);
-        assert heapRelocsSym.belowOrEqual(heapAnyRelocPointer) && heapAnyRelocPointer.belowThan(heapRelocsEndSym);
+        assert ImageLayerBuildingSupport.buildingImageLayer() || heapRelocsSym.belowOrEqual(heapAnyRelocPointer) && heapAnyRelocPointer.belowThan(heapRelocsEndSym);
         assert heapRelocsSym.belowOrEqual(heapRelocsEndSym) && heapRelocsEndSym.belowOrEqual(heapWritablePatchedSym) && heapWritablePatchedSym.belowOrEqual(heapWritableEndSym);
 
         SignedWord fd = cachedFd.read();
@@ -444,14 +444,26 @@ private static int copyRelocations(Pointer imageHeap, UnsignedWord pageSize, Wor
         Pointer sourceRelocsBoundary = cachedRelocsBoundary.isNonNull() ? cachedRelocsBoundary : linkedRelocsBoundary;
         Pointer linkedCopyStart = Word.nullPointer();
         if (heapRelocsEndSym.subtract(heapRelocsSym).isNonNull()) {
-            /*
-             * Use a representative pointer to determine whether it is necessary to copy over the
-             * relocations from the original image, or if it has already been performed during
-             * build-link time.
-             */
-            ComparableWord relocatedValue = sourceRelocsBoundary.readWord(heapAnyRelocPointer.subtract(linkedRelocsBoundary));
-            ComparableWord mappedValue = imageHeap.readWord(heapAnyRelocPointer.subtract(heapBeginSym));
-            if (relocatedValue.notEqual(mappedValue)) {
+            boolean copyRequired;
+            if (ImageLayerBuildingSupport.buildingImageLayer()) {
+                assert heapAnyRelocPointer.isNull();
+                /*
+                 * The relocatable section with layered images will normally contain relocations
+                 * referring to both the same and different layers. Hence, it is not possible to use
+                 * a representative pointer to determine whether copying is necessary.
+                 */
+                copyRequired = true;
+            } else {
+                /*
+                 * Use a representative pointer to determine whether it is necessary to copy over
+                 * the relocations from the original image, or if it has already been performed
+                 * during build-link time.
+                 */
+                ComparableWord relocatedValue = sourceRelocsBoundary.readWord(heapAnyRelocPointer.subtract(linkedRelocsBoundary));
+                ComparableWord mappedValue = imageHeap.readWord(heapAnyRelocPointer.subtract(heapBeginSym));
+                copyRequired = relocatedValue.notEqual(mappedValue);
+            }
+            if (copyRequired) {
                 linkedCopyStart = heapRelocsSym;
             }
         }
@@ -464,14 +476,17 @@ private static int copyRelocations(Pointer imageHeap, UnsignedWord pageSize, Wor
         }
         if (linkedCopyStart.isNonNull()) {
             /*
-             * A portion of the image heap has relocations either resolved by the dynamic linker or
-             * (for layered images) manually during our runtime initialization code. To preserve the
-             * relocations, we must copy this code directly from the original image heap and not
-             * reload it from disk.
+             * A portion of the image heap needs to be manually copied over from the original image.
+             * This is needed whenever:
+             *
+             * 1. Relocations resolved by the dynamic linker are present.
+             *
+             * 2. (For layered images only): Heap relative relocations are present (i.e. the
+             * heapWritablePatched section is non-zero).
              *
-             * We need to round to page boundaries, so we may copy some extra data which could be
-             * copy-on-write. Also, we must first remap the pages to avoid loading them from disk
-             * (only to then overwrite them).
+             * To preserve this information, we must copy over this data from the original image
+             * heap and not reload it from disk. Note this copying must be performed at a page
+             * granularity, and hence may copy some extra data which could be copy-on-write.
              */
             Pointer linkedCopyStartBoundary = roundDown(linkedCopyStart, pageSize);
             UnsignedWord copyAlignedSize = roundUp(heapWritablePatchedEndSym.subtract(linkedCopyStartBoundary), pageSize);

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/imagelayer/ImageLayerSection.java

@@ -57,7 +57,6 @@ public enum SectionEntries {
         HEAP_END,
         HEAP_RELOCATABLE_BEGIN,
         HEAP_RELOCATABLE_END,
-        HEAP_ANY_RELOCATABLE_POINTER,
         HEAP_WRITEABLE_BEGIN,
         HEAP_WRITEABLE_END,
         HEAP_WRITEABLE_PATCHED_BEGIN,

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImage.java

@@ -504,7 +504,7 @@ public void build(String imageName, DebugContext debug) {
             objectFile.createDefinedSymbol(heapSection.getName(), heapSection, 0, 0, false, false);
 
             long sectionOffsetOfARelocatablePointer = writer.writeHeap(debug, heapSectionBuffer);
-            if (SpawnIsolates.getValue()) {
+            if (!ImageLayerBuildingSupport.buildingImageLayer() && SpawnIsolates.getValue()) {
                 if (heapLayout.getReadOnlyRelocatableSize() == 0) {
                     /*
                      * When there isn't a read only relocation section, the value of the relocatable
@@ -530,7 +530,10 @@ public void build(String imageName, DebugContext debug) {
             defineDataSymbol(Isolates.IMAGE_HEAP_RELOCATABLE_BEGIN_SYMBOL_NAME, heapSection, heapLayout.getReadOnlyRelocatableOffset() - heapLayout.getStartOffset());
             defineDataSymbol(Isolates.IMAGE_HEAP_RELOCATABLE_END_SYMBOL_NAME, heapSection,
                             heapLayout.getReadOnlyRelocatableOffset() + heapLayout.getReadOnlyRelocatableSize() - heapLayout.getStartOffset());
-            defineDataSymbol(Isolates.IMAGE_HEAP_A_RELOCATABLE_POINTER_SYMBOL_NAME, heapSection, sectionOffsetOfARelocatablePointer);
+            if (!ImageLayerBuildingSupport.buildingImageLayer()) {
+                /* Layered native-image builds do not use this symbol. */
+                defineDataSymbol(Isolates.IMAGE_HEAP_A_RELOCATABLE_POINTER_SYMBOL_NAME, heapSection, sectionOffsetOfARelocatablePointer);
+            }
             defineDataSymbol(Isolates.IMAGE_HEAP_WRITABLE_BEGIN_SYMBOL_NAME, heapSection, heapLayout.getWritableOffset() - heapLayout.getStartOffset());
             defineDataSymbol(Isolates.IMAGE_HEAP_WRITABLE_END_SYMBOL_NAME, heapSection, heapLayout.getWritableOffset() + heapLayout.getWritableSize() - heapLayout.getStartOffset());
             defineDataSymbol(Isolates.IMAGE_HEAP_WRITABLE_PATCHED_BEGIN_SYMBOL_NAME, heapSection, heapLayout.getWritablePatchedOffset() - heapLayout.getStartOffset());

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/imagelayer/ImageLayerSectionFeature.java

@@ -75,13 +75,12 @@
  *  |  8            | heap end                              |
  *  |  16           | heap relocatable begin                |
  *  |  24           | heap relocatable end                  |
- *  |  32           | heap any relocatable pointer          |
- *  |  40           | heap writable begin                   |
- *  |  48           | heap writable end                     |
- *  |  56           | heap writable patched begin           |
- *  |  64           | heap writable patched end             |
- *  |  72           | next layer section (0 if final layer) |
- *  |  80           | cross-layer singleton table start     |
+ *  |  32           | heap writable begin                   |
+ *  |  40           | heap writable end                     |
+ *  |  48           | heap writable patched begin           |
+ *  |  56           | heap writable patched end             |
+ *  |  64           | next layer section (0 if final layer) |
+ *  |  72           | cross-layer singleton table start     |
  *  | (after table) | heap relative patches                 |
  *  ---------------------------------------------------------
  * </pre>
@@ -95,13 +94,12 @@ public final class ImageLayerSectionFeature implements InternalFeature, FeatureS
     private static final int HEAP_END_OFFSET = 8;
     private static final int HEAP_RELOCATABLE_BEGIN_OFFSET = 16;
     private static final int HEAP_RELOCATABLE_END_OFFSET = 24;
-    private static final int HEAP_ANY_RELOCATABLE_POINTER_OFFSET = 32;
-    private static final int HEAP_WRITABLE_BEGIN_OFFSET = 40;
-    private static final int HEAP_WRITABLE_END_OFFSET = 48;
-    private static final int HEAP_WRITABLE_PATCHED_BEGIN_OFFSET = 56;
-    private static final int HEAP_WRITABLE_PATCHED_END_OFFSET = 64;
-    private static final int NEXT_SECTION_OFFSET = 72;
-    private static final int STATIC_SECTION_SIZE = 80;
+    private static final int HEAP_WRITABLE_BEGIN_OFFSET = 32;
+    private static final int HEAP_WRITABLE_END_OFFSET = 40;
+    private static final int HEAP_WRITABLE_PATCHED_BEGIN_OFFSET = 48;
+    private static final int HEAP_WRITABLE_PATCHED_END_OFFSET = 56;
+    private static final int NEXT_SECTION_OFFSET = 64;
+    private static final int STATIC_SECTION_SIZE = 72;
 
     private static final String CACHED_IMAGE_FDS_NAME = "__svm_layer_cached_image_fds";
     private static final String CACHED_IMAGE_HEAP_OFFSETS_NAME = "__svm_layer_cached_image_heap_offsets";
@@ -241,7 +239,6 @@ public void beforeImageWrite(BeforeImageWriteAccess access) {
         layeredSectionData.markRelocationSite(HEAP_END_OFFSET, ObjectFile.RelocationKind.DIRECT_8, Isolates.IMAGE_HEAP_END_SYMBOL_NAME, 0);
         layeredSectionData.markRelocationSite(HEAP_RELOCATABLE_BEGIN_OFFSET, ObjectFile.RelocationKind.DIRECT_8, Isolates.IMAGE_HEAP_RELOCATABLE_BEGIN_SYMBOL_NAME, 0);
         layeredSectionData.markRelocationSite(HEAP_RELOCATABLE_END_OFFSET, ObjectFile.RelocationKind.DIRECT_8, Isolates.IMAGE_HEAP_RELOCATABLE_END_SYMBOL_NAME, 0);
-        layeredSectionData.markRelocationSite(HEAP_ANY_RELOCATABLE_POINTER_OFFSET, ObjectFile.RelocationKind.DIRECT_8, Isolates.IMAGE_HEAP_A_RELOCATABLE_POINTER_SYMBOL_NAME, 0);
         layeredSectionData.markRelocationSite(HEAP_WRITABLE_BEGIN_OFFSET, ObjectFile.RelocationKind.DIRECT_8, Isolates.IMAGE_HEAP_WRITABLE_BEGIN_SYMBOL_NAME, 0);
         layeredSectionData.markRelocationSite(HEAP_WRITABLE_END_OFFSET, ObjectFile.RelocationKind.DIRECT_8, Isolates.IMAGE_HEAP_WRITABLE_END_SYMBOL_NAME, 0);
         layeredSectionData.markRelocationSite(HEAP_WRITABLE_PATCHED_BEGIN_OFFSET, ObjectFile.RelocationKind.DIRECT_8, Isolates.IMAGE_HEAP_WRITABLE_PATCHED_BEGIN_SYMBOL_NAME, 0);
@@ -305,7 +302,6 @@ public int getEntryOffsetInternal(SectionEntries entry) {
                 case HEAP_END -> HEAP_END_OFFSET;
                 case HEAP_RELOCATABLE_BEGIN -> HEAP_RELOCATABLE_BEGIN_OFFSET;
                 case HEAP_RELOCATABLE_END -> HEAP_RELOCATABLE_END_OFFSET;
-                case HEAP_ANY_RELOCATABLE_POINTER -> HEAP_ANY_RELOCATABLE_POINTER_OFFSET;
                 case HEAP_WRITEABLE_BEGIN -> HEAP_WRITABLE_BEGIN_OFFSET;
                 case HEAP_WRITEABLE_END -> HEAP_WRITABLE_END_OFFSET;
                 case HEAP_WRITEABLE_PATCHED_BEGIN -> HEAP_WRITABLE_PATCHED_BEGIN_OFFSET;