EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS

[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Lib / compiler / pyassem.py

"""A flow graph representation for Python bytecode"""\r
\r
import dis\r
import types\r
import sys\r
\r
from compiler import misc\r
from compiler.consts \\r
     import CO_OPTIMIZED, CO_NEWLOCALS, CO_VARARGS, CO_VARKEYWORDS\r
\r
class FlowGraph:\r
    def __init__(self):\r
        self.current = self.entry = Block()\r
        self.exit = Block("exit")\r
        self.blocks = misc.Set()\r
        self.blocks.add(self.entry)\r
        self.blocks.add(self.exit)\r
\r
    def startBlock(self, block):\r
        if self._debug:\r
            if self.current:\r
                print "end", repr(self.current)\r
                print "    next", self.current.next\r
                print "    prev", self.current.prev\r
                print "   ", self.current.get_children()\r
            print repr(block)\r
        self.current = block\r
\r
    def nextBlock(self, block=None):\r
        # XXX think we need to specify when there is implicit transfer\r
        # from one block to the next.  might be better to represent this\r
        # with explicit JUMP_ABSOLUTE instructions that are optimized\r
        # out when they are unnecessary.\r
        #\r
        # I think this strategy works: each block has a child\r
        # designated as "next" which is returned as the last of the\r
        # children.  because the nodes in a graph are emitted in\r
        # reverse post order, the "next" block will always be emitted\r
        # immediately after its parent.\r
        # Worry: maintaining this invariant could be tricky\r
        if block is None:\r
            block = self.newBlock()\r
\r
        # Note: If the current block ends with an unconditional control\r
        # transfer, then it is techically incorrect to add an implicit\r
        # transfer to the block graph. Doing so results in code generation\r
        # for unreachable blocks.  That doesn't appear to be very common\r
        # with Python code and since the built-in compiler doesn't optimize\r
        # it out we don't either.\r
        self.current.addNext(block)\r
        self.startBlock(block)\r
\r
    def newBlock(self):\r
        b = Block()\r
        self.blocks.add(b)\r
        return b\r
\r
    def startExitBlock(self):\r
        self.startBlock(self.exit)\r
\r
    _debug = 0\r
\r
    def _enable_debug(self):\r
        self._debug = 1\r
\r
    def _disable_debug(self):\r
        self._debug = 0\r
\r
    def emit(self, *inst):\r
        if self._debug:\r
            print "\t", inst\r
        if len(inst) == 2 and isinstance(inst[1], Block):\r
            self.current.addOutEdge(inst[1])\r
        self.current.emit(inst)\r
\r
    def getBlocksInOrder(self):\r
        """Return the blocks in reverse postorder\r
\r
        i.e. each node appears before all of its successors\r
        """\r
        order = order_blocks(self.entry, self.exit)\r
        return order\r
\r
    def getBlocks(self):\r
        return self.blocks.elements()\r
\r
    def getRoot(self):\r
        """Return nodes appropriate for use with dominator"""\r
        return self.entry\r
\r
    def getContainedGraphs(self):\r
        l = []\r
        for b in self.getBlocks():\r
            l.extend(b.getContainedGraphs())\r
        return l\r
\r
\r
def order_blocks(start_block, exit_block):\r
    """Order blocks so that they are emitted in the right order"""\r
    # Rules:\r
    # - when a block has a next block, the next block must be emitted just after\r
    # - when a block has followers (relative jumps), it must be emitted before\r
    #   them\r
    # - all reachable blocks must be emitted\r
    order = []\r
\r
    # Find all the blocks to be emitted.\r
    remaining = set()\r
    todo = [start_block]\r
    while todo:\r
        b = todo.pop()\r
        if b in remaining:\r
            continue\r
        remaining.add(b)\r
        for c in b.get_children():\r
            if c not in remaining:\r
                todo.append(c)\r
\r
    # A block is dominated by another block if that block must be emitted\r
    # before it.\r
    dominators = {}\r
    for b in remaining:\r
        if __debug__ and b.next:\r
            assert b is b.next[0].prev[0], (b, b.next)\r
        # Make sure every block appears in dominators, even if no\r
        # other block must precede it.\r
        dominators.setdefault(b, set())\r
        # preceeding blocks dominate following blocks\r
        for c in b.get_followers():\r
            while 1:\r
                dominators.setdefault(c, set()).add(b)\r
                # Any block that has a next pointer leading to c is also\r
                # dominated because the whole chain will be emitted at once.\r
                # Walk backwards and add them all.\r
                if c.prev and c.prev[0] is not b:\r
                    c = c.prev[0]\r
                else:\r
                    break\r
\r
    def find_next():\r
        # Find a block that can be emitted next.\r
        for b in remaining:\r
            for c in dominators[b]:\r
                if c in remaining:\r
                    break # can't emit yet, dominated by a remaining block\r
            else:\r
                return b\r
        assert 0, 'circular dependency, cannot find next block'\r
\r
    b = start_block\r
    while 1:\r
        order.append(b)\r
        remaining.discard(b)\r
        if b.next:\r
            b = b.next[0]\r
            continue\r
        elif b is not exit_block and not b.has_unconditional_transfer():\r
            order.append(exit_block)\r
        if not remaining:\r
            break\r
        b = find_next()\r
    return order\r
\r
\r
class Block:\r
    _count = 0\r
\r
    def __init__(self, label=''):\r
        self.insts = []\r
        self.outEdges = set()\r
        self.label = label\r
        self.bid = Block._count\r
        self.next = []\r
        self.prev = []\r
        Block._count = Block._count + 1\r
\r
    def __repr__(self):\r
        if self.label:\r
            return "<block %s id=%d>" % (self.label, self.bid)\r
        else:\r
            return "<block id=%d>" % (self.bid)\r
\r
    def __str__(self):\r
        insts = map(str, self.insts)\r
        return "<block %s %d:\n%s>" % (self.label, self.bid,\r
                                       '\n'.join(insts))\r
\r
    def emit(self, inst):\r
        op = inst[0]\r
        self.insts.append(inst)\r
\r
    def getInstructions(self):\r
        return self.insts\r
\r
    def addOutEdge(self, block):\r
        self.outEdges.add(block)\r
\r
    def addNext(self, block):\r
        self.next.append(block)\r
        assert len(self.next) == 1, map(str, self.next)\r
        block.prev.append(self)\r
        assert len(block.prev) == 1, map(str, block.prev)\r
\r
    _uncond_transfer = ('RETURN_VALUE', 'RAISE_VARARGS',\r
                        'JUMP_ABSOLUTE', 'JUMP_FORWARD', 'CONTINUE_LOOP',\r
                        )\r
\r
    def has_unconditional_transfer(self):\r
        """Returns True if there is an unconditional transfer to an other block\r
        at the end of this block. This means there is no risk for the bytecode\r
        executer to go past this block's bytecode."""\r
        try:\r
            op, arg = self.insts[-1]\r
        except (IndexError, ValueError):\r
            return\r
        return op in self._uncond_transfer\r
\r
    def get_children(self):\r
        return list(self.outEdges) + self.next\r
\r
    def get_followers(self):\r
        """Get the whole list of followers, including the next block."""\r
        followers = set(self.next)\r
        # Blocks that must be emitted *after* this one, because of\r
        # bytecode offsets (e.g. relative jumps) pointing to them.\r
        for inst in self.insts:\r
            if inst[0] in PyFlowGraph.hasjrel:\r
                followers.add(inst[1])\r
        return followers\r
\r
    def getContainedGraphs(self):\r
        """Return all graphs contained within this block.\r
\r
        For example, a MAKE_FUNCTION block will contain a reference to\r
        the graph for the function body.\r
        """\r
        contained = []\r
        for inst in self.insts:\r
            if len(inst) == 1:\r
                continue\r
            op = inst[1]\r
            if hasattr(op, 'graph'):\r
                contained.append(op.graph)\r
        return contained\r
\r
# flags for code objects\r
\r
# the FlowGraph is transformed in place; it exists in one of these states\r
RAW = "RAW"\r
FLAT = "FLAT"\r
CONV = "CONV"\r
DONE = "DONE"\r
\r
class PyFlowGraph(FlowGraph):\r
    super_init = FlowGraph.__init__\r
\r
    def __init__(self, name, filename, args=(), optimized=0, klass=None):\r
        self.super_init()\r
        self.name = name\r
        self.filename = filename\r
        self.docstring = None\r
        self.args = args # XXX\r
        self.argcount = getArgCount(args)\r
        self.klass = klass\r
        if optimized:\r
            self.flags = CO_OPTIMIZED | CO_NEWLOCALS\r
        else:\r
            self.flags = 0\r
        self.consts = []\r
        self.names = []\r
        # Free variables found by the symbol table scan, including\r
        # variables used only in nested scopes, are included here.\r
        self.freevars = []\r
        self.cellvars = []\r
        # The closure list is used to track the order of cell\r
        # variables and free variables in the resulting code object.\r
        # The offsets used by LOAD_CLOSURE/LOAD_DEREF refer to both\r
        # kinds of variables.\r
        self.closure = []\r
        self.varnames = list(args) or []\r
        for i in range(len(self.varnames)):\r
            var = self.varnames[i]\r
            if isinstance(var, TupleArg):\r
                self.varnames[i] = var.getName()\r
        self.stage = RAW\r
\r
    def setDocstring(self, doc):\r
        self.docstring = doc\r
\r
    def setFlag(self, flag):\r
        self.flags = self.flags | flag\r
        if flag == CO_VARARGS:\r
            self.argcount = self.argcount - 1\r
\r
    def checkFlag(self, flag):\r
        if self.flags & flag:\r
            return 1\r
\r
    def setFreeVars(self, names):\r
        self.freevars = list(names)\r
\r
    def setCellVars(self, names):\r
        self.cellvars = names\r
\r
    def getCode(self):\r
        """Get a Python code object"""\r
        assert self.stage == RAW\r
        self.computeStackDepth()\r
        self.flattenGraph()\r
        assert self.stage == FLAT\r
        self.convertArgs()\r
        assert self.stage == CONV\r
        self.makeByteCode()\r
        assert self.stage == DONE\r
        return self.newCodeObject()\r
\r
    def dump(self, io=None):\r
        if io:\r
            save = sys.stdout\r
            sys.stdout = io\r
        pc = 0\r
        for t in self.insts:\r
            opname = t[0]\r
            if opname == "SET_LINENO":\r
                print\r
            if len(t) == 1:\r
                print "\t", "%3d" % pc, opname\r
                pc = pc + 1\r
            else:\r
                print "\t", "%3d" % pc, opname, t[1]\r
                pc = pc + 3\r
        if io:\r
            sys.stdout = save\r
\r
    def computeStackDepth(self):\r
        """Compute the max stack depth.\r
\r
        Approach is to compute the stack effect of each basic block.\r
        Then find the path through the code with the largest total\r
        effect.\r
        """\r
        depth = {}\r
        exit = None\r
        for b in self.getBlocks():\r
            depth[b] = findDepth(b.getInstructions())\r
\r
        seen = {}\r
\r
        def max_depth(b, d):\r
            if b in seen:\r
                return d\r
            seen[b] = 1\r
            d = d + depth[b]\r
            children = b.get_children()\r
            if children:\r
                return max([max_depth(c, d) for c in children])\r
            else:\r
                if not b.label == "exit":\r
                    return max_depth(self.exit, d)\r
                else:\r
                    return d\r
\r
        self.stacksize = max_depth(self.entry, 0)\r
\r
    def flattenGraph(self):\r
        """Arrange the blocks in order and resolve jumps"""\r
        assert self.stage == RAW\r
        self.insts = insts = []\r
        pc = 0\r
        begin = {}\r
        end = {}\r
        for b in self.getBlocksInOrder():\r
            begin[b] = pc\r
            for inst in b.getInstructions():\r
                insts.append(inst)\r
                if len(inst) == 1:\r
                    pc = pc + 1\r
                elif inst[0] != "SET_LINENO":\r
                    # arg takes 2 bytes\r
                    pc = pc + 3\r
            end[b] = pc\r
        pc = 0\r
        for i in range(len(insts)):\r
            inst = insts[i]\r
            if len(inst) == 1:\r
                pc = pc + 1\r
            elif inst[0] != "SET_LINENO":\r
                pc = pc + 3\r
            opname = inst[0]\r
            if opname in self.hasjrel:\r
                oparg = inst[1]\r
                offset = begin[oparg] - pc\r
                insts[i] = opname, offset\r
            elif opname in self.hasjabs:\r
                insts[i] = opname, begin[inst[1]]\r
        self.stage = FLAT\r
\r
    hasjrel = set()\r
    for i in dis.hasjrel:\r
        hasjrel.add(dis.opname[i])\r
    hasjabs = set()\r
    for i in dis.hasjabs:\r
        hasjabs.add(dis.opname[i])\r
\r
    def convertArgs(self):\r
        """Convert arguments from symbolic to concrete form"""\r
        assert self.stage == FLAT\r
        self.consts.insert(0, self.docstring)\r
        self.sort_cellvars()\r
        for i in range(len(self.insts)):\r
            t = self.insts[i]\r
            if len(t) == 2:\r
                opname, oparg = t\r
                conv = self._converters.get(opname, None)\r
                if conv:\r
                    self.insts[i] = opname, conv(self, oparg)\r
        self.stage = CONV\r
\r
    def sort_cellvars(self):\r
        """Sort cellvars in the order of varnames and prune from freevars.\r
        """\r
        cells = {}\r
        for name in self.cellvars:\r
            cells[name] = 1\r
        self.cellvars = [name for name in self.varnames\r
                         if name in cells]\r
        for name in self.cellvars:\r
            del cells[name]\r
        self.cellvars = self.cellvars + cells.keys()\r
        self.closure = self.cellvars + self.freevars\r
\r
    def _lookupName(self, name, list):\r
        """Return index of name in list, appending if necessary\r
\r
        This routine uses a list instead of a dictionary, because a\r
        dictionary can't store two different keys if the keys have the\r
        same value but different types, e.g. 2 and 2L.  The compiler\r
        must treat these two separately, so it does an explicit type\r
        comparison before comparing the values.\r
        """\r
        t = type(name)\r
        for i in range(len(list)):\r
            if t == type(list[i]) and list[i] == name:\r
                return i\r
        end = len(list)\r
        list.append(name)\r
        return end\r
\r
    _converters = {}\r
    def _convert_LOAD_CONST(self, arg):\r
        if hasattr(arg, 'getCode'):\r
            arg = arg.getCode()\r
        return self._lookupName(arg, self.consts)\r
\r
    def _convert_LOAD_FAST(self, arg):\r
        self._lookupName(arg, self.names)\r
        return self._lookupName(arg, self.varnames)\r
    _convert_STORE_FAST = _convert_LOAD_FAST\r
    _convert_DELETE_FAST = _convert_LOAD_FAST\r
\r
    def _convert_LOAD_NAME(self, arg):\r
        if self.klass is None:\r
            self._lookupName(arg, self.varnames)\r
        return self._lookupName(arg, self.names)\r
\r
    def _convert_NAME(self, arg):\r
        if self.klass is None:\r
            self._lookupName(arg, self.varnames)\r
        return self._lookupName(arg, self.names)\r
    _convert_STORE_NAME = _convert_NAME\r
    _convert_DELETE_NAME = _convert_NAME\r
    _convert_IMPORT_NAME = _convert_NAME\r
    _convert_IMPORT_FROM = _convert_NAME\r
    _convert_STORE_ATTR = _convert_NAME\r
    _convert_LOAD_ATTR = _convert_NAME\r
    _convert_DELETE_ATTR = _convert_NAME\r
    _convert_LOAD_GLOBAL = _convert_NAME\r
    _convert_STORE_GLOBAL = _convert_NAME\r
    _convert_DELETE_GLOBAL = _convert_NAME\r
\r
    def _convert_DEREF(self, arg):\r
        self._lookupName(arg, self.names)\r
        self._lookupName(arg, self.varnames)\r
        return self._lookupName(arg, self.closure)\r
    _convert_LOAD_DEREF = _convert_DEREF\r
    _convert_STORE_DEREF = _convert_DEREF\r
\r
    def _convert_LOAD_CLOSURE(self, arg):\r
        self._lookupName(arg, self.varnames)\r
        return self._lookupName(arg, self.closure)\r
\r
    _cmp = list(dis.cmp_op)\r
    def _convert_COMPARE_OP(self, arg):\r
        return self._cmp.index(arg)\r
\r
    # similarly for other opcodes...\r
\r
    for name, obj in locals().items():\r
        if name[:9] == "_convert_":\r
            opname = name[9:]\r
            _converters[opname] = obj\r
    del name, obj, opname\r
\r
    def makeByteCode(self):\r
        assert self.stage == CONV\r
        self.lnotab = lnotab = LineAddrTable()\r
        for t in self.insts:\r
            opname = t[0]\r
            if len(t) == 1:\r
                lnotab.addCode(self.opnum[opname])\r
            else:\r
                oparg = t[1]\r
                if opname == "SET_LINENO":\r
                    lnotab.nextLine(oparg)\r
                    continue\r
                hi, lo = twobyte(oparg)\r
                try:\r
                    lnotab.addCode(self.opnum[opname], lo, hi)\r
                except ValueError:\r
                    print opname, oparg\r
                    print self.opnum[opname], lo, hi\r
                    raise\r
        self.stage = DONE\r
\r
    opnum = {}\r
    for num in range(len(dis.opname)):\r
        opnum[dis.opname[num]] = num\r
    del num\r
\r
    def newCodeObject(self):\r
        assert self.stage == DONE\r
        if (self.flags & CO_NEWLOCALS) == 0:\r
            nlocals = 0\r
        else:\r
            nlocals = len(self.varnames)\r
        argcount = self.argcount\r
        if self.flags & CO_VARKEYWORDS:\r
            argcount = argcount - 1\r
        return types.CodeType(argcount, nlocals, self.stacksize, self.flags,\r
                        self.lnotab.getCode(), self.getConsts(),\r
                        tuple(self.names), tuple(self.varnames),\r
                        self.filename, self.name, self.lnotab.firstline,\r
                        self.lnotab.getTable(), tuple(self.freevars),\r
                        tuple(self.cellvars))\r
\r
    def getConsts(self):\r
        """Return a tuple for the const slot of the code object\r
\r
        Must convert references to code (MAKE_FUNCTION) to code\r
        objects recursively.\r
        """\r
        l = []\r
        for elt in self.consts:\r
            if isinstance(elt, PyFlowGraph):\r
                elt = elt.getCode()\r
            l.append(elt)\r
        return tuple(l)\r
\r
def isJump(opname):\r
    if opname[:4] == 'JUMP':\r
        return 1\r
\r
class TupleArg:\r
    """Helper for marking func defs with nested tuples in arglist"""\r
    def __init__(self, count, names):\r
        self.count = count\r
        self.names = names\r
    def __repr__(self):\r
        return "TupleArg(%s, %s)" % (self.count, self.names)\r
    def getName(self):\r
        return ".%d" % self.count\r
\r
def getArgCount(args):\r
    argcount = len(args)\r
    if args:\r
        for arg in args:\r
            if isinstance(arg, TupleArg):\r
                numNames = len(misc.flatten(arg.names))\r
                argcount = argcount - numNames\r
    return argcount\r
\r
def twobyte(val):\r
    """Convert an int argument into high and low bytes"""\r
    assert isinstance(val, int)\r
    return divmod(val, 256)\r
\r
class LineAddrTable:\r
    """lnotab\r
\r
    This class builds the lnotab, which is documented in compile.c.\r
    Here's a brief recap:\r
\r
    For each SET_LINENO instruction after the first one, two bytes are\r
    added to lnotab.  (In some cases, multiple two-byte entries are\r
    added.)  The first byte is the distance in bytes between the\r
    instruction for the last SET_LINENO and the current SET_LINENO.\r
    The second byte is offset in line numbers.  If either offset is\r
    greater than 255, multiple two-byte entries are added -- see\r
    compile.c for the delicate details.\r
    """\r
\r
    def __init__(self):\r
        self.code = []\r
        self.codeOffset = 0\r
        self.firstline = 0\r
        self.lastline = 0\r
        self.lastoff = 0\r
        self.lnotab = []\r
\r
    def addCode(self, *args):\r
        for arg in args:\r
            self.code.append(chr(arg))\r
        self.codeOffset = self.codeOffset + len(args)\r
\r
    def nextLine(self, lineno):\r
        if self.firstline == 0:\r
            self.firstline = lineno\r
            self.lastline = lineno\r
        else:\r
            # compute deltas\r
            addr = self.codeOffset - self.lastoff\r
            line = lineno - self.lastline\r
            # Python assumes that lineno always increases with\r
            # increasing bytecode address (lnotab is unsigned char).\r
            # Depending on when SET_LINENO instructions are emitted\r
            # this is not always true.  Consider the code:\r
            #     a = (1,\r
            #          b)\r
            # In the bytecode stream, the assignment to "a" occurs\r
            # after the loading of "b".  This works with the C Python\r
            # compiler because it only generates a SET_LINENO instruction\r
            # for the assignment.\r
            if line >= 0:\r
                push = self.lnotab.append\r
                while addr > 255:\r
                    push(255); push(0)\r
                    addr -= 255\r
                while line > 255:\r
                    push(addr); push(255)\r
                    line -= 255\r
                    addr = 0\r
                if addr > 0 or line > 0:\r
                    push(addr); push(line)\r
                self.lastline = lineno\r
                self.lastoff = self.codeOffset\r
\r
    def getCode(self):\r
        return ''.join(self.code)\r
\r
    def getTable(self):\r
        return ''.join(map(chr, self.lnotab))\r
\r
class StackDepthTracker:\r
    # XXX 1. need to keep track of stack depth on jumps\r
    # XXX 2. at least partly as a result, this code is broken\r
\r
    def findDepth(self, insts, debug=0):\r
        depth = 0\r
        maxDepth = 0\r
        for i in insts:\r
            opname = i[0]\r
            if debug:\r
                print i,\r
            delta = self.effect.get(opname, None)\r
            if delta is not None:\r
                depth = depth + delta\r
            else:\r
                # now check patterns\r
                for pat, pat_delta in self.patterns:\r
                    if opname[:len(pat)] == pat:\r
                        delta = pat_delta\r
                        depth = depth + delta\r
                        break\r
                # if we still haven't found a match\r
                if delta is None:\r
                    meth = getattr(self, opname, None)\r
                    if meth is not None:\r
                        depth = depth + meth(i[1])\r
            if depth > maxDepth:\r
                maxDepth = depth\r
            if debug:\r
                print depth, maxDepth\r
        return maxDepth\r
\r
    effect = {\r
        'POP_TOP': -1,\r
        'DUP_TOP': 1,\r
        'LIST_APPEND': -1,\r
        'SET_ADD': -1,\r
        'MAP_ADD': -2,\r
        'SLICE+1': -1,\r
        'SLICE+2': -1,\r
        'SLICE+3': -2,\r
        'STORE_SLICE+0': -1,\r
        'STORE_SLICE+1': -2,\r
        'STORE_SLICE+2': -2,\r
        'STORE_SLICE+3': -3,\r
        'DELETE_SLICE+0': -1,\r
        'DELETE_SLICE+1': -2,\r
        'DELETE_SLICE+2': -2,\r
        'DELETE_SLICE+3': -3,\r
        'STORE_SUBSCR': -3,\r
        'DELETE_SUBSCR': -2,\r
        # PRINT_EXPR?\r
        'PRINT_ITEM': -1,\r
        'RETURN_VALUE': -1,\r
        'YIELD_VALUE': -1,\r
        'EXEC_STMT': -3,\r
        'BUILD_CLASS': -2,\r
        'STORE_NAME': -1,\r
        'STORE_ATTR': -2,\r
        'DELETE_ATTR': -1,\r
        'STORE_GLOBAL': -1,\r
        'BUILD_MAP': 1,\r
        'COMPARE_OP': -1,\r
        'STORE_FAST': -1,\r
        'IMPORT_STAR': -1,\r
        'IMPORT_NAME': -1,\r
        'IMPORT_FROM': 1,\r
        'LOAD_ATTR': 0, # unlike other loads\r
        # close enough...\r
        'SETUP_EXCEPT': 3,\r
        'SETUP_FINALLY': 3,\r
        'FOR_ITER': 1,\r
        'WITH_CLEANUP': -1,\r
        }\r
    # use pattern match\r
    patterns = [\r
        ('BINARY_', -1),\r
        ('LOAD_', 1),\r
        ]\r
\r
    def UNPACK_SEQUENCE(self, count):\r
        return count-1\r
    def BUILD_TUPLE(self, count):\r
        return -count+1\r
    def BUILD_LIST(self, count):\r
        return -count+1\r
    def BUILD_SET(self, count):\r
        return -count+1\r
    def CALL_FUNCTION(self, argc):\r
        hi, lo = divmod(argc, 256)\r
        return -(lo + hi * 2)\r
    def CALL_FUNCTION_VAR(self, argc):\r
        return self.CALL_FUNCTION(argc)-1\r
    def CALL_FUNCTION_KW(self, argc):\r
        return self.CALL_FUNCTION(argc)-1\r
    def CALL_FUNCTION_VAR_KW(self, argc):\r
        return self.CALL_FUNCTION(argc)-2\r
    def MAKE_FUNCTION(self, argc):\r
        return -argc\r
    def MAKE_CLOSURE(self, argc):\r
        # XXX need to account for free variables too!\r
        return -argc\r
    def BUILD_SLICE(self, argc):\r
        if argc == 2:\r
            return -1\r
        elif argc == 3:\r
            return -2\r
    def DUP_TOPX(self, argc):\r
        return argc\r
\r
findDepth = StackDepthTracker().findDepth\r