lldb/examples/python/lldbtk.py

   1 #!/usr/bin/env python
   2
   3 import lldb
   4 import shlex
   5 import sys
   6
   7 try:
   8     from tkinter import *
   9     import tkinter.ttk as ttk
  10 except ImportError:
  11     from Tkinter import *
  12     import ttk
  13
  14
  15 class ValueTreeItemDelegate(object):
  16     def __init__(self, value):
  17         self.value = value
  18
  19     def get_item_dictionary(self):
  20         name = self.value.name
  21         if name is None:
  22             name = ""
  23         typename = self.value.type
  24         if typename is None:
  25             typename = ""
  26         value = self.value.value
  27         if value is None:
  28             value = ""
  29         summary = self.value.summary
  30         if summary is None:
  31             summary = ""
  32         has_children = self.value.MightHaveChildren()
  33         return {
  34             "#0": name,
  35             "typename": typename,
  36             "value": value,
  37             "summary": summary,
  38             "children": has_children,
  39             "tree-item-delegate": self,
  40         }
  41
  42     def get_child_item_dictionaries(self):
  43         item_dicts = list()
  44         for i in range(self.value.num_children):
  45             item_delegate = ValueTreeItemDelegate(self.value.GetChildAtIndex(i))
  46             item_dicts.append(item_delegate.get_item_dictionary())
  47         return item_dicts
  48
  49
  50 class FrameTreeItemDelegate(object):
  51     def __init__(self, frame):
  52         self.frame = frame
  53
  54     def get_item_dictionary(self):
  55         id = self.frame.GetFrameID()
  56         name = "frame #%u" % (id)
  57         value = "0x%16.16x" % (self.frame.GetPC())
  58         stream = lldb.SBStream()
  59         self.frame.GetDescription(stream)
  60         summary = stream.GetData().split("`")[1]
  61         return {
  62             "#0": name,
  63             "value": value,
  64             "summary": summary,
  65             "children": self.frame.GetVariables(True, True, True, True).GetSize() > 0,
  66             "tree-item-delegate": self,
  67         }
  68
  69     def get_child_item_dictionaries(self):
  70         item_dicts = list()
  71         variables = self.frame.GetVariables(True, True, True, True)
  72         n = variables.GetSize()
  73         for i in range(n):
  74             item_delegate = ValueTreeItemDelegate(variables[i])
  75             item_dicts.append(item_delegate.get_item_dictionary())
  76         return item_dicts
  77
  78
  79 class ThreadTreeItemDelegate(object):
  80     def __init__(self, thread):
  81         self.thread = thread
  82
  83     def get_item_dictionary(self):
  84         num_frames = self.thread.GetNumFrames()
  85         name = "thread #%u" % (self.thread.GetIndexID())
  86         value = "0x%x" % (self.thread.GetThreadID())
  87         summary = "%u frames" % (num_frames)
  88         return {
  89             "#0": name,
  90             "value": value,
  91             "summary": summary,
  92             "children": num_frames > 0,
  93             "tree-item-delegate": self,
  94         }
  95
  96     def get_child_item_dictionaries(self):
  97         item_dicts = list()
  98         for frame in self.thread:
  99             item_delegate = FrameTreeItemDelegate(frame)
 100             item_dicts.append(item_delegate.get_item_dictionary())
 101         return item_dicts
 102
 103
 104 class ProcessTreeItemDelegate(object):
 105     def __init__(self, process):
 106         self.process = process
 107
 108     def get_item_dictionary(self):
 109         id = self.process.GetProcessID()
 110         num_threads = self.process.GetNumThreads()
 111         value = str(self.process.GetProcessID())
 112         summary = self.process.target.executable.fullpath
 113         return {
 114             "#0": "process",
 115             "value": value,
 116             "summary": summary,
 117             "children": num_threads > 0,
 118             "tree-item-delegate": self,
 119         }
 120
 121     def get_child_item_dictionaries(self):
 122         item_dicts = list()
 123         for thread in self.process:
 124             item_delegate = ThreadTreeItemDelegate(thread)
 125             item_dicts.append(item_delegate.get_item_dictionary())
 126         return item_dicts
 127
 128
 129 class TargetTreeItemDelegate(object):
 130     def __init__(self, target):
 131         self.target = target
 132
 133     def get_item_dictionary(self):
 134         value = str(self.target.triple)
 135         summary = self.target.executable.fullpath
 136         return {
 137             "#0": "target",
 138             "value": value,
 139             "summary": summary,
 140             "children": True,
 141             "tree-item-delegate": self,
 142         }
 143
 144     def get_child_item_dictionaries(self):
 145         item_dicts = list()
 146         image_item_delegate = TargetImagesTreeItemDelegate(self.target)
 147         item_dicts.append(image_item_delegate.get_item_dictionary())
 148         return item_dicts
 149
 150
 151 class TargetImagesTreeItemDelegate(object):
 152     def __init__(self, target):
 153         self.target = target
 154
 155     def get_item_dictionary(self):
 156         value = str(self.target.triple)
 157         summary = self.target.executable.fullpath
 158         num_modules = self.target.GetNumModules()
 159         return {
 160             "#0": "images",
 161             "value": "",
 162             "summary": "%u images" % num_modules,
 163             "children": num_modules > 0,
 164             "tree-item-delegate": self,
 165         }
 166
 167     def get_child_item_dictionaries(self):
 168         item_dicts = list()
 169         for i in range(self.target.GetNumModules()):
 170             module = self.target.GetModuleAtIndex(i)
 171             image_item_delegate = ModuleTreeItemDelegate(self.target, module, i)
 172             item_dicts.append(image_item_delegate.get_item_dictionary())
 173         return item_dicts
 174
 175
 176 class ModuleTreeItemDelegate(object):
 177     def __init__(self, target, module, index):
 178         self.target = target
 179         self.module = module
 180         self.index = index
 181
 182     def get_item_dictionary(self):
 183         name = "module %u" % (self.index)
 184         value = self.module.file.basename
 185         summary = self.module.file.dirname
 186         return {
 187             "#0": name,
 188             "value": value,
 189             "summary": summary,
 190             "children": True,
 191             "tree-item-delegate": self,
 192         }
 193
 194     def get_child_item_dictionaries(self):
 195         item_dicts = list()
 196         sections_item_delegate = ModuleSectionsTreeItemDelegate(
 197             self.target, self.module
 198         )
 199         item_dicts.append(sections_item_delegate.get_item_dictionary())
 200
 201         symbols_item_delegate = ModuleSymbolsTreeItemDelegate(self.target, self.module)
 202         item_dicts.append(symbols_item_delegate.get_item_dictionary())
 203
 204         comp_units_item_delegate = ModuleCompileUnitsTreeItemDelegate(
 205             self.target, self.module
 206         )
 207         item_dicts.append(comp_units_item_delegate.get_item_dictionary())
 208         return item_dicts
 209
 210
 211 class ModuleSectionsTreeItemDelegate(object):
 212     def __init__(self, target, module):
 213         self.target = target
 214         self.module = module
 215
 216     def get_item_dictionary(self):
 217         name = "sections"
 218         value = ""
 219         summary = "%u sections" % (self.module.GetNumSections())
 220         return {
 221             "#0": name,
 222             "value": value,
 223             "summary": summary,
 224             "children": True,
 225             "tree-item-delegate": self,
 226         }
 227
 228     def get_child_item_dictionaries(self):
 229         item_dicts = list()
 230         num_sections = self.module.GetNumSections()
 231         for i in range(num_sections):
 232             section = self.module.GetSectionAtIndex(i)
 233             image_item_delegate = SectionTreeItemDelegate(self.target, section)
 234             item_dicts.append(image_item_delegate.get_item_dictionary())
 235         return item_dicts
 236
 237
 238 class SectionTreeItemDelegate(object):
 239     def __init__(self, target, section):
 240         self.target = target
 241         self.section = section
 242
 243     def get_item_dictionary(self):
 244         name = self.section.name
 245         section_load_addr = self.section.GetLoadAddress(self.target)
 246         if section_load_addr != lldb.LLDB_INVALID_ADDRESS:
 247             value = "0x%16.16x" % (section_load_addr)
 248         else:
 249             value = "0x%16.16x *" % (self.section.file_addr)
 250         summary = ""
 251         return {
 252             "#0": name,
 253             "value": value,
 254             "summary": summary,
 255             "children": self.section.GetNumSubSections() > 0,
 256             "tree-item-delegate": self,
 257         }
 258
 259     def get_child_item_dictionaries(self):
 260         item_dicts = list()
 261         num_sections = self.section.GetNumSubSections()
 262         for i in range(num_sections):
 263             section = self.section.GetSubSectionAtIndex(i)
 264             image_item_delegate = SectionTreeItemDelegate(self.target, section)
 265             item_dicts.append(image_item_delegate.get_item_dictionary())
 266         return item_dicts
 267
 268
 269 class ModuleCompileUnitsTreeItemDelegate(object):
 270     def __init__(self, target, module):
 271         self.target = target
 272         self.module = module
 273
 274     def get_item_dictionary(self):
 275         name = "compile units"
 276         value = ""
 277         summary = "%u compile units" % (self.module.GetNumSections())
 278         return {
 279             "#0": name,
 280             "value": value,
 281             "summary": summary,
 282             "children": self.module.GetNumCompileUnits() > 0,
 283             "tree-item-delegate": self,
 284         }
 285
 286     def get_child_item_dictionaries(self):
 287         item_dicts = list()
 288         num_cus = self.module.GetNumCompileUnits()
 289         for i in range(num_cus):
 290             cu = self.module.GetCompileUnitAtIndex(i)
 291             image_item_delegate = CompileUnitTreeItemDelegate(self.target, cu)
 292             item_dicts.append(image_item_delegate.get_item_dictionary())
 293         return item_dicts
 294
 295
 296 class CompileUnitTreeItemDelegate(object):
 297     def __init__(self, target, cu):
 298         self.target = target
 299         self.cu = cu
 300
 301     def get_item_dictionary(self):
 302         name = self.cu.GetFileSpec().basename
 303         value = ""
 304         num_lines = self.cu.GetNumLineEntries()
 305         summary = ""
 306         return {
 307             "#0": name,
 308             "value": value,
 309             "summary": summary,
 310             "children": num_lines > 0,
 311             "tree-item-delegate": self,
 312         }
 313
 314     def get_child_item_dictionaries(self):
 315         item_dicts = list()
 316         item_delegate = LineTableTreeItemDelegate(self.target, self.cu)
 317         item_dicts.append(item_delegate.get_item_dictionary())
 318         return item_dicts
 319
 320
 321 class LineTableTreeItemDelegate(object):
 322     def __init__(self, target, cu):
 323         self.target = target
 324         self.cu = cu
 325
 326     def get_item_dictionary(self):
 327         name = "line table"
 328         value = ""
 329         num_lines = self.cu.GetNumLineEntries()
 330         summary = "%u line entries" % (num_lines)
 331         return {
 332             "#0": name,
 333             "value": value,
 334             "summary": summary,
 335             "children": num_lines > 0,
 336             "tree-item-delegate": self,
 337         }
 338
 339     def get_child_item_dictionaries(self):
 340         item_dicts = list()
 341         num_lines = self.cu.GetNumLineEntries()
 342         for i in range(num_lines):
 343             line_entry = self.cu.GetLineEntryAtIndex(i)
 344             item_delegate = LineEntryTreeItemDelegate(self.target, line_entry, i)
 345             item_dicts.append(item_delegate.get_item_dictionary())
 346         return item_dicts
 347
 348
 349 class LineEntryTreeItemDelegate(object):
 350     def __init__(self, target, line_entry, index):
 351         self.target = target
 352         self.line_entry = line_entry
 353         self.index = index
 354
 355     def get_item_dictionary(self):
 356         name = str(self.index)
 357         address = self.line_entry.GetStartAddress()
 358         load_addr = address.GetLoadAddress(self.target)
 359         if load_addr != lldb.LLDB_INVALID_ADDRESS:
 360             value = "0x%16.16x" % (load_addr)
 361         else:
 362             value = "0x%16.16x *" % (address.file_addr)
 363         summary = (
 364             self.line_entry.GetFileSpec().fullpath + ":" + str(self.line_entry.line)
 365         )
 366         return {
 367             "#0": name,
 368             "value": value,
 369             "summary": summary,
 370             "children": False,
 371             "tree-item-delegate": self,
 372         }
 373
 374     def get_child_item_dictionaries(self):
 375         item_dicts = list()
 376         return item_dicts
 377
 378
 379 class InstructionTreeItemDelegate(object):
 380     def __init__(self, target, instr):
 381         self.target = target
 382         self.instr = instr
 383
 384     def get_item_dictionary(self):
 385         address = self.instr.GetAddress()
 386         load_addr = address.GetLoadAddress(self.target)
 387         if load_addr != lldb.LLDB_INVALID_ADDRESS:
 388             name = "0x%16.16x" % (load_addr)
 389         else:
 390             name = "0x%16.16x *" % (address.file_addr)
 391         value = (
 392             self.instr.GetMnemonic(self.target)
 393             + " "
 394             + self.instr.GetOperands(self.target)
 395         )
 396         summary = self.instr.GetComment(self.target)
 397         return {
 398             "#0": name,
 399             "value": value,
 400             "summary": summary,
 401             "children": False,
 402             "tree-item-delegate": self,
 403         }
 404
 405
 406 class ModuleSymbolsTreeItemDelegate(object):
 407     def __init__(self, target, module):
 408         self.target = target
 409         self.module = module
 410
 411     def get_item_dictionary(self):
 412         name = "symbols"
 413         value = ""
 414         summary = "%u symbols" % (self.module.GetNumSymbols())
 415         return {
 416             "#0": name,
 417             "value": value,
 418             "summary": summary,
 419             "children": True,
 420             "tree-item-delegate": self,
 421         }
 422
 423     def get_child_item_dictionaries(self):
 424         item_dicts = list()
 425         num_symbols = self.module.GetNumSymbols()
 426         for i in range(num_symbols):
 427             symbol = self.module.GetSymbolAtIndex(i)
 428             image_item_delegate = SymbolTreeItemDelegate(self.target, symbol, i)
 429             item_dicts.append(image_item_delegate.get_item_dictionary())
 430         return item_dicts
 431
 432
 433 class SymbolTreeItemDelegate(object):
 434     def __init__(self, target, symbol, index):
 435         self.target = target
 436         self.symbol = symbol
 437         self.index = index
 438
 439     def get_item_dictionary(self):
 440         address = self.symbol.GetStartAddress()
 441         name = "[%u]" % self.index
 442         symbol_load_addr = address.GetLoadAddress(self.target)
 443         if symbol_load_addr != lldb.LLDB_INVALID_ADDRESS:
 444             value = "0x%16.16x" % (symbol_load_addr)
 445         else:
 446             value = "0x%16.16x *" % (address.file_addr)
 447         summary = self.symbol.name
 448         return {
 449             "#0": name,
 450             "value": value,
 451             "summary": summary,
 452             "children": False,
 453             "tree-item-delegate": self,
 454         }
 455
 456     def get_child_item_dictionaries(self):
 457         item_dicts = list()
 458         return item_dicts
 459
 460
 461 class DelegateTree(ttk.Frame):
 462     def __init__(self, column_dicts, delegate, title, name):
 463         ttk.Frame.__init__(self, name=name)
 464         self.pack(expand=Y, fill=BOTH)
 465         self.master.title(title)
 466         self.delegate = delegate
 467         self.columns_dicts = column_dicts
 468         self.item_id_to_item_dict = dict()
 469         frame = Frame(self)
 470         frame.pack(side=TOP, fill=BOTH, expand=Y)
 471         self._create_treeview(frame)
 472         self._populate_root()
 473
 474     def _create_treeview(self, parent):
 475         frame = ttk.Frame(parent)
 476         frame.pack(side=TOP, fill=BOTH, expand=Y)
 477
 478         column_ids = list()
 479         for i in range(1, len(self.columns_dicts)):
 480             column_ids.append(self.columns_dicts[i]["id"])
 481         # create the tree and scrollbars
 482         self.tree = ttk.Treeview(columns=column_ids)
 483
 484         scroll_bar_v = ttk.Scrollbar(orient=VERTICAL, command=self.tree.yview)
 485         scroll_bar_h = ttk.Scrollbar(orient=HORIZONTAL, command=self.tree.xview)
 486         self.tree["yscroll"] = scroll_bar_v.set
 487         self.tree["xscroll"] = scroll_bar_h.set
 488
 489         # setup column headings and columns properties
 490         for columns_dict in self.columns_dicts:
 491             self.tree.heading(
 492                 columns_dict["id"],
 493                 text=columns_dict["text"],
 494                 anchor=columns_dict["anchor"],
 495             )
 496             self.tree.column(columns_dict["id"], stretch=columns_dict["stretch"])
 497
 498         # add tree and scrollbars to frame
 499         self.tree.grid(in_=frame, row=0, column=0, sticky=NSEW)
 500         scroll_bar_v.grid(in_=frame, row=0, column=1, sticky=NS)
 501         scroll_bar_h.grid(in_=frame, row=1, column=0, sticky=EW)
 502
 503         # set frame resizing priorities
 504         frame.rowconfigure(0, weight=1)
 505         frame.columnconfigure(0, weight=1)
 506
 507         # action to perform when a node is expanded
 508         self.tree.bind("<<TreeviewOpen>>", self._update_tree)
 509
 510     def insert_items(self, parent_id, item_dicts):
 511         for item_dict in item_dicts:
 512             name = None
 513             values = list()
 514             first = True
 515             for columns_dict in self.columns_dicts:
 516                 if first:
 517                     name = item_dict[columns_dict["id"]]
 518                     first = False
 519                 else:
 520                     values.append(item_dict[columns_dict["id"]])
 521             item_id = self.tree.insert(
 522                 parent_id, END, text=name, values=values  # root item has an empty name
 523             )
 524             self.item_id_to_item_dict[item_id] = item_dict
 525             if item_dict["children"]:
 526                 self.tree.insert(item_id, END, text="dummy")
 527
 528     def _populate_root(self):
 529         # use current directory as root node
 530         self.insert_items("", self.delegate.get_child_item_dictionaries())
 531
 532     def _update_tree(self, event):
 533         # user expanded a node - build the related directory
 534         item_id = self.tree.focus()  # the id of the expanded node
 535         children = self.tree.get_children(item_id)
 536         if len(children):
 537             first_child = children[0]
 538             # if the node only has a 'dummy' child, remove it and
 539             # build new directory; skip if the node is already
 540             # populated
 541             if self.tree.item(first_child, option="text") == "dummy":
 542                 self.tree.delete(first_child)
 543                 item_dict = self.item_id_to_item_dict[item_id]
 544                 item_dicts = item_dict[
 545                     "tree-item-delegate"
 546                 ].get_child_item_dictionaries()
 547                 self.insert_items(item_id, item_dicts)
 548
 549
 550 @lldb.command("tk-variables")
 551 def tk_variable_display(debugger, command, result, dict):
 552     # needed for tree creation in TK library as it uses sys.argv...
 553     sys.argv = ["tk-variables"]
 554     target = debugger.GetSelectedTarget()
 555     if not target:
 556         print("invalid target", file=result)
 557         return
 558     process = target.GetProcess()
 559     if not process:
 560         print("invalid process", file=result)
 561         return
 562     thread = process.GetSelectedThread()
 563     if not thread:
 564         print("invalid thread", file=result)
 565         return
 566     frame = thread.GetSelectedFrame()
 567     if not frame:
 568         print("invalid frame", file=result)
 569         return
 570     # Parse command line args
 571     command_args = shlex.split(command)
 572     column_dicts = [
 573         {"id": "#0", "text": "Name", "anchor": W, "stretch": 0},
 574         {"id": "typename", "text": "Type", "anchor": W, "stretch": 0},
 575         {"id": "value", "text": "Value", "anchor": W, "stretch": 0},
 576         {"id": "summary", "text": "Summary", "anchor": W, "stretch": 1},
 577     ]
 578     tree = DelegateTree(
 579         column_dicts, FrameTreeItemDelegate(frame), "Variables", "lldb-tk-variables"
 580     )
 581     tree.mainloop()
 582
 583
 584 @lldb.command("tk-process")
 585 def tk_process_display(debugger, command, result, dict):
 586     # needed for tree creation in TK library as it uses sys.argv...
 587     sys.argv = ["tk-process"]
 588     target = debugger.GetSelectedTarget()
 589     if not target:
 590         print("invalid target", file=result)
 591         return
 592     process = target.GetProcess()
 593     if not process:
 594         print("invalid process", file=result)
 595         return
 596     # Parse command line args
 597     columnd_dicts = [
 598         {"id": "#0", "text": "Name", "anchor": W, "stretch": 0},
 599         {"id": "value", "text": "Value", "anchor": W, "stretch": 0},
 600         {"id": "summary", "text": "Summary", "anchor": W, "stretch": 1},
 601     ]
 602     command_args = shlex.split(command)
 603     tree = DelegateTree(
 604         columnd_dicts, ProcessTreeItemDelegate(process), "Process", "lldb-tk-process"
 605     )
 606     tree.mainloop()
 607
 608
 609 @lldb.command("tk-target")
 610 def tk_target_display(debugger, command, result, dict):
 611     # needed for tree creation in TK library as it uses sys.argv...
 612     sys.argv = ["tk-target"]
 613     target = debugger.GetSelectedTarget()
 614     if not target:
 615         print("invalid target", file=result)
 616         return
 617     # Parse command line args
 618     columnd_dicts = [
 619         {"id": "#0", "text": "Name", "anchor": W, "stretch": 0},
 620         {"id": "value", "text": "Value", "anchor": W, "stretch": 0},
 621         {"id": "summary", "text": "Summary", "anchor": W, "stretch": 1},
 622     ]
 623     command_args = shlex.split(command)
 624     tree = DelegateTree(
 625         columnd_dicts, TargetTreeItemDelegate(target), "Target", "lldb-tk-target"
 626     )
 627     tree.mainloop()