Mailman 3 February 2005 - Python-checkins

python/dist/src/Python compile.c,2.344,2.345
by rhettinger＠users.sourceforge.net Feb. 20, 2005

Feb. 20, 2005

Update of /cvsroot/python/python/dist/src/Python In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv2403 Modified Files: compile.c Log Message: Teach the peepholer to fold unary operations on constants. Afterwards, -0.5 loads in a single step and no longer requires a runtime UNARY_NEGATIVE operation. Index: compile.c =================================================================== RCS file: /cvsroot/python/python/dist/src/Python/compile.c,v retrieving revision 2.344 retrieving revision 2.345 diff -u -d -r2.344 -r2.345 --- compile.c 10 Feb 2005 01:42:32 -0000 2.344 +++ compile.c 20 Feb 2005 12:41:32 -0000 2.345 @@ -542,6 +542,54 @@ return 1; } +static int +fold_unaryops_on_constants(unsigned char *codestr, PyObject *consts) +{ + PyObject *newconst, *v; + int len_consts, opcode; + + /* Pre-conditions */ + assert(PyList_CheckExact(consts)); + assert(codestr[0] == LOAD_CONST); + + /* Create new constant */ + v = PyList_GET_ITEM(consts, GETARG(codestr, 0)); + opcode = codestr[3]; + switch (opcode) { + case UNARY_NEGATIVE: + newconst = PyNumber_Negative(v); + break; + case UNARY_CONVERT: + newconst = PyObject_Repr(v); + break; + case UNARY_INVERT: + newconst = PyNumber_Invert(v); + break; + default: + /* Called with an unknown opcode */ + assert(0); + return 0; + } + if (newconst == NULL) { + PyErr_Clear(); + return 0; + } + + /* Append folded constant into consts table */ + len_consts = PyList_GET_SIZE(consts); + if (PyList_Append(consts, newconst)) { + Py_DECREF(newconst); + return 0; + } + Py_DECREF(newconst); + + /* Write NOP LOAD_CONST newconst */ + codestr[0] = NOP; + codestr[1] = LOAD_CONST; + SETARG(codestr, 1, len_consts); + return 1; +} + static unsigned int * markblocks(unsigned char *code, int len) { @@ -771,6 +819,20 @@ } break; + /* Fold unary ops on constants. + LOAD_CONST c1 UNARY_OP --> LOAD_CONST unary_op(c) */ + case UNARY_NEGATIVE: + case UNARY_CONVERT: + case UNARY_INVERT: + if (lastlc >= 1 && + ISBASICBLOCK(blocks, i-3, 4) && + fold_unaryops_on_constants(&codestr[i-3], consts)) { + i -= 2; + assert(codestr[i] == LOAD_CONST); + cumlc = 1; + } + break; + /* Simplify conditional jump to conditional jump where the result of the first test implies the success of a similar test or the failure of the opposite test.

1 0

python/dist/src/Objects stringobject.c, 2.228, 2.229
by rhettinger＠users.sourceforge.net Feb. 20, 2005

Feb. 20, 2005

Update of /cvsroot/python/python/dist/src/Objects In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv22296/Objects Modified Files: stringobject.c Log Message: * Beef-up tests for str.count(). * Speed-up str.count() by using memchr() to fly between first char matches. Index: stringobject.c =================================================================== RCS file: /cvsroot/python/python/dist/src/Objects/stringobject.c,v retrieving revision 2.228 retrieving revision 2.229 diff -u -d -r2.228 -r2.229 --- stringobject.c 20 Feb 2005 04:07:04 -0000 2.228 +++ stringobject.c 20 Feb 2005 09:54:52 -0000 2.229 @@ -2145,7 +2145,7 @@ static PyObject * string_count(PyStringObject *self, PyObject *args) { - const char *s = PyString_AS_STRING(self), *sub; + const char *s = PyString_AS_STRING(self), *sub, *t; int len = PyString_GET_SIZE(self), n; int i = 0, last = INT_MAX; int m, r; @@ -2186,11 +2186,16 @@ } else { i++; } + if (i >= m) + break; + t = memchr(s+i, sub[0], m-i); + if (t == NULL) + break; + i = t - s; } return PyInt_FromLong((long) r); } - PyDoc_STRVAR(swapcase__doc__, "S.swapcase() -> string\n\ \n\

1 0

python/dist/src/Lib/test string_tests.py, 1.43, 1.44
by rhettinger＠users.sourceforge.net Feb. 20, 2005

Feb. 20, 2005

Update of /cvsroot/python/python/dist/src/Lib/test In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv22296/Lib/test Modified Files: string_tests.py Log Message: * Beef-up tests for str.count(). * Speed-up str.count() by using memchr() to fly between first char matches. Index: string_tests.py =================================================================== RCS file: /cvsroot/python/python/dist/src/Lib/test/string_tests.py,v retrieving revision 1.43 retrieving revision 1.44 diff -u -d -r1.43 -r1.44 --- string_tests.py 20 Feb 2005 04:07:08 -0000 1.43 +++ string_tests.py 20 Feb 2005 09:54:53 -0000 1.44 @@ -114,6 +114,33 @@ self.checkraises(TypeError, 'hello', 'count') self.checkraises(TypeError, 'hello', 'count', 42) + # For a variety of combinations, + # verify that str.count() matches an equivalent function + # replacing all occurrences and then differencing the string lengths + charset = ['', 'a', 'b'] + digits = 7 + base = len(charset) + teststrings = set() + for i in xrange(base ** digits): + entry = [] + for j in xrange(digits): + i, m = divmod(i, base) + entry.append(charset[m]) + teststrings.add(''.join(entry)) + teststrings = list(teststrings) + for i in teststrings: + i = self.fixtype(i) + n = len(i) + for j in teststrings: + r1 = i.count(j) + if j: + r2, rem = divmod(n - len(i.replace(j, '')), len(j)) + else: + r2, rem = len(i)+1, 0 + if rem or r1 != r2: + self.assertEqual(rem, 0) + self.assertEqual(r1, r2) + def test_find(self): self.checkequal(0, 'abcdefghiabc', 'find', 'abc') self.checkequal(9, 'abcdefghiabc', 'find', 'abc', 1) @@ -135,6 +162,7 @@ i, m = divmod(i, base) entry.append(charset[m]) teststrings.add(''.join(entry)) + teststrings = list(teststrings) for i in teststrings: i = self.fixtype(i) for j in teststrings:

1 0

python/dist/src/Objects stringobject.c, 2.227, 2.228
by rhettinger＠users.sourceforge.net Feb. 20, 2005

Feb. 20, 2005

Update of /cvsroot/python/python/dist/src/Objects In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv21408/Objects Modified Files: stringobject.c Log Message: * Beef-up testing of str.__contains__() and str.find(). * Speed-up "x in y" where x has more than one character. The existing code made excessive calls to the expensive memcmp() function. The new code uses memchr() to rapidly find a start point for memcmp(). In addition to knowing that the first character is a match, the new code also checks that the last character is a match. This significantly reduces the incidence of false starts (saving memcmp() calls and making quadratic behavior less likely). Improves the timings on: python -m timeit -r7 -s"x='a'*1000" "'ab' in x" python -m timeit -r7 -s"x='a'*1000" "'bc' in x" Once this code has proven itself, then string_find_internal() should refer to it rather than running its own version. Also, something similar may apply to unicode objects. Index: stringobject.c =================================================================== RCS file: /cvsroot/python/python/dist/src/Objects/stringobject.c,v retrieving revision 2.227 retrieving revision 2.228 diff -u -d -r2.227 -r2.228 --- stringobject.c 31 Jan 2005 17:09:25 -0000 2.227 +++ stringobject.c 20 Feb 2005 04:07:04 -0000 2.228 @@ -1002,8 +1002,12 @@ static int string_contains(PyObject *a, PyObject *el) { - const char *lhs, *rhs, *end; - int size; + char *s = PyString_AS_STRING(a); + const char *sub = PyString_AS_STRING(el); + char *last; + int len_sub = PyString_GET_SIZE(el); + int shortsub; + char firstchar, lastchar; if (!PyString_CheckExact(el)) { #ifdef Py_USING_UNICODE @@ -1016,20 +1020,29 @@ return -1; } } - size = PyString_GET_SIZE(el); - rhs = PyString_AS_STRING(el); - lhs = PyString_AS_STRING(a); - - /* optimize for a single character */ - if (size == 1) - return memchr(lhs, *rhs, PyString_GET_SIZE(a)) != NULL; - end = lhs + (PyString_GET_SIZE(a) - size); - while (lhs <= end) { - if (memcmp(lhs++, rhs, size) == 0) + if (len_sub == 0) + return 1; + /* last points to one char beyond the start of the rightmost + substring. When s<last, there is still room for a possible match + and s[0] through s[len_sub-1] will be in bounds. + shortsub is len_sub minus the last character which is checked + separately just before the memcmp(). That check helps prevent + false starts and saves the setup time for memcmp(). + */ + firstchar = sub[0]; + shortsub = len_sub - 1; + lastchar = sub[shortsub]; + last = s + PyString_GET_SIZE(a) - len_sub + 1; + while (s < last) { + s = memchr(s, firstchar, last-s); + if (s == NULL) + return 0; + assert(s < last); + if (s[shortsub] == lastchar && memcmp(s, sub, shortsub) == 0) return 1; + s++; } - return 0; }

