Renamings.

Author: christianhaeubl

substratevm/src/com.oracle.objectfile/src/com/oracle/objectfile/debugentry/DebugInfoBase.java

@@ -171,11 +171,11 @@ public abstract class DebugInfoBase {
     /**
      * Bit mask used for tagging oops.
      */
-    private int reservedBitsMask;
+    private int reservedHubBitsMask;
     /**
      * Number of low order bits used for tagging oops.
      */
-    private int numReservedBits;
+    private int numReservedHubBits;
     /**
      * Number of bytes used to store an oop reference.
      */
@@ -211,8 +211,8 @@ public abstract class DebugInfoBase {
     public DebugInfoBase(ByteOrder byteOrder) {
         this.byteOrder = byteOrder;
         this.useHeapBase = true;
-        this.reservedBitsMask = 0;
-        this.numReservedBits = 0;
+        this.reservedHubBitsMask = 0;
+        this.numReservedHubBits = 0;
         this.compressionShift = 0;
         this.referenceSize = 0;
         this.pointerSize = 0;
@@ -250,12 +250,12 @@ public void installDebugInfo(DebugInfoProvider debugInfoProvider) {
         /*
          * Save count of low order tag bits that may appear in references.
          */
-        reservedBitsMask = debugInfoProvider.reservedBitsMask();
+        reservedHubBitsMask = debugInfoProvider.reservedHubBitsMask();
 
         /* Mask must be contiguous from bit 0. */
-        assert ((reservedBitsMask + 1) & reservedBitsMask) == 0;
+        assert ((reservedHubBitsMask + 1) & reservedHubBitsMask) == 0;
 
-        numReservedBits = Integer.bitCount(reservedBitsMask);
+        numReservedHubBits = Integer.bitCount(reservedHubBitsMask);
 
         /* Save amount we need to shift references by when loading from an object field. */
         compressionShift = debugInfoProvider.compressionShift();
@@ -705,12 +705,12 @@ public boolean useHeapBase() {
         return useHeapBase;
     }
 
-    public int reservedBitsMask() {
-        return reservedBitsMask;
+    public int reservedHubBitsMask() {
+        return reservedHubBitsMask;
     }
 
-    public int numReservedBits() {
-        return numReservedBits;
+    public int numReservedHubBits() {
+        return numReservedHubBits;
     }
 
     public int compressionShift() {

substratevm/src/com.oracle.objectfile/src/com/oracle/objectfile/debuginfo/DebugInfoProvider.java

@@ -52,7 +52,7 @@ public interface DebugInfoProvider {
     /**
      * Mask selecting low order bits used for tagging oops.
      */
-    int reservedBitsMask();
+    int reservedHubBitsMask();
 
     /**
      * Number of bytes used to store an oop reference.

substratevm/src/com.oracle.objectfile/src/com/oracle/objectfile/elf/dwarf/DwarfInfoSectionImpl.java

@@ -2132,8 +2132,8 @@ public int writeCompressedOopConversionExpression(boolean isHub, byte[] buffer,
          */
 
         boolean useHeapBase = dwarfSections.useHeapBase();
-        int reservedBitsMask = dwarfSections.reservedBitsMask();
-        int numReservedBits = dwarfSections.numReservedBits();
+        int reservedHubBitsMask = dwarfSections.reservedHubBitsMask();
+        int numReservedHubBits = dwarfSections.numReservedHubBits();
         int compressionShift = dwarfSections.compressionShift();
         int numAlignmentBits = dwarfSections.numAlignmentBits();
 
@@ -2143,12 +2143,12 @@ public int writeCompressedOopConversionExpression(boolean isHub, byte[] buffer,
          * The required expression will be one of these paths:
          *
          * push object address ................................ (1 byte) ..... [offset] ............
-         * IF reservedBitsMask != 0 ................................................................
-         * . push reservedBitsMask ............................ (1 byte) ..... [offset, mask] ......
+         * IF reservedHubBitsMask != 0 .............................................................
+         * . push reservedHubBitsMask.......................... (1 byte) ..... [offset, mask] ......
          * . NOT .............................................. (1 byte) ..... [offset, ~mask] .....
          * . AND .............................................. (1 byte) ..... [offset] ............
-         * . IF numReservedBits == numAlignmentBits && compressionShift == 0 .......................
-         * ... push numReservedBits ........................... (1 byte) ..... [offset, right shift]
+         * . IF numReservedHubBits == numAlignmentBits && compressionShift == 0 ....................
+         * ... push numReservedHubBits ........................ (1 byte) ..... [offset, right shift]
          * ... LSHR ........................................... (1 byte) ..... [offset] ............
          * ... IF compressionShift != numAlignmentBits .............................................
          * ..... push numAlignmentBits - compressionShift ..... (1 byte) ..... [offset, left shift]
@@ -2176,13 +2176,13 @@ public int writeCompressedOopConversionExpression(boolean isHub, byte[] buffer,
         pos = writeULEB(0, buffer, pos);
         int exprStart = pos;
         pos = writeExprOpcode(DwarfExpressionOpcode.DW_OP_push_object_address, buffer, pos);
-        if (isHub && reservedBitsMask != 0) {
-            if (numReservedBits == numAlignmentBits && compressionShift == 0) {
-                pos = writeExprOpcodeLiteral(reservedBitsMask, buffer, pos);
+        if (isHub && reservedHubBitsMask != 0) {
+            if (numReservedHubBits == numAlignmentBits && compressionShift == 0) {
+                pos = writeExprOpcodeLiteral(reservedHubBitsMask, buffer, pos);
                 pos = writeExprOpcode(DwarfExpressionOpcode.DW_OP_not, buffer, pos);
                 pos = writeExprOpcode(DwarfExpressionOpcode.DW_OP_and, buffer, pos);
             } else {
-                pos = writeExprOpcodeLiteral(numReservedBits, buffer, pos);
+                pos = writeExprOpcodeLiteral(numReservedHubBits, buffer, pos);
                 pos = writeExprOpcode(DwarfExpressionOpcode.DW_OP_shr, buffer, pos);
                 if (compressionShift != numAlignmentBits) {
                     pos = writeExprOpcodeLiteral(numAlignmentBits - compressionShift, buffer, pos);

substratevm/src/com.oracle.svm.core.genscavenge/src/com/oracle/svm/core/genscavenge/HeapImpl.java

@@ -867,7 +867,7 @@ public int maxInvocationCount() {
         @RestrictHeapAccess(access = RestrictHeapAccess.Access.NO_ALLOCATION, reason = "Must not allocate while printing diagnostics.")
         public void printDiagnostics(Log log, ErrorContext context, int maxDiagnosticLevel, int invocationCount) {
             log.string("Heap settings and statistics:").indent(true);
-            log.string("Reserved object header bits: 0b").number(Heap.getHeap().getObjectHeader().getReservedBitsMask(), 2, false).newline();
+            log.string("Reserved hub pointer bits: 0b").number(Heap.getHeap().getObjectHeader().getReservedHubBitsMask(), 2, false).newline();
 
             log.string("Aligned chunk size: ").unsigned(HeapParameters.getAlignedHeapChunkSize()).newline();
             log.string("Large array threshold: ").unsigned(HeapParameters.getLargeArrayThreshold()).newline();

substratevm/src/com.oracle.svm.core.genscavenge/src/com/oracle/svm/core/genscavenge/ObjectHeaderImpl.java

@@ -79,26 +79,26 @@ public final class ObjectHeaderImpl extends ObjectHeader {
     private static final UnsignedWord IDHASH_STATE_IN_FIELD = Word.unsigned(0b10);
 
     private final int numAlignmentBits;
-    private final int numReservedBits;
-    private final int numReservedExtraBits;
+    private final int numReservedHubBits;
+    private final int numReservedExtraHubBits;
 
-    private final int reservedBitsMask;
+    private final int reservedHubBitsMask;
 
     @Platforms(Platform.HOSTED_ONLY.class)
     ObjectHeaderImpl() {
         numAlignmentBits = CodeUtil.log2(ConfigurationValues.getObjectLayout().getAlignment());
-        int numMinimumReservedBits = 3;
-        VMError.guarantee(numMinimumReservedBits <= numAlignmentBits, "Minimum set of reserved bits must be provided by object alignment");
+        int numMinReservedHubBits = 3;
+        VMError.guarantee(numMinReservedHubBits <= numAlignmentBits, "Minimum set of reserved bits must be provided by object alignment");
         if (isIdentityHashFieldOptional()) {
             VMError.guarantee(ReferenceAccess.singleton().haveCompressedReferences(), "Ensures hubs (at the start of the image heap) remain addressable");
-            numReservedBits = numMinimumReservedBits + 2;
-            VMError.guarantee(numReservedBits <= numAlignmentBits || hasShift(),
+            numReservedHubBits = numMinReservedHubBits + 2;
+            VMError.guarantee(numReservedHubBits <= numAlignmentBits || hasShift(),
                             "With no shift, forwarding references are stored directly in the header (with 64-bit, must be) and we cannot use non-alignment header bits");
         } else {
-            numReservedBits = numMinimumReservedBits;
+            numReservedHubBits = numMinReservedHubBits;
         }
-        numReservedExtraBits = numReservedBits - numAlignmentBits;
-        reservedBitsMask = (1 << numReservedBits) - 1;
+        numReservedExtraHubBits = numReservedHubBits - numAlignmentBits;
+        reservedHubBitsMask = (1 << numReservedHubBits) - 1;
     }
 
     @Fold
@@ -109,15 +109,15 @@ public static ObjectHeaderImpl getObjectHeaderImpl() {
     }
 
     @Override
-    public int getReservedBitsMask() {
-        return reservedBitsMask;
+    public int getReservedHubBitsMask() {
+        return reservedHubBitsMask;
     }
 
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
     @Override
     public Pointer extractPotentialDynamicHubFromHeader(Word header) {
         if (ReferenceAccess.singleton().haveCompressedReferences()) {
-            UnsignedWord hubBits = header.unsignedShiftRight(numReservedBits);
+            UnsignedWord hubBits = header.unsignedShiftRight(numReservedHubBits);
             UnsignedWord baseRelativeBits = hubBits.shiftLeft(numAlignmentBits);
             return KnownIntrinsics.heapBase().add(baseRelativeBits);
         } else {
@@ -277,7 +277,7 @@ public Word encodeAsObjectHeader(DynamicHub hub, boolean rememberedSet, boolean
         Word result = Word.objectToUntrackedPointer(hub);
         if (SubstrateOptions.SpawnIsolates.getValue()) {
             result = result.subtract(KnownIntrinsics.heapBase());
-            result = result.shiftLeft(numReservedExtraBits);
+            result = result.shiftLeft(numReservedExtraHubBits);
         }
         if (rememberedSet) {
             result = result.or(REMSET_OR_MARKED1_BIT);
@@ -291,7 +291,7 @@ public Word encodeAsObjectHeader(DynamicHub hub, boolean rememberedSet, boolean
     /** Clear the object header bits from a header. */
     @Uninterruptible(reason = "Called from uninterruptible code.", mayBeInlined = true)
     UnsignedWord clearBits(UnsignedWord header) {
-        UnsignedWord mask = Word.unsigned(reservedBitsMask);
+        UnsignedWord mask = Word.unsigned(reservedHubBitsMask);
         return header.and(mask.not());
     }
 
@@ -314,9 +314,9 @@ public static boolean isConsumedHeapChunkZapped(UnsignedWord header) {
     }
 
     @Override
-    public long encodeAsImageHeapObjectHeader(ImageHeapObject obj, long hubOffsetFromHeapBase) {
-        long header = hubOffsetFromHeapBase << numReservedExtraBits;
-        assert (header & reservedBitsMask) == 0 : "Object header bits must be zero initially";
+    public long encodeHubPointerForImageHeap(ImageHeapObject obj, long hubOffsetFromHeapBase) {
+        long header = hubOffsetFromHeapBase << numReservedExtraHubBits;
+        assert (header & reservedHubBitsMask) == 0 : "Object header bits must be zero initially";
         if (obj.getPartition() instanceof ChunkedImageHeapPartition partition) {
             if (partition.isWritable() && HeapImpl.usesImageHeapCardMarking()) {
                 header |= REMSET_OR_MARKED1_BIT.rawValue();
@@ -336,8 +336,8 @@ public long encodeAsImageHeapObjectHeader(ImageHeapObject obj, long hubOffsetFro
     @Override
     public void verifyDynamicHubOffsetInImageHeap(long offsetFromHeapBase) {
         long referenceSizeMask = getReferenceSize() == Integer.BYTES ? 0xFFFF_FFFFL : -1L;
-        long encoded = (offsetFromHeapBase << numReservedExtraBits) & referenceSizeMask;
-        boolean shiftLosesInformation = (encoded >>> numReservedExtraBits != offsetFromHeapBase);
+        long encoded = (offsetFromHeapBase << numReservedExtraHubBits) & referenceSizeMask;
+        boolean shiftLosesInformation = (encoded >>> numReservedExtraHubBits != offsetFromHeapBase);
         if (shiftLosesInformation) {
             throw VMError.shouldNotReachHere("Hub is too far from heap base for encoding in object header: " + offsetFromHeapBase);
         }
@@ -487,7 +487,7 @@ private UnsignedWord getForwardHeader(Object copy) {
     private UnsignedWord getHeaderBitsFromHeader(UnsignedWord header) {
         assert !isProducedHeapChunkZapped(header) : "Produced chunk zap value";
         assert !isConsumedHeapChunkZapped(header) : "Consumed chunk zap value";
-        return header.and(reservedBitsMask);
+        return header.and(reservedHubBitsMask);
     }
 
     @Fold

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/graal/meta/SubstrateBasicLoweringProvider.java

@@ -259,12 +259,12 @@ protected ValueNode createReadHub(StructuredGraph graph, ValueNode object, Lower
 
         int hubOffset = ol.getHubOffset();
         int bytesToRead = ol.getHubSize();
-        long reservedHeaderBitsMask = oh.getReservedBitsMask();
+        long reservedHubBitsMask = oh.getReservedHubBitsMask();
         if (hubOffset > 0 && hubOffset + ol.getHubSize() <= Long.BYTES && target.arch.getByteOrder() == ByteOrder.LITTLE_ENDIAN) {
             /* Prepare to emit a 64-bit read at offset 0 (reduces the code size). */
             hubOffset = 0;
             bytesToRead = Long.BYTES;
-            reservedHeaderBitsMask = (reservedHeaderBitsMask << Integer.SIZE) | ((1L << Integer.SIZE) - 1);
+            reservedHubBitsMask = (reservedHubBitsMask << Integer.SIZE) | ((1L << Integer.SIZE) - 1);
         }
 
         /* Read the raw hub data from the correct part of the object header. */
@@ -273,19 +273,19 @@ protected ValueNode createReadHub(StructuredGraph graph, ValueNode object, Lower
         AddressNode hubAddressNode = graph.unique(new OffsetAddressNode(object, hubOffsetNode));
         ValueNode rawHubData = graph.unique(new FloatingReadNode(hubAddressNode, NamedLocationIdentity.FINAL_LOCATION, null, readStamp, null, BarrierType.NONE));
 
-        if (reservedHeaderBitsMask != 0L) {
+        if (reservedHubBitsMask != 0L) {
             /* Get rid of the reserved header bits and extract the actual hub bits. */
-            assert CodeUtil.isPowerOf2(reservedHeaderBitsMask + 1) : "only the lowest bits may be set";
-            int numReservedBits = CodeUtil.log2(reservedHeaderBitsMask + 1);
+            assert CodeUtil.isPowerOf2(reservedHubBitsMask + 1) : "only the lowest bits may be set";
+            int numReservedHubBits = CodeUtil.log2(reservedHubBitsMask + 1);
             int compressionShift = ReferenceAccess.singleton().getCompressionShift();
             int numAlignmentBits = CodeUtil.log2(ol.getAlignment());
             assert compressionShift <= numAlignmentBits : "compression discards bits";
 
-            if (numReservedBits == numAlignmentBits && compressionShift == 0) {
+            if (numReservedHubBits == numAlignmentBits && compressionShift == 0) {
                 /* AND with a constant is slightly smaller than 2 shifts. */
-                rawHubData = graph.unique(new AndNode(rawHubData, ConstantNode.forIntegerStamp(readStamp, ~reservedHeaderBitsMask, graph)));
+                rawHubData = graph.unique(new AndNode(rawHubData, ConstantNode.forIntegerStamp(readStamp, ~reservedHubBitsMask, graph)));
             } else {
-                rawHubData = graph.unique(new UnsignedRightShiftNode(rawHubData, ConstantNode.forInt(numReservedBits, graph)));
+                rawHubData = graph.unique(new UnsignedRightShiftNode(rawHubData, ConstantNode.forInt(numReservedHubBits, graph)));
                 if (compressionShift != numAlignmentBits) {
                     int shift = numAlignmentBits - compressionShift;
                     rawHubData = graph.unique(new LeftShiftNode(rawHubData, ConstantNode.forInt(shift, graph)));

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/heap/ObjectHeader.java

@@ -60,9 +60,13 @@ protected ObjectHeader() {
     /**
      * Returns a mask where all reserved bits are set.
      */
-    public abstract int getReservedBitsMask();
+    public abstract int getReservedHubBitsMask();
 
-    public abstract long encodeAsImageHeapObjectHeader(ImageHeapObject obj, long hubOffsetFromHeapBase);
+    /**
+     * Returns an encoded hub pointer that can be used when writing the object header of an image
+     * heap object. Note that the returned value is not necessarily the full object header.
+     */
+    public abstract long encodeHubPointerForImageHeap(ImageHeapObject obj, long hubOffsetFromHeapBase);
 
     public abstract Word encodeAsTLABObjectHeader(DynamicHub hub);
 

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

@@ -30,8 +30,6 @@
 import java.util.function.Function;
 import java.util.function.Supplier;
 
-import com.oracle.svm.core.ReservedRegisters;
-import jdk.graal.compiler.word.Word;
 import org.graalvm.nativeimage.ImageSingletons;
 import org.graalvm.nativeimage.Platform;
 import org.graalvm.word.PointerBase;
@@ -42,6 +40,7 @@
 import com.oracle.objectfile.BasicProgbitsSectionImpl;
 import com.oracle.objectfile.debuginfo.DebugInfoProvider;
 import com.oracle.objectfile.io.AssemblyBuffer;
+import com.oracle.svm.core.ReservedRegisters;
 import com.oracle.svm.core.SubstrateOptions;
 import com.oracle.svm.core.UniqueShortNameProvider;
 import com.oracle.svm.core.UniqueShortNameProviderDefaultImpl;
@@ -63,6 +62,7 @@
 import jdk.graal.compiler.core.common.CompressEncoding;
 import jdk.graal.compiler.debug.DebugContext;
 import jdk.graal.compiler.printer.GraalDebugHandlersFactory;
+import jdk.graal.compiler.word.Word;
 
 @AutomaticallyRegisteredFeature
 @SuppressWarnings("unused")
@@ -120,12 +120,12 @@ public void beforeAnalysis(BeforeAnalysisAccess access) {
         CompressEncoding compressEncoding = ImageSingletons.lookup(CompressEncoding.class);
         CGlobalData<PointerBase> compressionShift = CGlobalDataFactory.createWord(Word.signed(compressEncoding.getShift()), "__svm_compression_shift");
         CGlobalData<PointerBase> useHeapBase = CGlobalDataFactory.createWord(Word.unsigned(compressEncoding.hasBase() ? 1 : 0), "__svm_use_heap_base");
-        CGlobalData<PointerBase> reservedBitsMask = CGlobalDataFactory.createWord(Word.unsigned(Heap.getHeap().getObjectHeader().getReservedBitsMask()), "__svm_reserved_bits_mask");
+        CGlobalData<PointerBase> reservedHubBitsMask = CGlobalDataFactory.createWord(Word.unsigned(Heap.getHeap().getObjectHeader().getReservedHubBitsMask()), "__svm_reserved_bits_mask");
         CGlobalData<PointerBase> objectAlignment = CGlobalDataFactory.createWord(Word.unsigned(ConfigurationValues.getObjectLayout().getAlignment()), "__svm_object_alignment");
         CGlobalData<PointerBase> heapBaseRegnum = CGlobalDataFactory.createWord(Word.unsigned(ReservedRegisters.singleton().getHeapBaseRegister().number), "__svm_heap_base_regnum");
         CGlobalDataFeature.singleton().registerWithGlobalHiddenSymbol(compressionShift);
         CGlobalDataFeature.singleton().registerWithGlobalHiddenSymbol(useHeapBase);
-        CGlobalDataFeature.singleton().registerWithGlobalHiddenSymbol(reservedBitsMask);
+        CGlobalDataFeature.singleton().registerWithGlobalHiddenSymbol(reservedHubBitsMask);
         CGlobalDataFeature.singleton().registerWithGlobalHiddenSymbol(objectAlignment);
         CGlobalDataFeature.singleton().registerWithGlobalHiddenSymbol(heapBaseRegnum);
     }