[GR-58932] Update gate to use GDB 14.2.

substratevm/ci/ci.jsonnet

@@ -117,23 +117,23 @@
 
   // START MAIN BUILD DEFINITION
   local task_dict = {
-    "style-fullbuild": mxgate("fullbuild,style,nativeimagehelp,check_libcontainer_annotations,check_libcontainer_namespace") + eclipse + jdt + maven + mx_build_exploded + gdb("10.2") + platform_spec(no_jobs) + platform_spec({
+    "style-fullbuild": mxgate("fullbuild,style,nativeimagehelp,check_libcontainer_annotations,check_libcontainer_namespace") + eclipse + jdt + maven + mx_build_exploded + gdb("14.2") + platform_spec(no_jobs) + platform_spec({
       // We could run the style gate on JDK 22 as well, and use old JDKs for running tools like StopBugs etc.,
       // but since we support JDK 21 anyways, there is not good reason to do so.
       "linux:amd64:jdk21": gate + t("30:00"),
     }),
     "basics": mxgate("build,helloworld,native_unittests,truffle_unittests,debuginfotest,hellomodule,java_agent") + maven + jsonschema + platform_spec(no_jobs) + platform_spec({
-      "linux:amd64:jdk-latest": gate + gdb("10.2") + t("55:00"),
+      "linux:amd64:jdk-latest": gate + gdb("14.2") + t("55:00"),
       "windows:amd64:jdk-latest": gate + t("1:30:00"),
     }) + variants({
       "optlevel:quickbuild": {
         "windows:amd64:jdk-latest": gate + t("1:30:00"),
       },
       "libc:musl_static": {
-        "linux:amd64:jdk-latest": gate + gdb("10.2") + t("55:00"),
+        "linux:amd64:jdk-latest": gate + gdb("14.2") + t("55:00"),
       },
       "java-compiler:ecj": {
-        "linux:amd64:jdk-latest": gate + gdb("10.2") + t("55:00"),
+        "linux:amd64:jdk-latest": gate + gdb("14.2") + t("55:00"),
       },
     }),
     "oraclejdk-helloworld": mxgate("build,helloworld,hellomodule") + maven + jsonschema + platform_spec(no_jobs) + platform_spec({

substratevm/debug/gdbpy/gdb-debughelpers.py

@@ -103,6 +103,7 @@ class SVMUtil:
     compression_shift = try_or_else(lambda: int(gdb.parse_and_eval('(int)__svm_compression_shift')), 0, gdb.error)
     reserved_bits_mask = try_or_else(lambda: int(gdb.parse_and_eval('(int)__svm_reserved_bits_mask')), 0, gdb.error)
     object_alignment = try_or_else(lambda: int(gdb.parse_and_eval('(int)__svm_object_alignment')), 0, gdb.error)
+    heap_base_regnum = try_or_else(lambda: int(gdb.parse_and_eval('(int)__svm_heap_base_regnum')), 0, gdb.error)
 
     string_type = gdb.lookup_type("java.lang.String")
     enum_type = gdb.lookup_type("java.lang.Enum")
@@ -124,39 +125,13 @@ class SVMUtil:
     deopt_stub_adr = 0
 
     @classmethod
-    def get_architecture(cls) -> str:
+    def get_heap_base(cls) -> gdb.Value:
         try:
-            arch_name = gdb.selected_frame().architecture().name()
+            return gdb.selected_frame().read_register(cls.heap_base_regnum)
         except gdb.error:
             # no frame available
-            arch_name = ""
-
-        if "x86-64" in arch_name:
-            return "amd64"
-        elif "aarch64" in arch_name:
-            return "arm64"
-        else:
-            return arch_name
-
-    @classmethod
-    def get_isolate_thread(cls) -> gdb.Value:
-        arch = cls.get_architecture()
-        if arch == "amd64":
-            return gdb.selected_frame().read_register('r15')
-        elif arch == "arm64":
-            return gdb.selected_frame().read_register('r28')
-        else:
             return cls.null
 
-    @classmethod
-    def get_heap_base(cls) -> gdb.Value:
-        arch = cls.get_architecture()
-        if arch == "amd64":
-            return gdb.selected_frame().read_register('r14')
-        elif arch == "arm64":
-            return gdb.selected_frame().read_register('r29')
-        return cls.null
-
     @classmethod
     def is_null(cls, obj: gdb.Value) -> bool:
         return adr(obj) == 0 or (cls.use_heap_base and adr(obj) == int(cls.get_heap_base()))
@@ -211,7 +186,7 @@ def get_compressed_oop(cls, obj: gdb.Value) -> int:
             compressed_oop -= int(SVMUtil.get_heap_base())
             assert compression_shift >= 0
             compressed_oop = compressed_oop >> compression_shift
-        if is_hub:
+        if is_hub and num_reserved_bits != 0:
             assert compression_shift >= 0
             compressed_oop = compressed_oop << compression_shift
             assert num_alignment_bits >= 0

substratevm/mx.substratevm/mx_substratevm.py

@@ -1028,18 +1028,17 @@ def build_debug_test(variant_name, image_name, extra_args):
 def _gdbdebughelperstest(native_image, path, with_isolates_only, args):
 
     # ====== check gdb version ======
-    # gdb-debughelperstest and this tests are designed for gdb 14 and higher with the python API enabled
-    # if we encounter a version lower than 14, we skip this tests
-    # TODO: remove when gdb 14 is available
+    # gdb-debughelperstests are designed for GDB 14 and higher with the GDB Python API enabled
+    # abort if we encounter a version lower than 14 or the GDB Python API is not available
     gdb_version = mx.run([
         os.environ.get('GDB_BIN', 'gdb'), '--nx', '-q',
-        '-ex', 'py gdb.execute("quit " + gdb.VERSION.split(".")[0])',  # try to get gdb version via python
-        '-ex', 'quit 0'  # fallback gdb exit
+        '-ex', 'py gdb.execute("quit " + gdb.VERSION.split(".")[0])',  # try to get GDB version via Python API
+        '-ex', 'quit 0'  # fallback GDB exit
         ]
         , nonZeroIsFatal=False)
     if gdb_version < 14:
-        mx.warn(f"Skipping gdb-debughelpers tests (Requires gdb version 14, found gdb version {gdb_version}).")
-        return
+        mx.abort('gdb-debughelpers test requires at least GDB version 14 with the GDB Python API enabled, ' +
+                 ('GDB Python API is not available.' if gdb_version == 0 else f'found GDB version {gdb_version}.'))
     # ===============================
 
     test_proj = mx.dependency('com.oracle.svm.test')
@@ -1108,6 +1107,9 @@ def run_debug_test(image_name: str, testfile: str, source_path: str, with_isolat
                 '-H:DebugInfoSourceSearchPath=' + source_path,
             ]) + extra_args
 
+            if '--shared' in extra_args:
+                build_args = [arg for arg in build_args if arg not in ['--libc=musl', '--static']]
+
             if not with_isolates:
                 build_args += svm_experimental_options(['-H:-SpawnIsolates'])
 
@@ -1695,7 +1697,7 @@ def gdbdebughelperstest(args, config=None):
     builds and tests gdb-debughelpers.py with multiple native images with debuginfo
     """
     parser = ArgumentParser(prog='mx gdbdebughelperstest')
-    all_args = ['--output-path', '--with-isolates-only', '--build-only', '--test-only']
+    all_args = ['--output-path', '--with-isolates-only']
     masked_args = [_mask(arg, all_args) for arg in args]
     parser.add_argument(all_args[0], metavar='<output-path>', nargs=1, help='Path of the generated image', default=[join(svmbuild_dir(), "gdbdebughelperstest")])
     parser.add_argument(all_args[1], action='store_true', help='Only build and test the native image with isolates')

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

@@ -30,6 +30,7 @@
 import java.util.function.Function;
 import java.util.function.Supplier;
 
+import com.oracle.svm.core.ReservedRegisters;
 import org.graalvm.nativeimage.ImageSingletons;
 import org.graalvm.nativeimage.Platform;
 import org.graalvm.word.PointerBase;
@@ -121,10 +122,12 @@ public void beforeAnalysis(BeforeAnalysisAccess access) {
         CGlobalData<PointerBase> useHeapBase = CGlobalDataFactory.createWord(WordFactory.unsigned(compressEncoding.hasBase() ? 1 : 0), "__svm_use_heap_base");
         CGlobalData<PointerBase> reservedBitsMask = CGlobalDataFactory.createWord(WordFactory.unsigned(Heap.getHeap().getObjectHeader().getReservedBitsMask()), "__svm_reserved_bits_mask");
         CGlobalData<PointerBase> objectAlignment = CGlobalDataFactory.createWord(WordFactory.unsigned(ConfigurationValues.getObjectLayout().getAlignment()), "__svm_object_alignment");
+        CGlobalData<PointerBase> heapBaseRegnum = CGlobalDataFactory.createWord(WordFactory.unsigned(ReservedRegisters.singleton().getHeapBaseRegister().number), "__svm_heap_base_regnum");
         CGlobalDataFeature.singleton().registerWithGlobalHiddenSymbol(compressionShift);
         CGlobalDataFeature.singleton().registerWithGlobalHiddenSymbol(useHeapBase);
         CGlobalDataFeature.singleton().registerWithGlobalHiddenSymbol(reservedBitsMask);
         CGlobalDataFeature.singleton().registerWithGlobalHiddenSymbol(objectAlignment);
+        CGlobalDataFeature.singleton().registerWithGlobalHiddenSymbol(heapBaseRegnum);
     }
 
     @Override

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

@@ -47,15 +47,21 @@ def tearDown(self):
     def test_instanceMethod_named_classloader(self):
         gdb_set_breakpoint("com.oracle.svm.test.missing.classes.TestClass::instanceMethod")
         gdb_continue()  # named classloader is called first in test code
-        self.assertRegex(gdb_output("this"), rf'testClassLoader_{hex_rexp.pattern}::com\.oracle\.svm\.test\.missing\.classes\.TestClass = {{instanceField = null}}')
+        exec_string = gdb_output("this")
+        self.assertTrue(exec_string.startswith("testClassLoader_"), f"GDB output: '{exec_string}'")  # check for correct class loader
+        self.assertIn("::com.oracle.svm.test.missing.classes.TestClass = {", exec_string)  # check if TestClass has a namespace
+        self.assertIn("instanceField = null", exec_string)
         gdb_output("$other=(('java.lang.Object' *)this)")
         self.assertIn("null", gdb_advanced_print("$other.instanceField"))  # force a typecast
 
     def test_instanceMethod_unnamed_classloader(self):
         gdb_set_breakpoint("com.oracle.svm.test.missing.classes.TestClass::instanceMethod")
         gdb_continue()  # skip named classloader
         gdb_continue()  # unnamed classloader is called second in test code
-        self.assertRegex(gdb_output("this"), rf'URLClassLoader_{hex_rexp.pattern}::com\.oracle\.svm\.test\.missing\.classes\.TestClass = {{instanceField = null}}')
+        exec_string = gdb_output("this")
+        self.assertTrue(exec_string.startswith("URLClassLoader_"), f"GDB output: '{exec_string}'")  # check for correct class loader
+        self.assertIn("::com.oracle.svm.test.missing.classes.TestClass = {", exec_string)  # check if TestClass has a namespace
+        self.assertIn("instanceField = null", exec_string)
         gdb_output("$other=(('java.lang.Object' *)this)")
         self.assertIn("null", gdb_advanced_print("$other.instanceField"))  # force a typecast
 

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

@@ -185,11 +185,17 @@ def test_svm_print_field_limit(self):
         gdb_set_breakpoint("com.oracle.svm.test.debug.helper.PrettyPrinterTest::testObject")
         gdb_run()
         gdb_set_param('svm-print-field-limit', '1')
-        self.assertIn('f7 = "test string"', gdb_output('object'))
-        self.assertIn('f8 = ...', gdb_output('object'))
+        exec_string_1 = gdb_output('object')
+        self.assertTrue(exec_string_1.startswith('com.oracle.svm.test.debug.helper.PrettyPrinterTest$ExampleClass = {'))
+        self.assertEqual(exec_string_1.count('='), 3)  # 3 '=' signs, one each for object, first field, cut off field
+        self.assertTrue(exec_string_1.endswith('= ...}'))
         gdb_set_param('svm-print-field-limit', 'unlimited')
-        self.assertIn('f7 = "test string"', gdb_output('object'))
-        self.assertIn('f8 = Monday(0)', gdb_output('object'))
+        exec_string = gdb_output('object')
+        # check if at least 2 member fields are printed
+        self.assertIn('f7 = "test string"', exec_string)
+        self.assertIn('f8 = Monday(0)', exec_string)
+        self.assertNotIn('= ...', exec_string)
+        self.assertNotEqual(exec_string, exec_string_1)
 
     def test_svm_print_depth_limit(self):
         gdb_set_breakpoint("com.oracle.svm.test.debug.helper.PrettyPrinterTest::testObject")