[lldb] [test] Use raise(SIGSTOP) instead of trap in fork tests

[mgorny]

Summary

Replace the use of "trap" with a new "stop" command in fork tests,
that maps to raise(SIGSTOP). Since traps do not increment PC on some
architectures (notably ARM), using traps would require special logic
to increment it while testing. Using SIGSTOP avoids the problem
and is probably more logical, given that the purpose of the "trap"s
was to simply stop the inferior at a synchronization point. This fixes
tests on AArch64 (and possibly ARM, I'll update XFAILs when it is
confirmed by the buildbot).

Sponsored by: The FreeBSD Foundation

[labath]

lldb/packages/Python/lldbsuite/test/tools/lldb-server/fork_testbase.py

157

SIGSTOP is 17 (0x11) on macos. Maybe you could check for "reason:signal" instead?

[mgorny]

lldb/packages/Python/lldbsuite/test/tools/lldb-server/fork_testbase.py

157

I don't think macos is really relevant but you're right. I've forgotten that we haven't changed lldb-server to use normalized signos. I'll fix all the tests not to rely on specific signos.

[mgorny]

lldb/test/API/tools/lldb-server/main.cpp

357

Changing this to arg == "stop", as right now it unintentionally matches stuff like "stop-me-now" that other tests use as output.

lldb/packages/Python/lldbsuite/test/tools/lldb-server/fork_testbase.py

 import gdbremote_testcase
 
 
 class GdbRemoteForkTestBase(gdbremote_testcase.GdbRemoteTestCaseBase):
     fork_regex = ("[$]T05thread:p([0-9a-f]+)[.]([0-9a-f]+);.*"
                   "{}:p([0-9a-f]+)[.]([0-9a-f]+).*")
     fork_regex_nonstop = ("%Stop:T05thread:p([0-9a-f]+)[.]([0-9a-f]+);.*"
                           "{}:p([0-9a-f]+)[.]([0-9a-f]+).*")
     fork_capture = {1: "parent_pid", 2: "parent_tid",
                     3: "child_pid", 4: "child_tid"}
+    stop_regex_base = "T[0-9a-fA-F]{{2}}thread:p{}.{};.*reason:signal.*"
+    stop_regex = "^[$]" + stop_regex_base
 
     def start_fork_test(self, args, variant="fork", nonstop=False):
         self.build()
         self.prep_debug_monitor_and_inferior(inferior_args=args)
         self.add_qSupported_packets(["multiprocess+",
                                      "{}-events+".format(variant)])
         ret = self.expect_gdbremote_sequence()
         self.assertIn("{}-events+".format(variant), ret["qSupported_response"])
def vkill_test(self, kill_parent=False, kill_child=False, nonstop=False):
             # check parent PID/TID
             "read packet: $Hgp{}.{}#00".format(parent_pid, parent_tid),
             "send packet: ${}#00".format("Eff" if kill_parent else "OK"),
         ], True)
         self.expect_gdbremote_sequence()
 
     def resume_one_test(self, run_order, use_vCont=False, nonstop=False):
         parent_pid, parent_tid, child_pid, child_tid = (
-            self.start_fork_test(["fork", "trap"], nonstop=nonstop))
+            self.start_fork_test(["fork", "stop"], nonstop=nonstop))
 
         parent_expect = [
-            "T05thread:p{}.{};.*".format(parent_pid, parent_tid),
+            self.stop_regex_base.format(parent_pid, parent_tid),
             "W00;process:{}#.*".format(parent_pid),
         ]
         child_expect = [
-            "T05thread:p{}.{};.*".format(child_pid, child_tid),
+            self.stop_regex_base.format(child_pid, child_tid),
             "W00;process:{}#.*".format(child_pid),
         ]
 
         for x in run_order:
             if x == "parent":
                 pidtid = (parent_pid, parent_tid)
                 expect = parent_expect.pop(0)
             elif x == "child":

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

class TestGdbRemoteFork(GdbRemoteForkTestBase):
     def test_vkill_parent(self):
         self.vkill_test(kill_parent=True)
 
     @add_test_categories(["fork"])
     def test_vkill_both(self):
         self.vkill_test(kill_parent=True, kill_child=True)
 
     @expectedFailureAll(archs=["arm"])  # TODO
-    @expectedFailureAll(archs=["aarch64"],
-                        bugnumber="https://github.com/llvm/llvm-project/issues/56268")
     @add_test_categories(["fork"])
     def test_c_parent(self):
         self.resume_one_test(run_order=["parent", "parent"])
 
     @expectedFailureAll(archs=["arm"])  # TODO
