Change offsets used in heap layouting to be relative to the heap base.

Author: peter-hofer

Diff for: substratevm/src/com.oracle.objectfile/src/com/oracle/objectfile/debugentry/DebugInfoBase.java

@@ -36,7 +36,6 @@
 
 import org.graalvm.collections.EconomicMap;
 import org.graalvm.collections.EconomicSet;
-import jdk.graal.compiler.debug.DebugContext;
 
 import com.oracle.objectfile.debugentry.range.PrimaryRange;
 import com.oracle.objectfile.debugentry.range.Range;
@@ -49,6 +48,7 @@
 import com.oracle.objectfile.debuginfo.DebugInfoProvider.DebugTypeInfo.DebugTypeKind;
 import com.oracle.objectfile.elf.dwarf.DwarfDebugInfo;
 
+import jdk.graal.compiler.debug.DebugContext;
 import jdk.vm.ci.meta.ResolvedJavaType;
 
 /**
@@ -351,10 +351,10 @@ public void installDebugInfo(DebugInfoProvider debugInfoProvider) {
                 String provenance = debugDataInfo.getProvenance();
                 String typeName = debugDataInfo.getTypeName();
                 String partitionName = debugDataInfo.getPartition();
-                /* Address is heap-register relative pointer. */
-                long address = debugDataInfo.getAddress();
+                /* Offset is relative to heap-base register. */
+                long offset = debugDataInfo.getOffset();
                 long size = debugDataInfo.getSize();
-                debugContext.log(DebugContext.INFO_LEVEL, "Data: address 0x%x size 0x%x type %s partition %s provenance %s ", address, size, typeName, partitionName, provenance);
+                debugContext.log(DebugContext.INFO_LEVEL, "Data: offset 0x%x size 0x%x type %s partition %s provenance %s ", offset, size, typeName, partitionName, provenance);
             }
         }));
         // populate a file and dir list and associated index for each class entry

Diff for: substratevm/src/com.oracle.objectfile/src/com/oracle/objectfile/debuginfo/DebugInfoProvider.java

@@ -31,11 +31,11 @@
 import java.util.function.Consumer;
 import java.util.stream.Stream;
 
+import jdk.graal.compiler.debug.DebugContext;
 import jdk.vm.ci.meta.JavaConstant;
 import jdk.vm.ci.meta.JavaKind;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.ResolvedJavaType;
