[lldb] [test] Rewrite g/p/G/P tests not to rely on hardcoded ARM regs

[mgorny]

Summary

Rewrite the register reading/writing tests to use explicit qRegisterInfo
packets rather than relying on ARM registers being hardcoded in LLDB.
While at it, use x86_64 for tests -- since it was easier for me to get
the register lists from that architecture.

lldb/test/API/functionalities/gdb_remote_client/TestGDBRemoteClient.py

 import lldb
 import binascii
 import os.path
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 from gdbclientutils import *
 
 
 class TestGDBRemoteClient(GDBRemoteTestBase):
 
     class gPacketResponder(MockGDBServerResponder):
+        registers = [
+            "name:rax;bitsize:64;offset:0;encoding:uint;format:hex;set:General Purpose Registers;ehframe:0;dwarf:0;",
+            "name:rbx;bitsize:64;offset:8;encoding:uint;format:hex;set:General Purpose Registers;ehframe:3;dwarf:3;",
+            "name:rcx;bitsize:64;offset:16;encoding:uint;format:hex;set:General Purpose Registers;ehframe:2;dwarf:2;generic:arg4;",
+            "name:rdx;bitsize:64;offset:24;encoding:uint;format:hex;set:General Purpose Registers;ehframe:1;dwarf:1;generic:arg3;",
+            "name:rdi;bitsize:64;offset:32;encoding:uint;format:hex;set:General Purpose Registers;ehframe:5;dwarf:5;generic:arg1;",
+            "name:rsi;bitsize:64;offset:40;encoding:uint;format:hex;set:General Purpose Registers;ehframe:4;dwarf:4;generic:arg2;",
+            "name:rbp;bitsize:64;offset:48;encoding:uint;format:hex;set:General Purpose Registers;ehframe:6;dwarf:6;generic:fp;",
+            "name:rsp;bitsize:64;offset:56;encoding:uint;format:hex;set:General Purpose Registers;ehframe:7;dwarf:7;generic:sp;",
+        ]
+
+        def qRegisterInfo(self, num):
+            try:
+                return self.registers[num]
+            except IndexError:
+                return "E45"
+
         def readRegisters(self):
-            return '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'
+            return len(self.registers) * 16 * '0'
+
+        def readRegister(self, register):
+            return "0000000000000000"
 
     def test_connect(self):
         """Test connecting to a remote gdb server"""
         target = self.createTarget("a.yaml")
         process = self.connect(target)
         self.assertPacketLogContains(["qProcessInfo", "qfThreadInfo"])
 
     def test_attach_fail(self):
def test_read_registers_using_g_packets(self):
         # Reading registers should not cause any 'p' packets to be exchanged.
         self.assertEquals(
                 0, len([p for p in self.server.responder.packetLog if p.startswith("p")]))
 
     def test_read_registers_using_p_packets(self):
         """Test reading registers using 'p' packets"""
         self.dbg.HandleCommand(
                 "settings set plugin.process.gdb-remote.use-g-packet-for-reading false")
+        self.server.responder = self.gPacketResponder()
         target = self.createTarget("a.yaml")
         process = self.connect(target)
 
         self.read_registers(process)
         self.assertNotIn("g", self.server.responder.packetLog)
         self.assertGreater(
                 len([p for p in self.server.responder.packetLog if p.startswith("p")]), 0)
 
def test_write_registers_using_G_packets(self):
         self.write_registers(process)
         self.assertEquals(0, len(
                 [p for p in self.server.responder.packetLog if p.startswith("P")]))
         self.assertGreater(len(
                 [p for p in self.server.responder.packetLog if p.startswith("G")]), 0)
 
     def read_registers(self, process):
         self.for_each_gpr(
-                process, lambda r: self.assertEquals("0x00000000", r.GetValue()))
+                process, lambda r: self.assertEquals("0x0000000000000000", r.GetValue()))
 
     def write_registers(self, process):
         self.for_each_gpr(
-                process, lambda r: r.SetValueFromCString("0x00000000"))
+                process, lambda r: r.SetValueFromCString("0x0000000000000000"))
 
     def for_each_gpr(self, process, operation):
         registers = process.GetThreadAtIndex(0).GetFrameAtIndex(0).GetRegisters()
         self.assertGreater(registers.GetSize(), 0)
         regSet = registers[0]
         numChildren = regSet.GetNumChildren()
         self.assertGreater(numChildren, 0)
         for i in range(numChildren):

lldb/test/API/functionalities/gdb_remote_client/a.yaml

-!ELF
+--- !ELF
 FileHeader:
-  Class:           ELFCLASS32
+  Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
-  Machine:         EM_ARM
+  Machine:         EM_X86_64
 Sections:
   - Name:            .text
     Type:            SHT_PROGBITS
     Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
     Address:         0x1000
     AddressAlign:    0x4
     Content:         "c3c3c3c3"
   - Name:            .data

lldb/test/API/functionalities/gdb_remote_client/gdbclientutils.py

def respond(self, packet):
         if packet.startswith("vRun;"):
             return self.vRun(packet)
         if packet.startswith("qLaunchSuccess"):
             return self.qLaunchSuccess()
         if packet.startswith("QEnvironment:"):
             return self.QEnvironment(packet)
         if packet.startswith("QEnvironmentHexEncoded:"):
             return self.QEnvironmentHexEncoded(packet)
+        if packet.startswith("qRegisterInfo"):
+            regnum = int(packet[len("qRegisterInfo"):], 16)
+            return self.qRegisterInfo(regnum)
 
         return self.other(packet)
 
     def qsProcessInfo(self):
         return "E04"
 
     def qfProcessInfo(self, packet):
         return "E04"
def qLaunchSuccess(self):
         return ""
 
     def QEnvironment(self, packet):
         return "OK"
 
     def QEnvironmentHexEncoded(self, packet):
         return "OK"
 
+    def qRegisterInfo(self, num):
+        return ""
+
     """
     Raised when we receive a packet for which there is no default action.
     Override the responder class to implement behavior suitable for the test at
     hand.
     """
     class UnexpectedPacketException(Exception):
         pass