Disable TestLldbGdbServer on Dwarf2 and clang versions below 14

[rastogishubham]

Summary

We have been noticing issues with the lldb bots on builds using versions below clang 14 and dwarf 2, so to make sure we can get clean builds for a while, we are disabling the tests for those versions

[aprantl]

From a pragmatic point of view this LGTM. It would be great if someone with an interest in lldb server could look into how to make this test more reliable. Thanks!

[labath]

What's the failure mode?

I find it highly unlikely that compiler or dwarf info version has anything to do with the failures. lldb-server tests don't read debug info at all and they might just as well be compiled with -g0.

The only unusual thing I can think of which makes these tests different from all other lldb-server tests is that there is so many of them in the same file. Are you sure you're not just running into some per-test timeout limit?

[labath]

Also, if you're running these tests on some kind of a matrix bot, maybe you can just skip all lldb-server tests completely (dotest.py --skip-categories llgs). Given that they don't use debug info, they definitely don't provide any useful signal in these contexts.

[aprantl]

In D118395#3278431, @labath wrote:

Also, if you're running these tests on some kind of a matrix bot, maybe you can just skip all lldb-server tests completely (dotest.py --skip-categories llgs). Given that they don't use debug info, they definitely don't provide any useful signal in these contexts.

That's a great point! I'll change the config to do that.

[aprantl]

Done in zorg and reverted this patch.

lldb/test/API/tools/lldb-server/TestLldbGdbServer.py

 from lldbsuite.test.lldbdwarf import *
 from lldbsuite.test import lldbutil, lldbplatformutil
 
 
 class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
 
     mydir = TestBase.compute_mydir(__file__)
 
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_thread_suffix_supported(self):
         server = self.connect_to_debug_monitor()
         self.assertIsNotNone(server)
 
         self.do_handshake()
         self.test_sequence.add_log_lines(
             ["lldb-server <  26> read packet: $QThreadSuffixSupported#e4",
              "lldb-server <   6> send packet: $OK#9a"],
             True)
 
         self.expect_gdbremote_sequence()
 
 
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_list_threads_in_stop_reply_supported(self):
         server = self.connect_to_debug_monitor()
         self.assertIsNotNone(server)
 
         self.do_handshake()
         self.test_sequence.add_log_lines(
             ["lldb-server <  27> read packet: $QListThreadsInStopReply#21",
              "lldb-server <   6> send packet: $OK#9a"],
             True)
         self.expect_gdbremote_sequence()
 
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<'3 '4'])
     def test_c_packet_works(self):
         self.build()
         procs = self.prep_debug_monitor_and_inferior()
         self.test_sequence.add_log_lines(
             ["read packet: $c#63",
              "send packet: $W00#00"],
             True)
 
         self.expect_gdbremote_sequence()
 
     @skipIfWindows # No pty support to test any inferior output
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_inferior_print_exit(self):
         self.build()
         procs = self.prep_debug_monitor_and_inferior(
                 inferior_args=["hello, world"])
         self.test_sequence.add_log_lines(
             ["read packet: $vCont;c#a8",
              {"type": "output_match", "regex": self.maybe_strict_output_regex(r"hello, world\r\n")},
              "send packet: $W00#00"],
             True)
 
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_first_launch_stop_reply_thread_matches_first_qC(self):
         self.build()
         procs = self.prep_debug_monitor_and_inferior()
         self.test_sequence.add_log_lines(["read packet: $qC#00",
                                           {"direction": "send",
                                            "regex": r"^\$QC([0-9a-fA-F]+)#",
                                            "capture": {1: "thread_id_QC"}},
                                           "read packet: $?#00",
                                           {"direction": "send",
                                               "regex": r"^\$T[0-9a-fA-F]{2}thread:([0-9a-fA-F]+)",
                                               "capture": {1: "thread_id_?"}}],
                                          True)
         context = self.expect_gdbremote_sequence()
         self.assertEqual(context.get("thread_id_QC"), context.get("thread_id_?"))
 
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_attach_commandline_continue_app_exits(self):
         self.build()
         self.set_inferior_startup_attach()
         procs = self.prep_debug_monitor_and_inferior()
         self.test_sequence.add_log_lines(
             ["read packet: $vCont;c#a8",
              "send packet: $W00#00"],
             True)
