Bugfixes after rebase

Author: dominikmascherbauer

substratevm/debug/gdbpy/gdb-debughelpers.py

@@ -158,17 +158,6 @@ def is_reachable(cls, this: hex, other: hex) -> bool:
             # create a flat list of all ancestors of each tested node
             test_nodes = [parent for node in test_nodes for parent in cls.parents.get(node, [])]
 
-    @classmethod
-    def is_compressed(cls, t: gdb.Type) -> bool:
-        type_name = cls.get_basic_type(t).name
-        if type_name is None:
-            # fallback to the GDB type printer for t
-            type_name = str(t)
-        # compressed types from a different classLoader have the format <loader_name>::_z_.<type_name>
-        result = type_name.startswith(cls.compressed_ref_prefix) or ('::' + cls.compressed_ref_prefix) in type_name
-        trace(f'<SVMUtil> - is_compressed({type_name}) = {result}')
-        return result
-
     @classmethod
     def is_primitive(cls, t: gdb.Type) -> bool:
         result = cls.get_basic_type(t).is_scalar
@@ -236,7 +225,7 @@ def __init__(self):
         self.object_type = gdb.lookup_type("java.lang.Object")
         self.object_header_type = gdb.lookup_type("_objhdr")
         self.stack_type = gdb.lookup_type("long")
