| """Disassembler of Python byte code into mnemonics.""" |
| |
| import sys |
| import types |
| |
| from opcode import * |
| from opcode import __all__ as _opcodes_all |
| |
| __all__ = ["code_info", "dis", "disassemble", "distb", "disco", |
| "findlinestarts", "findlabels", "show_code"] + _opcodes_all |
| del _opcodes_all |
| |
| _have_code = (types.MethodType, types.FunctionType, types.CodeType, type) |
| |
| def _try_compile(source, name): |
| """Attempts to compile the given source, first as an expression and |
| then as a statement if the first approach fails. |
| |
| Utility function to accept strings in functions that otherwise |
| expect code objects |
| """ |
| try: |
| c = compile(source, name, 'eval') |
| except SyntaxError: |
| c = compile(source, name, 'exec') |
| return c |
| |
| def dis(x=None): |
| """Disassemble classes, methods, functions, or code. |
| |
| With no argument, disassemble the last traceback. |
| |
| """ |
| if x is None: |
| distb() |
| return |
| if hasattr(x, '__func__'): # Method |
| x = x.__func__ |
| if hasattr(x, '__code__'): # Function |
| x = x.__code__ |
| if hasattr(x, '__dict__'): # Class or module |
| items = sorted(x.__dict__.items()) |
| for name, x1 in items: |
| if isinstance(x1, _have_code): |
| print("Disassembly of %s:" % name) |
| try: |
| dis(x1) |
| except TypeError as msg: |
| print("Sorry:", msg) |
| print() |
| elif hasattr(x, 'co_code'): # Code object |
| disassemble(x) |
| elif isinstance(x, (bytes, bytearray)): # Raw bytecode |
| _disassemble_bytes(x) |
| elif isinstance(x, str): # Source code |
| _disassemble_str(x) |
| else: |
| raise TypeError("don't know how to disassemble %s objects" % |
| type(x).__name__) |
| |
| def distb(tb=None): |
| """Disassemble a traceback (default: last traceback).""" |
| if tb is None: |
| try: |
| tb = sys.last_traceback |
| except AttributeError: |
| raise RuntimeError("no last traceback to disassemble") |
| while tb.tb_next: tb = tb.tb_next |
| disassemble(tb.tb_frame.f_code, tb.tb_lasti) |
| |
| # The inspect module interrogates this dictionary to build its |
| # list of CO_* constants. It is also used by pretty_flags to |
| # turn the co_flags field into a human readable list. |
| COMPILER_FLAG_NAMES = { |
| 1: "OPTIMIZED", |
| 2: "NEWLOCALS", |
| 4: "VARARGS", |
| 8: "VARKEYWORDS", |
| 16: "NESTED", |
| 32: "GENERATOR", |
| 64: "NOFREE", |
| } |
| |
| def pretty_flags(flags): |
| """Return pretty representation of code flags.""" |
| names = [] |
| for i in range(32): |
| flag = 1<<i |
| if flags & flag: |
| names.append(COMPILER_FLAG_NAMES.get(flag, hex(flag))) |
| flags ^= flag |
| if not flags: |
| break |
| else: |
| names.append(hex(flags)) |
| return ", ".join(names) |
| |
| def code_info(x): |
| """Formatted details of methods, functions, or code.""" |
| if hasattr(x, '__func__'): # Method |
| x = x.__func__ |
| if hasattr(x, '__code__'): # Function |
| x = x.__code__ |
| if isinstance(x, str): # Source code |
| x = _try_compile(x, "<code_info>") |
| if hasattr(x, 'co_code'): # Code object |
| return _format_code_info(x) |
| else: |
| raise TypeError("don't know how to disassemble %s objects" % |
| type(x).__name__) |
| |
| def _format_code_info(co): |
| lines = [] |
| lines.append("Name: %s" % co.co_name) |
| lines.append("Filename: %s" % co.co_filename) |
| lines.append("Argument count: %s" % co.co_argcount) |
| lines.append("Kw-only arguments: %s" % co.co_kwonlyargcount) |
| lines.append("Number of locals: %s" % co.co_nlocals) |
| lines.append("Stack size: %s" % co.co_stacksize) |
| lines.append("Flags: %s" % pretty_flags(co.co_flags)) |
| if co.co_consts: |
| lines.append("Constants:") |
| for i_c in enumerate(co.co_consts): |
| lines.append("%4d: %r" % i_c) |
| if co.co_names: |
| lines.append("Names:") |
| for i_n in enumerate(co.co_names): |
| lines.append("%4d: %s" % i_n) |
| if co.co_varnames: |
| lines.append("Variable names:") |
| for i_n in enumerate(co.co_varnames): |
| lines.append("%4d: %s" % i_n) |
| if co.co_freevars: |
| lines.append("Free variables:") |
| for i_n in enumerate(co.co_freevars): |
| lines.append("%4d: %s" % i_n) |
| if co.co_cellvars: |
| lines.append("Cell variables:") |
| for i_n in enumerate(co.co_cellvars): |
| lines.append("%4d: %s" % i_n) |
| return "\n".join(lines) |
| |
| def show_code(co): |
| """Print details of methods, functions, or code to stdout.""" |
| print(code_info(co)) |
| |
| def disassemble(co, lasti=-1): |
| """Disassemble a code object.""" |
| code = co.co_code |
| labels = findlabels(code) |
| linestarts = dict(findlinestarts(co)) |
| n = len(code) |
| i = 0 |
| extended_arg = 0 |
| free = None |
| while i < n: |
| op = code[i] |
| if i in linestarts: |
| if i > 0: |
| print() |
| print("%3d" % linestarts[i], end=' ') |
| else: |
| print(' ', end=' ') |
| |
| if i == lasti: print('-->', end=' ') |
| else: print(' ', end=' ') |
| if i in labels: print('>>', end=' ') |
| else: print(' ', end=' ') |
| print(repr(i).rjust(4), end=' ') |
| print(opname[op].ljust(20), end=' ') |
| i = i+1 |
| if op >= HAVE_ARGUMENT: |
| oparg = code[i] + code[i+1]*256 + extended_arg |
| extended_arg = 0 |
| i = i+2 |
| if op == EXTENDED_ARG: |
| extended_arg = oparg*65536 |
| print(repr(oparg).rjust(5), end=' ') |
| if op in hasconst: |
| print('(' + repr(co.co_consts[oparg]) + ')', end=' ') |
| elif op in hasname: |
| print('(' + co.co_names[oparg] + ')', end=' ') |
| elif op in hasjrel: |
| print('(to ' + repr(i + oparg) + ')', end=' ') |
| elif op in haslocal: |
| print('(' + co.co_varnames[oparg] + ')', end=' ') |
| elif op in hascompare: |
| print('(' + cmp_op[oparg] + ')', end=' ') |
| elif op in hasfree: |
| if free is None: |
| free = co.co_cellvars + co.co_freevars |
| print('(' + free[oparg] + ')', end=' ') |
| print() |
| |
| def _disassemble_bytes(code, lasti=-1, varnames=None, names=None, |
| constants=None): |
| labels = findlabels(code) |
| n = len(code) |
| i = 0 |
| while i < n: |
| op = code[i] |
| if i == lasti: print('-->', end=' ') |
| else: print(' ', end=' ') |
| if i in labels: print('>>', end=' ') |
| else: print(' ', end=' ') |
| print(repr(i).rjust(4), end=' ') |
| print(opname[op].ljust(15), end=' ') |
| i = i+1 |
| if op >= HAVE_ARGUMENT: |
| oparg = code[i] + code[i+1]*256 |
| i = i+2 |
| print(repr(oparg).rjust(5), end=' ') |
| if op in hasconst: |
| if constants: |
| print('(' + repr(constants[oparg]) + ')', end=' ') |
| else: |
| print('(%d)'%oparg, end=' ') |
| elif op in hasname: |
| if names is not None: |
| print('(' + names[oparg] + ')', end=' ') |
| else: |
| print('(%d)'%oparg, end=' ') |
| elif op in hasjrel: |
| print('(to ' + repr(i + oparg) + ')', end=' ') |
| elif op in haslocal: |
| if varnames: |
| print('(' + varnames[oparg] + ')', end=' ') |
| else: |
| print('(%d)' % oparg, end=' ') |
| elif op in hascompare: |
| print('(' + cmp_op[oparg] + ')', end=' ') |
| print() |
| |
| def _disassemble_str(source): |
| """Compile the source string, then disassemble the code object.""" |
| disassemble(_try_compile(source, '<dis>')) |
| |
| disco = disassemble # XXX For backwards compatibility |
| |
| def findlabels(code): |
| """Detect all offsets in a byte code which are jump targets. |
| |
| Return the list of offsets. |
| |
| """ |
| labels = [] |
| n = len(code) |
| i = 0 |
| while i < n: |
| op = code[i] |
| i = i+1 |
| if op >= HAVE_ARGUMENT: |
| oparg = code[i] + code[i+1]*256 |
| i = i+2 |
| label = -1 |
| if op in hasjrel: |
| label = i+oparg |
| elif op in hasjabs: |
| label = oparg |
| if label >= 0: |
| if label not in labels: |
| labels.append(label) |
| return labels |
| |
| def findlinestarts(code): |
| """Find the offsets in a byte code which are start of lines in the source. |
| |
| Generate pairs (offset, lineno) as described in Python/compile.c. |
| |
| """ |
| byte_increments = list(code.co_lnotab[0::2]) |
| line_increments = list(code.co_lnotab[1::2]) |
| |
| lastlineno = None |
| lineno = code.co_firstlineno |
| addr = 0 |
| for byte_incr, line_incr in zip(byte_increments, line_increments): |
| if byte_incr: |
| if lineno != lastlineno: |
| yield (addr, lineno) |
| lastlineno = lineno |
| addr += byte_incr |
| lineno += line_incr |
| if lineno != lastlineno: |
| yield (addr, lineno) |
| |
| def _test(): |
| """Simple test program to disassemble a file.""" |
| if sys.argv[1:]: |
| if sys.argv[2:]: |
| sys.stderr.write("usage: python dis.py [-|file]\n") |
| sys.exit(2) |
| fn = sys.argv[1] |
| if not fn or fn == "-": |
| fn = None |
| else: |
| fn = None |
| if fn is None: |
| f = sys.stdin |
| else: |
| f = open(fn) |
| source = f.read() |
| if fn is not None: |
| f.close() |
| else: |
| fn = "<stdin>" |
| code = compile(source, fn, "exec") |
| dis(code) |
| |
| if __name__ == "__main__": |
| _test() |