python2.6-compiler-package

compiler/pyassem.py

8:3dea01325c0d
2012-06-12 Paul Boddie Added confusing but probably necessary licensing statements.
     1 """A flow graph representation for Python bytecode"""     2      3 import dis     4 import types     5 import sys     6      7 from compiler import misc     8 from compiler.consts \     9      import CO_OPTIMIZED, CO_NEWLOCALS, CO_VARARGS, CO_VARKEYWORDS    10     11 class FlowGraph:    12     def __init__(self):    13         self.current = self.entry = Block()    14         self.exit = Block("exit")    15         self.blocks = misc.Set()    16         self.blocks.add(self.entry)    17         self.blocks.add(self.exit)    18     19     def startBlock(self, block):    20         if self._debug:    21             if self.current:    22                 print "end", repr(self.current)    23                 print "    next", self.current.next    24                 print "   ", self.current.get_children()    25             print repr(block)    26         self.current = block    27     28     def nextBlock(self, block=None):    29         # XXX think we need to specify when there is implicit transfer    30         # from one block to the next.  might be better to represent this    31         # with explicit JUMP_ABSOLUTE instructions that are optimized    32         # out when they are unnecessary.    33         #    34         # I think this strategy works: each block has a child    35         # designated as "next" which is returned as the last of the    36         # children.  because the nodes in a graph are emitted in    37         # reverse post order, the "next" block will always be emitted    38         # immediately after its parent.    39         # Worry: maintaining this invariant could be tricky    40         if block is None:    41             block = self.newBlock()    42     43         # Note: If the current block ends with an unconditional    44         # control transfer, then it is incorrect to add an implicit    45         # transfer to the block graph.  The current code requires    46         # these edges to get the blocks emitted in the right order,    47         # however. :-(  If a client needs to remove these edges, call    48         # pruneEdges().    49     50         self.current.addNext(block)    51         self.startBlock(block)    52     53     def newBlock(self):    54         b = Block()    55         self.blocks.add(b)    56         return b    57     58     def startExitBlock(self):    59         self.startBlock(self.exit)    60     61     _debug = 0    62     63     def _enable_debug(self):    64         self._debug = 1    65     66     def _disable_debug(self):    67         self._debug = 0    68     69     def emit(self, *inst):    70         if self._debug:    71             print "\t", inst    72         if inst[0] in ['RETURN_VALUE', 'YIELD_VALUE']:    73             self.current.addOutEdge(self.exit)    74         if len(inst) == 2 and isinstance(inst[1], Block):    75             self.current.addOutEdge(inst[1])    76         self.current.emit(inst)    77     78     def getBlocksInOrder(self):    79         """Return the blocks in reverse postorder    80     81         i.e. each node appears before all of its successors    82         """    83         # XXX make sure every node that doesn't have an explicit next    84         # is set so that next points to exit    85         for b in self.blocks.elements():    86             if b is self.exit:    87                 continue    88             if not b.next:    89                 b.addNext(self.exit)    90         order = dfs_postorder(self.entry, {})    91         order.reverse()    92         self.fixupOrder(order, self.exit)    93         # hack alert    94         if not self.exit in order:    95             order.append(self.exit)    96     97         return order    98     99     def fixupOrder(self, blocks, default_next):   100         """Fixup bad order introduced by DFS."""   101    102         # XXX This is a total mess.  There must be a better way to get   103         # the code blocks in the right order.   104    105         self.fixupOrderHonorNext(blocks, default_next)   106         self.fixupOrderForward(blocks, default_next)   107    108     def fixupOrderHonorNext(self, blocks, default_next):   109         """Fix one problem with DFS.   110    111         The DFS uses child block, but doesn't know about the special   112         "next" block.  As a result, the DFS can order blocks so that a   113         block isn't next to the right block for implicit control   114         transfers.   115         """   116         index = {}   117         for i in range(len(blocks)):   118             index[blocks[i]] = i   119    120         for i in range(0, len(blocks) - 1):   121             b = blocks[i]   122             n = blocks[i + 1]   123             if not b.next or b.next[0] == default_next or b.next[0] == n:   124                 continue   125             # The blocks are in the wrong order.  Find the chain of   126             # blocks to insert where they belong.   127             cur = b   128             chain = []   129             elt = cur   130             while elt.next and elt.next[0] != default_next:   131                 chain.append(elt.next[0])   132                 elt = elt.next[0]   133             # Now remove the blocks in the chain from the current   134             # block list, so that they can be re-inserted.   135             l = []   136             for b in chain:   137                 assert index[b] > i   138                 l.append((index[b], b))   139             l.sort()   140             l.reverse()   141             for j, b in l:   142                 del blocks[index[b]]   143             # Insert the chain in the proper location   144             blocks[i:i + 1] = [cur] + chain   145             # Finally, re-compute the block indexes   146             for i in range(len(blocks)):   147                 index[blocks[i]] = i   148    149     def fixupOrderForward(self, blocks, default_next):   150         """Make sure all JUMP_FORWARDs jump forward"""   151         index = {}   152         chains = []   153         cur = []   154         for b in blocks:   155             index[b] = len(chains)   156             cur.append(b)   157             if b.next and b.next[0] == default_next:   158                 chains.append(cur)   159                 cur = []   160         chains.append(cur)   161    162         while 1:   163             constraints = []   164    165             for i in range(len(chains)):   166                 l = chains[i]   167                 for b in l:   168                     for c in b.get_children():   169                         if index[c] < i:   170                             forward_p = 0   171                             for inst in b.insts:   172                                 if inst[0] == 'JUMP_FORWARD':   173                                     if inst[1] == c:   174                                         forward_p = 1   175                             if not forward_p:   176                                 continue   177                             constraints.append((index[c], i))   178    179             if not constraints:   180                 break   181    182             # XXX just do one for now   183             # do swaps to get things in the right order   184             goes_before, a_chain = constraints[0]   185             assert a_chain > goes_before   186             c = chains[a_chain]   187             chains.remove(c)   188             chains.insert(goes_before, c)   189    190         del blocks[:]   191         for c in chains:   192             for b in c:   193                 blocks.append(b)   194    195     def getBlocks(self):   196         return self.blocks.elements()   197    198     def getRoot(self):   199         """Return nodes appropriate for use with dominator"""   200         return self.entry   201    202     def getContainedGraphs(self):   203         l = []   204         for b in self.getBlocks():   205             l.extend(b.getContainedGraphs())   206         return l   207    208 def dfs_postorder(b, seen):   209     """Depth-first search of tree rooted at b, return in postorder"""   210     order = []   211     seen[b] = b   212     for c in b.get_children():   213         if c in seen:   214             continue   215         order = order + dfs_postorder(c, seen)   216     order.append(b)   217     return order   218    219 class Block:   220     _count = 0   221    222     def __init__(self, label=''):   223         self.insts = []   224         self.inEdges = misc.Set()   225         self.outEdges = misc.Set()   226         self.label = label   227         self.bid = Block._count   228         self.next = []   229         Block._count = Block._count + 1   230    231     def __repr__(self):   232         if self.label:   233             return "<block %s id=%d>" % (self.label, self.bid)   234         else:   235             return "<block id=%d>" % (self.bid)   236    237     def __str__(self):   238         insts = map(str, self.insts)   239         return "<block %s %d:\n%s>" % (self.label, self.bid,   240                                        '\n'.join(insts))   241    242     def emit(self, inst):   243         op = inst[0]   244         if op[:4] == 'JUMP':   245             self.outEdges.add(inst[1])   246         self.insts.append(inst)   247    248     def getInstructions(self):   249         return self.insts   250    251     def addInEdge(self, block):   252         self.inEdges.add(block)   253    254     def addOutEdge(self, block):   255         self.outEdges.add(block)   256    257     def addNext(self, block):   258         self.next.append(block)   259         assert len(self.next) == 1, map(str, self.next)   260    261     _uncond_transfer = ('RETURN_VALUE', 'RAISE_VARARGS', 'YIELD_VALUE',   262                         'JUMP_ABSOLUTE', 'JUMP_FORWARD', 'CONTINUE_LOOP')   263    264     def pruneNext(self):   265         """Remove bogus edge for unconditional transfers   266    267         Each block has a next edge that accounts for implicit control   268         transfers, e.g. from a JUMP_IF_FALSE to the block that will be   269         executed if the test is true.   270    271         These edges must remain for the current assembler code to   272         work. If they are removed, the dfs_postorder gets things in   273         weird orders.  However, they shouldn't be there for other   274         purposes, e.g. conversion to SSA form.  This method will   275         remove the next edge when it follows an unconditional control   276         transfer.   277         """   278         try:   279             op, arg = self.insts[-1]   280         except (IndexError, ValueError):   281             return   282         if op in self._uncond_transfer:   283             self.next = []   284    285     def get_children(self):   286         if self.next and self.next[0] in self.outEdges:   287             self.outEdges.remove(self.next[0])   288         return self.outEdges.elements() + self.next   289    290     def getContainedGraphs(self):   291         """Return all graphs contained within this block.   292    293         For example, a MAKE_FUNCTION block will contain a reference to   294         the graph for the function body.   295         """   296         contained = []   297         for inst in self.insts:   298             if len(inst) == 1:   299                 continue   300             op = inst[1]   301             if hasattr(op, 'graph'):   302                 contained.append(op.graph)   303         return contained   304    305 # flags for code objects   306    307 # the FlowGraph is transformed in place; it exists in one of these states   308 RAW = "RAW"   309 FLAT = "FLAT"   310 CONV = "CONV"   311 DONE = "DONE"   312    313 class PyFlowGraph(FlowGraph):   314     super_init = FlowGraph.__init__   315    316     def __init__(self, name, filename, args=(), optimized=0, klass=None):   317         self.super_init()   318         self.name = name   319         self.filename = filename   320         self.docstring = None   321         self.args = args # XXX   322         self.argcount = getArgCount(args)   323         self.klass = klass   324         if optimized:   325             self.flags = CO_OPTIMIZED | CO_NEWLOCALS   326         else:   327             self.flags = 0   328         self.consts = []   329         self.names = []   330         # Free variables found by the symbol table scan, including   331         # variables used only in nested scopes, are included here.   332         self.freevars = []   333         self.cellvars = []   334         # The closure list is used to track the order of cell   335         # variables and free variables in the resulting code object.   336         # The offsets used by LOAD_CLOSURE/LOAD_DEREF refer to both   337         # kinds of variables.   338         self.closure = []   339         self.varnames = list(args) or []   340         for i in range(len(self.varnames)):   341             var = self.varnames[i]   342             if isinstance(var, TupleArg):   343                 self.varnames[i] = var.getName()   344         self.stage = RAW   345    346     def setDocstring(self, doc):   347         self.docstring = doc   348    349     def setFlag(self, flag):   350         self.flags = self.flags | flag   351         if flag == CO_VARARGS:   352             self.argcount = self.argcount - 1   353    354     def checkFlag(self, flag):   355         if self.flags & flag:   356             return 1   357    358     def setFreeVars(self, names):   359         self.freevars = list(names)   360    361     def setCellVars(self, names):   362         self.cellvars = names   363    364     def getCode(self):   365         """Get a Python code object"""   366         assert self.stage == RAW   367         self.computeStackDepth()   368         self.flattenGraph()   369         assert self.stage == FLAT   370         self.convertArgs()   371         assert self.stage == CONV   372         self.makeByteCode()   373         assert self.stage == DONE   374         return self.newCodeObject()   375    376     def dump(self, io=None):   377         if io:   378             save = sys.stdout   379             sys.stdout = io   380         pc = 0   381         for t in self.insts:   382             opname = t[0]   383             if opname == "SET_LINENO":   384                 print   385             if len(t) == 1:   386                 print "\t", "%3d" % pc, opname   387                 pc = pc + 1   388             else:   389                 print "\t", "%3d" % pc, opname, t[1]   390                 pc = pc + 3   391         if io:   392             sys.stdout = save   393    394     def computeStackDepth(self):   395         """Compute the max stack depth.   396    397         Approach is to compute the stack effect of each basic block.   398         Then find the path through the code with the largest total   399         effect.   400         """   401         depth = {}   402         exit = None   403         for b in self.getBlocks():   404             depth[b] = findDepth(b.getInstructions())   405    406         seen = {}   407    408         def max_depth(b, d):   409             if b in seen:   410                 return d   411             seen[b] = 1   412             d = d + depth[b]   413             children = b.get_children()   414             if children:   415                 return max([max_depth(c, d) for c in children])   416             else:   417                 if not b.label == "exit":   418                     return max_depth(self.exit, d)   419                 else:   420                     return d   421    422         self.stacksize = max_depth(self.entry, 0)   423    424     def flattenGraph(self):   425         """Arrange the blocks in order and resolve jumps"""   426         assert self.stage == RAW   427         self.insts = insts = []   428         pc = 0   429         begin = {}   430         end = {}   431         for b in self.getBlocksInOrder():   432             begin[b] = pc   433             for inst in b.getInstructions():   434                 insts.append(inst)   435                 if len(inst) == 1:   436                     pc = pc + 1   437                 elif inst[0] != "SET_LINENO":   438                     # arg takes 2 bytes   439                     pc = pc + 3   440             end[b] = pc   441         pc = 0   442         for i in range(len(insts)):   443             inst = insts[i]   444             if len(inst) == 1:   445                 pc = pc + 1   446             elif inst[0] != "SET_LINENO":   447                 pc = pc + 3   448             opname = inst[0]   449             if self.hasjrel.has_elt(opname):   450                 oparg = inst[1]   451                 offset = begin[oparg] - pc   452                 insts[i] = opname, offset   453             elif self.hasjabs.has_elt(opname):   454                 insts[i] = opname, begin[inst[1]]   455         self.stage = FLAT   456    457     hasjrel = misc.Set()   458     for i in dis.hasjrel:   459         hasjrel.add(dis.opname[i])   460     hasjabs = misc.Set()   461     for i in dis.hasjabs:   462         hasjabs.add(dis.opname[i])   463    464     def convertArgs(self):   465         """Convert arguments from symbolic to concrete form"""   466         assert self.stage == FLAT   467         self.consts.insert(0, self.docstring)   468         self.sort_cellvars()   469         for i in range(len(self.insts)):   470             t = self.insts[i]   471             if len(t) == 2:   472                 opname, oparg = t   473                 conv = self._converters.get(opname, None)   474                 if conv:   475                     self.insts[i] = opname, conv(self, oparg)   476         self.stage = CONV   477    478     def sort_cellvars(self):   479         """Sort cellvars in the order of varnames and prune from freevars.   480         """   481         cells = {}   482         for name in self.cellvars:   483             cells[name] = 1   484         self.cellvars = [name for name in self.varnames   485                          if name in cells]   486         for name in self.cellvars:   487             del cells[name]   488         self.cellvars = self.cellvars + cells.keys()   489         self.closure = self.cellvars + self.freevars   490    491     def _lookupName(self, name, list):   492         """Return index of name in list, appending if necessary   493    494         This routine uses a list instead of a dictionary, because a   495         dictionary can't store two different keys if the keys have the   496         same value but different types, e.g. 2 and 2L.  The compiler   497         must treat these two separately, so it does an explicit type   498         comparison before comparing the values.   499         """   500         t = type(name)   501         for i in range(len(list)):   502             if t == type(list[i]) and list[i] == name:   503                 return i   504         end = len(list)   505         list.append(name)   506         return end   507    508     _converters = {}   509     def _convert_LOAD_CONST(self, arg):   510         if hasattr(arg, 'getCode'):   511             arg = arg.getCode()   512         return self._lookupName(arg, self.consts)   513    514     def _convert_LOAD_FAST(self, arg):   515         self._lookupName(arg, self.names)   516         return self._lookupName(arg, self.varnames)   517     _convert_STORE_FAST = _convert_LOAD_FAST   518     _convert_DELETE_FAST = _convert_LOAD_FAST   519    520     def _convert_LOAD_NAME(self, arg):   521         if self.klass is None:   522             self._lookupName(arg, self.varnames)   523         return self._lookupName(arg, self.names)   524    525     def _convert_NAME(self, arg):   526         if self.klass is None:   527             self._lookupName(arg, self.varnames)   528         return self._lookupName(arg, self.names)   529     _convert_STORE_NAME = _convert_NAME   530     _convert_DELETE_NAME = _convert_NAME   531     _convert_IMPORT_NAME = _convert_NAME   532     _convert_IMPORT_FROM = _convert_NAME   533     _convert_STORE_ATTR = _convert_NAME   534     _convert_LOAD_ATTR = _convert_NAME   535     _convert_DELETE_ATTR = _convert_NAME   536     _convert_LOAD_GLOBAL = _convert_NAME   537     _convert_STORE_GLOBAL = _convert_NAME   538     _convert_DELETE_GLOBAL = _convert_NAME   539    540     def _convert_DEREF(self, arg):   541         self._lookupName(arg, self.names)   542         self._lookupName(arg, self.varnames)   543         return self._lookupName(arg, self.closure)   544     _convert_LOAD_DEREF = _convert_DEREF   545     _convert_STORE_DEREF = _convert_DEREF   546    547     def _convert_LOAD_CLOSURE(self, arg):   548         self._lookupName(arg, self.varnames)   549         return self._lookupName(arg, self.closure)   550    551     _cmp = list(dis.cmp_op)   552     def _convert_COMPARE_OP(self, arg):   553         return self._cmp.index(arg)   554    555     # similarly for other opcodes...   556    557     for name, obj in locals().items():   558         if name[:9] == "_convert_":   559             opname = name[9:]   560             _converters[opname] = obj   561     del name, obj, opname   562    563     def makeByteCode(self):   564         assert self.stage == CONV   565         self.lnotab = lnotab = LineAddrTable()   566         for t in self.insts:   567             opname = t[0]   568             if len(t) == 1:   569                 lnotab.addCode(self.opnum[opname])   570             else:   571                 oparg = t[1]   572                 if opname == "SET_LINENO":   573                     lnotab.nextLine(oparg)   574                     continue   575                 hi, lo = twobyte(oparg)   576                 try:   577                     lnotab.addCode(self.opnum[opname], lo, hi)   578                 except ValueError:   579                     print opname, oparg   580                     print self.opnum[opname], lo, hi   581                     raise   582         self.stage = DONE   583    584     opnum = {}   585     for num in range(len(dis.opname)):   586         opnum[dis.opname[num]] = num   587     del num   588    589     def newCodeObject(self):   590         assert self.stage == DONE   591         if (self.flags & CO_NEWLOCALS) == 0:   592             nlocals = 0   593         else:   594             nlocals = len(self.varnames)   595         argcount = self.argcount   596         if self.flags & CO_VARKEYWORDS:   597             argcount = argcount - 1   598         return types.CodeType(argcount, nlocals, self.stacksize, self.flags,   599                         self.lnotab.getCode(), self.getConsts(),   600                         tuple(self.names), tuple(self.varnames),   601                         self.filename, self.name, self.lnotab.firstline,   602                         self.lnotab.getTable(), tuple(self.freevars),   603                         tuple(self.cellvars))   604    605     def getConsts(self):   606         """Return a tuple for the const slot of the code object   607    608         Must convert references to code (MAKE_FUNCTION) to code   609         objects recursively.   610         """   611         l = []   612         for elt in self.consts:   613             if isinstance(elt, PyFlowGraph):   614                 elt = elt.getCode()   615             l.append(elt)   616         return tuple(l)   617    618 def isJump(opname):   619     if opname[:4] == 'JUMP':   620         return 1   621    622 class TupleArg:   623     """Helper for marking func defs with nested tuples in arglist"""   624     def __init__(self, count, names):   625         self.count = count   626         self.names = names   627     def __repr__(self):   628         return "TupleArg(%s, %s)" % (self.count, self.names)   629     def getName(self):   630         return ".%d" % self.count   631    632 def getArgCount(args):   633     argcount = len(args)   634     if args:   635         for arg in args:   636             if isinstance(arg, TupleArg):   637                 numNames = len(misc.flatten(arg.names))   638                 argcount = argcount - numNames   639     return argcount   640    641 def twobyte(val):   642     """Convert an int argument into high and low bytes"""   643     assert isinstance(val, int)   644     return divmod(val, 256)   645    646 class LineAddrTable:   647     """lnotab   648    649     This class builds the lnotab, which is documented in compile.c.   650     Here's a brief recap:   651    652     For each SET_LINENO instruction after the first one, two bytes are   653     added to lnotab.  (In some cases, multiple two-byte entries are   654     added.)  The first byte is the distance in bytes between the   655     instruction for the last SET_LINENO and the current SET_LINENO.   656     The second byte is offset in line numbers.  If either offset is   657     greater than 255, multiple two-byte entries are added -- see   658     compile.c for the delicate details.   659     """   660    661     def __init__(self):   662         self.code = []   663         self.codeOffset = 0   664         self.firstline = 0   665         self.lastline = 0   666         self.lastoff = 0   667         self.lnotab = []   668    669     def addCode(self, *args):   670         for arg in args:   671             self.code.append(chr(arg))   672         self.codeOffset = self.codeOffset + len(args)   673    674     def nextLine(self, lineno):   675         if self.firstline == 0:   676             self.firstline = lineno   677             self.lastline = lineno   678         else:   679             # compute deltas   680             addr = self.codeOffset - self.lastoff   681             line = lineno - self.lastline   682             # Python assumes that lineno always increases with   683             # increasing bytecode address (lnotab is unsigned char).   684             # Depending on when SET_LINENO instructions are emitted   685             # this is not always true.  Consider the code:   686             #     a = (1,   687             #          b)   688             # In the bytecode stream, the assignment to "a" occurs   689             # after the loading of "b".  This works with the C Python   690             # compiler because it only generates a SET_LINENO instruction   691             # for the assignment.   692             if line >= 0:   693                 push = self.lnotab.append   694                 while addr > 255:   695                     push(255); push(0)   696                     addr -= 255   697                 while line > 255:   698                     push(addr); push(255)   699                     line -= 255   700                     addr = 0   701                 if addr > 0 or line > 0:   702                     push(addr); push(line)   703                 self.lastline = lineno   704                 self.lastoff = self.codeOffset   705    706     def getCode(self):   707         return ''.join(self.code)   708    709     def getTable(self):   710         return ''.join(map(chr, self.lnotab))   711    712 class StackDepthTracker:   713     # XXX 1. need to keep track of stack depth on jumps   714     # XXX 2. at least partly as a result, this code is broken   715    716     def findDepth(self, insts, debug=0):   717         depth = 0   718         maxDepth = 0   719         for i in insts:   720             opname = i[0]   721             if debug:   722                 print i,   723             delta = self.effect.get(opname, None)   724             if delta is not None:   725                 depth = depth + delta   726             else:   727                 # now check patterns   728                 for pat, pat_delta in self.patterns:   729                     if opname[:len(pat)] == pat:   730                         delta = pat_delta   731                         depth = depth + delta   732                         break   733                 # if we still haven't found a match   734                 if delta is None:   735                     meth = getattr(self, opname, None)   736                     if meth is not None:   737                         depth = depth + meth(i[1])   738             if depth > maxDepth:   739                 maxDepth = depth   740             if debug:   741                 print depth, maxDepth   742         return maxDepth   743    744     effect = {   745         'POP_TOP': -1,   746         'DUP_TOP': 1,   747         'LIST_APPEND': -2,   748         'SLICE+1': -1,   749         'SLICE+2': -1,   750         'SLICE+3': -2,   751         'STORE_SLICE+0': -1,   752         'STORE_SLICE+1': -2,   753         'STORE_SLICE+2': -2,   754         'STORE_SLICE+3': -3,   755         'DELETE_SLICE+0': -1,   756         'DELETE_SLICE+1': -2,   757         'DELETE_SLICE+2': -2,   758         'DELETE_SLICE+3': -3,   759         'STORE_SUBSCR': -3,   760         'DELETE_SUBSCR': -2,   761         # PRINT_EXPR?   762         'PRINT_ITEM': -1,   763         'RETURN_VALUE': -1,   764         'YIELD_VALUE': -1,   765         'EXEC_STMT': -3,   766         'BUILD_CLASS': -2,   767         'STORE_NAME': -1,   768         'STORE_ATTR': -2,   769         'DELETE_ATTR': -1,   770         'STORE_GLOBAL': -1,   771         'BUILD_MAP': 1,   772         'COMPARE_OP': -1,   773         'STORE_FAST': -1,   774         'IMPORT_STAR': -1,   775         'IMPORT_NAME': -1,   776         'IMPORT_FROM': 1,   777         'LOAD_ATTR': 0, # unlike other loads   778         # close enough...   779         'SETUP_EXCEPT': 3,   780         'SETUP_FINALLY': 3,   781         'FOR_ITER': 1,   782         'WITH_CLEANUP': -1,   783         }   784     # use pattern match   785     patterns = [   786         ('BINARY_', -1),   787         ('LOAD_', 1),   788         ]   789    790     def UNPACK_SEQUENCE(self, count):   791         return count-1   792     def BUILD_TUPLE(self, count):   793         return -count+1   794     def BUILD_LIST(self, count):   795         return -count+1   796     def CALL_FUNCTION(self, argc):   797         hi, lo = divmod(argc, 256)   798         return -(lo + hi * 2)   799     def CALL_FUNCTION_VAR(self, argc):   800         return self.CALL_FUNCTION(argc)-1   801     def CALL_FUNCTION_KW(self, argc):   802         return self.CALL_FUNCTION(argc)-1   803     def CALL_FUNCTION_VAR_KW(self, argc):   804         return self.CALL_FUNCTION(argc)-2   805     def MAKE_FUNCTION(self, argc):   806         return -argc   807     def MAKE_CLOSURE(self, argc):   808         # XXX need to account for free variables too!   809         return -argc   810     def BUILD_SLICE(self, argc):   811         if argc == 2:   812             return -1   813         elif argc == 3:   814             return -2   815     def DUP_TOPX(self, argc):   816         return argc   817    818 findDepth = StackDepthTracker().findDepth