1 0

python/dist/src/Lib/test string_tests.py, 1.42, 1.43
by rhettinger＠users.sourceforge.net Feb. 20, 2005

Feb. 20, 2005

Update of /cvsroot/python/python/dist/src/Lib/test In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv21408/Lib/test Modified Files: string_tests.py Log Message: * Beef-up testing of str.__contains__() and str.find(). * Speed-up "x in y" where x has more than one character. The existing code made excessive calls to the expensive memcmp() function. The new code uses memchr() to rapidly find a start point for memcmp(). In addition to knowing that the first character is a match, the new code also checks that the last character is a match. This significantly reduces the incidence of false starts (saving memcmp() calls and making quadratic behavior less likely). Improves the timings on: python -m timeit -r7 -s"x='a'*1000" "'ab' in x" python -m timeit -r7 -s"x='a'*1000" "'bc' in x" Once this code has proven itself, then string_find_internal() should refer to it rather than running its own version. Also, something similar may apply to unicode objects. Index: string_tests.py =================================================================== RCS file: /cvsroot/python/python/dist/src/Lib/test/string_tests.py,v retrieving revision 1.42 retrieving revision 1.43 diff -u -d -r1.42 -r1.43 --- string_tests.py 26 Oct 2004 01:52:36 -0000 1.42 +++ string_tests.py 20 Feb 2005 04:07:08 -0000 1.43 @@ -122,6 +122,30 @@ self.checkraises(TypeError, 'hello', 'find') self.checkraises(TypeError, 'hello', 'find', 42) + # For a variety of combinations, + # verify that str.find() matches __contains__ + # and that the found substring is really at that location + charset = ['', 'a', 'b', 'c'] + digits = 5 + base = len(charset) + teststrings = set() + for i in xrange(base ** digits): + entry = [] + for j in xrange(digits): + i, m = divmod(i, base) + entry.append(charset[m]) + teststrings.add(''.join(entry)) + for i in teststrings: + i = self.fixtype(i) + for j in teststrings: + loc = i.find(j) + r1 = (loc != -1) + r2 = j in i + if r1 != r2: + self.assertEqual(r1, r2) + if loc != -1: + self.assertEqual(i[loc:loc+len(j)], j) + def test_rfind(self): self.checkequal(9, 'abcdefghiabc', 'rfind', 'abc') self.checkequal(12, 'abcdefghiabc', 'rfind', '')

1 0

python/dist/src/Modules threadmodule.c,2.59,2.60
by gvanrossum＠users.sourceforge.net Feb. 20, 2005

Feb. 20, 2005