def test_attach_commandline_continue_app_exits(self):
             self.assertIsNotNone(poll_result)
 
         # Where possible, verify at the system level that the process is not
         # running.
         self.assertFalse(
             lldbgdbserverutils.process_is_running(
                 procs["inferior"].pid, False))
 
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qRegisterInfo_returns_one_valid_result(self):
         self.build()
         self.prep_debug_monitor_and_inferior()
         self.test_sequence.add_log_lines(
             ["read packet: $qRegisterInfo0#00",
              {"direction": "send", "regex": r"^\$(.+);#[0-9A-Fa-f]{2}", "capture": {1: "reginfo_0"}}],
             True)
 
         # Run the stream
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         reg_info_packet = context.get("reginfo_0")
         self.assertIsNotNone(reg_info_packet)
         self.assert_valid_reg_info(
             lldbgdbserverutils.parse_reg_info_response(reg_info_packet))
 
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qRegisterInfo_returns_all_valid_results(self):
         self.build()
         self.prep_debug_monitor_and_inferior()
         self.add_register_info_collection_packets()
 
         # Run the stream.
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         # Validate that each register info returned validates.
         for reg_info in self.parse_register_info_packets(context):
             self.assert_valid_reg_info(reg_info)
 
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qRegisterInfo_contains_required_generics_debugserver(self):
         self.build()
         self.prep_debug_monitor_and_inferior()
         self.add_register_info_collection_packets()
 
         # Run the packet stream.
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
def test_qRegisterInfo_contains_required_generics_debugserver(self):
             self.assertIn('fp', generic_regs)
 
         # Ensure we have a stack pointer register.
         self.assertIn('sp', generic_regs)
 
         # Ensure we have a flags register.
         self.assertIn('flags', generic_regs)
 
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qRegisterInfo_contains_at_least_one_register_set(self):
         self.build()
         self.prep_debug_monitor_and_inferior()
         self.add_register_info_collection_packets()
 
         # Run the packet stream.
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
def targetHasAVX(self):
         f = open(cpuinfo_path, 'r')
         cpuinfo = f.read()
         f.close()
         return " avx " in cpuinfo
 
     @expectedFailureAll(oslist=["windows"]) # no avx for now.
     @skipIf(archs=no_match(['amd64', 'i386', 'x86_64']))
     @add_test_categories(["llgs"])
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qRegisterInfo_contains_avx_registers(self):
         self.build()
         self.prep_debug_monitor_and_inferior()
         self.add_register_info_collection_packets()
 
         # Run the packet stream.
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
def qThreadInfo_contains_thread(self):
 
         # Gather threadinfo entries.
         threads = self.parse_threadinfo_packets(context)
         self.assertIsNotNone(threads)
 
         # We should have exactly one thread.
         self.assertEqual(len(threads), 1)
 
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qThreadInfo_contains_thread_launch(self):
         self.build()
         self.set_inferior_startup_launch()
         self.qThreadInfo_contains_thread()
 
     @expectedFailureAll(oslist=["windows"]) # expect one more thread stopped
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qThreadInfo_contains_thread_attach(self):
         self.build()
         self.set_inferior_startup_attach()
         self.qThreadInfo_contains_thread()
 
     def qThreadInfo_matches_qC(self):
         procs = self.prep_debug_monitor_and_inferior()
 
def qThreadInfo_matches_qC(self):
         # We should have a valid thread_id from $QC.
         QC_thread_id_hex = context.get("thread_id")
         self.assertIsNotNone(QC_thread_id_hex)
         QC_thread_id = int(QC_thread_id_hex, 16)
 
         # Those two should be the same.
         self.assertEqual(threads[0], QC_thread_id)
 
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qThreadInfo_matches_qC_launch(self):
         self.build()
         self.set_inferior_startup_launch()
         self.qThreadInfo_matches_qC()
 
     @expectedFailureAll(oslist=["windows"]) # expect one more thread stopped
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qThreadInfo_matches_qC_attach(self):
         self.build()
         self.set_inferior_startup_attach()
         self.qThreadInfo_matches_qC()
 
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_p_returns_correct_data_size_for_each_qRegisterInfo_launch(self):
         self.build()
         self.set_inferior_startup_launch()
         procs = self.prep_debug_monitor_and_inferior()
         self.add_register_info_collection_packets()
 
         # Run the packet stream.
         context = self.expect_gdbremote_sequence()
