| """ |
| Multiple threads stop at a code address where there is a breakpoint |
| at the same time. Some threads have executed the breakpoint |
| instruction and have a stop reason. Other threads have not yet hit |
| the breakpoint instruction. When lldb resumes execution, only the |
| threads that have hit the breakpoint should instruction-step past |
| the breakpoint before resuming. |
| """ |
| |
| import re |
| import json |
| |
| import lldb |
| from lldbsuite.test.lldbtest import * |
| from lldbsuite.test.decorators import * |
| from lldbsuite.test.gdbclientutils import * |
| from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase |
| |
| |
| class TestBreakpointNotHit(GDBRemoteTestBase): |
| @skipIfXmlSupportMissing |
| def test(self): |
| BP_ADDR = 0x1004 |
| NUM_THREADS = 4 |
| |
| class MyResponder(MockGDBServerResponder): |
| def __init__(self): |
| MockGDBServerResponder.__init__(self) |
| self.bp_addr = BP_ADDR |
| self.tids = [0x101 + i for i in range(NUM_THREADS)] |
| self.pcs = [0x1000 for _ in range(NUM_THREADS)] |
| self.selected_thread = 0x101 |
| self.breakpoints = set() |
| self.second_stop_at_bp_addr = False |
| |
| # Threads that have just hit a breakpoint. |
| self.tids_hit_bp = [] |
| # Threads that have just completed an instruction step. |
| self.tids_completed_stepi = [] |
| |
| def qSupported(self, client_supported): |
| return ( |
| "PacketSize=3fff;QStartNoAckMode+;" |
| "qXfer:features:read+;swbreak+;hwbreak+" |
| ) |
| |
| def qXferRead(self, obj, annex, offset, length): |
| if annex == "target.xml": |
| return ( |
| """<?xml version="1.0"?> |
| <target version="1.0"> |
| <feature name="com.apple.debugserver.arm64"> |
| <reg name="fp" regnum="29" bitsize="64" group="general" generic="fp"/> |
| <reg name="lr" regnum="30" bitsize="64" group="general" generic="ra"/> |
| <reg name="sp" regnum="31" bitsize="64" group="general" generic="sp"/> |
| <reg name="pc" regnum="32" bitsize="64" group="general" generic="pc"/> |
| </feature> |
| </target>""", |
| False, |
| ) |
| return None, False |
| |
| def cont(self): |
| # Clear the tid states. |
| self.tids_completed_stepi = [] |
| self.tids_hit_bp = [] |
| new_pcs = [] |
| for idx, tid in enumerate(self.tids): |
| pc = self.pcs[idx] |
| # Thread 0x104 |
| # (1) first stops at BP_ADDR but hasn't hit it. |
| # then on next continue, |
| # (2) hits the breakpoint at BP_ADDR (pc does not advance). |
| if ( |
| tid == 0x104 |
| and pc == BP_ADDR |
| and not self.second_stop_at_bp_addr |
| ): |
| self.tids_hit_bp.append(tid) |
| self.second_stop_at_bp_addr = True |
| new_pcs.append(pc) |
| else: |
| new_pcs.append(pc + 4) |
| if (pc + 4) == BP_ADDR and tid != 0x104: |
| self.tids_hit_bp.append(tid) |
| self.pcs = new_pcs |
| return self.haltReason() |
| |
| def setBreakpoint(self, packet): |
| bp_data = packet[1:].split(",") |
| self.breakpoints.add(int(bp_data[1], 16)) |
| return "OK" |
| |
| def clearBreakpoint(self, packet): |
| bp_data = packet[1:].split(",") |
| self.breakpoints.remove(int(bp_data[1], 16)) |
| return "OK" |
| |
| def qHostInfo(self): |
| return "cputype:16777228;cpusubtype:2;addressing_bits:47;ostype:macosx;watchpoint_exceptions_received:before;vendor:apple;os_version:27.0.0;triple:61726D36342D6170706C652D6D61636F7378;" |
| |
| def haltReason(self): |
| threads_str = ",".join("{:x}".format(t) for t in self.tids) |
| pcs_str = ",".join("{:x}".format(p) for p in self.pcs) |
| jstopinfos = [] |
| for idx, tid in enumerate(self.tids): |
| if tid in self.tids_completed_stepi or tid in self.tids_hit_bp: |
| medata = 0 |
| if tid in self.tids_hit_bp: |
| medata = self.pcs[idx] |
| jstopinfos.append( |
| '{"tid":%d,"metype":6,"medata":[1,%d],"reason":"exception"}' |
| % (tid, medata) |
| ) |
| response = "T05thread:{:x};threads:{};thread-pcs:{};".format( |
| self.tids[0], threads_str, pcs_str |
| ) |
| if len(jstopinfos) > 0: |
| json_str = "[%s]" % ",".join(jstopinfos) |
| response += "jstopinfo:%s;" % json_str.encode().hex() |
| if self.tids[0] in self.tids_hit_bp: |
| response += "metype:6;mecount:2;medata:1;medata:%x;" % (self.pcs[0]) |
| else: |
| if self.tids[0] in self.tids_completed_stepi: |
| response += "metype:6;mecount:2;medata:1;medata:0;" |
| |
| response += "20:%016x;" % (self.swap64(self.pcs[0])) |
| response += "1d:0000000000000000;" |
| response += "1f:0000000000000000;" |
| return response |
| |
| # Register values need to be sent in native-endian (little) |
| def swap64(self, x): |
| return ( |
| ((x << 56) & 0xFF00000000000000) |
| | ((x << 40) & 0x00FF000000000000) |
| | ((x << 24) & 0x0000FF0000000000) |
| | ((x << 8) & 0x000000FF00000000) |
| | ((x >> 8) & 0x00000000FF000000) |
| | ((x >> 24) & 0x0000000000FF0000) |
| | ((x >> 40) & 0x000000000000FF00) |
| | ((x >> 56) & 0x00000000000000FF) |
| ) |
| |
| def jThreadsInfo(self): |
| response_array = [] |
| for idx, tid in enumerate(self.tids): |
| this = {} |
| this["tid"] = tid |
| if tid in self.tids_hit_bp: |
| this["metype"] = 6 |
| this["medata"] = [1, self.pcs[idx]] |
| this["reason"] = "exception" |
| if tid in self.tids_completed_stepi: |
| this["metype"] = 6 |
| this["medata"] = [1, 0] |
| this["reason"] = "exception" |
| this["registers"] = { |
| "20": "%016x" % (self.swap64(self.pcs[idx])), |
| "1d": "0000000000000000", |
| "1f": "0000000000000000", |
| } |
| response_array.append(this) |
| return json.dumps(response_array, indent=2) |
| |
| def _handle_vCont(self, packet): |
| self.tids_completed_stepi = [] |
| stepping_tids = [] |
| tids_hit_a_bp = [] |
| # Parse step actions from vCont. |
| for action in packet[6:].split(";"): |
| if not action: |
| continue |
| if action.startswith("s:"): |
| tid_str = action[2:] |
| if "." in tid_str: |
| tid_str = tid_str.split(".")[1] |
| stepping_tids.append(int(tid_str, 16)) |
| |
| for idx, tid in enumerate(self.tids): |
| # If a thread is _at_ a breakpoint instruction |
| # but hasn't hit yet it, mark it as a breakpoint |
| # hit and don't advance. |
| if tid in stepping_tids: |
| if ( |
| self.pcs[idx] in self.breakpoints |
| and tid not in self.tids_hit_bp |
| ): |
| tids_hit_a_bp.append(tid) |
| else: |
| self.pcs[idx] += 4 |
| self.tids_completed_stepi.append(tid) |
| self.tids_hit_bp = tids_hit_a_bp |
| |
| return self.haltReason() |
| |
| def readRegisters(self): |
| return "00" * (8 * 4) |
| |
| def readRegister(self, regno): |
| if self.selected_thread in self.tids and regno == 32: |
| for idx, tid in enumerate(self.tids): |
| if tid == self.selected_thread: |
| return "%016x" % self.swap64(self.pcs[idx]) |
| return "00" * 8 |
| |
| def selectThread(self, op, thread_id): |
| self.selected_thread = thread_id |
| return "OK" |
| |
| def other(self, packet): |
| if packet == "vCont?": |
| return "vCont;c;C;s;S" |
| if packet.startswith("vCont;"): |
| return self._handle_vCont(packet) |
| return "" |
| |
| self.server.responder = MyResponder() |
| if self.TraceOn(): |
| self.runCmd("log enable gdb-remote packets") |
| # self.runCmd("log enable -v lldb break") |
| # self.runCmd("log enable -v lldb step") |
| # self.runCmd("log enable -v lldb temp") |
| target = self.dbg.CreateTarget("") |
| process = self.connect(target) |
| self.assertEqual(process.GetNumThreads(), NUM_THREADS) |
| |
| bkpt = target.BreakpointCreateByAddress(BP_ADDR) |
| self.assertTrue(bkpt.IsValid()) |
| self.runCmd("break list") |
| self.runCmd("thread list") |
| |
| # Continue to the breakpoint hit on 3 threads; not on 4th |
| process.Continue() |
| |
| self.runCmd("break list") |
| self.runCmd("thread list") |
| self.assertEqual(bkpt.GetHitCount(), 3) |
| |
| # Continue the process, which must instruction step |
| # the three threads that have hit the breakpoint, then |
| # resume all threads (and the 4th thread will hit the breakpoint) |
| process.Continue() |
| |
| self.runCmd("break list") |
| self.runCmd("thread list") |
| self.assertEqual(bkpt.GetHitCount(), 4) |