Update of /cvsroot/python/python/dist/src/Modules In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv9262 Modified Files: threadmodule.c Log Message: The error message "can't start new thread" should not end in a newline. Index: threadmodule.c =================================================================== RCS file: /cvsroot/python/python/dist/src/Modules/threadmodule.c,v retrieving revision 2.59 retrieving revision 2.60 diff -u -d -r2.59 -r2.60 --- threadmodule.c 24 Aug 2004 22:24:08 -0000 2.59 +++ threadmodule.c 20 Feb 2005 03:02:16 -0000 2.60 @@ -494,7 +494,7 @@ PyEval_InitThreads(); /* Start the interpreter's thread-awareness */ ident = PyThread_start_new_thread(t_bootstrap, (void*) boot); if (ident == -1) { - PyErr_SetString(ThreadError, "can't start new thread\n"); + PyErr_SetString(ThreadError, "can't start new thread"); Py_DECREF(func); Py_DECREF(args); Py_XDECREF(keyw);

1 0

python/dist/src/Lib pydoc.py,1.103,1.104
by ping＠users.sourceforge.net Feb. 19, 2005

Feb. 19, 2005

Update of /cvsroot/python/python/dist/src/Lib In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv19132 Modified Files: pydoc.py Log Message: Use getdoc(object) instead of object.__doc__ to fix indentation problems. Thanks to Robert Dick <dickrp(a)ece.northwestern.edu> for reporting this bug and submitting a patch. Adjust doc(object) to display useful documentation for plain values (e.g. help([]) now shows the methods on the list instead of just printing "[]"). (This change has been tested interactively, by generating docs for the standard library, and by running the module documentation webserver.) Index: pydoc.py =================================================================== RCS file: /cvsroot/python/python/dist/src/Lib/pydoc.py,v retrieving revision 1.103 retrieving revision 1.104 diff -u -d -r1.103 -r1.104 --- pydoc.py 6 Feb 2005 06:57:07 -0000 1.103 +++ pydoc.py 19 Feb 2005 22:58:26 -0000 1.104 @@ -886,7 +886,7 @@ if name: push('<dl><dt>%s</dt>\n' % name) if value.__doc__ is not None: - doc = self.markup(value.__doc__, self.preformat) + doc = self.markup(getdoc(value), self.preformat) push('<dd><tt>%s</tt></dd>\n' % doc) push('</dl>\n') @@ -1160,7 +1160,7 @@ push(msg) for name, kind, homecls, value in ok: if callable(value) or inspect.isdatadescriptor(value): - doc = getattr(value, "__doc__", None) + doc = getdoc(value) else: doc = None push(self.docother(getattr(object, name), @@ -1454,6 +1454,14 @@ desc += ' in ' + name[:name.rfind('.')] elif module and module is not object: desc += ' in module ' + module.__name__ + if not (inspect.ismodule(object) or + inspect.isclass(object) or + inspect.isroutine(object) or + isinstance(object, property)): + # If the passed object is a piece of data or an instance, + # document its available methods instead of its value. + object = type(object) + desc += ' object' pager(title % desc + '\n\n' + text.document(object, name)) except (ImportError, ErrorDuringImport), value: print value

1 0

python/dist/src/Lib pydoc.py,1.100.2.1,1.100.2.2
by ping＠users.sourceforge.net Feb. 19, 2005

Feb. 19, 2005

Update of /cvsroot/python/python/dist/src/Lib In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv18476 Modified Files: Tag: release24-maint pydoc.py Log Message: Use getdoc(object) instead of object.__doc__ to fix indentation problems. Thanks to Robert Dick <dickrp(a)ece.northwestern.edu> for reporting this bug and submitting a patch. Adjust doc(object) to display useful documentation for plain values (e.g. help([]) now shows the methods on the list instead of just printing "[]"). (This change has been tested interactively, by generating docs for the standard library, and by running the module documentation webserver.) Index: pydoc.py =================================================================== RCS file: /cvsroot/python/python/dist/src/Lib/pydoc.py,v retrieving revision 1.100.2.1 retrieving revision 1.100.2.2 diff -u -d -r1.100.2.1 -r1.100.2.2 --- pydoc.py 1 Jan 2005 07:52:40 -0000 1.100.2.1 +++ pydoc.py 19 Feb 2005 22:57:37 -0000 1.100.2.2 @@ -878,7 +878,7 @@ if name: push('<dl><dt>%s</dt>\n' % name) if value.__doc__ is not None: - doc = self.markup(value.__doc__, self.preformat) + doc = self.markup(getdoc(value), self.preformat) push('<dd><tt>%s</tt></dd>\n' % doc) for attr, tag in [('fget', 'get'), ('fset', 'set'), @@ -1159,7 +1159,7 @@ push(msg) for name, kind, homecls, value in ok: if callable(value) or inspect.isdatadescriptor(value): - doc = getattr(value, "__doc__", None) + doc = getdoc(value) else: doc = None push(self.docother(getattr(object, name), @@ -1464,6 +1464,14 @@ desc += ' in ' + name[:name.rfind('.')] elif module and module is not object: desc += ' in module ' + module.__name__ + if not (inspect.ismodule(object) or + inspect.isclass(object) or + inspect.isroutine(object) or + isinstance(object, property)): + # If the passed object is a piece of data or an instance, + # document its available methods instead of its value. + object = type(object) + desc += ' object' pager(title % desc + '\n\n' + text.document(object, name)) except (ImportError, ErrorDuringImport), value: print value

1 0

python/dist/src/Python newcompile.c, 1.1.2.102, 1.1.2.103
by nascheme＠users.sourceforge.net Feb. 19, 2005

Feb. 19, 2005

Update of /cvsroot/python/python/dist/src/Python In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv30888/Python Modified Files: Tag: ast-branch newcompile.c Log Message: Store basic blocks in a linked list rather than an array. The code is a little simpler that way. Index: newcompile.c =================================================================== RCS file: /cvsroot/python/python/dist/src/Python/Attic/newcompile.c,v retrieving revision 1.1.2.102 retrieving revision 1.1.2.103 diff -u -d -r1.1.2.102 -r1.1.2.103 --- newcompile.c 19 Feb 2005 02:43:45 -0000 1.1.2.102 +++ newcompile.c 19 Feb 2005 03:42:35 -0000 1.1.2.103 @@ -65,6 +65,9 @@ }; typedef struct basicblock_ { + /* next block in the list of blocks for a unit (don't confuse with + * b_next) */ + struct basicblock_ *b_list; /* number of instructions used */ int b_iused; /* length of instruction array (b_instr) */ @@ -118,12 +121,9 @@ PyObject *u_private; /* for private name mangling */ int u_argcount; /* number of arguments for block */ - int u_nblocks; /* number of used blocks in u_blocks - u_nblocks < u_nalloc */ - int u_nalloc; /* current alloc count for u_blocks */ - basicblock *u_curblock; /* pointer to current block (from u_blocks) */ + basicblock *u_blocks; /* pointer to list of blocks */ + basicblock *u_curblock; /* pointer to current block */ int u_tmpname; /* temporary variables for list comps */ - basicblock **u_blocks; int u_nfblocks; struct fblockinfo u_fblock[CO_MAXBLOCKS]; @@ -438,18 +438,12 @@ u->u_freevars = dictbytype(u->u_ste->ste_symbols, FREE, DEF_FREE_CLASS, PyDict_Size(u->u_cellvars)); - u->u_nblocks = 0; - u->u_nalloc = DEFAULT_BLOCKS; - u->u_blocks = (basicblock **)PyObject_Malloc( - sizeof(basicblock *) * DEFAULT_BLOCKS); - if (!u->u_blocks) - return 0; + u->u_blocks = NULL; u->u_tmpname = 0; u->u_nfblocks = 0; u->u_firstlineno = lineno; u->u_lineno = 0; u->u_lineno_set = false; - memset(u->u_blocks, 0, sizeof(basicblock *) * DEFAULT_BLOCKS); u->u_consts = PyDict_New(); if (!u->u_consts) return 0; @@ -484,11 +478,8 @@ static void compiler_unit_check(struct compiler_unit *u) { - int i; - assert(u->u_nblocks <= u->u_nalloc); - for (i = 0; i < u->u_nblocks; i++) { - basicblock *block = u->u_blocks[i]; - assert(block); + basicblock *block; + for (block = u->u_blocks; block != NULL; block = block->b_list) { assert(block != (void *)0xcbcbcbcb); assert(block != (void *)0xfbfbfbfb); assert(block != (void *)0xdbdbdbdb); @@ -507,17 +498,17 @@ static void compiler_unit_free(struct compiler_unit *u) { - int i; + basicblock *b, *next; compiler_unit_check(u); - for (i = 0; i < u->u_nblocks; i++) { - basicblock *b = u->u_blocks[i]; + b = u->u_blocks; + while (b != NULL) { if (b->b_instr) PyObject_Free((void *)b->b_instr); + next = b->b_list; PyObject_Free((void *)b); + b = next; } - if (u->u_blocks) - PyObject_Free((void *)u->u_blocks); Py_XDECREF(u->u_ste); Py_XDECREF(u->u_name); Py_XDECREF(u->u_consts); @@ -561,28 +552,15 @@ { basicblock *b; struct compiler_unit *u; - int i; u = c->u; - if (u->u_nblocks == u->u_nalloc) { - int newsize = ((u->u_nalloc + u->u_nalloc) - * sizeof(basicblock *)); - u->u_blocks = (basicblock **)PyObject_Realloc( - u->u_blocks, newsize); - if (u->u_blocks == NULL) - return NULL; - memset(u->u_blocks + u->u_nalloc, 0, - sizeof(basicblock *) * u->u_nalloc); - u->u_nalloc += u->u_nalloc; - } b = (basicblock *)PyObject_Malloc(sizeof(basicblock)); if (b == NULL) return NULL; memset((void *)b, 0, sizeof(basicblock)); assert (b->b_next == NULL); - i = u->u_nblocks++; - assert(u->u_blocks[i] == NULL); - u->u_blocks[i] = b; + b->b_list = u->u_blocks; + u->u_blocks = b; return b; } @@ -2886,12 +2864,14 @@ static int stackdepth(struct compiler *c) { - int i; - for (i = 0; i < c->u->u_nblocks; i++) { - c->u->u_blocks[i]->b_seen = 0; - c->u->u_blocks[i]->b_startdepth = INT_MIN; + basicblock *b, *entryblock; + entryblock = NULL; + for (b = c->u->u_blocks; b != NULL; b = b->b_list) { + b->b_seen = 0; + b->b_startdepth = INT_MIN; + entryblock = b; } - return stackdepth_walk(c, c->u->u_blocks[0], 0, 0); + return stackdepth_walk(c, entryblock, 0, 0); } static int @@ -3134,23 +3114,22 @@ static int assemble_jump_offsets(struct assembler *a, struct compiler *c) { + basicblock *b; int bsize, totsize = 0; - int i, j; + int i; /* Compute the size of each block and fixup jump args. Replace block pointer with position in bytecode. */ - assert(a->a_nblocks <= c->u->u_nblocks); for (i = a->a_nblocks - 1; i >= 0; i--) { basicblock *b = a->a_postorder[i]; bsize = blocksize(b); b->b_offset = totsize; totsize += bsize; } - for (i = 0; i < c->u->u_nblocks; i++) { - basicblock *b = c->u->u_blocks[i]; + for (b = c->u->u_blocks; b != NULL; b = b->b_list) { bsize = b->b_offset; - for (j = 0; j < b->b_iused; j++) { - struct instr *instr = &b->b_instr[j]; + for (i = 0; i < b->b_iused; i++) { + struct instr *instr = &b->b_instr[i]; /* Relative jumps are computed relative to the instruction pointer after fetching the jump instruction. @@ -3278,8 +3257,9 @@ static PyCodeObject * assemble(struct compiler *c, int addNone) { + basicblock *b, *entryblock; struct assembler a; - int i, j; + int i, j, nblocks; PyCodeObject *co = NULL; /* Make sure every block that falls off the end returns None. @@ -3291,9 +3271,16 @@ ADDOP_O(c, LOAD_CONST, Py_None, consts); ADDOP(c, RETURN_VALUE); - if (!assemble_init(&a, c->u->u_nblocks)) + nblocks = 0; + entryblock = NULL; + for (b = c->u->u_blocks; b != NULL; b = b->b_list) { + nblocks++; + entryblock = b; + } + + if (!assemble_init(&a, nblocks)) goto error; - dfs(c, c->u->u_blocks[0], &a); + dfs(c, entryblock, &a); /* Can't modify the bytecode after computing jump offsets. */ if (!assemble_jump_offsets(&a, c))

1 0

python/dist/src/Python newcompile.c, 1.1.2.101, 1.1.2.102
by nascheme＠users.sourceforge.net Feb. 19, 2005

Feb. 19, 2005

Update of /cvsroot/python/python/dist/src/Python In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv18511/Python Modified Files: Tag: ast-branch newcompile.c Log Message: Use pointers to basic blocks rather than indexes into the u_blocks array. Index: newcompile.c =================================================================== RCS file: /cvsroot/python/python/dist/src/Python/Attic/newcompile.c,v retrieving revision 1.1.2.101 retrieving revision 1.1.2.102 diff -u -d -r1.1.2.101 -r1.1.2.102 --- newcompile.c 16 Jan 2005 17:09:12 -0000 1.1.2.101 +++ newcompile.c 19 Feb 2005 02:43:45 -0000 1.1.2.102 @@ -42,10 +42,6 @@ ISSUES: - Tim mentioned that it's more common for a basic blocks representation - to use real pointers for jump targets rather than indexes into an - array of basic blocks. - opcode_stack_effect() function should be reviewed since stack depth bugs could be really hard to find later. @@ -53,20 +49,6 @@ */ -/* fblockinfo tracks the current frame block. - - A frame block is used to handle loops, try/except, and try/finally. - It's called a frame block to distinguish it from a basic block in the - compiler IR. -*/ - -enum fblocktype { LOOP, EXCEPT, FINALLY_TRY, FINALLY_END }; - -struct fblockinfo { - enum fblocktype fb_type; - int fb_block; -}; - #define DEFAULT_BLOCK_SIZE 16 #define DEFAULT_BLOCKS 8 #define DEFAULT_CODE_SIZE 128 @@ -78,24 +60,42 @@ int i_hasarg : 1; unsigned char i_opcode; int i_oparg; - int i_target; /* target block index (if jump instruction) */ + struct basicblock_ *i_target; /* target block (if jump instruction) */ int i_lineno; }; -struct basicblock { +typedef struct basicblock_ { + /* number of instructions used */ int b_iused; + /* length of instruction array (b_instr) */ int b_ialloc; - /* If b_next is non-zero, it is the block id of the next - block reached by normal control flow. - Since a valid b_next must always be > 0, - 0 can be reserved to mean no next block. */ - int b_next; + /* pointer to an array of instructions, initially NULL */ + struct instr *b_instr; + /* If b_next is non-NULL, it is a pointer to the next + block reached by normal control flow. */ + struct basicblock_ *b_next; /* b_seen is used to perform a DFS of basicblocks. */ int b_seen : 1; /* b_return is true if a RETURN_VALUE opcode is inserted. */ int b_return : 1; - int b_startdepth; /* depth of stack upon entry of block */ - struct instr b_instr[DEFAULT_BLOCK_SIZE]; + /* depth of stack upon entry of block, computed by stackdepth() */ + int b_startdepth; + /* instruction offset for block, computed by assemble_jump_offsets() */ + int b_offset; +} basicblock; + +/* fblockinfo tracks the current frame block. + + A frame block is used to handle loops, try/except, and try/finally. + It's called a frame block to distinguish it from a basic block in the + compiler IR. +*/ + +enum fblocktype { LOOP, EXCEPT, FINALLY_TRY, FINALLY_END }; + +struct fblockinfo { + enum fblocktype fb_type; + basicblock *fb_block; }; /* The following items change on entry and exit of code blocks. @@ -121,9 +121,9 @@ int u_nblocks; /* number of used blocks in u_blocks u_nblocks < u_nalloc */ int u_nalloc; /* current alloc count for u_blocks */ - int u_curblock; /* index of current block in u_blocks */ + basicblock *u_curblock; /* pointer to current block (from u_blocks) */ int u_tmpname; /* temporary variables for list comps */ - struct basicblock **u_blocks; + basicblock **u_blocks; int u_nfblocks; struct fblockinfo u_fblock[CO_MAXBLOCKS]; @@ -152,7 +152,7 @@ PyObject *a_bytecode; /* string containing bytecode */ int a_offset; /* offset into bytecode */ int a_nblocks; /* number of reachable blocks */ - int *a_postorder; /* list of block indices in dfs postorder */ + basicblock **a_postorder; /* list of blocks in dfs postorder */ PyObject *a_lnotab; /* string containing lnotab */ int a_lnotab_off; /* offset into lnotab */ int a_lineno; /* last lineno of emitted instruction */ @@ -161,14 +161,14 @@ static int compiler_enter_scope(struct compiler *, identifier, void *, int); static void compiler_free(struct compiler *); -static int compiler_new_block(struct compiler *); -static int compiler_next_instr(struct compiler *, int); +static basicblock *compiler_new_block(struct compiler *); +static int compiler_next_instr(struct compiler *, basicblock *); static int compiler_addop(struct compiler *, int); static int compiler_addop_o(struct compiler *, int, PyObject *, PyObject *); static int compiler_addop_i(struct compiler *, int, int); -static int compiler_addop_j(struct compiler *, int, int, int); -static void compiler_use_block(struct compiler *, int); -static int compiler_use_new_block(struct compiler *); +static int compiler_addop_j(struct compiler *, int, basicblock *, int); +static void compiler_use_block(struct compiler *, basicblock *); +static basicblock *compiler_use_new_block(struct compiler *); static int compiler_error(struct compiler *, const char *); static int compiler_nameop(struct compiler *, identifier, expr_context_ty); @@ -180,8 +180,10 @@ static int compiler_visit_slice(struct compiler *, slice_ty, expr_context_ty); -static int compiler_push_fblock(struct compiler *, enum fblocktype, int); -static void compiler_pop_fblock(struct compiler *, enum fblocktype, int); +static int compiler_push_fblock(struct compiler *, enum fblocktype, + basicblock *); +static void compiler_pop_fblock(struct compiler *, enum fblocktype, + basicblock *); static int inplace_binop(struct compiler *, operator_ty); static int expr_constant(expr_ty e); @@ -438,8 +440,8 @@ u->u_nblocks = 0; u->u_nalloc = DEFAULT_BLOCKS; - u->u_blocks = (struct basicblock **)PyObject_Malloc( - sizeof(struct basicblock *) * DEFAULT_BLOCKS); + u->u_blocks = (basicblock **)PyObject_Malloc( + sizeof(basicblock *) * DEFAULT_BLOCKS); if (!u->u_blocks) return 0; u->u_tmpname = 0; @@ -447,7 +449,7 @@ u->u_firstlineno = lineno; u->u_lineno = 0; u->u_lineno_set = false; - memset(u->u_blocks, 0, sizeof(struct basicblock *) * DEFAULT_BLOCKS); + memset(u->u_blocks, 0, sizeof(basicblock *) * DEFAULT_BLOCKS); u->u_consts = PyDict_New(); if (!u->u_consts) return 0; @@ -483,16 +485,22 @@ compiler_unit_check(struct compiler_unit *u) { int i; - assert(u->u_curblock < u->u_nblocks); assert(u->u_nblocks <= u->u_nalloc); for (i = 0; i < u->u_nblocks; i++) { - struct basicblock *block = u->u_blocks[i]; + basicblock *block = u->u_blocks[i]; assert(block); assert(block != (void *)0xcbcbcbcb); assert(block != (void *)0xfbfbfbfb); - assert(block->b_ialloc > 0); - assert(block->b_iused >= 0 - && block->b_ialloc >= block->b_iused); + assert(block != (void *)0xdbdbdbdb); + if (block->b_instr != NULL) { + assert(block->b_ialloc > 0); + assert(block->b_iused > 0); + assert(block->b_ialloc >= block->b_iused); + } + else { + assert (block->b_iused == 0); + assert (block->b_ialloc == 0); + } } } @@ -502,8 +510,12 @@ int i; compiler_unit_check(u); - for (i = 0; i < u->u_nblocks; i++) - PyObject_Free((void *)u->u_blocks[i]); + for (i = 0; i < u->u_nblocks; i++) { + basicblock *b = u->u_blocks[i]; + if (b->b_instr) + PyObject_Free((void *)b->b_instr); + PyObject_Free((void *)b); + } if (u->u_blocks) PyObject_Free((void *)u->u_blocks); Py_XDECREF(u->u_ste); @@ -540,75 +552,73 @@ return 1; /* XXX void? */ } -/* Allocate a new block and return its index in c_blocks. - Returns -1 on error. +/* Allocate a new block and return a pointer to it. + Returns NULL on error. */ -static int +static basicblock * compiler_new_block(struct compiler *c) { - struct basicblock *b; + basicblock *b; struct compiler_unit *u; - int block; + int i; u = c->u; if (u->u_nblocks == u->u_nalloc) { int newsize = ((u->u_nalloc + u->u_nalloc) - * sizeof(struct basicblock *)); - u->u_blocks = (struct basicblock **)PyObject_Realloc( + * sizeof(basicblock *)); + u->u_blocks = (basicblock **)PyObject_Realloc( u->u_blocks, newsize); if (u->u_blocks == NULL) - return -1; + return NULL; memset(u->u_blocks + u->u_nalloc, 0, - sizeof(struct basicblock *) * u->u_nalloc); + sizeof(basicblock *) * u->u_nalloc); u->u_nalloc += u->u_nalloc; } - b = (struct basicblock *)PyObject_Malloc(sizeof(struct basicblock)); + b = (basicblock *)PyObject_Malloc(sizeof(basicblock)); if (b == NULL) - return -1; - memset((void *)b, 0, sizeof(struct basicblock)); - b->b_ialloc = DEFAULT_BLOCK_SIZE; - block = u->u_nblocks++; - assert(u->u_blocks[block] == NULL); - u->u_blocks[block] = b; - return block; + return NULL; + memset((void *)b, 0, sizeof(basicblock)); + assert (b->b_next == NULL); + i = u->u_nblocks++; + assert(u->u_blocks[i] == NULL); + u->u_blocks[i] = b; + return b; } static void -compiler_use_block(struct compiler *c, int block) +compiler_use_block(struct compiler *c, basicblock *block) { - assert(block < c->u->u_nblocks); + assert (block != NULL); c->u->u_curblock = block; - assert(c->u->u_blocks[block]); } -static int +static basicblock * compiler_use_new_block(struct compiler *c) { - int block = compiler_new_block(c); - if (block < 0) - return 0; + basicblock *block = compiler_new_block(c); + if (block == NULL) + return NULL; c->u->u_curblock = block; return block; } -static int +static basicblock * compiler_next_block(struct compiler *c) { - int block = compiler_new_block(c); - if (block < 0) - return 0; - c->u->u_blocks[c->u->u_curblock]->b_next = block; + basicblock *block = compiler_new_block(c); + if (block == NULL) + return NULL; + c->u->u_curblock->b_next = block; c->u->u_curblock = block; return block; } -static int -compiler_use_next_block(struct compiler *c, int block) +static basicblock * +compiler_use_next_block(struct compiler *c, basicblock *block) { - assert(block < c->u->u_nblocks); - c->u->u_blocks[c->u->u_curblock]->b_next = block; - assert(c->u->u_blocks[block]); + assert(block != NULL); + c->u->u_curblock->b_next = block; c->u->u_curblock = block; return block; } @@ -619,34 +629,33 @@ */ static int -compiler_next_instr(struct compiler *c, int block) +compiler_next_instr(struct compiler *c, basicblock *b) { - struct basicblock *b; - assert(block < c->u->u_nblocks); - b = c->u->u_blocks[block]; - assert(b); - if (b->b_iused == b->b_ialloc) { - void *ptr; - int oldsize, newsize; - oldsize = sizeof(struct basicblock); - if (b->b_ialloc > DEFAULT_BLOCK_SIZE) - oldsize += ((b->b_ialloc - DEFAULT_BLOCK_SIZE) - * sizeof(struct instr)); - newsize = oldsize + b->b_ialloc * sizeof(struct instr); - if (newsize <= 0) { + assert(b != NULL); + if (b->b_instr == NULL) { + b->b_instr = PyObject_Malloc(sizeof(struct instr) * + DEFAULT_BLOCK_SIZE); + if (b->b_instr == NULL) { PyErr_NoMemory(); return -1; } - b->b_ialloc <<= 1; - ptr = PyObject_Realloc((void *)b, newsize); - if (ptr == NULL) + b->b_ialloc = DEFAULT_BLOCK_SIZE; + memset((char *)b->b_instr, 0, + sizeof(struct instr) * DEFAULT_BLOCK_SIZE); + } + else if (b->b_iused == b->b_ialloc) { + size_t oldsize, newsize; + oldsize = b->b_ialloc * sizeof(struct instr); + newsize = oldsize << 1; + if (newsize == 0) { + PyErr_NoMemory(); return -1; - memset((char *)ptr + oldsize, 0, newsize - oldsize); - if (ptr != (void *)b) { - fprintf(stderr, "resize block %d\n", block); - c->u->u_blocks[block] = (struct basicblock *)ptr; - b = ptr; } + b->b_ialloc <<= 1; + b->b_instr = PyObject_Realloc((void *)b->b_instr, newsize); + if (b->b_instr == NULL) + return -1; + memset((char *)b->b_instr + oldsize, 0, newsize - oldsize); } return b->b_iused++; } @@ -658,11 +667,11 @@ static void compiler_set_lineno(struct compiler *c, int off) { - struct basicblock *b; + basicblock *b; if (c->u->u_lineno_set) return; c->u->u_lineno_set = true; - b = c->u->u_blocks[c->u->u_curblock]; + b = c->u->u_curblock; b->b_instr[off].i_lineno = c->u->u_lineno; } @@ -886,13 +895,13 @@ static int compiler_addop(struct compiler *c, int opcode) { - struct basicblock *b; + basicblock *b; struct instr *i; int off; off = compiler_next_instr(c, c->u->u_curblock); if (off < 0) return 0; - b = c->u->u_blocks[c->u->u_curblock]; + b = c->u->u_curblock; i = &b->b_instr[off]; i->i_opcode = opcode; i->i_hasarg = 0; @@ -972,7 +981,7 @@ off = compiler_next_instr(c, c->u->u_curblock); if (off < 0) return 0; - i = &c->u->u_blocks[c->u->u_curblock]->b_instr[off]; + i = &c->u->u_curblock->b_instr[off]; i->i_opcode = opcode; i->i_oparg = oparg; i->i_hasarg = 1; @@ -981,19 +990,19 @@ } static int -compiler_addop_j(struct compiler *c, int opcode, int block, int absolute) +compiler_addop_j(struct compiler *c, int opcode, basicblock *b, int absolute) { struct instr *i; int off; - assert(block >= 0); + assert(b != NULL); off = compiler_next_instr(c, c->u->u_curblock); if (off < 0) return 0; compiler_set_lineno(c, off); - i = &c->u->u_blocks[c->u->u_curblock]->b_instr[off]; + i = &c->u->u_curblock->b_instr[off]; i->i_opcode = opcode; - i->i_target = block; + i->i_target = b; i->i_hasarg = 1; if (absolute) i->i_jabs = 1; @@ -1014,12 +1023,12 @@ #define NEW_BLOCK(C) { \ - if (compiler_use_new_block((C)) < 0) \ + if (compiler_use_new_block((C)) == NULL) \ return 0; \ } #define NEXT_BLOCK(C) { \ - if (compiler_next_block((C)) < 0) \ + if (compiler_next_block((C)) == NULL) \ return 0; \ } @@ -1410,14 +1419,14 @@ static int compiler_if(struct compiler *c, stmt_ty s) { - int end, next; + basicblock *end, *next; assert(s->kind == If_kind); end = compiler_new_block(c); - if (end < 0) + if (end == NULL) return 0; next = compiler_new_block(c); - if (next < 0) + if (next == NULL) return 0; VISIT(c, expr, s->v.If.test); ADDOP_JREL(c, JUMP_IF_FALSE, next); @@ -1435,12 +1444,12 @@ static int compiler_for(struct compiler *c, stmt_ty s) { - int start, cleanup, end; + basicblock *start, *cleanup, *end; start = compiler_new_block(c); cleanup = compiler_new_block(c); end = compiler_new_block(c); - if (start < 0 || end < 0 || cleanup < 0) + if (start == NULL || end == NULL || cleanup == NULL) return 0; ADDOP_JREL(c, SETUP_LOOP, end); if (!compiler_push_fblock(c, LOOP, start)) @@ -1463,7 +1472,7 @@ static int compiler_while(struct compiler *c, stmt_ty s) { - int loop, orelse, end, anchor; + basicblock *loop, *orelse, *end, *anchor; int constant = expr_constant(s->v.While.test); if (constant == 0) @@ -1472,18 +1481,18 @@ end = compiler_new_block(c); if (constant == -1) { anchor = compiler_new_block(c); - if (anchor < 0) + if (anchor == NULL) return 0; } - if (loop < 0 || end < 0) + if (loop == NULL || end == NULL) return 0; if (s->v.While.orelse) { orelse = compiler_new_block(c); - if (orelse < 0) + if (orelse == NULL) return 0; } else - orelse = -1; + orelse = NULL; ADDOP_JREL(c, SETUP_LOOP, end); compiler_use_next_block(c, loop); @@ -1507,7 +1516,7 @@ ADDOP(c, POP_BLOCK); } compiler_pop_fblock(c, LOOP, loop); - if (orelse != -1) + if (orelse != NULL) VISIT_SEQ(c, stmt, s->v.While.orelse); compiler_use_next_block(c, end); @@ -1579,10 +1588,10 @@ static int compiler_try_finally(struct compiler *c, stmt_ty s) { - int body, end; + basicblock *body, *end; body = compiler_new_block(c); end = compiler_new_block(c); - if (body < 0 || end < 0) + if (body == NULL || end == NULL) return 0; ADDOP_JREL(c, SETUP_FINALLY, end); @@ -1641,13 +1650,14 @@ static int compiler_try_except(struct compiler *c, stmt_ty s) { - int i, n, body, orelse, except, end; + basicblock *body, *orelse, *except, *end; + int i, n; body = compiler_new_block(c); except = compiler_new_block(c); orelse = compiler_new_block(c); end = compiler_new_block(c); - if (body < 0 || except < 0 || orelse < 0 || end < 0) + if (body == NULL || except == NULL || orelse == NULL || end == NULL) return 0; ADDOP_JREL(c, SETUP_EXCEPT, except); compiler_use_next_block(c, body); @@ -1665,7 +1675,7 @@ if (!handler->type && i < n-1) return compiler_error(c, "default 'except:' must be last"); except = compiler_new_block(c); - if (except < 0) + if (except == NULL) return 0; if (handler->type) { ADDOP(c, DUP_TOP); @@ -1792,7 +1802,7 @@ compiler_assert(struct compiler *c, stmt_ty s) { static PyObject *assertion_error = NULL; - int end; + basicblock *end; if (Py_OptimizeFlag) return 1; @@ -1803,7 +1813,7 @@ } VISIT(c, expr, s->v.Assert.test); end = compiler_new_block(c); - if (end < 0) + if (end == NULL) return 0; ADDOP_JREL(c, JUMP_IF_TRUE, end); ADDOP(c, POP_TOP); @@ -2167,7 +2177,8 @@ static int compiler_boolop(struct compiler *c, expr_ty e) { - int end, jumpi, i, n; + basicblock *end; + int jumpi, i, n; asdl_seq *s; assert(e->kind == BoolOp_kind); @@ -2221,7 +2232,8 @@ static int compiler_compare(struct compiler *c, expr_ty e) { - int i, n, cleanup = -1; + int i, n; + basicblock *cleanup = NULL; /* XXX the logic can be cleaned up for 1 or multiple comparisons */ VISIT(c, expr, e->v.Compare.left); @@ -2229,6 +2241,8 @@ assert(n > 0); if (n > 1) { cleanup = compiler_new_block(c); + if (cleanup == NULL) + return 0; VISIT(c, expr, asdl_seq_GET(e->v.Compare.comparators, 0)); } for (i = 1; i < n; i++) { @@ -2248,7 +2262,9 @@ /* XXX We're casting a void* to cmpop_ty in the next stmt. */ cmpop((cmpop_ty)asdl_seq_GET(e->v.Compare.ops, n - 1))); if (n > 1) { - int end = compiler_new_block(c); + basicblock *end = compiler_new_block(c); + if (end == NULL) + return 0; ADDOP_JREL(c, JUMP_FORWARD, end); compiler_use_next_block(c, cleanup); ADDOP(c, ROT_TWO); @@ -2304,14 +2320,16 @@ and then write to the element */ comprehension_ty l; - int start, anchor, skip, if_cleanup, i, n; + basicblock *start, *anchor, *skip, *if_cleanup; + int i, n; start = compiler_new_block(c); skip = compiler_new_block(c); if_cleanup = compiler_new_block(c); anchor = compiler_new_block(c); - if (start < 0 || skip < 0 || if_cleanup < 0 || anchor < 0) + if (start == NULL || skip == NULL || if_cleanup == NULL || + anchor == NULL) return 0; l = asdl_seq_GET(generators, gen_index); @@ -2585,7 +2603,7 @@ } static int -compiler_push_fblock(struct compiler *c, enum fblocktype t, int b) +compiler_push_fblock(struct compiler *c, enum fblocktype t, basicblock *b) { struct fblockinfo *f; if (c->u->u_nfblocks >= CO_MAXBLOCKS) @@ -2597,7 +2615,7 @@ } static void -compiler_pop_fblock(struct compiler *c, enum fblocktype t, int b) +compiler_pop_fblock(struct compiler *c, enum fblocktype t, basicblock *b) { struct compiler_unit *u = c->u; assert(u->u_nfblocks > 0); @@ -2809,40 +2827,34 @@ */ static void -dfs(struct compiler *c, int block, struct assembler *a) +dfs(struct compiler *c, basicblock *b, struct assembler *a) { int i; - struct basicblock *b; struct instr *instr = NULL; - if (block >= c->u->u_nblocks) - return; - b = c->u->u_blocks[block]; if (b->b_seen) return; b->b_seen = 1; - if (b->b_next) + if (b->b_next != NULL) dfs(c, b->b_next, a); for (i = 0; i < b->b_iused; i++) { instr = &b->b_instr[i]; if (instr->i_jrel || instr->i_jabs) dfs(c, instr->i_target, a); } - a->a_postorder[a->a_nblocks++] = block; + a->a_postorder[a->a_nblocks++] = b; } int -stackdepth_walk(struct compiler *c, int block, int depth, int maxdepth) +stackdepth_walk(struct compiler *c, basicblock *b, int depth, int maxdepth) { int i; struct instr *instr; - struct basicblock *b; - b = c->u->u_blocks[block]; if (b->b_seen || b->b_startdepth >= depth) return maxdepth; b->b_seen = 1; b->b_startdepth = depth; - fprintf(stderr, "block %d\n", block); + fprintf(stderr, "block %p\n", b); for (i = 0; i < b->b_iused; i++) { instr = &b->b_instr[i]; depth += opcode_stack_effect(instr->i_opcode, instr->i_oparg); @@ -2879,7 +2891,7 @@ c->u->u_blocks[i]->b_seen = 0; c->u->u_blocks[i]->b_startdepth = INT_MIN; } - return stackdepth_walk(c, 0, 0, 0); + return stackdepth_walk(c, c->u->u_blocks[0], 0, 0); } static int @@ -2893,7 +2905,8 @@ a->a_lnotab = PyString_FromStringAndSize(NULL, DEFAULT_LNOTAB_SIZE); if (!a->a_lnotab) return 0; - a->a_postorder = (int *)PyObject_Malloc(sizeof(int) * nblocks); + a->a_postorder = (basicblock **)PyObject_Malloc( + sizeof(basicblock *) * nblocks); if (!a->a_postorder) return 0; return 1; @@ -2923,7 +2936,7 @@ } static int -blocksize(struct basicblock *b) +blocksize(basicblock *b) { int i; int size = 0; @@ -3121,28 +3134,21 @@ static int assemble_jump_offsets(struct assembler *a, struct compiler *c) { - int *blockoff; int bsize, totsize = 0; int i, j; /* Compute the size of each block and fixup jump args. - Replace block index with position in bytecode. */ - blockoff = malloc(sizeof(int) * c->u->u_nblocks); - if (!blockoff) - return 0; - /* blockoff computed in dfs postorder, but stored using - c_blocks[] indices. - */ + Replace block pointer with position in bytecode. */ assert(a->a_nblocks <= c->u->u_nblocks); for (i = a->a_nblocks - 1; i >= 0; i--) { - int block = a->a_postorder[i]; - bsize = blocksize(c->u->u_blocks[block]); - blockoff[block] = totsize; + basicblock *b = a->a_postorder[i]; + bsize = blocksize(b); + b->b_offset = totsize; totsize += bsize; } for (i = 0; i < c->u->u_nblocks; i++) { - struct basicblock *b = c->u->u_blocks[i]; - bsize = blockoff[i]; + basicblock *b = c->u->u_blocks[i]; + bsize = b->b_offset; for (j = 0; j < b->b_iused; j++) { struct instr *instr = &b->b_instr[j]; /* Relative jumps are computed relative to @@ -3151,15 +3157,13 @@ */ bsize += instrsize(instr); if (instr->i_jabs) - instr->i_oparg = blockoff[instr->i_target]; + instr->i_oparg = instr->i_target->b_offset; else if (instr->i_jrel) { - int delta = blockoff[instr->i_target] - bsize; + int delta = instr->i_target->b_offset - bsize; instr->i_oparg = delta; } } } - free(blockoff); - return 1; } @@ -3289,7 +3293,7 @@ if (!assemble_init(&a, c->u->u_nblocks)) goto error; - dfs(c, 0, &a); + dfs(c, c->u->u_blocks[0], &a); /* Can't modify the bytecode after computing jump offsets. */ if (!assemble_jump_offsets(&a, c)) @@ -3297,10 +3301,10 @@ /* Emit code in reverse postorder from dfs. */ for (i = a.a_nblocks - 1; i >= 0; i--) { - struct basicblock *b = c->u->u_blocks[a.a_postorder[i]]; + basicblock *b = a.a_postorder[i]; fprintf(stderr, - "\nblock %d: order=%d used=%d alloc=%d next=%d\n", - i, a.a_postorder[i], b->b_iused, b->b_ialloc, + "\nblock %p: order=%d used=%d alloc=%d next=%p\n", + a.a_postorder[i], i, b->b_iused, b->b_ialloc, b->b_next); for (j = 0; j < b->b_iused; j++) if (!assemble_emit(&a, &b->b_instr[j]))

1 0