def Hg_switches_to_3_threads(self, pass_pid=False):
             self.assertIsNotNone(context)
 
             # Verify the thread id.
             self.assertIsNotNone(context.get("thread_id"))
             self.assertEqual(int(context.get("thread_id"), 16), thread)
 
     @expectedFailureAll(oslist=["windows"]) # expect 4 threads
     @skipIf(compiler="clang", compiler_version=['<', '11.0'])
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_Hg_switches_to_3_threads_launch(self):
         self.build()
         self.set_inferior_startup_launch()
         self.Hg_switches_to_3_threads()
 
     @expectedFailureAll(oslist=["windows"]) # expecting one more thread
     @skipIf(compiler="clang", compiler_version=['<', '11.0'])
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_Hg_switches_to_3_threads_attach(self):
         self.build()
         self.set_inferior_startup_attach()
         self.Hg_switches_to_3_threads()
 
     @expectedFailureAll(oslist=["windows"]) # expect 4 threads
     @add_test_categories(["llgs"])
     @skipIf(compiler="clang", compiler_version=['<', '11.0'])
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_Hg_switches_to_3_threads_attach_pass_correct_pid(self):
         self.build()
         self.set_inferior_startup_attach()
         self.Hg_switches_to_3_threads(pass_pid=True)
 
     def Hg_fails_on_pid(self, pass_pid):
         # Start the inferior.
         procs = self.prep_debug_monitor_and_inferior(
def Hg_fails_on_pid(self, pass_pid):
             ["read packet: $Hg{0}{1:x}#00".format(pid_str, thread),  # Set current thread.
              "send packet: $Eff#00"],
             True)
 
         self.expect_gdbremote_sequence()
 
     @expectedFailureAll(oslist=["windows"])
     @add_test_categories(["llgs"])
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_Hg_fails_on_another_pid(self):
         self.build()
         self.set_inferior_startup_launch()
         self.Hg_fails_on_pid(1)
 
     @expectedFailureAll(oslist=["windows"])
     @add_test_categories(["llgs"])
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_Hg_fails_on_zero_pid(self):
         self.build()
         self.set_inferior_startup_launch()
         self.Hg_fails_on_pid(0)
 
     @expectedFailureAll(oslist=["windows"])
     @add_test_categories(["llgs"])
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_Hg_fails_on_minus_one_pid(self):
         self.build()
         self.set_inferior_startup_launch()
         self.Hg_fails_on_pid(-1)
 
     def Hc_then_Csignal_signals_correct_thread(self, segfault_signo):
         # NOTE only run this one in inferior-launched mode: we can't grab inferior stdout when running attached,
         # and the test requires getting stdout from the exe.
def Hc_then_Csignal_signals_correct_thread(self, segfault_signo):
             self.assertIsNotNone(post_handle_thread_id)
             post_handle_thread_id = int(post_handle_thread_id, 16)
             self.assertEqual(post_handle_thread_id, print_thread_id)
 
     @expectedFailureDarwin
     @skipIfWindows # no SIGSEGV support
     @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48419")
     @expectedFailureNetBSD
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_Hc_then_Csignal_signals_correct_thread_launch(self):
         self.build()
         self.set_inferior_startup_launch()
 
         if self.platformIsDarwin():
             # Darwin debugserver translates some signals like SIGSEGV into some gdb
             # expectations about fixed signal numbers.
             self.Hc_then_Csignal_signals_correct_thread(self.TARGET_EXC_BAD_ACCESS)
         else:
             self.Hc_then_Csignal_signals_correct_thread(
                 lldbutil.get_signal_number('SIGSEGV'))
 
     @skipIfWindows # No pty support to test any inferior output
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_m_packet_reads_memory(self):
         self.build()
         self.set_inferior_startup_launch()
         # This is the memory we will write into the inferior and then ensure we
         # can read back with $m.
         MEMORY_CONTENTS = "Test contents 0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz"
 
         # Start up the inferior.
def test_m_packet_reads_memory(self):
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         # Ensure what we read from inferior memory is what we wrote.
         self.assertIsNotNone(context.get("read_contents"))
         read_contents = seven.unhexlify(context.get("read_contents"))
         self.assertEqual(read_contents, MEMORY_CONTENTS)
 
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qMemoryRegionInfo_is_supported(self):
         self.build()
         self.set_inferior_startup_launch()
         # Start up the inferior.
         procs = self.prep_debug_monitor_and_inferior()
 
         # Ask if it supports $qMemoryRegionInfo.
         self.test_sequence.add_log_lines(
             ["read packet: $qMemoryRegionInfo#00",
              "send packet: $OK#00"
              ], True)
         self.expect_gdbremote_sequence()
 
     @skipIfWindows # No pty support to test any inferior output
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qMemoryRegionInfo_reports_code_address_as_executable(self):
         self.build()
         self.set_inferior_startup_launch()
 
         # Start up the inferior.
         procs = self.prep_debug_monitor_and_inferior(
             inferior_args=["get-code-address-hex:hello", "sleep:5"])
 
