1import lldb
2import binascii
3from lldbsuite.test.lldbtest import *
4from lldbsuite.test.decorators import *
5from gdbclientutils import *
6
7
8class TestGDBRemoteClient(GDBRemoteTestBase):
9
10    class gPacketResponder(MockGDBServerResponder):
11        def readRegisters(self):
12            return '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'
13
14    def test_connect(self):
15        """Test connecting to a remote gdb server"""
16        target = self.createTarget("a.yaml")
17        process = self.connect(target)
18        self.assertPacketLogContains(["qProcessInfo", "qfThreadInfo"])
19
20    def test_attach_fail(self):
21        error_msg = "mock-error-msg"
22
23        class MyResponder(MockGDBServerResponder):
24            # Pretend we don't have any process during the initial queries.
25            def qC(self):
26                return "E42"
27
28            def qfThreadInfo(self):
29                return "OK" # No threads.
30
31            # Then, when we are asked to attach, error out.
32            def vAttach(self, pid):
33                return "E42;" + binascii.hexlify(error_msg.encode()).decode()
34
35        self.server.responder = MyResponder()
36
37        target = self.dbg.CreateTarget("")
38        process = self.connect(target)
39        lldbutil.expect_state_changes(self, self.dbg.GetListener(), process, [lldb.eStateConnected])
40
41        error = lldb.SBError()
42        target.AttachToProcessWithID(lldb.SBListener(), 47, error)
43        self.assertEquals(error_msg, error.GetCString())
44
45    def test_launch_fail(self):
46        class MyResponder(MockGDBServerResponder):
47            # Pretend we don't have any process during the initial queries.
48            def qC(self):
49                return "E42"
50
51            def qfThreadInfo(self):
52                return "OK" # No threads.
53
54            # Then, when we are asked to attach, error out.
55            def A(self, packet):
56                return "E47"
57
58        self.server.responder = MyResponder()
59
60        target = self.createTarget("a.yaml")
61        process = self.connect(target)
62        lldbutil.expect_state_changes(self, self.dbg.GetListener(), process, [lldb.eStateConnected])
63
64        error = lldb.SBError()
65        target.Launch(lldb.SBListener(), None, None, None, None, None,
66                None, 0, True, error)
67        self.assertEquals("'A' packet returned an error: 71", error.GetCString())
68
69    def test_read_registers_using_g_packets(self):
70        """Test reading registers using 'g' packets (default behavior)"""
71        self.dbg.HandleCommand(
72                "settings set plugin.process.gdb-remote.use-g-packet-for-reading true")
73        self.addTearDownHook(lambda:
74                self.runCmd("settings set plugin.process.gdb-remote.use-g-packet-for-reading false"))
75        self.server.responder = self.gPacketResponder()
76        target = self.createTarget("a.yaml")
77        process = self.connect(target)
78
79        self.assertEquals(1, self.server.responder.packetLog.count("g"))
80        self.server.responder.packetLog = []
81        self.read_registers(process)
82        # Reading registers should not cause any 'p' packets to be exchanged.
83        self.assertEquals(
84                0, len([p for p in self.server.responder.packetLog if p.startswith("p")]))
85
86    def test_read_registers_using_p_packets(self):
87        """Test reading registers using 'p' packets"""
88        self.dbg.HandleCommand(
89                "settings set plugin.process.gdb-remote.use-g-packet-for-reading false")
90        target = self.createTarget("a.yaml")
91        process = self.connect(target)
92
93        self.read_registers(process)
94        self.assertFalse("g" in self.server.responder.packetLog)
95        self.assertGreater(
96                len([p for p in self.server.responder.packetLog if p.startswith("p")]), 0)
97
98    def test_write_registers_using_P_packets(self):
99        """Test writing registers using 'P' packets (default behavior)"""
100        self.server.responder = self.gPacketResponder()
101        target = self.createTarget("a.yaml")
102        process = self.connect(target)
103
104        self.write_registers(process)
105        self.assertEquals(0, len(
106                [p for p in self.server.responder.packetLog if p.startswith("G")]))
107        self.assertGreater(
108                len([p for p in self.server.responder.packetLog if p.startswith("P")]), 0)
109
110    def test_write_registers_using_G_packets(self):
111        """Test writing registers using 'G' packets"""
112
113        class MyResponder(self.gPacketResponder):
114            def readRegister(self, register):
115                # empty string means unsupported
116                return ""
117
118        self.server.responder = MyResponder()
119        target = self.createTarget("a.yaml")
120        process = self.connect(target)
121
122        self.write_registers(process)
123        self.assertEquals(0, len(
124                [p for p in self.server.responder.packetLog if p.startswith("P")]))
125        self.assertGreater(len(
126                [p for p in self.server.responder.packetLog if p.startswith("G")]), 0)
127
128    def read_registers(self, process):
129        self.for_each_gpr(
130                process, lambda r: self.assertEquals("0x00000000", r.GetValue()))
131
132    def write_registers(self, process):
133        self.for_each_gpr(
134                process, lambda r: r.SetValueFromCString("0x00000000"))
135
136    def for_each_gpr(self, process, operation):
137        registers = process.GetThreadAtIndex(0).GetFrameAtIndex(0).GetRegisters()
138        self.assertGreater(registers.GetSize(), 0)
139        regSet = registers[0]
140        numChildren = regSet.GetNumChildren()
141        self.assertGreater(numChildren, 0)
142        for i in range(numChildren):
143            operation(regSet.GetChildAtIndex(i))
144