Lib/dis.py

   1 """Disassembler of Python byte code into mnemonics."""
   2
   3 import sys
   4 import types
   5
   6 __all__ = ["dis","disassemble","distb","disco","opname","cmp_op",
   7            "hasconst","hasname","hasjrel","hasjabs","haslocal",
   8            "hascompare", "hasfree"]
   9
  10 def dis(x=None):
  11     """Disassemble classes, methods, functions, or code.
  12
  13     With no argument, disassemble the last traceback.
  14
  15     """
  16     if not x:
  17         distb()
  18         return
  19     if type(x) is types.InstanceType:
  20         x = x.__class__
  21     if hasattr(x, 'im_func'):
  22         x = x.im_func
  23     if hasattr(x, 'func_code'):
  24         x = x.func_code
  25     if hasattr(x, '__dict__'):
  26         items = x.__dict__.items()
  27         items.sort()
  28         for name, x1 in items:
  29             if type(x1) in (types.MethodType,
  30                             types.FunctionType,
  31                             types.CodeType):
  32                 print "Disassembly of %s:" % name
  33                 try:
  34                     dis(x1)
  35                 except TypeError, msg:
  36                     print "Sorry:", msg
  37                 print
  38     elif hasattr(x, 'co_code'):
  39         disassemble(x)
  40     else:
  41         raise TypeError, \
  42               "don't know how to disassemble %s objects" % \
  43               type(x).__name__
  44
  45 def distb(tb=None):
  46     """Disassemble a traceback (default: last traceback)."""
  47     if not tb:
  48         try:
  49             tb = sys.last_traceback
  50         except AttributeError:
  51             raise RuntimeError, "no last traceback to disassemble"
  52         while tb.tb_next: tb = tb.tb_next
  53     disassemble(tb.tb_frame.f_code, tb.tb_lasti)
  54
  55 def disassemble(co, lasti=-1):
  56     """Disassemble a code object."""
  57     code = co.co_code
  58     labels = findlabels(code)
  59     n = len(code)
  60     i = 0
  61     extended_arg = 0
  62     free = None
  63     while i < n:
  64         c = code[i]
  65         op = ord(c)
  66         if op == SET_LINENO and i > 0: print # Extra blank line
  67         if i == lasti: print '-->',
  68         else: print '   ',
  69         if i in labels: print '>>',
  70         else: print '  ',
  71         print `i`.rjust(4),
  72         print opname[op].ljust(20),
  73         i = i+1
  74         if op >= HAVE_ARGUMENT:
  75             oparg = ord(code[i]) + ord(code[i+1])*256 + extended_arg
  76             extended_arg = 0
  77             i = i+2
  78             if op == EXTENDED_ARG:
  79                 extended_arg = oparg*65536L
  80             print `oparg`.rjust(5),
  81             if op in hasconst:
  82                 print '(' + `co.co_consts[oparg]` + ')',
  83             elif op in hasname:
  84                 print '(' + co.co_names[oparg] + ')',
  85             elif op in hasjrel:
  86                 print '(to ' + `i + oparg` + ')',
  87             elif op in haslocal:
  88                 print '(' + co.co_varnames[oparg] + ')',
  89             elif op in hascompare:
  90                 print '(' + cmp_op[oparg] + ')',
  91             elif op in hasfree:
  92                 if free is None:
  93                     free = co.co_cellvars + co.co_freevars
  94                 print '(' + free[oparg] + ')',
  95         print
  96
  97 disco = disassemble                     # XXX For backwards compatibility
  98
  99 def findlabels(code):
 100     """Detect all offsets in a byte code which are jump targets.
 101
 102     Return the list of offsets.
 103
 104     """
 105     labels = []
 106     n = len(code)
 107     i = 0
 108     while i < n:
 109         c = code[i]
 110         op = ord(c)
 111         i = i+1
 112         if op >= HAVE_ARGUMENT:
 113             oparg = ord(code[i]) + ord(code[i+1])*256
 114             i = i+2
 115             label = -1
 116             if op in hasjrel:
 117                 label = i+oparg
 118             elif op in hasjabs:
 119                 label = oparg
 120             if label >= 0:
 121                 if label not in labels:
 122                     labels.append(label)
 123     return labels
 124
 125 cmp_op = ('<', '<=', '==', '!=', '>', '>=', 'in', 'not in', 'is',
 126         'is not', 'exception match', 'BAD')
 127
 128 hasconst = []
 129 hasname = []
 130 hasjrel = []
 131 hasjabs = []
 132 haslocal = []
 133 hascompare = []
 134 hasfree = []
 135
 136 opname = [''] * 256
 137 for op in range(256): opname[op] = '<' + `op` + '>'
 138
 139 def def_op(name, op):
 140     opname[op] = name
 141
 142 def name_op(name, op):
 143     opname[op] = name
 144     hasname.append(op)
 145
 146 def jrel_op(name, op):
 147     opname[op] = name
 148     hasjrel.append(op)
 149
 150 def jabs_op(name, op):
 151     opname[op] = name
 152     hasjabs.append(op)
 153
 154 # Instruction opcodes for compiled code
 155
 156 def_op('STOP_CODE', 0)
 157 def_op('POP_TOP', 1)
 158 def_op('ROT_TWO', 2)
 159 def_op('ROT_THREE', 3)
 160 def_op('DUP_TOP', 4)
 161 def_op('ROT_FOUR', 5)
 162
 163 def_op('UNARY_POSITIVE', 10)
 164 def_op('UNARY_NEGATIVE', 11)
 165 def_op('UNARY_NOT', 12)
 166 def_op('UNARY_CONVERT', 13)
 167
 168 def_op('UNARY_INVERT', 15)
 169
 170 def_op('BINARY_POWER', 19)
 171
 172 def_op('BINARY_MULTIPLY', 20)
 173 def_op('BINARY_DIVIDE', 21)
 174 def_op('BINARY_MODULO', 22)
 175 def_op('BINARY_ADD', 23)
 176 def_op('BINARY_SUBTRACT', 24)
 177 def_op('BINARY_SUBSCR', 25)
 178
 179 def_op('SLICE+0', 30)
 180 def_op('SLICE+1', 31)
 181 def_op('SLICE+2', 32)
 182 def_op('SLICE+3', 33)
 183
 184 def_op('STORE_SLICE+0', 40)
 185 def_op('STORE_SLICE+1', 41)
 186 def_op('STORE_SLICE+2', 42)
 187 def_op('STORE_SLICE+3', 43)
 188
 189 def_op('DELETE_SLICE+0', 50)
 190 def_op('DELETE_SLICE+1', 51)
 191 def_op('DELETE_SLICE+2', 52)
 192 def_op('DELETE_SLICE+3', 53)
 193
 194 def_op('INPLACE_ADD', 55)
 195 def_op('INPLACE_SUBTRACT', 56)
 196 def_op('INPLACE_MULTIPLY', 57)
 197 def_op('INPLACE_DIVIDE', 58)
 198 def_op('INPLACE_MODULO', 59)
 199 def_op('STORE_SUBSCR', 60)
 200 def_op('DELETE_SUBSCR', 61)
 201
 202 def_op('BINARY_LSHIFT', 62)
 203 def_op('BINARY_RSHIFT', 63)
 204 def_op('BINARY_AND', 64)
 205 def_op('BINARY_XOR', 65)
 206 def_op('BINARY_OR', 66)
 207 def_op('INPLACE_POWER', 67)
 208
 209 def_op('PRINT_EXPR', 70)
 210 def_op('PRINT_ITEM', 71)
 211 def_op('PRINT_NEWLINE', 72)
 212 def_op('PRINT_ITEM_TO', 73)
 213 def_op('PRINT_NEWLINE_TO', 74)
 214 def_op('INPLACE_LSHIFT', 75)
 215 def_op('INPLACE_RSHIFT', 76)
 216 def_op('INPLACE_AND', 77)
 217 def_op('INPLACE_XOR', 78)
 218 def_op('INPLACE_OR', 79)
 219 def_op('BREAK_LOOP', 80)
 220
 221 def_op('LOAD_LOCALS', 82)
 222 def_op('RETURN_VALUE', 83)
 223 def_op('IMPORT_STAR', 84)
 224 def_op('EXEC_STMT', 85)
 225
 226 def_op('POP_BLOCK', 87)
 227 def_op('END_FINALLY', 88)
 228 def_op('BUILD_CLASS', 89)
 229
 230 HAVE_ARGUMENT = 90              # Opcodes from here have an argument:
 231
 232 name_op('STORE_NAME', 90)       # Index in name list
 233 name_op('DELETE_NAME', 91)      # ""
 234 def_op('UNPACK_SEQUENCE', 92)   # Number of tuple items
 235
 236 name_op('STORE_ATTR', 95)       # Index in name list
 237 name_op('DELETE_ATTR', 96)      # ""
 238 name_op('STORE_GLOBAL', 97)     # ""
 239 name_op('DELETE_GLOBAL', 98)    # ""
 240 def_op('DUP_TOPX', 99)          # number of items to duplicate
 241 def_op('LOAD_CONST', 100)       # Index in const list
 242 hasconst.append(100)
 243 name_op('LOAD_NAME', 101)       # Index in name list
 244 def_op('BUILD_TUPLE', 102)      # Number of tuple items
 245 def_op('BUILD_LIST', 103)       # Number of list items
 246 def_op('BUILD_MAP', 104)        # Always zero for now
 247 name_op('LOAD_ATTR', 105)       # Index in name list
 248 def_op('COMPARE_OP', 106)       # Comparison operator
 249 hascompare.append(106)
 250 name_op('IMPORT_NAME', 107)     # Index in name list
 251 name_op('IMPORT_FROM', 108)     # Index in name list
 252
 253 jrel_op('JUMP_FORWARD', 110)    # Number of bytes to skip
 254 jrel_op('JUMP_IF_FALSE', 111)   # ""
 255 jrel_op('JUMP_IF_TRUE', 112)    # ""
 256 jabs_op('JUMP_ABSOLUTE', 113)   # Target byte offset from beginning of code
 257 jrel_op('FOR_LOOP', 114)        # Number of bytes to skip
 258
 259 name_op('LOAD_GLOBAL', 116)     # Index in name list
 260
 261 jabs_op('CONTINUE_LOOP', 119)   # Target address
 262 jrel_op('SETUP_LOOP', 120)      # Distance to target address
 263 jrel_op('SETUP_EXCEPT', 121)    # ""
 264 jrel_op('SETUP_FINALLY', 122)   # ""
 265
 266 def_op('LOAD_FAST', 124)        # Local variable number
 267 haslocal.append(124)
 268 def_op('STORE_FAST', 125)       # Local variable number
 269 haslocal.append(125)
 270 def_op('DELETE_FAST', 126)      # Local variable number
 271 haslocal.append(126)
 272
 273 def_op('SET_LINENO', 127)       # Current line number
 274 SET_LINENO = 127
 275
 276 def_op('RAISE_VARARGS', 130)    # Number of raise arguments (1, 2, or 3)
 277 def_op('CALL_FUNCTION', 131)    # #args + (#kwargs << 8)
 278 def_op('MAKE_FUNCTION', 132)    # Number of args with default values
 279 def_op('BUILD_SLICE', 133)      # Number of items
 280
 281 def_op('MAKE_CLOSURE', 134)
 282 def_op('LOAD_CLOSURE', 135)
 283 hasfree.append(135)
 284 def_op('LOAD_DEREF', 136)
 285 hasfree.append(136)
 286 def_op('STORE_DEREF', 137)
 287 hasfree.append(137)
 288
 289 def_op('CALL_FUNCTION_VAR', 140)     # #args + (#kwargs << 8)
 290 def_op('CALL_FUNCTION_KW', 141)      # #args + (#kwargs << 8)
 291 def_op('CALL_FUNCTION_VAR_KW', 142)  # #args + (#kwargs << 8)
 292
 293 def_op('EXTENDED_ARG', 143)
 294 EXTENDED_ARG = 143
 295
 296 def _test():
 297     """Simple test program to disassemble a file."""
 298     if sys.argv[1:]:
 299         if sys.argv[2:]:
 300             sys.stderr.write("usage: python dis.py [-|file]\n")
 301             sys.exit(2)
 302         fn = sys.argv[1]
 303         if not fn or fn == "-":
 304             fn = None
 305     else:
 306         fn = None
 307     if not fn:
 308         f = sys.stdin
 309     else:
 310         f = open(fn)
 311     source = f.read()
 312     if fn:
 313         f.close()
 314     else:
 315         fn = "<stdin>"
 316     code = compile(source, fn, "exec")
 317     dis(code)
 318
 319 if __name__ == "__main__":
 320     _test()