Debian Codegraph @

cross-project-tests/debuginfo-tests/dexter/dex/debugger/lldb/LLDB.py

raw
1 # DExTer : Debugging Experience Tester
2 # ~~~~~~ ~ ~~ ~ ~~
3 #
4 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5 # See https://llvm.org/LICENSE.txt for license information.
6 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 """Interface for communicating with the LLDB debugger via its python interface.
8 """
9
10 import os
11 import shlex
12 from subprocess import CalledProcessError, check_output, STDOUT
13 import sys
14
15 from dex.debugger.DebuggerBase import DebuggerBase, watch_is_active
16 from dex.debugger.DAP import DAP
17 from dex.dextIR import FrameIR, LocIR, StepIR, StopReason, ValueIR
18 from dex.dextIR import StackFrame, SourceLocation, ProgramState
19 from dex.utils.Exceptions import DebuggerException, LoadDebuggerException
20 from dex.utils.ReturnCode import ReturnCode
21 from dex.utils.Imports import load_module
22
23
24 class LLDB(DebuggerBase):
25 def __init__(self, context, *args):
26 self.lldb_executable = context.options.lldb_executable
27 self._debugger = None
28 self._target = None
29 self._process = None
30 self._thread = None
31 # Map {id (int): condition (str)} for breakpoints which have a
32 # condition. See get_triggered_breakpoint_ids usage for more info.
33 self._breakpoint_conditions = {}
34 super(LLDB, self).__init__(context, *args)
35
36 def _custom_init(self):
37 self._debugger = self._interface.SBDebugger.Create()
38 self._debugger.SetAsync(False)
39 self._target = self._debugger.CreateTargetWithFileAndArch(
40 self.context.options.executable, self.context.options.arch
41 )
42 if not self._target:
43 raise LoadDebuggerException(
44 'could not create target for executable "{}" with arch:{}'.format(
45 self.context.options.executable, self.context.options.arch
46 )
47 )
48
49 def _custom_exit(self):
50 if getattr(self, "_process", None):
51 self._process.Kill()
52 if getattr(self, "_debugger", None) and getattr(self, "_target", None):
53 self._debugger.DeleteTarget(self._target)
54
55 def _translate_stop_reason(self, reason):
56 if reason == self._interface.eStopReasonNone:
57 return None
58 if reason == self._interface.eStopReasonBreakpoint:
59 return StopReason.BREAKPOINT
60 if reason == self._interface.eStopReasonPlanComplete:
61 return StopReason.STEP
62 if reason == self._interface.eStopReasonThreadExiting:
63 return StopReason.PROGRAM_EXIT
64 if reason == self._interface.eStopReasonException:
65 return StopReason.ERROR
66 return StopReason.OTHER
67
68 def _load_interface(self):
69 try:
70 args = [self.lldb_executable, "-P"]
71 pythonpath = check_output(args, stderr=STDOUT).rstrip().decode("utf-8")
72 except CalledProcessError as e:
73 raise LoadDebuggerException(str(e), sys.exc_info())
74 except OSError as e:
75 raise LoadDebuggerException(
76 '{} ["{}"]'.format(e.strerror, self.lldb_executable), sys.exc_info()
77 )
78
79 if not os.path.isdir(pythonpath):
80 raise LoadDebuggerException(
81 'path "{}" does not exist [result of {}]'.format(pythonpath, args),
82 sys.exc_info(),
83 )
84
85 try:
86 return load_module("lldb", pythonpath)
87 except ImportError as e:
88 msg = str(e)
89 if msg.endswith("not a valid Win32 application."):
90 msg = "{} [Are you mixing 32-bit and 64-bit binaries?]".format(msg)
91 raise LoadDebuggerException(msg, sys.exc_info())
92
93 @classmethod
94 def get_name(cls):
95 return "lldb"
96
97 @classmethod
98 def get_option_name(cls):
99 return "lldb"
100
101 @property
102 def version(self):
103 try:
104 return self._interface.SBDebugger_GetVersionString()
105 except AttributeError:
106 return None
107
108 def clear_breakpoints(self):
109 self._target.DeleteAllBreakpoints()
110
111 def _add_breakpoint(self, file_, line):
112 return self._add_conditional_breakpoint(file_, line, None)
113
114 def _add_conditional_breakpoint(self, file_, line, condition):
115 bp = self._target.BreakpointCreateByLocation(file_, line)
116 if not bp:
117 raise DebuggerException(
118 "could not add breakpoint [{}:{}]".format(file_, line)
119 )
120 id = bp.GetID()
121 if condition:
122 bp.SetCondition(condition)
123 assert id not in self._breakpoint_conditions
124 self._breakpoint_conditions[id] = condition
125 return id
126
127 def _evaulate_breakpoint_condition(self, id):
128 """Evaluate the breakpoint condition and return the result.
129
130 Returns True if a conditional breakpoint with the specified id cannot
131 be found (i.e. assume it is an unconditional breakpoint).
132 """
133 try:
134 condition = self._breakpoint_conditions[id]
135 except KeyError:
136 # This must be an unconditional breakpoint.
137 return True
138 valueIR = self.evaluate_expression(condition)
139 return valueIR.type_name == "bool" and valueIR.value == "true"
140
141 def get_triggered_breakpoint_ids(self):
142 # Breakpoints can only have been triggered if we've hit one.
143 stop_reason = self._translate_stop_reason(self._thread.GetStopReason())
144 if stop_reason != StopReason.BREAKPOINT:
145 return []
146 breakpoint_ids = set()
147 # When the stop reason is eStopReasonBreakpoint, GetStopReasonDataCount
148 # counts all breakpoints associated with the location that lldb has
149 # stopped at, regardless of their condition. I.e. Even if we have two
150 # breakpoints at the same source location that have mutually exclusive
151 # conditions, both will be counted by GetStopReasonDataCount when
152 # either condition is true. Check each breakpoint condition manually to
153 # filter the list down to breakpoints that have caused this stop.
154 #
155 # Breakpoints have two data parts: Breakpoint ID, Location ID. We're
156 # only interested in the Breakpoint ID so we skip every other item.
157 for i in range(0, self._thread.GetStopReasonDataCount(), 2):
158 id = self._thread.GetStopReasonDataAtIndex(i)
159 if self._evaulate_breakpoint_condition(id):
160 breakpoint_ids.add(id)
161 return breakpoint_ids
162
163 def delete_breakpoints(self, ids):
164 for id in ids:
165 bp = self._target.FindBreakpointByID(id)
166 if not bp:
167 # The ID is not valid.
168 raise KeyError
169 try:
170 del self._breakpoint_conditions[id]
171 except KeyError:
172 # This must be an unconditional breakpoint.
173 pass
174 self._target.BreakpointDelete(id)
175
176 def launch(self, cmdline):
177 num_resolved_breakpoints = 0
178 for b in self._target.breakpoint_iter():
179 num_resolved_breakpoints += b.GetNumLocations() > 0
180 assert num_resolved_breakpoints > 0
181
182 if self.context.options.target_run_args:
183 cmdline += shlex.split(self.context.options.target_run_args)
184 launch_info = self._target.GetLaunchInfo()
185 launch_info.SetWorkingDirectory(os.getcwd())
186 launch_info.SetArguments(cmdline, True)
187 error = self._interface.SBError()
188 self._process = self._target.Launch(launch_info, error)
189
190 if error.Fail():
191 raise DebuggerException(error.GetCString())
192 if not os.path.exists(self._target.executable.fullpath):
193 raise DebuggerException("exe does not exist")
194 if not self._process or self._process.GetNumThreads() == 0:
195 raise DebuggerException("could not launch process")
196 if self._process.GetNumThreads() != 1:
197 raise DebuggerException("multiple threads not supported")
198 self._thread = self._process.GetThreadAtIndex(0)
199
200 num_stopped_threads = 0
201 for thread in self._process:
202 if thread.GetStopReason() == self._interface.eStopReasonBreakpoint:
203 num_stopped_threads += 1
204 assert num_stopped_threads > 0
205 assert self._thread, (self._process, self._thread)
206
207 def step_in(self):
208 self._thread.StepInto()
209 stop_reason = self._thread.GetStopReason()
210 # If we (1) completed a step and (2) are sitting at a breakpoint,
211 # but (3) the breakpoint is not reported as the stop reason, then
212 # we'll need to step once more to hit the breakpoint.
213 #
214 # dexter sets breakpoints on every source line, then steps
215 # each source line. Older lldb's would overwrite the stop
216 # reason with "breakpoint hit" when we stopped at a breakpoint,
217 # even if the breakpoint hadn't been exectued yet. One
218 # step per source line, hitting a breakpoint each time.
219 #
220 # But a more accurate behavior is that the step completes
221 # with step-completed stop reason, then when we step again,
222 # we execute the breakpoint and stop (with the pc the same) and
223 # a breakpoint-hit stop reason. So we need to step twice per line.
224 if stop_reason == self._interface.eStopReasonPlanComplete:
225 stepped_to_breakpoint = False
226 pc = self._thread.GetFrameAtIndex(0).GetPC()
227 for bp in self._target.breakpoints:
228 for bploc in bp.locations:
229 if (
230 bploc.IsEnabled()
231 and bploc.GetAddress().GetLoadAddress(self._target) == pc
232 ):
233 stepped_to_breakpoint = True
234 if stepped_to_breakpoint:
235 self._process.Continue()
236
237 def go(self) -> ReturnCode:
238 self._process.Continue()
239 return ReturnCode.OK
240
241 def _get_step_info(self, watches, step_index):
242 frames = []
243 state_frames = []
244
245 for i in range(0, self._thread.GetNumFrames()):
246 sb_frame = self._thread.GetFrameAtIndex(i)
247 sb_line = sb_frame.GetLineEntry()
248 sb_filespec = sb_line.GetFileSpec()
249
250 try:
251 path = os.path.join(
252 sb_filespec.GetDirectory(), sb_filespec.GetFilename()
253 )
254 except (AttributeError, TypeError):
255 path = None
256
257 function = self._sanitize_function_name(sb_frame.GetFunctionName())
258
259 loc_dict = {
260 "path": path,
261 "lineno": sb_line.GetLine(),
262 "column": sb_line.GetColumn(),
263 }
264 loc = LocIR(**loc_dict)
265 valid_loc_for_watch = loc.path and os.path.exists(loc.path)
266
267 frame = FrameIR(function=function, is_inlined=sb_frame.IsInlined(), loc=loc)
268
269 if any(
270 name in (frame.function or "") # pylint: disable=no-member
271 for name in self.frames_below_main
272 ):
273 break
274
275 frames.append(frame)
276
277 state_frame = StackFrame(
278 function=frame.function,
279 is_inlined=frame.is_inlined,
280 location=SourceLocation(**loc_dict),
281 watches={},
282 )
283 if valid_loc_for_watch:
284 for expr in map(
285 # Filter out watches that are not active in the current frame,
286 # and then evaluate all the active watches.
287 lambda watch_info, idx=i: self.evaluate_expression(
288 watch_info.expression, idx
289 ),
290 filter(
291 lambda watch_info, idx=i, line_no=loc.lineno, loc_path=loc.path: watch_is_active(
292 watch_info, loc_path, idx, line_no
293 ),
294 watches,
295 ),
296 ):
297 state_frame.watches[expr.expression] = expr
298 state_frames.append(state_frame)
299
300 if len(frames) == 1 and frames[0].function is None:
301 frames = []
302 state_frames = []
303
304 reason = self._translate_stop_reason(self._thread.GetStopReason())
305
306 return StepIR(
307 step_index=step_index,
308 frames=frames,
309 stop_reason=reason,
310 program_state=ProgramState(state_frames),
311 )
312
313 @property
314 def is_running(self):
315 # We're not running in async mode so this is always False.
316 return False
317
318 @property
319 def is_finished(self):
320 return not self._thread.GetFrameAtIndex(0)
321
322 @property
323 def frames_below_main(self):
324 return ["__scrt_common_main_seh", "__libc_start_main", "__libc_start_call_main"]
325
326 def evaluate_expression(self, expression, frame_idx=0) -> ValueIR:
327 result = self._thread.GetFrameAtIndex(frame_idx).EvaluateExpression(expression)
328 error_string = str(result.error)
329
330 value = result.value
331 could_evaluate = not any(
332 s in error_string
333 for s in [
334 "Can't run the expression locally",
335 "use of undeclared identifier",
336 "no member named",
337 "Couldn't lookup symbols",
338 "Couldn't look up symbols",
339 "reference to local variable",
340 "invalid use of 'this' outside of a non-static member function",
341 ]
342 )
343
344 is_optimized_away = any(
345 s in error_string
346 for s in [
347 "value may have been optimized out",
348 ]
349 )
350
351 is_irretrievable = any(
352 s in error_string
353 for s in [
354 "couldn't get the value of variable",
355 "couldn't read its memory",
356 "couldn't read from memory",
357 "Cannot access memory at address",
358 "invalid address (fault address:",
359 ]
360 )
361
362 if could_evaluate and not is_irretrievable and not is_optimized_away:
363 assert error_string == "success", (error_string, expression, value)
364 # assert result.value is not None, (result.value, expression)
365
366 if error_string == "success":
367 error_string = None
368
369 # attempt to find expression as a variable, if found, take the variable
370 # obj's type information as it's 'usually' more accurate.
371 var_result = self._thread.GetFrameAtIndex(frame_idx).FindVariable(expression)
372 if str(var_result.error) == "success":
373 type_name = var_result.type.GetDisplayTypeName()
374 else:
375 type_name = result.type.GetDisplayTypeName()
376
377 return ValueIR(
378 expression=expression,
379 value=value,
380 type_name=type_name,
381 error_string=error_string,
382 could_evaluate=could_evaluate,
383 is_optimized_away=is_optimized_away,
384 is_irretrievable=is_irretrievable,
385 )
386
387
388 class LLDBDAP(DAP):
389 def __init__(self, context, *args):
390 self.lldb_dap_executable = context.options.lldb_executable
391 super(LLDBDAP, self).__init__(context, *args)
392
393 @classmethod
394 def get_name(cls):
395 return "lldb-dap"
396
397 @classmethod
398 def get_option_name(cls):
399 return "lldb-dap"
400
401 @property
402 def version(self):
403 return 1
404
405 @property
406 def _debug_adapter_name(self) -> str:
407 return "lldb-dap"
408
409 @property
410 def _debug_adapter_executable(self) -> str:
411 return self.lldb_dap_executable
412
413 @property
414 def frames_below_main(self):
415 return [
416 "__scrt_common_main_seh",
417 "__libc_start_main",
418 "__libc_start_call_main",
419 "_start",
420 ]
421
422 def _post_step_hook(self):
423 """Hook to be executed after completing a step request."""
424 if self._debugger_state.stopped_reason == "step":
425 trace_req_id = self.send_message(
426 self.make_request(
427 "stackTrace", {"threadId": self._debugger_state.thread, "levels": 1}
428 )
429 )
430 trace_response = self._await_response(trace_req_id)
431 if not trace_response["success"]:
432 raise DebuggerException("failed to get stack frames")
433 stackframes = trace_response["body"]["stackFrames"]
434 addr = stackframes[0]["instructionPointerReference"]
435 try:
436 path = stackframes[0]["source"]["path"]
437 except KeyError:
438 # We may have no path, e.g., if the module hasn't loaded or
439 # there's no debug info. If that's the case we won't have
440 # bound a source-location breakpoint here, so we can bail now.
441 return
442
443 if any(
444 self._debugger_state.bp_addr_map.get(self.dex_id_to_dap_id[dex_bp_id])
445 == addr
446 for dex_bp_id in self.file_to_bp.get(path, [])
447 ):
448 # Step again now to get to the breakpoint.
449 step_req_id = self.send_message(
450 self.make_request(
451 "continue", {"threadId": self._debugger_state.thread}
452 )
453 )
454 response = self._await_response(step_req_id)
455 if not response["success"]:
456 raise DebuggerException("failed to step")
457
458 def _get_launch_params(self, cmdline):
459 cwd = os.getcwd()
460 return {
461 "cwd": cwd,
462 "args": cmdline,
463 "program": self.context.options.executable,
464 }
465
466 @staticmethod
467 def _evaluate_result_value(
468 expression: str, result_string: str, type_string
469 ) -> ValueIR:
470 could_evaluate = not any(
471 s in result_string
472 for s in [
473 "Can't run the expression locally",
474 "use of undeclared identifier",
475 "no member named",
476 "Couldn't lookup symbols",
477 "Couldn't look up symbols",
478 "reference to local variable",
479 "invalid use of 'this' outside of a non-static member function",
480 ]
481 )
482
483 is_optimized_away = any(
484 s in result_string
485 for s in [
486 "value may have been optimized out",
487 ]
488 )
489
490 is_irretrievable = any(
491 s in result_string
492 for s in [
493 "couldn't get the value of variable",
494 "couldn't read its memory",
495 "couldn't read from memory",
496 "Cannot access memory at address",
497 "invalid address (fault address:",
498 ]
499 )
500
501 if could_evaluate and not is_irretrievable and not is_optimized_away:
502 error_string = None
503 else:
504 error_string = result_string
505
506 return ValueIR(
507 expression=expression,
508 value=result_string,
509 type_name=type_string,
510 error_string=error_string,
511 could_evaluate=could_evaluate,
512 is_optimized_away=is_optimized_away,
513 is_irretrievable=is_irretrievable,
514 )
515
516 def _update_requested_bp_list(self, bp_list):
517 """ "As lldb-dap cannot have multiple breakpoints at the same location with different conditions, we must
518 manually merge conditions here."""
519 line_to_cond = {}
520 for bp in bp_list:
521 if bp.condition is None:
522 line_to_cond[bp.line] = None
523 continue
524 # If we have a condition, we merge it with the existing condition if one exists, unless the known condition
525 # is None in which case we preserve the None condition (as the underlying breakpoint should always be hit).
526 if bp.line not in line_to_cond:
527 line_to_cond[bp.line] = f"({bp.condition})"
528 elif line_to_cond[bp.line] is not None:
529 line_to_cond[bp.line] = f"{line_to_cond[bp.line]} || ({bp.condition})"
530 bp.condition = line_to_cond[bp.line]
531 return bp_list
532
533 def _confirm_triggered_breakpoint_ids(self, dex_bp_ids):
534 """ "As lldb returns every breakpoint at the current PC regardless of whether their condition was met, we must
535 manually check conditions here."""
536 confirmed_breakpoint_ids = set()
537 for dex_bp_id in dex_bp_ids:
538 # Function and instruction breakpoints don't use conditions.
539 # FIXME: That's not a DAP restriction, so they could in future.
540 if dex_bp_id not in self.bp_info:
541 assert (
542 dex_bp_id in self.function_bp_info
543 or dex_bp_id in self.instruction_bp_info
544 )
545 confirmed_breakpoint_ids.add(dex_bp_id)
546 continue
547
548 _, _, cond = self.bp_info[dex_bp_id]
549 if cond is None:
550 confirmed_breakpoint_ids.add(dex_bp_id)
551 continue
552 valueIR = self.evaluate_expression(cond)
553 if valueIR.type_name == "bool" and valueIR.value == "true":
554 confirmed_breakpoint_ids.add(dex_bp_id)
555 return confirmed_breakpoint_ids