-    @expectedFailureAll(archs=["aarch64"],
-                        bugnumber="https://github.com/llvm/llvm-project/issues/56268")
     @add_test_categories(["fork"])
     def test_c_child(self):
         self.resume_one_test(run_order=["child", "child"])
 
     @expectedFailureAll(archs=["arm"])  # TODO
-    @expectedFailureAll(archs=["aarch64"],
-                        bugnumber="https://github.com/llvm/llvm-project/issues/56268")
     @add_test_categories(["fork"])
     def test_c_parent_then_child(self):
         self.resume_one_test(run_order=["parent", "parent", "child", "child"])
 
     @expectedFailureAll(archs=["arm"])  # TODO
-    @expectedFailureAll(archs=["aarch64"],
-                        bugnumber="https://github.com/llvm/llvm-project/issues/56268")
     @add_test_categories(["fork"])
     def test_c_child_then_parent(self):
         self.resume_one_test(run_order=["child", "child", "parent", "parent"])
 
     @expectedFailureAll(archs=["arm"])  # TODO
-    @expectedFailureAll(archs=["aarch64"],
-                        bugnumber="https://github.com/llvm/llvm-project/issues/56268")
     @add_test_categories(["fork"])
     def test_c_interspersed(self):
         self.resume_one_test(run_order=["parent", "child", "parent", "child"])
 
     @expectedFailureAll(archs=["arm"])  # TODO
-    @expectedFailureAll(archs=["aarch64"],
-                        bugnumber="https://github.com/llvm/llvm-project/issues/56268")
     @add_test_categories(["fork"])
     def test_vCont_parent(self):
         self.resume_one_test(run_order=["parent", "parent"], use_vCont=True)
 
     @expectedFailureAll(archs=["arm"])  # TODO
-    @expectedFailureAll(archs=["aarch64"],
-                        bugnumber="https://github.com/llvm/llvm-project/issues/56268")
     @add_test_categories(["fork"])
     def test_vCont_child(self):
         self.resume_one_test(run_order=["child", "child"], use_vCont=True)
 
     @expectedFailureAll(archs=["arm"])  # TODO
-    @expectedFailureAll(archs=["aarch64"],
-                        bugnumber="https://github.com/llvm/llvm-project/issues/56268")
     @add_test_categories(["fork"])
     def test_vCont_parent_then_child(self):
         self.resume_one_test(run_order=["parent", "parent", "child", "child"],
                              use_vCont=True)
 
     @expectedFailureAll(archs=["arm"])  # TODO
-    @expectedFailureAll(archs=["aarch64"],
-                        bugnumber="https://github.com/llvm/llvm-project/issues/56268")
     @add_test_categories(["fork"])
     def test_vCont_child_then_parent(self):
         self.resume_one_test(run_order=["child", "child", "parent", "parent"],
                              use_vCont=True)
 
     @expectedFailureAll(archs=["arm"])  # TODO
-    @expectedFailureAll(archs=["aarch64"],
-                        bugnumber="https://github.com/llvm/llvm-project/issues/56268")
     @add_test_categories(["fork"])
     def test_vCont_interspersed(self):
         self.resume_one_test(run_order=["parent", "child", "parent", "child"],
                              use_vCont=True)
 
     @add_test_categories(["fork"])
     def test_vCont_two_processes(self):
         parent_pid, parent_tid, child_pid, child_tid = (
-            self.start_fork_test(["fork", "trap"]))
+            self.start_fork_test(["fork", "stop"]))
 
         self.test_sequence.add_log_lines([
             # try to resume both processes
             "read packet: $vCont;c:p{}.{};c:p{}.{}#00".format(
                 parent_pid, parent_tid, child_pid, child_tid),
             "send packet: $E03#00",
         ], True)
         self.expect_gdbremote_sequence()
 
     @add_test_categories(["fork"])
     def test_vCont_all_processes_explicit(self):
-        self.start_fork_test(["fork", "trap"])
+        self.start_fork_test(["fork", "stop"])
 
         self.test_sequence.add_log_lines([
             # try to resume all processes implicitly
             "read packet: $vCont;c:p-1.-1#00",
             "send packet: $E03#00",
         ], True)
         self.expect_gdbremote_sequence()
 
     @add_test_categories(["fork"])
     def test_vCont_all_processes_implicit(self):