def test_qMemoryRegionInfo_reports_code_address_as_executable(self):
         self.assertIn("permissions", mem_region_dict)
         self.assertIn("r", mem_region_dict["permissions"])
         self.assertIn("x", mem_region_dict["permissions"])
 
         # Ensure the start address and size encompass the address we queried.
         self.assert_address_within_memory_region(code_address, mem_region_dict)
 
     @skipIfWindows # No pty support to test any inferior output
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qMemoryRegionInfo_reports_stack_address_as_rw(self):
         self.build()
         self.set_inferior_startup_launch()
 
         # Start up the inferior.
         procs = self.prep_debug_monitor_and_inferior(
             inferior_args=["get-stack-address-hex:", "sleep:5"])
 
def test_qMemoryRegionInfo_reports_stack_address_as_rw(self):
         self.assertIn("r", mem_region_dict["permissions"])
         self.assertIn("w", mem_region_dict["permissions"])
 
         # Ensure the start address and size encompass the address we queried.
         self.assert_address_within_memory_region(
             stack_address, mem_region_dict)
 
     @skipIfWindows # No pty support to test any inferior output
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qMemoryRegionInfo_reports_heap_address_as_rw(self):
         self.build()
         self.set_inferior_startup_launch()
 
         # Start up the inferior.
         procs = self.prep_debug_monitor_and_inferior(
             inferior_args=["get-heap-address-hex:", "sleep:5"])
 
