1 """ 2 GDB extension that adds Cython support. 3 """ 4 5 from __future__ import with_statement 6 7 import sys 8 import textwrap 9 import traceback 10 import functools 11 import itertools 12 import collections 13 14 import gdb 15 16 try: 17 from lxml import etree 18 have_lxml = True 19 except ImportError: 20 have_lxml = False 21 try: 22 # Python 2.5 23 from xml.etree import cElementTree as etree 24 except ImportError: 25 try: 26 # Python 2.5 27 from xml.etree import ElementTree as etree 28 except ImportError: 29 try: 30 # normal cElementTree install 31 import cElementTree as etree 32 except ImportError: 33 # normal ElementTree install 34 import elementtree.ElementTree as etree 35 36 try: 37 import pygments.lexers 38 import pygments.formatters 39 except ImportError: 40 pygments = None 41 sys.stderr.write("Install pygments for colorized source code.\n") 42 43 if hasattr(gdb, 'string_to_argv'): 44 from gdb import string_to_argv 45 else: 46 from shlex import split as string_to_argv 47 48 from Cython.Debugger import libpython 49 50 # C or Python type 51 CObject = 'CObject' 52 PythonObject = 'PythonObject' 53 54 _data_types = dict(CObject=CObject, PythonObject=PythonObject) 55 _filesystemencoding = sys.getfilesystemencoding() or 'UTF-8' 56 57 # decorators 58 59 def dont_suppress_errors(function): 60 "*sigh*, readline" 61 @functools.wraps(function) 62 def wrapper(*args, **kwargs): 63 try: 64 return function(*args, **kwargs) 65 except Exception: 66 traceback.print_exc() 67 raise 68 69 return wrapper 70 71 def default_selected_gdb_frame(err=True): 72 def decorator(function): 73 @functools.wraps(function) 74 def wrapper(self, frame=None, *args, **kwargs): 75 try: 76 frame = frame or gdb.selected_frame() 77 except RuntimeError: 78 raise gdb.GdbError("No frame is currently selected.") 79 80 if err and frame.name() is None: 81 raise NoFunctionNameInFrameError() 82 83 return function(self, frame, *args, **kwargs) 84 return wrapper 85 return decorator 86 87 def require_cython_frame(function): 88 @functools.wraps(function) 89 @require_running_program 90 def wrapper(self, *args, **kwargs): 91 frame = kwargs.get('frame') or gdb.selected_frame() 92 if not self.is_cython_function(frame): 93 raise gdb.GdbError('Selected frame does not correspond with a ' 94 'Cython function we know about.') 95 return function(self, *args, **kwargs) 96 return wrapper 97 98 def dispatch_on_frame(c_command, python_command=None): 99 def decorator(function): 100 @functools.wraps(function) 101 def wrapper(self, *args, **kwargs): 102 is_cy = self.is_cython_function() 103 is_py = self.is_python_function() 104 105 if is_cy or (is_py and not python_command): 106 function(self, *args, **kwargs) 107 elif is_py: 108 gdb.execute(python_command) 109 elif self.is_relevant_function(): 110 gdb.execute(c_command) 111 else: 112 raise gdb.GdbError("Not a function cygdb knows about. " 113 "Use the normal GDB commands instead.") 114 115 return wrapper 116 return decorator 117 118 def require_running_program(function): 119 @functools.wraps(function) 120 def wrapper(*args, **kwargs): 121 try: 122 gdb.selected_frame() 123 except RuntimeError: 124 raise gdb.GdbError("No frame is currently selected.") 125 126 return function(*args, **kwargs) 127 return wrapper 128 129 130 def gdb_function_value_to_unicode(function): 131 @functools.wraps(function) 132 def wrapper(self, string, *args, **kwargs): 133 if isinstance(string, gdb.Value): 134 string = string.string() 135 136 return function(self, string, *args, **kwargs) 137 return wrapper 138 139 140 # Classes that represent the debug information 141 # Don't rename the parameters of these classes, they come directly from the XML 142 143 class CythonModule(object): 144 def __init__(self, module_name, filename, c_filename): 145 self.name = module_name 146 self.filename = filename 147 self.c_filename = c_filename 148 self.globals = {} 149 # {cython_lineno: min(c_linenos)} 150 self.lineno_cy2c = {} 151 # {c_lineno: cython_lineno} 152 self.lineno_c2cy = {} 153 self.functions = {} 154 155 class CythonVariable(object): 156 157 def __init__(self, name, cname, qualified_name, type, lineno): 158 self.name = name 159 self.cname = cname 160 self.qualified_name = qualified_name 161 self.type = type 162 self.lineno = int(lineno) 163 164 class CythonFunction(CythonVariable): 165 def __init__(self, 166 module, 167 name, 168 cname, 169 pf_cname, 170 qualified_name, 171 lineno, 172 type=CObject, 173 is_initmodule_function="False"): 174 super(CythonFunction, self).__init__(name, 175 cname, 176 qualified_name, 177 type, 178 lineno) 179 self.module = module 180 self.pf_cname = pf_cname 181 self.is_initmodule_function = is_initmodule_function == "True" 182 self.locals = {} 183 self.arguments = [] 184 self.step_into_functions = set() 185 186 187 # General purpose classes 188 189 class CythonBase(object): 190 191 @default_selected_gdb_frame(err=False) 192 def is_cython_function(self, frame): 193 return frame.name() in self.cy.functions_by_cname 194 195 @default_selected_gdb_frame(err=False) 196 def is_python_function(self, frame): 197 """ 198 Tells if a frame is associated with a Python function. 199 If we can't read the Python frame information, don't regard it as such. 200 """ 201 if frame.name() == 'PyEval_EvalFrameEx': 202 pyframe = libpython.Frame(frame).get_pyop() 203 return pyframe and not pyframe.is_optimized_out() 204 return False 205 206 @default_selected_gdb_frame() 207 def get_c_function_name(self, frame): 208 return frame.name() 209 210 @default_selected_gdb_frame() 211 def get_c_lineno(self, frame): 212 return frame.find_sal().line 213 214 @default_selected_gdb_frame() 215 def get_cython_function(self, frame): 216 result = self.cy.functions_by_cname.get(frame.name()) 217 if result is None: 218 raise NoCythonFunctionInFrameError() 219 220 return result 221 222 @default_selected_gdb_frame() 223 def get_cython_lineno(self, frame): 224 """ 225 Get the current Cython line number. Returns 0 if there is no 226 correspondence between the C and Cython code. 227 """ 228 cyfunc = self.get_cython_function(frame) 229 return cyfunc.module.lineno_c2cy.get(self.get_c_lineno(frame), 0) 230 231 @default_selected_gdb_frame() 232 def get_source_desc(self, frame): 233 filename = lineno = lexer = None 234 if self.is_cython_function(frame): 235 filename = self.get_cython_function(frame).module.filename 236 lineno = self.get_cython_lineno(frame) 237 if pygments: 238 lexer = pygments.lexers.CythonLexer(stripall=False) 239 elif self.is_python_function(frame): 240 pyframeobject = libpython.Frame(frame).get_pyop() 241 242 if not pyframeobject: 243 raise gdb.GdbError( 244 'Unable to read information on python frame') 245 246 filename = pyframeobject.filename() 247 lineno = pyframeobject.current_line_num() 248 249 if pygments: 250 lexer = pygments.lexers.PythonLexer(stripall=False) 251 else: 252 symbol_and_line_obj = frame.find_sal() 253 if not symbol_and_line_obj or not symbol_and_line_obj.symtab: 254 filename = None 255 lineno = 0 256 else: 257 filename = symbol_and_line_obj.symtab.fullname() 258 lineno = symbol_and_line_obj.line 259 if pygments: 260 lexer = pygments.lexers.CLexer(stripall=False) 261 262 return SourceFileDescriptor(filename, lexer), lineno 263 264 @default_selected_gdb_frame() 265 def get_source_line(self, frame): 266 source_desc, lineno = self.get_source_desc() 267 return source_desc.get_source(lineno) 268 269 @default_selected_gdb_frame() 270 def is_relevant_function(self, frame): 271 """ 272 returns whether we care about a frame on the user-level when debugging 273 Cython code 274 """ 275 name = frame.name() 276 older_frame = frame.older() 277 if self.is_cython_function(frame) or self.is_python_function(frame): 278 return True 279 elif older_frame and self.is_cython_function(older_frame): 280 # check for direct C function call from a Cython function 281 cython_func = self.get_cython_function(older_frame) 282 return name in cython_func.step_into_functions 283 284 return False 285 286 @default_selected_gdb_frame(err=False) 287 def print_stackframe(self, frame, index, is_c=False): 288 """ 289 Print a C, Cython or Python stack frame and the line of source code 290 if available. 291 """ 292 # do this to prevent the require_cython_frame decorator from 293 # raising GdbError when calling self.cy.cy_cvalue.invoke() 294 selected_frame = gdb.selected_frame() 295 frame.select() 296 297 try: 298 source_desc, lineno = self.get_source_desc(frame) 299 except NoFunctionNameInFrameError: 300 print '#%-2d Unknown Frame (compile with -g)' % index 301 return 302 303 if not is_c and self.is_python_function(frame): 304 pyframe = libpython.Frame(frame).get_pyop() 305 if pyframe is None or pyframe.is_optimized_out(): 306 # print this python function as a C function 307 return self.print_stackframe(frame, index, is_c=True) 308 309 func_name = pyframe.co_name 310 func_cname = 'PyEval_EvalFrameEx' 311 func_args = [] 312 elif self.is_cython_function(frame): 313 cyfunc = self.get_cython_function(frame) 314 f = lambda arg: self.cy.cy_cvalue.invoke(arg, frame=frame) 315 316 func_name = cyfunc.name 317 func_cname = cyfunc.cname 318 func_args = [] # [(arg, f(arg)) for arg in cyfunc.arguments] 319 else: 320 source_desc, lineno = self.get_source_desc(frame) 321 func_name = frame.name() 322 func_cname = func_name 323 func_args = [] 324 325 try: 326 gdb_value = gdb.parse_and_eval(func_cname) 327 except RuntimeError: 328 func_address = 0 329 else: 330 # Seriously? Why is the address not an int? 331 func_address = int(str(gdb_value.address).split()[0], 0) 332 333 a = ', '.join('%s=%s' % (name, val) for name, val in func_args) 334 print '#%-2d 0x%016x in %s(%s)' % (index, func_address, func_name, a), 335 336 if source_desc.filename is not None: 337 print 'at %s:%s' % (source_desc.filename, lineno), 338 339 print 340 341 try: 342 print ' ' + source_desc.get_source(lineno) 343 except gdb.GdbError: 344 pass 345 346 selected_frame.select() 347 348 def get_remote_cython_globals_dict(self): 349 m = gdb.parse_and_eval('__pyx_m') 350 351 try: 352 PyModuleObject = gdb.lookup_type('PyModuleObject') 353 except RuntimeError: 354 raise gdb.GdbError(textwrap.dedent("""\ 355 Unable to lookup type PyModuleObject, did you compile python 356 with debugging support (-g)?""")) 357 358 m = m.cast(PyModuleObject.pointer()) 359 return m['md_dict'] 360 361 362 def get_cython_globals_dict(self): 363 """ 364 Get the Cython globals dict where the remote names are turned into 365 local strings. 366 """ 367 remote_dict = self.get_remote_cython_globals_dict() 368 pyobject_dict = libpython.PyObjectPtr.from_pyobject_ptr(remote_dict) 369 370 result = {} 371 seen = set() 372 for k, v in pyobject_dict.iteritems(): 373 result[k.proxyval(seen)] = v 374 375 return result 376 377 def print_gdb_value(self, name, value, max_name_length=None, prefix=''): 378 if libpython.pretty_printer_lookup(value): 379 typename = '' 380 else: 381 typename = '(%s) ' % (value.type,) 382 383 if max_name_length is None: 384 print '%s%s = %s%s' % (prefix, name, typename, value) 385 else: 386 print '%s%-*s = %s%s' % (prefix, max_name_length, name, typename, 387 value) 388 389 def is_initialized(self, cython_func, local_name): 390 cyvar = cython_func.locals[local_name] 391 cur_lineno = self.get_cython_lineno() 392 393 if '->' in cyvar.cname: 394 # Closed over free variable 395 if cur_lineno > cython_func.lineno: 396 if cyvar.type == PythonObject: 397 return long(gdb.parse_and_eval(cyvar.cname)) 398 return True 399 return False 400 401 return cur_lineno > cyvar.lineno 402 403 404 class SourceFileDescriptor(object): 405 def __init__(self, filename, lexer, formatter=None): 406 self.filename = filename 407 self.lexer = lexer 408 self.formatter = formatter 409 410 def valid(self): 411 return self.filename is not None 412 413 def lex(self, code): 414 if pygments and self.lexer and parameters.colorize_code: 415 bg = parameters.terminal_background.value 416 if self.formatter is None: 417 formatter = pygments.formatters.TerminalFormatter(bg=bg) 418 else: 419 formatter = self.formatter 420 421 return pygments.highlight(code, self.lexer, formatter) 422 423 return code 424 425 def _get_source(self, start, stop, lex_source, mark_line, lex_entire): 426 with open(self.filename) as f: 427 # to provide "correct" colouring, the entire code needs to be 428 # lexed. However, this makes a lot of things terribly slow, so 429 # we decide not to. Besides, it's unlikely to matter. 430 431 if lex_source and lex_entire: 432 f = self.lex(f.read()).splitlines() 433 434 slice = itertools.islice(f, start - 1, stop - 1) 435 436 for idx, line in enumerate(slice): 437 if start + idx == mark_line: 438 prefix = '>' 439 else: 440 prefix = ' ' 441 442 if lex_source and not lex_entire: 443 line = self.lex(line) 444 445 yield '%s %4d %s' % (prefix, start + idx, line.rstrip()) 446 447 def get_source(self, start, stop=None, lex_source=True, mark_line=0, 448 lex_entire=False): 449 exc = gdb.GdbError('Unable to retrieve source code') 450 451 if not self.filename: 452 raise exc 453 454 start = max(start, 1) 455 if stop is None: 456 stop = start + 1 457 458 try: 459 return '\n'.join( 460 self._get_source(start, stop, lex_source, mark_line, lex_entire)) 461 except IOError: 462 raise exc 463 464 465 # Errors 466 467 class CyGDBError(gdb.GdbError): 468 """ 469 Base class for Cython-command related erorrs 470 """ 471 472 def __init__(self, *args): 473 args = args or (self.msg,) 474 super(CyGDBError, self).__init__(*args) 475 476 class NoCythonFunctionInFrameError(CyGDBError): 477 """ 478 raised when the user requests the current cython function, which is 479 unavailable 480 """ 481 msg = "Current function is a function cygdb doesn't know about" 482 483 class NoFunctionNameInFrameError(NoCythonFunctionInFrameError): 484 """ 485 raised when the name of the C function could not be determined 486 in the current C stack frame 487 """ 488 msg = ('C function name could not be determined in the current C stack ' 489 'frame') 490 491 492 # Parameters 493 494 class CythonParameter(gdb.Parameter): 495 """ 496 Base class for cython parameters 497 """ 498 499 def __init__(self, name, command_class, parameter_class, default=None): 500 self.show_doc = self.set_doc = self.__class__.__doc__ 501 super(CythonParameter, self).__init__(name, command_class, 502 parameter_class) 503 if default is not None: 504 self.value = default 505 506 def __nonzero__(self): 507 return bool(self.value) 508 509 __bool__ = __nonzero__ # python 3 510 511 class CompleteUnqualifiedFunctionNames(CythonParameter): 512 """ 513 Have 'cy break' complete unqualified function or method names. 514 """ 515 516 class ColorizeSourceCode(CythonParameter): 517 """ 518 Tell cygdb whether to colorize source code. 519 """ 520 521 class TerminalBackground(CythonParameter): 522 """ 523 Tell cygdb about the user's terminal background (light or dark). 524 """ 525 526 class CythonParameters(object): 527 """ 528 Simple container class that might get more functionality in the distant 529 future (mostly to remind us that we're dealing with parameters). 530 """ 531 532 def __init__(self): 533 self.complete_unqualified = CompleteUnqualifiedFunctionNames( 534 'cy_complete_unqualified', 535 gdb.COMMAND_BREAKPOINTS, 536 gdb.PARAM_BOOLEAN, 537 True) 538 self.colorize_code = ColorizeSourceCode( 539 'cy_colorize_code', 540 gdb.COMMAND_FILES, 541 gdb.PARAM_BOOLEAN, 542 True) 543 self.terminal_background = TerminalBackground( 544 'cy_terminal_background_color', 545 gdb.COMMAND_FILES, 546 gdb.PARAM_STRING, 547 "dark") 548 549 parameters = CythonParameters() 550 551 552 # Commands 553 554 class CythonCommand(gdb.Command, CythonBase): 555 """ 556 Base class for Cython commands 557 """ 558 559 command_class = gdb.COMMAND_NONE 560 561 @classmethod 562 def _register(cls, clsname, args, kwargs): 563 if not hasattr(cls, 'completer_class'): 564 return cls(clsname, cls.command_class, *args, **kwargs) 565 else: 566 return cls(clsname, cls.command_class, cls.completer_class, 567 *args, **kwargs) 568 569 @classmethod 570 def register(cls, *args, **kwargs): 571 alias = getattr(cls, 'alias', None) 572 if alias: 573 cls._register(cls.alias, args, kwargs) 574 575 return cls._register(cls.name, args, kwargs) 576 577 578 class CyCy(CythonCommand): 579 """ 580 Invoke a Cython command. Available commands are: 581 582 cy import 583 cy break 584 cy step 585 cy next 586 cy run 587 cy cont 588 cy finish 589 cy up 590 cy down 591 cy select 592 cy bt / cy backtrace 593 cy list 594 cy print 595 cy set 596 cy locals 597 cy globals 598 cy exec 599 """ 600 601 name = 'cy' 602 command_class = gdb.COMMAND_NONE 603 completer_class = gdb.COMPLETE_COMMAND 604 605 def __init__(self, name, command_class, completer_class): 606 # keep the signature 2.5 compatible (i.e. do not use f(*a, k=v) 607 super(CythonCommand, self).__init__(name, command_class, 608 completer_class, prefix=True) 609 610 commands = dict( 611 # GDB commands 612 import_ = CyImport.register(), 613 break_ = CyBreak.register(), 614 step = CyStep.register(), 615 next = CyNext.register(), 616 run = CyRun.register(), 617 cont = CyCont.register(), 618 finish = CyFinish.register(), 619 up = CyUp.register(), 620 down = CyDown.register(), 621 select = CySelect.register(), 622 bt = CyBacktrace.register(), 623 list = CyList.register(), 624 print_ = CyPrint.register(), 625 locals = CyLocals.register(), 626 globals = CyGlobals.register(), 627 exec_ = libpython.FixGdbCommand('cy exec', '-cy-exec'), 628 _exec = CyExec.register(), 629 set = CySet.register(), 630 631 # GDB functions 632 cy_cname = CyCName('cy_cname'), 633 cy_cvalue = CyCValue('cy_cvalue'), 634 cy_lineno = CyLine('cy_lineno'), 635 cy_eval = CyEval('cy_eval'), 636 ) 637 638 for command_name, command in commands.iteritems(): 639 command.cy = self 640 setattr(self, command_name, command) 641 642 self.cy = self 643 644 # Cython module namespace 645 self.cython_namespace = {} 646 647 # maps (unique) qualified function names (e.g. 648 # cythonmodule.ClassName.method_name) to the CythonFunction object 649 self.functions_by_qualified_name = {} 650 651 # unique cnames of Cython functions 652 self.functions_by_cname = {} 653 654 # map function names like method_name to a list of all such 655 # CythonFunction objects 656 self.functions_by_name = collections.defaultdict(list) 657 658 659 class CyImport(CythonCommand): 660 """ 661 Import debug information outputted by the Cython compiler 662 Example: cy import FILE... 663 """ 664 665 name = 'cy import' 666 command_class = gdb.COMMAND_STATUS 667 completer_class = gdb.COMPLETE_FILENAME 668 669 def invoke(self, args, from_tty): 670 args = args.encode(_filesystemencoding) 671 for arg in string_to_argv(args): 672 try: 673 f = open(arg) 674 except OSError, e: 675 raise gdb.GdbError('Unable to open file %r: %s' % 676 (args, e.args[1])) 677 678 t = etree.parse(f) 679 680 for module in t.getroot(): 681 cython_module = CythonModule(**module.attrib) 682 self.cy.cython_namespace[cython_module.name] = cython_module 683 684 for variable in module.find('Globals'): 685 d = variable.attrib 686 cython_module.globals[d['name']] = CythonVariable(**d) 687 688 for function in module.find('Functions'): 689 cython_function = CythonFunction(module=cython_module, 690 **function.attrib) 691 692 # update the global function mappings 693 name = cython_function.name 694 qname = cython_function.qualified_name 695 696 self.cy.functions_by_name[name].append(cython_function) 697 self.cy.functions_by_qualified_name[ 698 cython_function.qualified_name] = cython_function 699 self.cy.functions_by_cname[ 700 cython_function.cname] = cython_function 701 702 d = cython_module.functions[qname] = cython_function 703 704 for local in function.find('Locals'): 705 d = local.attrib 706 cython_function.locals[d['name']] = CythonVariable(**d) 707 708 for step_into_func in function.find('StepIntoFunctions'): 709 d = step_into_func.attrib 710 cython_function.step_into_functions.add(d['name']) 711 712 cython_function.arguments.extend( 713 funcarg.tag for funcarg in function.find('Arguments')) 714 715 for marker in module.find('LineNumberMapping'): 716 cython_lineno = int(marker.attrib['cython_lineno']) 717 c_linenos = map(int, marker.attrib['c_linenos'].split()) 718 cython_module.lineno_cy2c[cython_lineno] = min(c_linenos) 719 for c_lineno in c_linenos: 720 cython_module.lineno_c2cy[c_lineno] = cython_lineno 721 722 723 class CyBreak(CythonCommand): 724 """ 725 Set a breakpoint for Cython code using Cython qualified name notation, e.g.: 726 727 cy break cython_modulename.ClassName.method_name... 728 729 or normal notation: 730 731 cy break function_or_method_name... 732 733 or for a line number: 734 735 cy break cython_module:lineno... 736 737 Set a Python breakpoint: 738 Break on any function or method named 'func' in module 'modname' 739 740 cy break -p modname.func... 741 742 Break on any function or method named 'func' 743 744 cy break -p func... 745 """ 746 747 name = 'cy break' 748 command_class = gdb.COMMAND_BREAKPOINTS 749 750 def _break_pyx(self, name): 751 modulename, _, lineno = name.partition(':') 752 lineno = int(lineno) 753 if modulename: 754 cython_module = self.cy.cython_namespace[modulename] 755 else: 756 cython_module = self.get_cython_function().module 757 758 if lineno in cython_module.lineno_cy2c: 759 c_lineno = cython_module.lineno_cy2c[lineno] 760 breakpoint = '%s:%s' % (cython_module.c_filename, c_lineno) 761 gdb.execute('break ' + breakpoint) 762 else: 763 raise gdb.GdbError("Not a valid line number. " 764 "Does it contain actual code?") 765 766 def _break_funcname(self, funcname): 767 func = self.cy.functions_by_qualified_name.get(funcname) 768 769 if func and func.is_initmodule_function: 770 func = None 771 772 break_funcs = [func] 773 774 if not func: 775 funcs = self.cy.functions_by_name.get(funcname) or [] 776 funcs = [f for f in funcs if not f.is_initmodule_function] 777 778 if not funcs: 779 gdb.execute('break ' + funcname) 780 return 781 782 if len(funcs) > 1: 783 # multiple functions, let the user pick one 784 print 'There are multiple such functions:' 785 for idx, func in enumerate(funcs): 786 print '%3d) %s' % (idx, func.qualified_name) 787 788 while True: 789 try: 790 result = raw_input( 791 "Select a function, press 'a' for all " 792 "functions or press 'q' or '^D' to quit: ") 793 except EOFError: 794 return 795 else: 796 if result.lower() == 'q': 797 return 798 elif result.lower() == 'a': 799 break_funcs = funcs 800 break 801 elif (result.isdigit() and 802 0 <= int(result) < len(funcs)): 803 break_funcs = [funcs[int(result)]] 804 break 805 else: 806 print 'Not understood...' 807 else: 808 break_funcs = [funcs[0]] 809 810 for func in break_funcs: 811 gdb.execute('break %s' % func.cname) 812 if func.pf_cname: 813 gdb.execute('break %s' % func.pf_cname) 814 815 def invoke(self, function_names, from_tty): 816 argv = string_to_argv(function_names.encode('UTF-8')) 817 if function_names.startswith('-p'): 818 argv = argv[1:] 819 python_breakpoints = True 820 else: 821 python_breakpoints = False 822 823 for funcname in argv: 824 if python_breakpoints: 825 gdb.execute('py-break %s' % funcname) 826 elif ':' in funcname: 827 self._break_pyx(funcname) 828 else: 829 self._break_funcname(funcname) 830 831 @dont_suppress_errors 832 def complete(self, text, word): 833 # Filter init-module functions (breakpoints can be set using 834 # modulename:linenumber). 835 names = [n for n, L in self.cy.functions_by_name.iteritems() 836 if any(not f.is_initmodule_function for f in L)] 837 qnames = [n for n, f in self.cy.functions_by_qualified_name.iteritems() 838 if not f.is_initmodule_function] 839 840 if parameters.complete_unqualified: 841 all_names = itertools.chain(qnames, names) 842 else: 843 all_names = qnames 844 845 words = text.strip().split() 846 if not words or '.' not in words[-1]: 847 # complete unqualified 848 seen = set(text[:-len(word)].split()) 849 return [n for n in all_names 850 if n.startswith(word) and n not in seen] 851 852 # complete qualified name 853 lastword = words[-1] 854 compl = [n for n in qnames if n.startswith(lastword)] 855 856 if len(lastword) > len(word): 857 # readline sees something (e.g. a '.') as a word boundary, so don't 858 # "recomplete" this prefix 859 strip_prefix_length = len(lastword) - len(word) 860 compl = [n[strip_prefix_length:] for n in compl] 861 862 return compl 863 864 865 class CythonInfo(CythonBase, libpython.PythonInfo): 866 """ 867 Implementation of the interface dictated by libpython.LanguageInfo. 868 """ 869 870 def lineno(self, frame): 871 # Take care of the Python and Cython levels. We need to care for both 872 # as we can't simply dispath to 'py-step', since that would work for 873 # stepping through Python code, but it would not step back into Cython- 874 # related code. The C level should be dispatched to the 'step' command. 875 if self.is_cython_function(frame): 876 return self.get_cython_lineno(frame) 877 return super(CythonInfo, self).lineno(frame) 878 879 def get_source_line(self, frame): 880 try: 881 line = super(CythonInfo, self).get_source_line(frame) 882 except gdb.GdbError: 883 return None 884 else: 885 return line.strip() or None 886 887 def exc_info(self, frame): 888 if self.is_python_function: 889 return super(CythonInfo, self).exc_info(frame) 890 891 def runtime_break_functions(self): 892 if self.is_cython_function(): 893 return self.get_cython_function().step_into_functions 894 return () 895 896 def static_break_functions(self): 897 result = ['PyEval_EvalFrameEx'] 898 result.extend(self.cy.functions_by_cname) 899 return result 900 901 902 class CythonExecutionControlCommand(CythonCommand, 903 libpython.ExecutionControlCommandBase): 904 905 @classmethod 906 def register(cls): 907 return cls(cls.name, cython_info) 908 909 910 class CyStep(CythonExecutionControlCommand, libpython.PythonStepperMixin): 911 "Step through Cython, Python or C code." 912 913 name = 'cy -step' 914 stepinto = True 915 916 def invoke(self, args, from_tty): 917 if self.is_python_function(): 918 self.python_step(self.stepinto) 919 elif not self.is_cython_function(): 920 if self.stepinto: 921 command = 'step' 922 else: 923 command = 'next' 924 925 self.finish_executing(gdb.execute(command, to_string=True)) 926 else: 927 self.step(stepinto=self.stepinto) 928 929 930 class CyNext(CyStep): 931 "Step-over Cython, Python or C code." 932 933 name = 'cy -next' 934 stepinto = False 935 936 937 class CyRun(CythonExecutionControlCommand): 938 """ 939 Run a Cython program. This is like the 'run' command, except that it 940 displays Cython or Python source lines as well 941 """ 942 943 name = 'cy run' 944 945 invoke = CythonExecutionControlCommand.run 946 947 948 class CyCont(CythonExecutionControlCommand): 949 """ 950 Continue a Cython program. This is like the 'run' command, except that it 951 displays Cython or Python source lines as well. 952 """ 953 954 name = 'cy cont' 955 invoke = CythonExecutionControlCommand.cont 956 957 958 class CyFinish(CythonExecutionControlCommand): 959 """ 960 Execute until the function returns. 961 """ 962 name = 'cy finish' 963 964 invoke = CythonExecutionControlCommand.finish 965 966 967 class CyUp(CythonCommand): 968 """ 969 Go up a Cython, Python or relevant C frame. 970 """ 971 name = 'cy up' 972 _command = 'up' 973 974 def invoke(self, *args): 975 try: 976 gdb.execute(self._command, to_string=True) 977 while not self.is_relevant_function(gdb.selected_frame()): 978 gdb.execute(self._command, to_string=True) 979 except RuntimeError, e: 980 raise gdb.GdbError(*e.args) 981 982 frame = gdb.selected_frame() 983 index = 0 984 while frame: 985 frame = frame.older() 986 index += 1 987 988 self.print_stackframe(index=index - 1) 989 990 991 class CyDown(CyUp): 992 """ 993 Go down a Cython, Python or relevant C frame. 994 """ 995 996 name = 'cy down' 997 _command = 'down' 998 999 1000 class CySelect(CythonCommand): 1001 """ 1002 Select a frame. Use frame numbers as listed in `cy backtrace`. 1003 This command is useful because `cy backtrace` prints a reversed backtrace. 1004 """ 1005 1006 name = 'cy select' 1007 1008 def invoke(self, stackno, from_tty): 1009 try: 1010 stackno = int(stackno) 1011 except ValueError: 1012 raise gdb.GdbError("Not a valid number: %r" % (stackno,)) 1013 1014 frame = gdb.selected_frame() 1015 while frame.newer(): 1016 frame = frame.newer() 1017 1018 stackdepth = libpython.stackdepth(frame) 1019 1020 try: 1021 gdb.execute('select %d' % (stackdepth - stackno - 1,)) 1022 except RuntimeError, e: 1023 raise gdb.GdbError(*e.args) 1024 1025 1026 class CyBacktrace(CythonCommand): 1027 'Print the Cython stack' 1028 1029 name = 'cy bt' 1030 alias = 'cy backtrace' 1031 command_class = gdb.COMMAND_STACK 1032 completer_class = gdb.COMPLETE_NONE 1033 1034 @require_running_program 1035 def invoke(self, args, from_tty): 1036 # get the first frame 1037 frame = gdb.selected_frame() 1038 while frame.older(): 1039 frame = frame.older() 1040 1041 print_all = args == '-a' 1042 1043 index = 0 1044 while frame: 1045 try: 1046 is_relevant = self.is_relevant_function(frame) 1047 except CyGDBError: 1048 is_relevant = False 1049 1050 if print_all or is_relevant: 1051 self.print_stackframe(frame, index) 1052 1053 index += 1 1054 frame = frame.newer() 1055 1056 1057 class CyList(CythonCommand): 1058 """ 1059 List Cython source code. To disable to customize colouring see the cy_* 1060 parameters. 1061 """ 1062 1063 name = 'cy list' 1064 command_class = gdb.COMMAND_FILES 1065 completer_class = gdb.COMPLETE_NONE 1066 1067 # @dispatch_on_frame(c_command='list') 1068 def invoke(self, _, from_tty): 1069 sd, lineno = self.get_source_desc() 1070 source = sd.get_source(lineno - 5, lineno + 5, mark_line=lineno, 1071 lex_entire=True) 1072 print source 1073 1074 1075 class CyPrint(CythonCommand): 1076 """ 1077 Print a Cython variable using 'cy-print x' or 'cy-print module.function.x' 1078 """ 1079 1080 name = 'cy print' 1081 command_class = gdb.COMMAND_DATA 1082 1083 def invoke(self, name, from_tty, max_name_length=None): 1084 if self.is_python_function(): 1085 return gdb.execute('py-print ' + name) 1086 elif self.is_cython_function(): 1087 value = self.cy.cy_cvalue.invoke(name.lstrip('*')) 1088 for c in name: 1089 if c == '*': 1090 value = value.dereference() 1091 else: 1092 break 1093 1094 self.print_gdb_value(name, value, max_name_length) 1095 else: 1096 gdb.execute('print ' + name) 1097 1098 def complete(self): 1099 if self.is_cython_function(): 1100 f = self.get_cython_function() 1101 return list(itertools.chain(f.locals, f.globals)) 1102 else: 1103 return [] 1104 1105 1106 sortkey = lambda (name, value): name.lower() 1107 1108 class CyLocals(CythonCommand): 1109 """ 1110 List the locals from the current Cython frame. 1111 """ 1112 1113 name = 'cy locals' 1114 command_class = gdb.COMMAND_STACK 1115 completer_class = gdb.COMPLETE_NONE 1116 1117 @dispatch_on_frame(c_command='info locals', python_command='py-locals') 1118 def invoke(self, args, from_tty): 1119 cython_function = self.get_cython_function() 1120 1121 if cython_function.is_initmodule_function: 1122 self.cy.globals.invoke(args, from_tty) 1123 return 1124 1125 local_cython_vars = cython_function.locals 1126 max_name_length = len(max(local_cython_vars, key=len)) 1127 for name, cyvar in sorted(local_cython_vars.iteritems(), key=sortkey): 1128 if self.is_initialized(self.get_cython_function(), cyvar.name): 1129 value = gdb.parse_and_eval(cyvar.cname) 1130 if not value.is_optimized_out: 1131 self.print_gdb_value(cyvar.name, value, 1132 max_name_length, '') 1133 1134 1135 class CyGlobals(CyLocals): 1136 """ 1137 List the globals from the current Cython module. 1138 """ 1139 1140 name = 'cy globals' 1141 command_class = gdb.COMMAND_STACK 1142 completer_class = gdb.COMPLETE_NONE 1143 1144 @dispatch_on_frame(c_command='info variables', python_command='py-globals') 1145 def invoke(self, args, from_tty): 1146 global_python_dict = self.get_cython_globals_dict() 1147 module_globals = self.get_cython_function().module.globals 1148 1149 max_globals_len = 0 1150 max_globals_dict_len = 0 1151 if module_globals: 1152 max_globals_len = len(max(module_globals, key=len)) 1153 if global_python_dict: 1154 max_globals_dict_len = len(max(global_python_dict)) 1155 1156 max_name_length = max(max_globals_len, max_globals_dict_len) 1157 1158 seen = set() 1159 print 'Python globals:' 1160 for k, v in sorted(global_python_dict.iteritems(), key=sortkey): 1161 v = v.get_truncated_repr(libpython.MAX_OUTPUT_LEN) 1162 seen.add(k) 1163 print ' %-*s = %s' % (max_name_length, k, v) 1164 1165 print 'C globals:' 1166 for name, cyvar in sorted(module_globals.iteritems(), key=sortkey): 1167 if name not in seen: 1168 try: 1169 value = gdb.parse_and_eval(cyvar.cname) 1170 except RuntimeError: 1171 pass 1172 else: 1173 if not value.is_optimized_out: 1174 self.print_gdb_value(cyvar.name, value, 1175 max_name_length, ' ') 1176 1177 1178 1179 class EvaluateOrExecuteCodeMixin(object): 1180 """ 1181 Evaluate or execute Python code in a Cython or Python frame. The 'evalcode' 1182 method evaluations Python code, prints a traceback if an exception went 1183 uncaught, and returns any return value as a gdb.Value (NULL on exception). 1184 """ 1185 1186 def _fill_locals_dict(self, executor, local_dict_pointer): 1187 "Fill a remotely allocated dict with values from the Cython C stack" 1188 cython_func = self.get_cython_function() 1189 1190 for name, cyvar in cython_func.locals.iteritems(): 1191 if (cyvar.type == PythonObject and 1192 self.is_initialized(cython_func, name)): 1193 1194 try: 1195 val = gdb.parse_and_eval(cyvar.cname) 1196 except RuntimeError: 1197 continue 1198 else: 1199 if val.is_optimized_out: 1200 continue 1201 1202 pystringp = executor.alloc_pystring(name) 1203 code = ''' 1204 (PyObject *) PyDict_SetItem( 1205 (PyObject *) %d, 1206 (PyObject *) %d, 1207 (PyObject *) %s) 1208 ''' % (local_dict_pointer, pystringp, cyvar.cname) 1209 1210 try: 1211 if gdb.parse_and_eval(code) < 0: 1212 gdb.parse_and_eval('PyErr_Print()') 1213 raise gdb.GdbError("Unable to execute Python code.") 1214 finally: 1215 # PyDict_SetItem doesn't steal our reference 1216 executor.xdecref(pystringp) 1217 1218 def _find_first_cython_or_python_frame(self): 1219 frame = gdb.selected_frame() 1220 while frame: 1221 if (self.is_cython_function(frame) or 1222 self.is_python_function(frame)): 1223 frame.select() 1224 return frame 1225 1226 frame = frame.older() 1227 1228 raise gdb.GdbError("There is no Cython or Python frame on the stack.") 1229 1230 1231 def _evalcode_cython(self, executor, code, input_type): 1232 with libpython.FetchAndRestoreError(): 1233 # get the dict of Cython globals and construct a dict in the 1234 # inferior with Cython locals 1235 global_dict = gdb.parse_and_eval( 1236 '(PyObject *) PyModule_GetDict(__pyx_m)') 1237 local_dict = gdb.parse_and_eval('(PyObject *) PyDict_New()') 1238 1239 try: 1240 self._fill_locals_dict(executor, 1241 libpython.pointervalue(local_dict)) 1242 result = executor.evalcode(code, input_type, global_dict, 1243 local_dict) 1244 finally: 1245 executor.xdecref(libpython.pointervalue(local_dict)) 1246 1247 return result 1248 1249 def evalcode(self, code, input_type): 1250 """ 1251 Evaluate `code` in a Python or Cython stack frame using the given 1252 `input_type`. 1253 """ 1254 frame = self._find_first_cython_or_python_frame() 1255 executor = libpython.PythonCodeExecutor() 1256 if self.is_python_function(frame): 1257 return libpython._evalcode_python(executor, code, input_type) 1258 return self._evalcode_cython(executor, code, input_type) 1259 1260 1261 class CyExec(CythonCommand, libpython.PyExec, EvaluateOrExecuteCodeMixin): 1262 """ 1263 Execute Python code in the nearest Python or Cython frame. 1264 """ 1265 1266 name = '-cy-exec' 1267 command_class = gdb.COMMAND_STACK 1268 completer_class = gdb.COMPLETE_NONE 1269 1270 def invoke(self, expr, from_tty): 1271 expr, input_type = self.readcode(expr) 1272 executor = libpython.PythonCodeExecutor() 1273 executor.xdecref(self.evalcode(expr, executor.Py_single_input)) 1274 1275 1276 class CySet(CythonCommand): 1277 """ 1278 Set a Cython variable to a certain value 1279 1280 cy set my_cython_c_variable = 10 1281 cy set my_cython_py_variable = $cy_eval("{'doner': 'kebab'}") 1282 1283 This is equivalent to 1284 1285 set $cy_value("my_cython_variable") = 10 1286 """ 1287 1288 name = 'cy set' 1289 command_class = gdb.COMMAND_DATA 1290 completer_class = gdb.COMPLETE_NONE 1291 1292 @require_cython_frame 1293 def invoke(self, expr, from_tty): 1294 name_and_expr = expr.split('=', 1) 1295 if len(name_and_expr) != 2: 1296 raise gdb.GdbError("Invalid expression. Use 'cy set var = expr'.") 1297 1298 varname, expr = name_and_expr 1299 cname = self.cy.cy_cname.invoke(varname.strip()) 1300 gdb.execute("set %s = %s" % (cname, expr)) 1301 1302 1303 # Functions 1304 1305 class CyCName(gdb.Function, CythonBase): 1306 """ 1307 Get the C name of a Cython variable in the current context. 1308 Examples: 1309 1310 print $cy_cname("function") 1311 print $cy_cname("Class.method") 1312 print $cy_cname("module.function") 1313 """ 1314 1315 @require_cython_frame 1316 @gdb_function_value_to_unicode 1317 def invoke(self, cyname, frame=None): 1318 frame = frame or gdb.selected_frame() 1319 cname = None 1320 1321 if self.is_cython_function(frame): 1322 cython_function = self.get_cython_function(frame) 1323 if cyname in cython_function.locals: 1324 cname = cython_function.locals[cyname].cname 1325 elif cyname in cython_function.module.globals: 1326 cname = cython_function.module.globals[cyname].cname 1327 else: 1328 qname = '%s.%s' % (cython_function.module.name, cyname) 1329 if qname in cython_function.module.functions: 1330 cname = cython_function.module.functions[qname].cname 1331 1332 if not cname: 1333 cname = self.cy.functions_by_qualified_name.get(cyname) 1334 1335 if not cname: 1336 raise gdb.GdbError('No such Cython variable: %s' % cyname) 1337 1338 return cname 1339 1340 1341 class CyCValue(CyCName): 1342 """ 1343 Get the value of a Cython variable. 1344 """ 1345 1346 @require_cython_frame 1347 @gdb_function_value_to_unicode 1348 def invoke(self, cyname, frame=None): 1349 globals_dict = self.get_cython_globals_dict() 1350 cython_function = self.get_cython_function(frame) 1351 1352 if self.is_initialized(cython_function, cyname): 1353 cname = super(CyCValue, self).invoke(cyname, frame=frame) 1354 return gdb.parse_and_eval(cname) 1355 elif cyname in globals_dict: 1356 return globals_dict[cyname]._gdbval 1357 else: 1358 raise gdb.GdbError("Variable %s is not initialized." % cyname) 1359 1360 1361 class CyLine(gdb.Function, CythonBase): 1362 """ 1363 Get the current Cython line. 1364 """ 1365 1366 @require_cython_frame 1367 def invoke(self): 1368 return self.get_cython_lineno() 1369 1370 1371 class CyEval(gdb.Function, CythonBase, EvaluateOrExecuteCodeMixin): 1372 """ 1373 Evaluate Python code in the nearest Python or Cython frame and return 1374 """ 1375 1376 @gdb_function_value_to_unicode 1377 def invoke(self, python_expression): 1378 input_type = libpython.PythonCodeExecutor.Py_eval_input 1379 return self.evalcode(python_expression, input_type) 1380 1381 1382 cython_info = CythonInfo() 1383 cy = CyCy.register() 1384 cython_info.cy = cy 1385 1386 def register_defines(): 1387 libpython.source_gdb_script(textwrap.dedent("""\ 1388 define cy step 1389 cy -step 1390 end 1391 1392 define cy next 1393 cy -next 1394 end 1395 1396 document cy step 1397 %s 1398 end 1399 1400 document cy next 1401 %s 1402 end 1403 """) % (CyStep.__doc__, CyNext.__doc__)) 1404 1405 register_defines() 1406