-        self.start_fork_test(["fork", "trap"])
+        self.start_fork_test(["fork", "stop"])
 
         self.test_sequence.add_log_lines([
             # try to resume all processes implicitly
             "read packet: $vCont;c#00",
             "send packet: $E03#00",
         ], True)
         self.expect_gdbremote_sequence()
 
     @expectedFailureAll(archs=["arm"])  # TODO
     @add_test_categories(["fork"])
     def test_threadinfo(self):
         parent_pid, parent_tid, child_pid, child_tid = (
-            self.start_fork_test(["fork", "thread:new", "trap"]))
+            self.start_fork_test(["fork", "thread:new", "stop"]))
         pidtids = [
             (parent_pid, parent_tid),
             (child_pid, child_tid),
         ]
 
         self.add_threadinfo_collection_packets()
         ret = self.expect_gdbremote_sequence()
         prev_pidtids = set(self.parse_threadinfo_packets(ret))
         self.assertEqual(prev_pidtids,
                          frozenset((int(pid, 16), int(tid, 16))
                                    for pid, tid in pidtids))
         self.reset_test_sequence()
 
         for pidtid in pidtids:
             self.test_sequence.add_log_lines(
                 ["read packet: $Hcp{}.{}#00".format(*pidtid),
                  "send packet: $OK#00",
                  "read packet: $c#00",
                  {"direction": "send",
-                  "regex": "^[$]T05thread:p{}.{}.*".format(*pidtid),
+                  "regex": self.stop_regex.format(*pidtid),
                   },
                  ], True)
             self.add_threadinfo_collection_packets()
             ret = self.expect_gdbremote_sequence()
             self.reset_test_sequence()
             new_pidtids = set(self.parse_threadinfo_packets(ret))
             added_pidtid = new_pidtids - prev_pidtids
             prev_pidtids = new_pidtids
class TestGdbRemoteFork(GdbRemoteForkTestBase):
     def test_memory_read_write(self):
         self.build()
         INITIAL_DATA = "Initial message"
         self.prep_debug_monitor_and_inferior(
             inferior_args=["set-message:{}".format(INITIAL_DATA),
                            "get-data-address-hex:g_message",
                            "fork",
                            "print-message:",
-                           "trap",
+                           "stop",
                            ])
         self.add_qSupported_packets(["multiprocess+",
                                      "fork-events+"])
         ret = self.expect_gdbremote_sequence()
         self.assertIn("fork-events+", ret["qSupported_response"])
         self.reset_test_sequence()
 
         # continue and expect fork
def test_memory_read_write(self):
                  # resume the process and wait for the trap
                  "read packet: $Hcp{}.{}#00".format(*pidtid),
                  "send packet: $OK#00",
                  "read packet: $c#00",
                  {"type": "output_match",
                   "regex": self.maybe_strict_output_regex(r"message: (.*)\r\n"),
                   "capture": {1: "printed_message"}},
                  {"direction": "send",
-                  "regex": "^[$]T05thread:p{}.{}.*".format(*pidtid),
+                  "regex": self.stop_regex.format(*pidtid),
                   },
                  ], True)
             ret = self.expect_gdbremote_sequence()
             data = seven.unhexlify(ret["data"])
             self.assertEqual(data, INITIAL_DATA + "\0")
             self.assertEqual(ret["printed_message"], name);
             self.reset_test_sequence()
 
def test_memory_read_write(self):
             data = seven.unhexlify(ret.get("data"))
             self.assertEqual(data, name + "\0")
             self.reset_test_sequence()
 
     @expectedFailureAll(archs=["arm"])  # TODO
     @add_test_categories(["fork"])
     def test_register_read_write(self):
         parent_pid, parent_tid, child_pid, child_tid = (
-            self.start_fork_test(["fork", "thread:new", "trap"]))
+            self.start_fork_test(["fork", "thread:new", "stop"]))
         pidtids = [
             (parent_pid, parent_tid),
             (child_pid, child_tid),
         ]
 
         for pidtid in pidtids:
             self.test_sequence.add_log_lines(
                 ["read packet: $Hcp{}.{}#00".format(*pidtid),
                  "send packet: $OK#00",
                  "read packet: $c#00",
                  {"direction": "send",
-                  "regex": "^[$]T05thread:p{}.{}.*".format(*pidtid),
+                  "regex": self.stop_regex.format(*pidtid),
                   },
                  ], True)
 
         self.add_threadinfo_collection_packets()
         ret = self.expect_gdbremote_sequence()
         self.reset_test_sequence()
 
         pidtids = set(self.parse_threadinfo_packets(ret))