def breakpoint_set_and_remove_work(self, want_hardware):
                 # And wait for program completion.
                 {"direction": "send", "regex": r"^\$W00(.*)#[0-9a-fA-F]{2}$"},
             ], True)
 
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
     @skipIfWindows # No pty support to test any inferior output
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_software_breakpoint_set_and_remove_work(self):
         if self.getArchitecture() == "arm":
             # TODO: Handle case when setting breakpoint in thumb code
             self.build(dictionary={'CFLAGS_EXTRAS': '-marm'})
         else:
             self.build()
         self.set_inferior_startup_launch()
         self.breakpoint_set_and_remove_work(want_hardware=False)
 
     @skipUnlessPlatform(oslist=['linux'])
     @skipIf(archs=no_match(['arm', 'aarch64']))
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_hardware_breakpoint_set_and_remove_work(self):
         if self.getArchitecture() == "arm":
             # TODO: Handle case when setting breakpoint in thumb code
             self.build(dictionary={'CFLAGS_EXTRAS': '-marm'})
         else:
             self.build()
         self.set_inferior_startup_launch()
         self.breakpoint_set_and_remove_work(want_hardware=True)
 
     def get_qSupported_dict(self, features=[]):
         self.build()
         self.set_inferior_startup_launch()
 
         # Start up the stub and start/prep the inferior.
         procs = self.prep_debug_monitor_and_inferior()
         self.add_qSupported_packets(features)
 
         # Run the packet stream.
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         # Retrieve the qSupported features.
         return self.parse_qSupported_response(context)
 
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qSupported_returns_known_stub_features(self):
         supported_dict = self.get_qSupported_dict()
         self.assertIsNotNone(supported_dict)
         self.assertTrue(len(supported_dict) > 0)
 
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<',3'4'])
     def test_qSupported_auvx(self):
         expected = ('+' if lldbplatformutil.getPlatform()
                     in ["freebsd", "linux", "netbsd"] else '-')
         supported_dict = self.get_qSupported_dict()
         self.assertEqual(supported_dict.get('qXfer:auxv:read', '-'), expected)
 
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qSupported_libraries_svr4(self):
         expected = ('+' if lldbplatformutil.getPlatform()
                     in ["freebsd", "linux", "netbsd"] else '-')
         supported_dict = self.get_qSupported_dict()
         self.assertEqual(supported_dict.get('qXfer:libraries-svr4:read', '-'),
                          expected)
 
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qSupported_siginfo_read(self):
         expected = ('+' if lldbplatformutil.getPlatform()
                     in ["freebsd", "linux"] else '-')
         supported_dict = self.get_qSupported_dict()
         self.assertEqual(supported_dict.get('qXfer:siginfo:read', '-'),
                          expected)
 
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qSupported_QPassSignals(self):
         expected = ('+' if lldbplatformutil.getPlatform()
                     in ["freebsd", "linux", "netbsd"] else '-')
         supported_dict = self.get_qSupported_dict()
         self.assertEqual(supported_dict.get('QPassSignals', '-'), expected)
 
     @add_test_categories(["fork"])
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qSupported_fork_events(self):
         supported_dict = (
             self.get_qSupported_dict(['multiprocess+', 'fork-events+']))
         self.assertEqual(supported_dict.get('multiprocess', '-'), '+')
         self.assertEqual(supported_dict.get('fork-events', '-'), '+')
         self.assertEqual(supported_dict.get('vfork-events', '-'), '-')
 
     @add_test_categories(["fork"])
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qSupported_fork_events_without_multiprocess(self):
         supported_dict = (
             self.get_qSupported_dict(['fork-events+']))
         self.assertEqual(supported_dict.get('multiprocess', '-'), '-')
         self.assertEqual(supported_dict.get('fork-events', '-'), '-')
         self.assertEqual(supported_dict.get('vfork-events', '-'), '-')
 
     @add_test_categories(["fork"])
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qSupported_vfork_events(self):
         supported_dict = (
             self.get_qSupported_dict(['multiprocess+', 'vfork-events+']))
         self.assertEqual(supported_dict.get('multiprocess', '-'), '+')
         self.assertEqual(supported_dict.get('fork-events', '-'), '-')
         self.assertEqual(supported_dict.get('vfork-events', '-'), '+')
 
     @add_test_categories(["fork"])
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qSupported_vfork_events_without_multiprocess(self):
         supported_dict = (
             self.get_qSupported_dict(['vfork-events+']))
         self.assertEqual(supported_dict.get('multiprocess', '-'), '-')
         self.assertEqual(supported_dict.get('fork-events', '-'), '-')
         self.assertEqual(supported_dict.get('vfork-events', '-'), '-')
 
     # We need to be able to self.runCmd to get cpuinfo,
     # which is not possible when using a remote platform.
     @skipIfRemote
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qSupported_memory_tagging(self):
         supported_dict = self.get_qSupported_dict()
         self.assertEqual(supported_dict.get("memory-tagging", '-'),
                          '+' if self.isAArch64MTE() else '-')
 
     @skipIfWindows # No pty support to test any inferior output
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_written_M_content_reads_back_correctly(self):
         self.build()
         self.set_inferior_startup_launch()
 
         TEST_MESSAGE = "Hello, memory"
 
         # Start up the stub and start/prep the inferior.
         procs = self.prep_debug_monitor_and_inferior(
def test_written_M_content_reads_back_correctly(self):
         # Ensure what we read from inferior memory is what we wrote.
         printed_message = context.get("printed_message")
         self.assertIsNotNone(printed_message)
         self.assertEqual(printed_message, TEST_MESSAGE + "X")
 
     # Note: as of this moment, a hefty number of the GPR writes are failing with E32 (everything except rax-rdx, rdi, rsi, rbp).
     # Come back to this.  I have the test rigged to verify that at least some
     # of the bit-flip writes work.
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_P_writes_all_gpr_registers(self):
         self.build()
         self.set_inferior_startup_launch()
 
         # Start inferior debug session, grab all register info.
         procs = self.prep_debug_monitor_and_inferior(inferior_args=["sleep:2"])
         self.add_register_info_collection_packets()
         self.add_process_info_collection_packets()
def test_P_writes_all_gpr_registers(self):
         (successful_writes, failed_writes) = self.flip_all_bits_in_each_register_value(
             gpr_reg_infos, endian)
         self.trace("successful writes: {}, failed writes: {}".format(successful_writes, failed_writes))
         self.assertTrue(successful_writes > 0)
 
     # Note: as of this moment, a hefty number of the GPR writes are failing
     # with E32 (everything except rax-rdx, rdi, rsi, rbp).
     @skipIfWindows
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_P_and_p_thread_suffix_work(self):
         self.build()
         self.set_inferior_startup_launch()
 
         # Startup the inferior with three threads.
         procs = self.prep_debug_monitor_and_inferior(
             inferior_args=["thread:new", "thread:new"])
         self.add_thread_suffix_request_packets()
def test_P_and_p_thread_suffix_work(self):
                 endian, p_response)
 
             # Make sure we read back what we wrote.
             self.assertEqual(read_value, expected_reg_values[thread_index])
             thread_index += 1
 
     @skipIfWindows # No pty support to test any inferior output
     @add_test_categories(["llgs"])
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['3', '4'])
     def test_launch_via_A(self):
         self.build()
         exe_path = self.getBuildArtifact("a.out")
         args = [exe_path, "stderr:arg1", "stderr:arg2", "stderr:arg3"]
         hex_args = [binascii.b2a_hex(x.encode()).decode() for x in args]
 
         server = self.connect_to_debug_monitor()
         self.assertIsNotNone(server)
