Specify checksums properly for llgs test suite packets.

[sas]

Summary

These checksums are ignored by llgs but some implementations require them to be specified properly.

[clayborg]

Looks good.

[sas]

Closed by commit rL221927 (authored by @sas).

test/tools/lldb-gdbserver/TestGdbRemoteAuxvSupport.py

def has_auxv_support(self):
         procs = self.prep_debug_monitor_and_inferior(inferior_args=inferior_args)
 
         # Don't do anything until we match the launched inferior main entry output.
         # Then immediately interrupt the process.
         # This prevents auxv data being asked for before it's ready and leaves
         # us in a stopped state.
         self.test_sequence.add_log_lines([
             # Start the inferior...
-            "read packet: $c#00",
+            "read packet: $c#63",
             # ... match output....
             { "type":"output_match", "regex":r"^message:main entered\r\n$" },
             ], True)
         # ... then interrupt.
         self.add_interrupt_packets()
         self.add_qSupported_packets()
 
         context = self.expect_gdbremote_sequence()

test/tools/lldb-gdbserver/TestGdbRemoteExpeditedRegisters.py

 import unittest2
 
 import gdbremote_testcase
 from lldbtest import *
 
 class TestGdbRemoteExpeditedRegisters(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     def gather_expedited_registers(self):
         # Setup the stub and set the gdb remote command stream.
         procs = self.prep_debug_monitor_and_inferior(inferior_args=["sleep:2"])
         self.test_sequence.add_log_lines([
             # Start up the inferior.
-            "read packet: $c#00",
+            "read packet: $c#63",
             # Immediately tell it to stop.  We want to see what it reports.
             "read packet: {}".format(chr(03)),
             {"direction":"send", "regex":r"^\$T([0-9a-fA-F]+)([^#]+)#[0-9a-fA-F]{2}$", "capture":{1:"stop_result", 2:"key_vals_text"} },
             ], True)
 
         # Run the gdb remote command stream.
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)

test/tools/lldb-gdbserver/TestGdbRemoteRegisterState.py

def grp_register_save_restore_works(self, with_suffix):
 
         self.add_process_info_collection_packets()
         self.add_register_info_collection_packets()
         if with_suffix:
             self.add_thread_suffix_request_packets()
         self.add_threadinfo_collection_packets()
         self.test_sequence.add_log_lines([
             # Start the inferior...
-            "read packet: $c#00",
+            "read packet: $c#63",
             # ... match output....
             { "type":"output_match", "regex":r"^message:main entered\r\n$" },
             ], True)
         # ... then interrupt.
         self.add_interrupt_packets()
 
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)