-import jdk.graal.compiler.debug.DebugContext;
 
 /**
  * Interfaces used to allow a native image to communicate details of types, code and data to the
@@ -356,8 +356,6 @@ interface DebugDataInfo {
 
         long getOffset();
 
-        long getAddress();
-
         long getSize();
     }
 

Diff for: substratevm/src/com.oracle.svm.core.genscavenge/src/com/oracle/svm/core/genscavenge/ChunkedImageHeapLayouter.java

@@ -35,7 +35,6 @@
 import com.oracle.svm.core.genscavenge.ChunkedImageHeapAllocator.Chunk;
 import com.oracle.svm.core.genscavenge.ChunkedImageHeapAllocator.UnalignedChunk;
 import com.oracle.svm.core.genscavenge.remset.RememberedSet;
-import com.oracle.svm.core.heap.Heap;
 import com.oracle.svm.core.hub.DynamicHub;
 import com.oracle.svm.core.image.ImageHeap;
 import com.oracle.svm.core.image.ImageHeapLayoutInfo;
@@ -83,10 +82,9 @@ public class ChunkedImageHeapLayouter implements ImageHeapLayouter {
     private final long hugeObjectThreshold;
     private ChunkedImageHeapAllocator allocator;
 
+    /** @param startOffset Offset relative to the heap base. */
     @SuppressWarnings("this-escape")
     public ChunkedImageHeapLayouter(ImageHeapInfo heapInfo, long startOffset) {
-        assert startOffset == 0 || startOffset >= Heap.getHeap().getImageHeapOffsetInAddressSpace() : "must be relative to the heap base";
-
         this.partitions = new ChunkedImageHeapPartition[PARTITION_COUNT];
         this.partitions[READ_ONLY_PRIMITIVE] = new ChunkedImageHeapPartition("readOnlyPrimitive", false, false);
         this.partitions[READ_ONLY_REFERENCE] = new ChunkedImageHeapPartition("readOnlyReference", false, false);
@@ -107,11 +105,6 @@ public ChunkedImageHeapLayouter(ImageHeapInfo heapInfo, long startOffset) {
         this.hugeObjectThreshold = hugeThreshold.rawValue();
     }
 
-    @Override
-    public long getStartOffset() {
-        return startOffset;
-    }
-
     @Override
     public ChunkedImageHeapPartition[] getPartitions() {
         return partitions;
@@ -214,34 +207,15 @@ private ImageHeapLayoutInfo populateInfoObjects(int dynamicHubCount) {
             break;
         }
 
-        initializeHeapInfo(dynamicHubCount, offsetOfFirstWritableAlignedChunk, offsetOfFirstWritableUnalignedChunk);
-        return createLayoutInfo(startOffset, offsetOfFirstWritableAlignedChunk);
-    }
-
-    private void initializeHeapInfo(int dynamicHubCount, long offsetOfFirstWritableAlignedChunk, long offsetOfFirstWritableUnalignedChunk) {
-        long writableAligned = offsetOfFirstWritableAlignedChunk;
-        long writableUnaligned = offsetOfFirstWritableUnalignedChunk;
-
-        if (startOffset == 0) {
-            // Adjust all offsets by the offset of the image heap in the address space.
-            int imageHeapOffsetInAddressSpace = Heap.getHeap().getImageHeapOffsetInAddressSpace();
-            writableAligned += imageHeapOffsetInAddressSpace;
-            if (writableUnaligned >= 0) {
-                writableUnaligned += imageHeapOffsetInAddressSpace;
-            }
-        }
-
         heapInfo.initialize(getReadOnlyPrimitive().firstObject, getReadOnlyPrimitive().lastObject, getReadOnlyReference().firstObject, getReadOnlyReference().lastObject,
                         getReadOnlyRelocatable().firstObject, getReadOnlyRelocatable().lastObject, getWritablePrimitive().firstObject, getWritablePrimitive().lastObject,
                         getWritableReference().firstObject, getWritableReference().lastObject, getWritableHuge().firstObject, getWritableHuge().lastObject,
-                        getReadOnlyHuge().firstObject, getReadOnlyHuge().lastObject, writableAligned, writableUnaligned, dynamicHubCount);
-    }
+                        getReadOnlyHuge().firstObject, getReadOnlyHuge().lastObject, offsetOfFirstWritableAlignedChunk, offsetOfFirstWritableUnalignedChunk, dynamicHubCount);
 
-    private ImageHeapLayoutInfo createLayoutInfo(long heapStartOffset, long writableBeginOffset) {
         long writableEnd = getWritableHuge().getStartOffset() + getWritableHuge().getSize();
-        long writableSize = writableEnd - writableBeginOffset;
-        long imageHeapSize = getReadOnlyHuge().getStartOffset() + getReadOnlyHuge().getSize() - heapStartOffset;
-        return new ImageHeapLayoutInfo(writableBeginOffset, writableSize, getReadOnlyRelocatable().getStartOffset(), getReadOnlyRelocatable().getSize(), imageHeapSize);
+        long writableSize = writableEnd - offsetOfFirstWritableAlignedChunk;
+        long imageHeapSize = getReadOnlyHuge().getStartOffset() + getReadOnlyHuge().getSize() - startOffset;
+        return new ImageHeapLayoutInfo(startOffset, offsetOfFirstWritableAlignedChunk, writableSize, getReadOnlyRelocatable().getStartOffset(), getReadOnlyRelocatable().getSize(), imageHeapSize);
     }
 
     @Override

Diff for: substratevm/src/com.oracle.svm.core.genscavenge/src/com/oracle/svm/core/genscavenge/graal/GenScavengeGCFeature.java