-        self.hub_type = gdb.lookup_type("java.lang.Class")
+        self.hub_type = gdb.lookup_type("Encoded$Dynamic$Hub")
         self.classloader_type = gdb.lookup_type("java.lang.ClassLoader")
         self.wrapper_types = [gdb.lookup_type(f'java.lang.{x}') for x in
                               ["Byte", "Short", "Integer", "Long", "Float", "Double", "Boolean", "Character"]
@@ -267,9 +256,24 @@ def get_adr(self, obj: gdb.Value) -> int:
     def is_null(self, obj: gdb.Value) -> bool:
         return self.get_adr(obj) == 0
 
+    def is_compressed(self, t: gdb.Type) -> bool:
+        # for the hub type we always want handle it as compressed as there is no clear distinction in debug info for
+        # the hub field, and it may always have an expression in the type's data_location attribute
+        if self.get_basic_type(t) == self.hub_type:
+            return True
+
+        type_name = self.get_basic_type(t).name
+        if type_name is None:
+            # fallback to the GDB type printer for t
+            type_name = str(t)
+        # compressed types from a different classLoader have the format <loader_name>::_z_.<type_name>
+        result = type_name.startswith(self.compressed_ref_prefix) or ('::' + self.compressed_ref_prefix) in type_name
+        trace(f'<SVMUtil> - is_compressed({type_name}) = {result}')
+        return result
+
     def get_compressed_oop(self, obj: gdb.Value) -> int:
         # use compressed ref if available - only compute it if necessary
-        if obj.type.code == gdb.TYPE_CODE_PTR and SVMUtil.is_compressed(obj.type):
+        if obj.type.code == gdb.TYPE_CODE_PTR and self.is_compressed(obj.type):
             return int(obj)
 
         obj_adr = self.get_adr(obj)
@@ -279,7 +283,7 @@ def get_compressed_oop(self, obj: gdb.Value) -> int:
         # recreate compressed oop from the object address
         # this reverses the uncompress expression from
         # com.oracle.objectfile.elf.dwarf.DwarfInfoSectionImpl#writeIndirectOopConversionExpression
-        is_hub = self.get_basic_type(obj) == self.hub_type
+        is_hub = self.get_basic_type(obj.type) == self.hub_type
         compression_shift = self.compression_shift
         num_reserved_bits = int.bit_count(self.reserved_bits_mask)
         num_alignment_bits = int.bit_count(self.object_alignment - 1)
@@ -299,7 +303,7 @@ def get_compressed_oop(self, obj: gdb.Value) -> int:
         return compressed_oop
 
     def adr_str(self, obj: gdb.Value) -> str:
-        if not svm_print_address.absolute_adr and SVMUtil.is_compressed(obj.type):
+        if not svm_print_address.absolute_adr and self.is_compressed(obj.type):
             result = f' @z({hex(self.get_compressed_oop(obj))})'
         else:
             result = f' @({hex(self.get_adr(obj))})'
@@ -375,7 +379,7 @@ def get_java_string(self, obj: gdb.Value, gdb_output_string: bool = False) -> st
 
     def get_hub_field(self, obj: gdb.Value) -> gdb.Value:
         try:
-            return obj.cast(self.object_header_type)[self.hub_field_name]
+            return self.cast_to(obj, self.object_header_type)[self.hub_field_name]
         except gdb.error:
             return self.null
 
@@ -472,7 +476,7 @@ def get_rtt(self, obj: gdb.Value) -> gdb.Type:
         else:
             rtt = gdb.lookup_type(rtt_name)
 
-        if SVMUtil.is_compressed(obj.type) and not SVMUtil.is_compressed(rtt):
+        if self.is_compressed(obj.type) and not self.is_compressed(rtt):
             rtt = self.get_compressed_type(rtt)
 
         trace(f'<SVMUtil> - get_rtt({hex(self.get_adr(obj))}) = {rtt_name}')
@@ -483,7 +487,7 @@ def cast_to(self, obj: gdb.Value, t: gdb.Type) -> gdb.Value:
             return obj
 
         # get objects address, take care of compressed oops
-        if SVMUtil.is_compressed(t):
+        if self.is_compressed(t):
             obj_oop = self.get_compressed_oop(obj)
         else:
             obj_oop = self.get_adr(obj)
@@ -501,7 +505,7 @@ def get_uncompressed_type(self, t: gdb.Type) -> gdb.Type:
         # compressed types only exist for java type which are either struct or union
         if t.code != gdb.TYPE_CODE_STRUCT and t.code != gdb.TYPE_CODE_UNION:
             return t
-        result = self.get_base_class(t) if SVMUtil.is_compressed(t) else t
+        result = self.get_base_class(t) if (self.is_compressed(t) and t != self.hub_type) else t
         trace(f'<SVMUtil> - get_uncompressed_type({t}) = {result}')
         return result
 
@@ -546,7 +550,7 @@ def get_compressed_type(self, t: gdb.Type) -> gdb.Type:
         t = SVMUtil.get_basic_type(t)
         # compressed types only exist for java types which are either struct or union
         # do not compress types that already have the compressed prefix
-        if not self.is_java_type(t) or SVMUtil.is_compressed(t):
+        if not self.is_java_type(t) or self.is_compressed(t):
             return t
 
         type_name = t.name
@@ -688,7 +692,7 @@ def children(self) -> Iterable[object]:
         trace('<SVMPPClass> - children (class field iterator)')
         if self.__skip_children:
             return
-        fields = [str(f.name) for f in SVMUtil.get_all_fields(self.__obj.type, svm_print_static_fields.value) if f.name != SVMUtil.hub_field_name]
+        fields = [str(f.name) for f in SVMUtil.get_all_fields(self.__obj.type, svm_print_static_fields.value) if f.parent_type != self.__svm_util.object_header_type]
         for index, f in enumerate(fields):
             trace(f'<SVMPPClass> - children: field "{f}"')
             # apply custom limit only for java objects
@@ -1343,7 +1347,7 @@ def cast_to_rtt(self, obj: gdb.Value, obj_str: str) -> tuple:  # tuple[gdb.Value
         if static_type.name == rtt.name:
             return obj, obj_str
         else:
-            obj_oop = self.svm_util.get_compressed_oop(obj) if SVMUtil.is_compressed(rtt) else self.svm_util.get_adr(obj)
+            obj_oop = self.svm_util.get_compressed_oop(obj) if self.svm_util.is_compressed(rtt) else self.svm_util.get_adr(obj)
             return obj, f"(('{rtt.name}' *)({obj_oop}))"
 
     # Define the token specifications
@@ -1389,6 +1393,7 @@ def check(self, expected: str):
             raise RuntimeError(f"{expected} expected after {self.expr[:self.t.end]} but got {self.sym}")
 
     def parse(self, completion: bool = False) -> str:
+        self.svm_util = SVMUtil()
         self.scan()
         if self.sym == "" and completion:
             raise self.AutoComplete(gdb.COMPLETE_EXPRESSION)
@@ -1539,7 +1544,7 @@ def params(self, completion: bool = False) -> str:
                     obj_str += self.t.val
 
             obj = gdb.parse_and_eval(obj_str)  # check if gdb can handle the current param
-            if self.svm_util.is_java_type(obj.type) and SVMUtil.is_compressed(obj.type):
+            if self.svm_util.is_java_type(obj.type) and self.svm_util.is_compressed(obj.type):
                 # uncompress compressed java params
                 obj_str = f"(('{self.svm_util.get_uncompressed_type(SVMUtil.get_basic_type(obj.type)).name}' *)({self.svm_util.get_adr(obj)}))"
             param_str += obj_str
@@ -1565,8 +1570,6 @@ def array_index(self, completion: bool = False) -> str:
         return i_obj_str
 
     def complete(self, text: str, word: str):  # -> list[str] | int:
-        self.svm_util = SVMUtil()
-
         if not svm_print.value:
             return gdb.COMPLETE_EXPRESSION
 
@@ -1580,8 +1583,6 @@ def complete(self, text: str, word: str):  # -> list[str] | int:
         return gdb.COMPLETE_NONE
 
     def invoke(self, arg: str, from_tty: bool) -> None:
-        self.svm_util = SVMUtil()
-
         if not svm_print.value:
             gdb.execute(f"print {arg}")
             return

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

@@ -182,7 +182,7 @@ public abstract class DebugInfoBase {
      * The name of the type for header field hub which needs special case processing to remove tag
      * bits.
      */
-    public static final String HUB_TYPE_NAME = "java.lang.Class";
+    public static final String HUB_TYPE_NAME = "Encoded$Dynamic$Hub";
     public static final String FOREIGN_METHOD_LIST_TYPE = "Foreign$Method$List";
 
     public DebugInfoBase(ByteOrder byteOrder) {
@@ -312,7 +312,6 @@ public ClassEntry lookupClassClass() {
         return classClass;
     }
 
-
     /* Accessors to query the debug info model. */
     public ByteOrder getByteOrder() {
         return byteOrder;

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

@@ -28,10 +28,13 @@
 
 public class HeaderTypeEntry extends StructureTypeEntry {
 
-    private final FieldEntry hubField;
+    private FieldEntry hubField;
 
-    public HeaderTypeEntry(String typeName, int size, long typeSignature, FieldEntry hubField) {
+    public HeaderTypeEntry(String typeName, int size, long typeSignature) {
         super(typeName, size, -1, typeSignature, typeSignature, typeSignature);
+    }
+
+    public void setHubField(FieldEntry hubField) {
         this.hubField = hubField;
     }
 

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

@@ -455,7 +455,7 @@ private int writeHeaderType(DebugContext context, HeaderTypeEntry headerTypeEntr
         writeInt(pos - lengthPos, buffer, typeOffsetPos);
 
         /* Write the type representing the object header. */
-        name = headerTypeEntry.getTypeName();
+        name = uniqueDebugString(headerTypeEntry.getTypeName());
         size = hubField.getSize();
         log(context, "  [0x%08x] header type %s", pos, name);
         abbrevCode = AbbrevCode.OBJECT_HEADER;
@@ -486,7 +486,7 @@ private int writeHubField(DebugContext context, FieldEntry hubFieldEntry, int hu
         log(context, "  [0x%08x] hub field", pos);
         log(context, "  [0x%08x] <2> Abbrev Number %d", pos, abbrevCode.ordinal());
         pos = writeAbbrevCode(abbrevCode, buffer, pos);
-        String fieldName = hubFieldEntry.fieldName();
+        String fieldName = uniqueDebugString(hubFieldEntry.fieldName());
         log(context, "  [0x%08x]     name  0x%x (%s)", pos, debugStringIndex(fieldName), fieldName);
         pos = writeStrSectionOffset(fieldName, buffer, pos);
         log(context, "  [0x%08x]     type 0x%x (%s)", pos, hubTypeIdx, DwarfDebugInfo.HUB_TYPE_NAME);
@@ -967,8 +967,7 @@ private int writeForeignStructLayoutTypeUnit(DebugContext context, ForeignStruct
         AbbrevCode abbrevCode = AbbrevCode.FOREIGN_STRUCT;
         log(context, "  [0x%08x] <1> Abbrev Number %d", pos, abbrevCode.ordinal());
         pos = writeAbbrevCode(abbrevCode, buffer, pos);
-        String typedefName = foreignStructTypeEntry.getTypedefName();
-        typedefName = uniqueDebugString(typedefName);
+        String typedefName = uniqueDebugString(foreignStructTypeEntry.getTypedefName());
         log(context, "  [0x%08x]     name  0x%x (%s)", pos, debugStringIndex(typedefName), typedefName);
         pos = writeStrSectionOffset(typedefName, buffer, pos);
         log(context, "  [0x%08x]     byte_size  0x%x", pos, size);
@@ -1022,8 +1021,9 @@ private int writeInstanceClassInfo(DebugContext context, ClassEntry classEntry,
         if (name == null) {
             name = classEntry.getTypeName().replace('.', '/') + ".java";
         }
+        name = uniqueDebugString(name);
         log(context, "  [0x%08x]     name  0x%x (%s)", pos, debugStringIndex(name), name);
-        pos = writeStrSectionOffset(uniqueDebugString(name), buffer, pos);
+        pos = writeStrSectionOffset(name, buffer, pos);
         String compilationDirectory = uniqueDebugString(dwarfSections.getCachePath());
         log(context, "  [0x%08x]     comp_dir  0x%x (%s)", pos, debugStringIndex(compilationDirectory), compilationDirectory);
         pos = writeStrSectionOffset(compilationDirectory, buffer, pos);
@@ -1318,8 +1318,7 @@ private int writeMethodDeclarations(DebugContext context, ClassEntry classEntry,
 
     private int writeMethodDeclaration(DebugContext context, ClassEntry classEntry, MethodEntry method, boolean isInlined, byte[] buffer, int p) {
         int pos = p;
-        String methodKey = method.getSymbolName();
-        String linkageName = uniqueDebugString(methodKey);
+        String linkageName = uniqueDebugString(method.getSymbolName());
         setMethodDeclarationIndex(method, pos);
         int modifiers = method.getModifiers();
         boolean isStatic = Modifier.isStatic(modifiers);
@@ -1409,7 +1408,7 @@ private int writeMethodParameterDeclaration(DebugContext context, LocalEntry par
         int pos = p;
         log(context, "  [0x%08x] method parameter declaration", pos);
         AbbrevCode abbrevCode;
-        String paramName = paramInfo.name();
+        String paramName = uniqueDebugString(paramInfo.name());
         TypeEntry paramType = paramInfo.type();
         int line = paramInfo.getLine();
         if (artificial) {
@@ -1422,7 +1421,7 @@ private int writeMethodParameterDeclaration(DebugContext context, LocalEntry par
         log(context, "  [0x%08x] <%d> Abbrev Number %d", pos, level, abbrevCode.ordinal());
         pos = writeAbbrevCode(abbrevCode, buffer, pos);
         log(context, "  [0x%08x]     name %s", pos, paramName);
-        pos = writeStrSectionOffset(uniqueDebugString(paramName), buffer, pos);
+        pos = writeStrSectionOffset(paramName, buffer, pos);
         if (abbrevCode == AbbrevCode.METHOD_PARAMETER_DECLARATION_2) {
             log(context, "  [0x%08x]     file 0x%x", pos, fileIdx);
             pos = writeAttrData2((short) fileIdx, buffer, pos);

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/SubstrateOptions.java

@@ -34,7 +34,6 @@
 
 import java.nio.file.InvalidPathException;
 import java.nio.file.Path;
-import java.nio.file.Paths;
 import java.util.List;
 import java.util.UUID;
 import java.util.function.Predicate;
@@ -1039,7 +1038,7 @@ public static boolean useDebugInfoGeneration() {
 
     private static void validateDebugInfoGenerationThreadCount(HostedOptionKey<Integer> optionKey) {
         int value = optionKey.getValue();
-        if (value <= 0) {
+        if (value < 0) {
             throw UserError.invalidOptionValue(optionKey, value, "The value must be bigger than 0");
         }
     }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/debug/SharedDebugInfoProvider.java

@@ -184,7 +184,7 @@ public abstract class SharedDebugInfoProvider implements DebugInfoProvider {
     protected final int referenceSize;
     protected final int pointerSize;
     protected final int objectAlignment;
-    protected final int reservedBitsMask;
+    protected final int reservedHubBitsMask;
 
     /**
      * The {@code SharedType} for {@link Class}. This is the type that represents a dynamic hub in
@@ -294,7 +294,7 @@ public SharedDebugInfoProvider(DebugContext debug, RuntimeConfiguration runtimeC
         this.pointerSize = ConfigurationValues.getTarget().wordSize;
         this.referenceSize = getObjectLayout().getReferenceSize();
         this.objectAlignment = getObjectLayout().getAlignment();
-        this.reservedBitsMask = Heap.getHeap().getObjectHeader().getReservedBitsMask();
+        this.reservedHubBitsMask = Heap.getHeap().getObjectHeader().getReservedHubBitsMask();
     }
 
     /**
@@ -334,8 +334,8 @@ public boolean isRuntimeCompilation() {
     }
 
     @Override
-    public int reservedBitsMask() {
-        return reservedBitsMask;
+    public int reservedHubBitsMask() {
+        return reservedHubBitsMask;
     }
 
     @Override
@@ -754,15 +754,14 @@ private void installHeaderTypeEntry() {
 
         // create the header type entry similar to a class entry without a super type
         ObjectLayout ol = getObjectLayout();
+        int hubOffset = ol.getHubOffset();
         headerTypeEntry = new HeaderTypeEntry(typeName, ol.getFirstFieldOffset(), typeSignature);
+        headerTypeEntry.setHubField(createSyntheticFieldEntry("hub", headerTypeEntry, hubType, hubOffset, ol.getHubSize()));
 
-        // add synthetic fields that hold the location of the hub and the idHash if it is in the
-        // object header
-        headerTypeEntry.addField(createSyntheticFieldEntry("hub", headerTypeEntry, hubType, ol.getHubOffset(), referenceSize));
-        if (ol.isIdentityHashFieldInObjectHeader()) {
-            int idHashSize = ol.sizeInBytes(JavaKind.Int);
-            headerTypeEntry.addField(createSyntheticFieldEntry("idHash", headerTypeEntry, (SharedType) metaAccess.lookupJavaType(JavaKind.Int.toJavaClass()), ol.getObjectHeaderIdentityHashOffset(),
-                            idHashSize));
+        if (hubOffset > 0) {
+            assert hubOffset == Integer.BYTES || hubOffset == Long.BYTES;
+            JavaKind kind = hubOffset == Integer.BYTES ? JavaKind.Int : JavaKind.Long;
+            headerTypeEntry.addField(createSyntheticFieldEntry("reserved", headerTypeEntry, (SharedType) metaAccess.lookupJavaType(kind.toJavaClass()), 0, hubOffset));
         }
     }
 

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

@@ -128,8 +128,8 @@ class NativeImageDebugInfoProvider extends SharedDebugInfoProvider {
         this.nativeLibs = nativeLibs;
 
         /* Offsets need to be adjusted relative to the heap base plus partition-specific offset. */
-        NativeImageHeap.ObjectInfo primitiveFields = heap.getObjectInfo(StaticFieldsSupport.getStaticPrimitiveFields());
-        NativeImageHeap.ObjectInfo objectFields = heap.getObjectInfo(StaticFieldsSupport.getStaticObjectFields());
+        NativeImageHeap.ObjectInfo primitiveFields = heap.getObjectInfo(StaticFieldsSupport.getCurrentLayerStaticPrimitiveFields());
+        NativeImageHeap.ObjectInfo objectFields = heap.getObjectInfo(StaticFieldsSupport.getCurrentLayerStaticObjectFields());
         primitiveStartOffset = (int) primitiveFields.getOffset();
         referenceStartOffset = (int) objectFields.getOffset();
 
@@ -381,7 +381,7 @@ protected Stream<Pair<SharedMethod, CompilationResult>> codeInfo() {
      */
     @Override
     protected Stream<Object> dataInfo() {
-        return heap.getObjects().stream().filter(obj -> obj.getPartition().getStartOffset() > 0).map(obj -> obj);
+        return heap.getObjects().stream().filter(obj -> !obj.getPartition().isFiller()).map(obj -> obj);
     }
 
     @Override

substratevm/src/com.oracle.svm.test/src/com/oracle/svm/test/debug/helper/test_cinterface.py

@@ -128,7 +128,7 @@ def test_print_from_java_shared_libray(self):
         exec_string = gdb_output("data")
         self.assertTrue(exec_string.startswith('my_data = {'), f"GDB output: '{exec_string}'")
         self.assertIn('f_primitive = 42', exec_string)
-        self.assertIn('f_array = int32_t [4] = {...}', exec_string)
+        self.assertIn('f_array = int [4] = {...}', exec_string)
         self.assertRegex(exec_string, f'f_cstr = 0x{hex_rexp.pattern} "Hello World"')
         self.assertRegex(exec_string, f'f_java_object_handle = 0x{hex_rexp.pattern}')
         self.assertRegex(exec_string, f'f_print_function = 0x{hex_rexp.pattern} <c_print>')