def test_register_read_write(self):
             data = ret.get("data")
             self.assertIsNotNone(data)
             self.assertEqual(data, old_val[1])
 
     @expectedFailureAll(archs=["arm"])  # TODO
     @add_test_categories(["fork"])
     def test_qC(self):
         parent_pid, parent_tid, child_pid, child_tid = (
-            self.start_fork_test(["fork", "thread:new", "trap"]))
+            self.start_fork_test(["fork", "thread:new", "stop"]))
         pidtids = [
             (parent_pid, parent_tid),
             (child_pid, child_tid),
         ]
 
         for pidtid in pidtids:
             self.test_sequence.add_log_lines(
                 ["read packet: $Hcp{}.{}#00".format(*pidtid),
                  "send packet: $OK#00",
                  "read packet: $c#00",
                  {"direction": "send",
-                  "regex": "^[$]T05thread:p{}.{}.*".format(*pidtid),
+                  "regex": self.stop_regex.format(*pidtid),
                   },
                  ], True)
 
         self.add_threadinfo_collection_packets()
         ret = self.expect_gdbremote_sequence()
         self.reset_test_sequence()
 
         pidtids = set(self.parse_threadinfo_packets(ret))
         self.assertEqual(len(pidtids), 4)
         for pidtid in pidtids:
             self.test_sequence.add_log_lines(
                 ["read packet: $Hgp{:x}.{:x}#00".format(*pidtid),
                  "send packet: $OK#00",
                  "read packet: $qC#00",
                  "send packet: $QCp{:x}.{:x}#00".format(*pidtid),
                  ], True)
         self.expect_gdbremote_sequence()
 
     @expectedFailureAll(archs=["arm"])  # TODO
     @add_test_categories(["fork"])
     def test_T(self):
         parent_pid, parent_tid, child_pid, child_tid = (
-            self.start_fork_test(["fork", "thread:new", "trap"]))
+            self.start_fork_test(["fork", "thread:new", "stop"]))
         pidtids = [
             (parent_pid, parent_tid),
             (child_pid, child_tid),
         ]
 
         for pidtid in pidtids:
             self.test_sequence.add_log_lines(
                 ["read packet: $Hcp{}.{}#00".format(*pidtid),
                  "send packet: $OK#00",
                  "read packet: $c#00",
                  {"direction": "send",
-                  "regex": "^[$]T05thread:p{}.{}.*".format(*pidtid),
+                  "regex": self.stop_regex.format(*pidtid),
                   },
                  ], True)
 
         self.add_threadinfo_collection_packets()
         ret = self.expect_gdbremote_sequence()
         self.reset_test_sequence()
 
         pidtids = set(self.parse_threadinfo_packets(ret))

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

def test_kill_all_nonstop(self):
         self.expect_gdbremote_sequence()
         self.assertEqual(set([pid1, pid2]), set([parent_pid, child_pid]))
 
     @add_test_categories(["fork"])
     def test_vkill_both_nonstop(self):
         self.vkill_test(kill_parent=True, kill_child=True, nonstop=True)
 
     @expectedFailureAll(archs=["arm"])  # TODO
-    @expectedFailureAll(archs=["aarch64"],
-                        bugnumber="https://github.com/llvm/llvm-project/issues/56268")
     @add_test_categories(["fork"])
     def test_c_interspersed_nonstop(self):
         self.resume_one_test(run_order=["parent", "child", "parent", "child"],
                              nonstop=True)
 
     @expectedFailureAll(archs=["arm"])  # TODO
-    @expectedFailureAll(archs=["aarch64"],
-                        bugnumber="https://github.com/llvm/llvm-project/issues/56268")
     @add_test_categories(["fork"])
     def test_vCont_interspersed_nonstop(self):
         self.resume_one_test(run_order=["parent", "child", "parent", "child"],
                              use_vCont=True, nonstop=True)

lldb/test/API/tools/lldb-server/main.cpp

#endif
     } else if (consume_front(arg, "print-pid")) {
       print_pid();
     } else if (consume_front(arg, "print-env:")) {
       // Print the value of specified envvar to stdout.
       const char *value = getenv(arg.c_str());
       printf("%s\n", value ? value : "__unset__");
     } else if (consume_front(arg, "trap")) {
       trap();
+#if !defined(_WIN32)
+    } else if (arg == "stop") {
+      raise(SIGSTOP);
+#endif
     } else {
       // Treat the argument as text for stdout.
       printf("%s\n", argv[i]);
     }
   }
 
   // If we launched any threads, join them
   for (std::vector<std::thread>::iterator it = threads.begin();
        it != threads.end(); ++it)
     it->join();
 
   return return_value;
 }