def test_launch_via_A(self):
              "send packet: $W00#00"],
             True)
         context = self.expect_gdbremote_sequence()
         self.assertEqual(context["O_content"],
                          b'arg1\r\narg2\r\narg3\r\n')
 
     @skipIfWindows # No pty support to test any inferior output
     @add_test_categories(["llgs"])
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<',3'4'])
     def test_launch_via_vRun(self):
         self.build()
         exe_path = self.getBuildArtifact("a.out")
         args = [exe_path, "stderr:arg1", "stderr:arg2", "stderr:arg3"]
         hex_args = [binascii.b2a_hex(x.encode()).decode() for x in args]
 
         server = self.connect_to_debug_monitor()
         self.assertIsNotNone(server)
         self.do_handshake()
         self.test_sequence.add_log_lines(
             ["read packet: $vRun;%s;%s;%s;%s#00" % tuple(hex_args),
              {"direction": "send",
               "regex": r"^\$T([0-9a-fA-F]+)"},
              "read packet: $c#00",
              "send packet: $W00#00"],
             True)
         context = self.expect_gdbremote_sequence()
         self.assertEqual(context["O_content"],
                          b'arg1\r\narg2\r\narg3\r\n')
 
     @add_test_categories(["llgs"])
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_launch_via_vRun_no_args(self):
         self.build()
         exe_path = self.getBuildArtifact("a.out")
         hex_path = binascii.b2a_hex(exe_path.encode()).decode()
 
         server = self.connect_to_debug_monitor()
         self.assertIsNotNone(server)
         self.do_handshake()
         self.test_sequence.add_log_lines(
             ["read packet: $vRun;%s#00" % (hex_path,),
              {"direction": "send",
               "regex": r"^\$T([0-9a-fA-F]+)"},
              "read packet: $c#00",
              "send packet: $W00#00"],
             True)
         self.expect_gdbremote_sequence()
 
     @skipIfWindows # No pty support to test any inferior output
     @add_test_categories(["llgs"])
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['3', '4'])
     def test_QEnvironment(self):
         self.build()
         exe_path = self.getBuildArtifact("a.out")
         env = {"FOO": "test", "BAR": "a=z"}
         args = [exe_path, "print-env:FOO", "print-env:BAR"]
         hex_args = [binascii.b2a_hex(x.encode()).decode() for x in args]
 
         server = self.connect_to_debug_monitor()
def test_QEnvironment(self):
              "read packet: $c#00",
              "send packet: $W00#00"],
             True)
         context = self.expect_gdbremote_sequence()
         self.assertEqual(context["O_content"], b"test\r\na=z\r\n")
 
     @skipIfWindows # No pty support to test any inferior output
     @add_test_categories(["llgs"])
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_QEnvironmentHexEncoded(self):
         self.build()
         exe_path = self.getBuildArtifact("a.out")
         env = {"FOO": "test", "BAR": "a=z", "BAZ": "a*}#z"}
         args = [exe_path, "print-env:FOO", "print-env:BAR", "print-env:BAZ"]
         hex_args = [binascii.b2a_hex(x.encode()).decode() for x in args]
 
         server = self.connect_to_debug_monitor()
def test_QEnvironmentHexEncoded(self):
              "read packet: $c#00",
              "send packet: $W00#00"],
             True)
         context = self.expect_gdbremote_sequence()
         self.assertEqual(context["O_content"], b"test\r\na=z\r\na*}#z\r\n")
 
     @skipUnlessPlatform(oslist=["freebsd", "linux"])
     @add_test_categories(["llgs"])
+    @skipIf(compiler="clang", compiler_version=['<', '14.0'])
+    @skipIf(dwarf_version=['<', '3'])
     def test_qXfer_siginfo_read(self):
         self.build()
         self.set_inferior_startup_launch()
         procs = self.prep_debug_monitor_and_inferior(
                 inferior_args=["thread:segfault", "thread:new", "sleep:10"])
         self.test_sequence.add_log_lines(["read packet: $c#63"], True)
         self.expect_gdbremote_sequence()