@@ -142,7 +142,7 @@ public void beforeAnalysis(BeforeAnalysisAccess access) {
 
     @Override
     public void afterAnalysis(AfterAnalysisAccess access) {
-        ImageHeapLayouter heapLayouter = new ChunkedImageHeapLayouter(HeapImpl.getFirstImageHeapInfo(), 0);
+        ImageHeapLayouter heapLayouter = new ChunkedImageHeapLayouter(HeapImpl.getFirstImageHeapInfo(), Heap.getHeap().getImageHeapOffsetInAddressSpace());
         ImageSingletons.add(ImageHeapLayouter.class, heapLayouter);
     }
 

Diff for: substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/image/ImageHeapLayoutInfo.java

@@ -27,21 +27,32 @@
 import com.oracle.svm.core.BuildPhaseProvider.AfterHeapLayout;
 import com.oracle.svm.core.heap.UnknownPrimitiveField;
 
+/** Layout offsets and sizes. All offsets are relative to the heap base. */
 public class ImageHeapLayoutInfo {
+    @UnknownPrimitiveField(availability = AfterHeapLayout.class) private final long startOffset;
+    @UnknownPrimitiveField(availability = AfterHeapLayout.class) private final long imageHeapSize;
+
     @UnknownPrimitiveField(availability = AfterHeapLayout.class) private final long writableOffset;
     @UnknownPrimitiveField(availability = AfterHeapLayout.class) private final long writableSize;
 
     @UnknownPrimitiveField(availability = AfterHeapLayout.class) private final long readOnlyRelocatableOffset;
     @UnknownPrimitiveField(availability = AfterHeapLayout.class) private final long readOnlyRelocatableSize;
 
-    @UnknownPrimitiveField(availability = AfterHeapLayout.class) private final long imageHeapSize;
-
-    public ImageHeapLayoutInfo(long writableOffset, long writableSize, long readOnlyRelocatableOffset, long readOnlyRelocatableSize, long imageHeapSize) {
+    public ImageHeapLayoutInfo(long startOffset, long writableOffset, long writableSize, long readOnlyRelocatableOffset, long readOnlyRelocatableSize, long imageHeapSize) {
+        this.startOffset = startOffset;
+        this.imageHeapSize = imageHeapSize;
         this.writableOffset = writableOffset;
         this.writableSize = writableSize;
         this.readOnlyRelocatableOffset = readOnlyRelocatableOffset;
         this.readOnlyRelocatableSize = readOnlyRelocatableSize;
-        this.imageHeapSize = imageHeapSize;
+    }
+
+    public long getStartOffset() {
+        return startOffset;
+    }
+
+    public long getImageHeapSize() {
+        return imageHeapSize;
     }
 
     public long getWritableOffset() {
@@ -60,11 +71,7 @@ public long getReadOnlyRelocatableSize() {
         return readOnlyRelocatableSize;
     }
 
-    public boolean isReadOnlyRelocatable(int offset) {
+    public boolean isReadOnlyRelocatable(long offset) {
         return offset >= readOnlyRelocatableOffset && offset < readOnlyRelocatableOffset + readOnlyRelocatableSize;
     }
-
-    public long getImageHeapSize() {
-        return imageHeapSize;
-    }
 }

Diff for: substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/image/ImageHeapLayouter.java

@@ -26,20 +26,12 @@
 
 import java.nio.ByteBuffer;
 
-import com.oracle.svm.core.heap.Heap;
-
 /**
  * This class is responsible for computing and storing the layout of the native image heap. A native
  * image heap consist of multiple {@link ImageHeapPartition}s. Every object in the native image heap
  * is assigned to a position within a {@link ImageHeapPartition}.
  */
 public interface ImageHeapLayouter {
-    /**
-     * The offset of this image heap relative to the start of the first image heap (which itself is
-     * not the same as the heap base, see {@link Heap#getImageHeapOffsetInAddressSpace}).
-     */
-    long getStartOffset();
-
     /**
      * Returns all native image heap partitions.
      */
@@ -51,9 +43,7 @@ public interface ImageHeapLayouter {
     void assignObjectToPartition(ImageHeapObject info, boolean immutable, boolean references, boolean relocatable);
 
     /**
-     * This method places all heap partitions as one contiguous memory block in one section. After
-     * calling that method, all native image heap objects are assigned their final address. This
-     * address must not change anymore.
+     * Places all heap partitions and assigns objects their final offsets.
      */
     ImageHeapLayoutInfo layout(ImageHeap imageHeap, int pageSize);
 

Diff for: substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/image/ImageHeapObject.java

@@ -39,6 +39,7 @@ public interface ImageHeapObject {
 
     void setOffsetInPartition(long value);
 
+    /** Returns the heap-base relative offset of this object. */
     long getOffset();
 
     ImageHeapPartition getPartition();

Diff for: substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/LIRNativeImageCodeCache.java

@@ -34,11 +34,6 @@
 import java.util.stream.StreamSupport;
 
 import org.graalvm.collections.Pair;
-import jdk.graal.compiler.code.CompilationResult;
-import jdk.graal.compiler.code.CompilationResult.CodeAnnotation;
-import jdk.graal.compiler.core.common.NumUtil;
-import jdk.graal.compiler.debug.DebugContext;
-import jdk.graal.compiler.debug.Indent;
 
 import com.oracle.graal.pointsto.BigBang;
 import com.oracle.objectfile.ObjectFile;
@@ -52,6 +47,11 @@
 import com.oracle.svm.hosted.image.NativeImageHeap.ObjectInfo;
 import com.oracle.svm.hosted.meta.HostedMethod;
 
+import jdk.graal.compiler.code.CompilationResult;
+import jdk.graal.compiler.code.CompilationResult.CodeAnnotation;
+import jdk.graal.compiler.core.common.NumUtil;
+import jdk.graal.compiler.debug.DebugContext;
+import jdk.graal.compiler.debug.Indent;
 import jdk.vm.ci.code.TargetDescription;
 import jdk.vm.ci.code.site.Call;
 import jdk.vm.ci.code.site.ConstantReference;
@@ -356,7 +356,7 @@ public void patchMethods(DebugContext debug, RelocatableBuffer relocs, ObjectFil
                     HostedImageHeapConstantPatch patch = (HostedImageHeapConstantPatch) codeAnnotation;
 
                     ObjectInfo objectInfo = imageHeap.getConstantInfo(patch.constant);
-                    long objectAddress = objectInfo.getAddress();
+                    long objectAddress = objectInfo.getOffset();
 
                     if (targetCode == null) {
                         targetCode = ByteBuffer.wrap(compilation.getTargetCode()).order(target.arch.getByteOrder());

Diff for: substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImage.java

@@ -470,16 +470,17 @@ public void build(String imageName, DebugContext debug) {
             heapSection = objectFile.newProgbitsSection(SectionName.SVM_HEAP.getFormatDependentName(objectFile.getFormat()), alignment, writable, false, heapSectionImpl);
             objectFile.createDefinedSymbol(heapSection.getName(), heapSection, 0, 0, false, false);
 
-            long offsetOfARelocatablePointer = writer.writeHeap(debug, heapSectionBuffer);
-            assert !SubstrateOptions.SpawnIsolates.getValue() || heapSectionBuffer.getByteBuffer().getLong((int) offsetOfARelocatablePointer) == 0L;
+            long sectionOffsetOfARelocatablePointer = writer.writeHeap(debug, heapSectionBuffer);
+            assert !SubstrateOptions.SpawnIsolates.getValue() || heapSectionBuffer.getByteBuffer().getLong((int) sectionOffsetOfARelocatablePointer) == 0L;
 
             defineDataSymbol(Isolates.IMAGE_HEAP_BEGIN_SYMBOL_NAME, heapSection, 0);
             defineDataSymbol(Isolates.IMAGE_HEAP_END_SYMBOL_NAME, heapSection, imageHeapSize);
-            defineDataSymbol(Isolates.IMAGE_HEAP_RELOCATABLE_BEGIN_SYMBOL_NAME, heapSection, heapLayout.getReadOnlyRelocatableOffset());
-            defineDataSymbol(Isolates.IMAGE_HEAP_RELOCATABLE_END_SYMBOL_NAME, heapSection, heapLayout.getReadOnlyRelocatableOffset() + heapLayout.getReadOnlyRelocatableSize());
-            defineDataSymbol(Isolates.IMAGE_HEAP_A_RELOCATABLE_POINTER_SYMBOL_NAME, heapSection, offsetOfARelocatablePointer);
-            defineDataSymbol(Isolates.IMAGE_HEAP_WRITABLE_BEGIN_SYMBOL_NAME, heapSection, heapLayout.getWritableOffset());
-            defineDataSymbol(Isolates.IMAGE_HEAP_WRITABLE_END_SYMBOL_NAME, heapSection, heapLayout.getWritableOffset() + heapLayout.getWritableSize());
+            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);
+            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());
 
             // Mark the sections with the relocations from the maps.
             markRelocationSitesFromBuffer(textBuffer, textImpl);
@@ -625,8 +626,7 @@ private void markDataRelocationSite(ProgbitsSectionImpl sectionImpl, int offset,
         assert ConfigurationValues.getTarget().arch instanceof AArch64 || info.getRelocationSize() == 4 || info.getRelocationSize() == 8 : "AMD64 Data relocation size should be 4 or 8 bytes.";
         assert targetObjectInfo != null;
         String targetSectionName = heapSection.getName();
-        long address = targetObjectInfo.getAddress();
-        long relocationAddend = address + info.getAddend();
+        long relocationAddend = targetObjectInfo.getOffset() + info.getAddend();
         sectionImpl.markRelocationSite(offset, info.getRelocationKind(), targetSectionName, relocationAddend);
     }
 
@@ -661,7 +661,7 @@ private void markDataRelocationSiteFromText(RelocatableBuffer buffer, final Prog
         } else if (target instanceof ConstantReference) {
             // Direct object reference in code that must be patched (not a linker relocation)
             JavaConstant constant = (JavaConstant) ((ConstantReference) target).getConstant();
-            long address = heap.getConstantInfo(constant).getAddress();
+            long address = heap.getConstantInfo(constant).getOffset();
             int encShift = ImageSingletons.lookup(CompressEncoding.class).getShift();
             long targetValue = address >>> encShift;
             assert (targetValue << encShift) == address : "Reference compression shift discards non-zero bits: " + Long.toHexString(address);

Diff for: substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImageDebugInfoProvider.java

@@ -2622,11 +2622,6 @@ public long getOffset() {
             return objectInfo.getOffset();
         }
 
-        @Override
-        public long getAddress() {
-            return objectInfo.getAddress();
-        }
-
         @Override
         public long getSize() {
             return objectInfo.getSize();

Diff for: substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/image/NativeImageDebugInfoProviderBase.java

@@ -118,8 +118,8 @@ public NativeImageDebugInfoProviderBase(NativeImageCodeCache codeCache, NativeIm
         this.referenceSize = getObjectLayout().getReferenceSize();
         this.referenceAlignment = getObjectLayout().getAlignment();
         /* Offsets need to be adjusted relative to the heap base plus partition-specific offset. */
-        primitiveStartOffset = (int) primitiveFields.getAddress();
-        referenceStartOffset = (int) objectFields.getAddress();
+        primitiveStartOffset = (int) primitiveFields.getOffset();
+        referenceStartOffset = (int) objectFields.getOffset();
         javaKindToHostedType = initJavaKindToHostedTypes(metaAccess);
     }
 
@@ -408,7 +408,7 @@ public long objectOffset(JavaConstant constant) {
         assert constant.getJavaKind() == JavaKind.Object && !constant.isNull() : "invalid constant for object offset lookup";
         NativeImageHeap.ObjectInfo objectInfo = heap.getConstantInfo(constant);
         if (objectInfo != null) {
-            return objectInfo.getAddress();
+            return objectInfo.getOffset();
         }
         return -1;
     }