test/tools/lldb-gdbserver/TestGdbRemoteThreadsInStopReply.py

 import unittest2
 
 import gdbremote_testcase
 from lldbtest import *
 
 class TestGdbRemoteThreadsInStopReply(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     ENABLE_THREADS_IN_STOP_REPLY_ENTRIES = [
-        "read packet: $QListThreadsInStopReply#00",
+        "read packet: $QListThreadsInStopReply#21",
         "send packet: $OK#00",
     ]
 
     def gather_stop_reply_threads(self, post_startup_log_lines, thread_count):
         # Set up the inferior args.
         inferior_args=[]
         for i in range(thread_count - 1):
             inferior_args.append("thread:new")
         inferior_args.append("sleep:10")
         procs = self.prep_debug_monitor_and_inferior(inferior_args=inferior_args)
 
         # Assumes test_sequence has anything added needed to setup the initial state.
         # (Like optionally enabling QThreadsInStopReply.)
         if post_startup_log_lines:
             self.test_sequence.add_log_lines(post_startup_log_lines, True)
         self.test_sequence.add_log_lines([
-            "read packet: $c#00"
+            "read packet: $c#63"
             ], True)
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         # Give threads time to start up, then break.
         time.sleep(1)
         self.reset_test_sequence()
         self.test_sequence.add_log_lines([
             "read packet: {}".format(chr(03)),
             {"direction":"send", "regex":r"^\$T([0-9a-fA-F]+)([^#]+)#[0-9a-fA-F]{2}$", "capture":{1:"stop_result", 2:"key_vals_text"} },
             ], True)
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         # Wait until all threads have started.
         threads = self.wait_for_thread_count(thread_count, timeout_seconds=3)
         self.assertIsNotNone(threads)
         self.assertEquals(len(threads), thread_count)
 
         # Run, then stop the process, grab the stop reply content.
         self.reset_test_sequence()
         self.test_sequence.add_log_lines([
-            "read packet: $c#00",
+            "read packet: $c#63",
             "read packet: {}".format(chr(03)),
             {"direction":"send", "regex":r"^\$T([0-9a-fA-F]+)([^#]+)#[0-9a-fA-F]{2}$", "capture":{1:"stop_result", 2:"key_vals_text"} },
             ], True)
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         # Parse the stop reply contents.
         key_vals_text = context.get("key_vals_text")

test/tools/lldb-gdbserver/TestGdbRemote_qThreadStopInfo.py

def gather_stop_replies_via_qThreadStopInfo(self, thread_count):
         for i in range(thread_count - 1):
             inferior_args.append("thread:new")
         inferior_args.append("sleep:10")
         procs = self.prep_debug_monitor_and_inferior(inferior_args=inferior_args)
 
         # Assumes test_sequence has anything added needed to setup the initial state.
         # (Like optionally enabling QThreadsInStopReply.)
         self.test_sequence.add_log_lines([
-            "read packet: $c#00"
+            "read packet: $c#63"
             ], True)
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         # Give threads time to start up, then break.
         time.sleep(1)
         self.reset_test_sequence()
         self.test_sequence.add_log_lines([

test/tools/lldb-gdbserver/TestLldbGdbServer.py

def c_packet_works(self):
         self.assertIsNotNone(server)
 
         # build launch args
         launch_args = [os.path.abspath('a.out')]
 
         self.add_no_ack_remote_stream()
         self.add_verified_launch_packets(launch_args)
         self.test_sequence.add_log_lines(
-            ["read packet: $c#00",
+            ["read packet: $c#63",
              "send packet: $W00#00"],
             True)
 
         self.expect_gdbremote_sequence()
 
     @debugserver_test
     @dsym_test
     def test_c_packet_works_debugserver_dsym(self):
def Hc_then_Csignal_signals_correct_thread(self, segfault_signo):
             # if i > 0:
                 # Give time between thread creation/segfaulting for the handler to work.
                 # inferior_args.append("sleep:1")
             inferior_args.append("thread:new")
         inferior_args.append("sleep:10")
 
         # Launch/attach.  (In our case, this should only ever be launched since we need inferior stdout/stderr).
         procs = self.prep_debug_monitor_and_inferior(inferior_args=inferior_args)
-        self.test_sequence.add_log_lines(["read packet: $c#00"], True)
+        self.test_sequence.add_log_lines(["read packet: $c#63"], True)
         context = self.expect_gdbremote_sequence()
 
         # Let the inferior process have a few moments to start up the thread when launched.
         # context = self.run_process_then_stop(run_seconds=1)
 
         # Wait at most x seconds for all threads to be present.
         # threads = self.wait_for_thread_count(NUM_THREADS, timeout_seconds=5)
         # self.assertEquals(len(threads), NUM_THREADS)
def Hc_then_Csignal_signals_correct_thread(self, segfault_signo):
                  "read packet: $C{0:x}#00".format(signal.SIGUSR1),
                  # "read packet: $vCont;C{0:x}:{1:x};c#00".format(signal.SIGUSR1, thread_id),
 
                  # FIXME: Linux does not report the thread stop on the delivered signal (SIGUSR1 here).  MacOSX debugserver does.
                  # But MacOSX debugserver isn't guaranteeing the thread the signal handler runs on, so currently its an XFAIL.
                  # Need to rectify behavior here.  The linux behavior is more intuitive to me since we're essentially swapping out
                  # an about-to-be-delivered signal (for which we already sent a stop packet) to a different signal.
                  # {"direction":"send", "regex":r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture":{1:"stop_signo", 2:"stop_thread_id"} },
-                 #  "read packet: $c#00",
+                 #  "read packet: $c#63",
                  { "type":"output_match", "regex":r"^received SIGUSR1 on thread id: ([0-9a-fA-F]+)\r\nthread ([0-9a-fA-F]+): past SIGSEGV\r\n", "capture":{ 1:"print_thread_id", 2:"post_handle_thread_id" } },
                 ],
                 True)
 
             # Run the sequence.
             context = self.expect_gdbremote_sequence(timeout_seconds=10)
             self.assertIsNotNone(context)
 
def m_packet_reads_memory(self):
         # Start up the inferior.
         procs = self.prep_debug_monitor_and_inferior(
             inferior_args=["set-message:%s" % MEMORY_CONTENTS, "get-data-address-hex:g_message", "sleep:5"])
 
         # Run the process
         self.test_sequence.add_log_lines(
             [
              # Start running after initial stop.
-             "read packet: $c#00",
+             "read packet: $c#63",
              # Match output line that prints the memory address of the message buffer within the inferior. 
              # Note we require launch-only testing so we can get inferior otuput.
              { "type":"output_match", "regex":r"^data address: 0x([0-9a-fA-F]+)\r\n$", "capture":{ 1:"message_address"} },
              # Now stop the inferior.
              "read packet: {}".format(chr(03)),
              # And wait for the stop notification.
              {"direction":"send", "regex":r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture":{1:"stop_signo", 2:"stop_thread_id"} }],
             True)
def qMemoryRegionInfo_reports_code_address_as_executable(self):
         # Start up the inferior.
         procs = self.prep_debug_monitor_and_inferior(
             inferior_args=["get-code-address-hex:hello", "sleep:5"])
 
         # Run the process
         self.test_sequence.add_log_lines(
             [
              # Start running after initial stop.
-             "read packet: $c#00",
+             "read packet: $c#63",
              # Match output line that prints the memory address of the message buffer within the inferior. 
              # Note we require launch-only testing so we can get inferior otuput.
              { "type":"output_match", "regex":r"^code address: 0x([0-9a-fA-F]+)\r\n$", "capture":{ 1:"code_address"} },
              # Now stop the inferior.
              "read packet: {}".format(chr(03)),
              # And wait for the stop notification.
              {"direction":"send", "regex":r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture":{1:"stop_signo", 2:"stop_thread_id"} }],
             True)
def qMemoryRegionInfo_reports_stack_address_as_readable_writeable(self):
         # Start up the inferior.
         procs = self.prep_debug_monitor_and_inferior(
             inferior_args=["get-stack-address-hex:", "sleep:5"])
 
         # Run the process
         self.test_sequence.add_log_lines(
             [
              # Start running after initial stop.
-             "read packet: $c#00",
+             "read packet: $c#63",
              # Match output line that prints the memory address of the message buffer within the inferior. 
              # Note we require launch-only testing so we can get inferior otuput.
              { "type":"output_match", "regex":r"^stack address: 0x([0-9a-fA-F]+)\r\n$", "capture":{ 1:"stack_address"} },
              # Now stop the inferior.
              "read packet: {}".format(chr(03)),
              # And wait for the stop notification.
              {"direction":"send", "regex":r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture":{1:"stop_signo", 2:"stop_thread_id"} }],
             True)
def qMemoryRegionInfo_reports_heap_address_as_readable_writeable(self):
         # Start up the inferior.
         procs = self.prep_debug_monitor_and_inferior(
             inferior_args=["get-heap-address-hex:", "sleep:5"])
 
         # Run the process
         self.test_sequence.add_log_lines(
             [
              # Start running after initial stop.
-             "read packet: $c#00",
+             "read packet: $c#63",
              # Match output line that prints the memory address of the message buffer within the inferior. 
              # Note we require launch-only testing so we can get inferior otuput.
              { "type":"output_match", "regex":r"^heap address: 0x([0-9a-fA-F]+)\r\n$", "capture":{ 1:"heap_address"} },
              # Now stop the inferior.
              "read packet: {}".format(chr(03)),
              # And wait for the stop notification.
              {"direction":"send", "regex":r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture":{1:"stop_signo", 2:"stop_thread_id"} }],
             True)
def software_breakpoint_set_and_remove_work(self):
         procs = self.prep_debug_monitor_and_inferior(
             inferior_args=["get-code-address-hex:hello", "sleep:1", "call-function:hello"])
 
         # Run the process
         self.add_register_info_collection_packets()
         self.add_process_info_collection_packets()
         self.test_sequence.add_log_lines(
             [# Start running after initial stop.
-             "read packet: $c#00",
+             "read packet: $c#63",
              # Match output line that prints the memory address of the function call entry point.
              # Note we require launch-only testing so we can get inferior otuput.
              { "type":"output_match", "regex":r"^code address: 0x([0-9a-fA-F]+)\r\n$", "capture":{ 1:"function_address"} },
              # Now stop the inferior.
              "read packet: {}".format(chr(03)),
              # And wait for the stop notification.
              {"direction":"send", "regex":r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture":{1:"stop_signo", 2:"stop_thread_id"} }],
             True)
def software_breakpoint_set_and_remove_work(self):
         self.reset_test_sequence()
         self.test_sequence.add_log_lines(
             [
             # Remove the breakpoint.
             "read packet: $z0,{0:x},{1}#00".format(function_address, BREAKPOINT_KIND),
             # Verify the stub could unset it.
             "send packet: $OK#00",
             # Continue running.
-            "read packet: $c#00",
+            "read packet: $c#63",
             # We should now receive the output from the call.
             { "type":"output_match", "regex":r"^hello, world\r\n$" },
             # And wait for program completion.
             {"direction":"send", "regex":r"^\$W00(.*)#[0-9a-fA-F]{2}$" },
             ], True)
 
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)

     def written_M_content_reads_back_correctly(self):
         TEST_MESSAGE = "Hello, memory"
 
         # Start up the stub and start/prep the inferior.
         procs = self.prep_debug_monitor_and_inferior(inferior_args=["set-message:xxxxxxxxxxxxxX", "get-data-address-hex:g_message", "sleep:1", "print-message:"])
         self.test_sequence.add_log_lines(
             [
              # Start running after initial stop.
-             "read packet: $c#00",
+             "read packet: $c#63",
              # Match output line that prints the memory address of the message buffer within the inferior. 
              # Note we require launch-only testing so we can get inferior otuput.
              { "type":"output_match", "regex":r"^data address: 0x([0-9a-fA-F]+)\r\n$", "capture":{ 1:"message_address"} },
              # Now stop the inferior.
              "read packet: {}".format(chr(03)),
              # And wait for the stop notification.
              {"direction":"send", "regex":r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture":{1:"stop_signo", 2:"stop_thread_id"} }],
             True)
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         # Grab the message address.
         self.assertIsNotNone(context.get("message_address"))
         message_address = int(context.get("message_address"), 16)
 
         # Hex-encode the test message, adding null termination.
         hex_encoded_message = TEST_MESSAGE.encode("hex")
 
         # Write the message to the inferior.
         self.reset_test_sequence()
         self.test_sequence.add_log_lines(
             ["read packet: $M{0:x},{1:x}:{2}#00".format(message_address, len(hex_encoded_message)/2, hex_encoded_message),
              "send packet: $OK#00",
-             "read packet: $c#00",
+             "read packet: $c#63",
              { "type":"output_match", "regex":r"^message: (.+)\r\n$", "capture":{ 1:"printed_message"} },
              "send packet: $W00#00",
             ], True)
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         # Ensure what we read from inferior memory is what we wrote.
         printed_message = context.get("printed_message")

test/tools/lldb-gdbserver/gdbremote_testcase.py

def add_verified_launch_packets(self, launch_args):
             ["read packet: %s" % build_gdbremote_A_packet(launch_args),
              "send packet: $OK#00",
              "read packet: $qLaunchSuccess#a5",
              "send packet: $OK#00"],
             True)
 
     def add_thread_suffix_request_packets(self):
         self.test_sequence.add_log_lines(
-            ["read packet: $QThreadSuffixSupported#00",
+            ["read packet: $QThreadSuffixSupported#e4",
              "send packet: $OK#00",
             ], True)
 
     def add_process_info_collection_packets(self):
         self.test_sequence.add_log_lines(
-            ["read packet: $qProcessInfo#00",
+            ["read packet: $qProcessInfo#dc",
               { "direction":"send", "regex":r"^\$(.+)#[0-9a-fA-F]{2}$", "capture":{1:"process_info_raw"} }],
             True)
 
     _KNOWN_PROCESS_INFO_KEYS = [
         "pid",
         "parent-pid",
         "real-uid",
         "real-gid",
def add_set_breakpoint_packets(self, address, do_continue=True, breakpoint_kind=1):
              "read packet: $Z0,{0:x},{1}#00".format(address, breakpoint_kind),
              # Verify the stub could set it.
              "send packet: $OK#00",
              ], True)
 
         if (do_continue):
             self.test_sequence.add_log_lines(
                 [# Continue the inferior.
-                 "read packet: $c#00",
+                 "read packet: $c#63",
                  # Expect a breakpoint stop report.
                  {"direction":"send", "regex":r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture":{1:"stop_signo", 2:"stop_thread_id"} },
                  ], True)        
 
     def add_remove_breakpoint_packets(self, address, breakpoint_kind=1):
         self.test_sequence.add_log_lines(
             [# Remove the breakpoint.
              "read packet: $z0,{0:x},{1}#00".format(address, breakpoint_kind),
def read_register_values(self, reg_infos, endian, thread_id=None):
             self.assertFalse(p_response[0] == "E")
             
             values[reg_index] = unpack_register_hex_unsigned(endian, p_response)
             
         return values
 
     def add_vCont_query_packets(self):
         self.test_sequence.add_log_lines([
-            "read packet: $vCont?#00",
+            "read packet: $vCont?#49",
             {"direction":"send", "regex":r"^\$(vCont)?(.*)#[0-9a-fA-F]{2}$", "capture":{2:"vCont_query_response" } },
             ], True)
 
     def parse_vCont_query_response(self, context):
         self.assertIsNotNone(context)
         vCont_query_response = context.get("vCont_query_response")
 
         # Handle case of no vCont support at all - in which case the capture group will be none or zero length.
def single_step_only_steps_one_instruction(self, use_Hc_packet=True, step_instruction="s"):
         """Used by single step test that appears in a few different contexts."""
         # Start up the inferior.
         procs = self.prep_debug_monitor_and_inferior(
             inferior_args=["get-code-address-hex:swap_chars", "get-data-address-hex:g_c1", "get-data-address-hex:g_c2", "sleep:1", "call-function:swap_chars", "sleep:5"])
 
         # Run the process
         self.test_sequence.add_log_lines(
             [# Start running after initial stop.
-             "read packet: $c#00",
+             "read packet: $c#63",
              # Match output line that prints the memory address of the function call entry point.
              # Note we require launch-only testing so we can get inferior otuput.
              { "type":"output_match", "regex":r"^code address: 0x([0-9a-fA-F]+)\r\ndata address: 0x([0-9a-fA-F]+)\r\ndata address: 0x([0-9a-fA-F]+)\r\n$", 
                "capture":{ 1:"function_address", 2:"g_c1_address", 3:"g_c2_address"} },
              # Now stop the inferior.
              "read packet: {}".format(chr(03)),
              # And wait for the stop notification.
              {"direction":"send", "regex":r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture":{1:"stop_signo", 2:"stop_thread_id"} }],