|
1 /* Peephole optimizations for bytecode compiler. */ |
|
2 |
|
3 #include "Python.h" |
|
4 |
|
5 #include "Python-ast.h" |
|
6 #include "node.h" |
|
7 #include "pyarena.h" |
|
8 #include "ast.h" |
|
9 #include "code.h" |
|
10 #include "compile.h" |
|
11 #include "symtable.h" |
|
12 #include "opcode.h" |
|
13 |
|
14 #define GETARG(arr, i) ((int)((arr[i+2]<<8) + arr[i+1])) |
|
15 #define UNCONDITIONAL_JUMP(op) (op==JUMP_ABSOLUTE || op==JUMP_FORWARD) |
|
16 #define ABSOLUTE_JUMP(op) (op==JUMP_ABSOLUTE || op==CONTINUE_LOOP) |
|
17 #define GETJUMPTGT(arr, i) (GETARG(arr,i) + (ABSOLUTE_JUMP(arr[i]) ? 0 : i+3)) |
|
18 #define SETARG(arr, i, val) arr[i+2] = val>>8; arr[i+1] = val & 255 |
|
19 #define CODESIZE(op) (HAS_ARG(op) ? 3 : 1) |
|
20 #define ISBASICBLOCK(blocks, start, bytes) \ |
|
21 (blocks[start]==blocks[start+bytes-1]) |
|
22 |
|
23 /* Replace LOAD_CONST c1. LOAD_CONST c2 ... LOAD_CONST cn BUILD_TUPLE n |
|
24 with LOAD_CONST (c1, c2, ... cn). |
|
25 The consts table must still be in list form so that the |
|
26 new constant (c1, c2, ... cn) can be appended. |
|
27 Called with codestr pointing to the first LOAD_CONST. |
|
28 Bails out with no change if one or more of the LOAD_CONSTs is missing. |
|
29 Also works for BUILD_LIST when followed by an "in" or "not in" test. |
|
30 */ |
|
31 static int |
|
32 tuple_of_constants(unsigned char *codestr, Py_ssize_t n, PyObject *consts) |
|
33 { |
|
34 PyObject *newconst, *constant; |
|
35 Py_ssize_t i, arg, len_consts; |
|
36 |
|
37 /* Pre-conditions */ |
|
38 assert(PyList_CheckExact(consts)); |
|
39 assert(codestr[n*3] == BUILD_TUPLE || codestr[n*3] == BUILD_LIST); |
|
40 assert(GETARG(codestr, (n*3)) == n); |
|
41 for (i=0 ; i<n ; i++) |
|
42 assert(codestr[i*3] == LOAD_CONST); |
|
43 |
|
44 /* Buildup new tuple of constants */ |
|
45 newconst = PyTuple_New(n); |
|
46 if (newconst == NULL) |
|
47 return 0; |
|
48 len_consts = PyList_GET_SIZE(consts); |
|
49 for (i=0 ; i<n ; i++) { |
|
50 arg = GETARG(codestr, (i*3)); |
|
51 assert(arg < len_consts); |
|
52 constant = PyList_GET_ITEM(consts, arg); |
|
53 Py_INCREF(constant); |
|
54 PyTuple_SET_ITEM(newconst, i, constant); |
|
55 } |
|
56 |
|
57 /* Append folded constant onto consts */ |
|
58 if (PyList_Append(consts, newconst)) { |
|
59 Py_DECREF(newconst); |
|
60 return 0; |
|
61 } |
|
62 Py_DECREF(newconst); |
|
63 |
|
64 /* Write NOPs over old LOAD_CONSTS and |
|
65 add a new LOAD_CONST newconst on top of the BUILD_TUPLE n */ |
|
66 memset(codestr, NOP, n*3); |
|
67 codestr[n*3] = LOAD_CONST; |
|
68 SETARG(codestr, (n*3), len_consts); |
|
69 return 1; |
|
70 } |
|
71 |
|
72 /* Replace LOAD_CONST c1. LOAD_CONST c2 BINOP |
|
73 with LOAD_CONST binop(c1,c2) |
|
74 The consts table must still be in list form so that the |
|
75 new constant can be appended. |
|
76 Called with codestr pointing to the first LOAD_CONST. |
|
77 Abandons the transformation if the folding fails (i.e. 1+'a'). |
|
78 If the new constant is a sequence, only folds when the size |
|
79 is below a threshold value. That keeps pyc files from |
|
80 becoming large in the presence of code like: (None,)*1000. |
|
81 */ |
|
82 static int |
|
83 fold_binops_on_constants(unsigned char *codestr, PyObject *consts) |
|
84 { |
|
85 PyObject *newconst, *v, *w; |
|
86 Py_ssize_t len_consts, size; |
|
87 int opcode; |
|
88 |
|
89 /* Pre-conditions */ |
|
90 assert(PyList_CheckExact(consts)); |
|
91 assert(codestr[0] == LOAD_CONST); |
|
92 assert(codestr[3] == LOAD_CONST); |
|
93 |
|
94 /* Create new constant */ |
|
95 v = PyList_GET_ITEM(consts, GETARG(codestr, 0)); |
|
96 w = PyList_GET_ITEM(consts, GETARG(codestr, 3)); |
|
97 opcode = codestr[6]; |
|
98 switch (opcode) { |
|
99 case BINARY_POWER: |
|
100 newconst = PyNumber_Power(v, w, Py_None); |
|
101 break; |
|
102 case BINARY_MULTIPLY: |
|
103 newconst = PyNumber_Multiply(v, w); |
|
104 break; |
|
105 case BINARY_DIVIDE: |
|
106 /* Cannot fold this operation statically since |
|
107 the result can depend on the run-time presence |
|
108 of the -Qnew flag */ |
|
109 return 0; |
|
110 case BINARY_TRUE_DIVIDE: |
|
111 newconst = PyNumber_TrueDivide(v, w); |
|
112 break; |
|
113 case BINARY_FLOOR_DIVIDE: |
|
114 newconst = PyNumber_FloorDivide(v, w); |
|
115 break; |
|
116 case BINARY_MODULO: |
|
117 newconst = PyNumber_Remainder(v, w); |
|
118 break; |
|
119 case BINARY_ADD: |
|
120 newconst = PyNumber_Add(v, w); |
|
121 break; |
|
122 case BINARY_SUBTRACT: |
|
123 newconst = PyNumber_Subtract(v, w); |
|
124 break; |
|
125 case BINARY_SUBSCR: |
|
126 newconst = PyObject_GetItem(v, w); |
|
127 break; |
|
128 case BINARY_LSHIFT: |
|
129 newconst = PyNumber_Lshift(v, w); |
|
130 break; |
|
131 case BINARY_RSHIFT: |
|
132 newconst = PyNumber_Rshift(v, w); |
|
133 break; |
|
134 case BINARY_AND: |
|
135 newconst = PyNumber_And(v, w); |
|
136 break; |
|
137 case BINARY_XOR: |
|
138 newconst = PyNumber_Xor(v, w); |
|
139 break; |
|
140 case BINARY_OR: |
|
141 newconst = PyNumber_Or(v, w); |
|
142 break; |
|
143 default: |
|
144 /* Called with an unknown opcode */ |
|
145 PyErr_Format(PyExc_SystemError, |
|
146 "unexpected binary operation %d on a constant", |
|
147 opcode); |
|
148 return 0; |
|
149 } |
|
150 if (newconst == NULL) { |
|
151 PyErr_Clear(); |
|
152 return 0; |
|
153 } |
|
154 size = PyObject_Size(newconst); |
|
155 if (size == -1) |
|
156 PyErr_Clear(); |
|
157 else if (size > 20) { |
|
158 Py_DECREF(newconst); |
|
159 return 0; |
|
160 } |
|
161 |
|
162 /* Append folded constant into consts table */ |
|
163 len_consts = PyList_GET_SIZE(consts); |
|
164 if (PyList_Append(consts, newconst)) { |
|
165 Py_DECREF(newconst); |
|
166 return 0; |
|
167 } |
|
168 Py_DECREF(newconst); |
|
169 |
|
170 /* Write NOP NOP NOP NOP LOAD_CONST newconst */ |
|
171 memset(codestr, NOP, 4); |
|
172 codestr[4] = LOAD_CONST; |
|
173 SETARG(codestr, 4, len_consts); |
|
174 return 1; |
|
175 } |
|
176 |
|
177 static int |
|
178 fold_unaryops_on_constants(unsigned char *codestr, PyObject *consts) |
|
179 { |
|
180 PyObject *newconst=NULL, *v; |
|
181 Py_ssize_t len_consts; |
|
182 int opcode; |
|
183 |
|
184 /* Pre-conditions */ |
|
185 assert(PyList_CheckExact(consts)); |
|
186 assert(codestr[0] == LOAD_CONST); |
|
187 |
|
188 /* Create new constant */ |
|
189 v = PyList_GET_ITEM(consts, GETARG(codestr, 0)); |
|
190 opcode = codestr[3]; |
|
191 switch (opcode) { |
|
192 case UNARY_NEGATIVE: |
|
193 /* Preserve the sign of -0.0 */ |
|
194 if (PyObject_IsTrue(v) == 1) |
|
195 newconst = PyNumber_Negative(v); |
|
196 break; |
|
197 case UNARY_CONVERT: |
|
198 newconst = PyObject_Repr(v); |
|
199 break; |
|
200 case UNARY_INVERT: |
|
201 newconst = PyNumber_Invert(v); |
|
202 break; |
|
203 default: |
|
204 /* Called with an unknown opcode */ |
|
205 PyErr_Format(PyExc_SystemError, |
|
206 "unexpected unary operation %d on a constant", |
|
207 opcode); |
|
208 return 0; |
|
209 } |
|
210 if (newconst == NULL) { |
|
211 PyErr_Clear(); |
|
212 return 0; |
|
213 } |
|
214 |
|
215 /* Append folded constant into consts table */ |
|
216 len_consts = PyList_GET_SIZE(consts); |
|
217 if (PyList_Append(consts, newconst)) { |
|
218 Py_DECREF(newconst); |
|
219 return 0; |
|
220 } |
|
221 Py_DECREF(newconst); |
|
222 |
|
223 /* Write NOP LOAD_CONST newconst */ |
|
224 codestr[0] = NOP; |
|
225 codestr[1] = LOAD_CONST; |
|
226 SETARG(codestr, 1, len_consts); |
|
227 return 1; |
|
228 } |
|
229 |
|
230 static unsigned int * |
|
231 markblocks(unsigned char *code, Py_ssize_t len) |
|
232 { |
|
233 unsigned int *blocks = (unsigned int *)PyMem_Malloc(len*sizeof(int)); |
|
234 int i,j, opcode, blockcnt = 0; |
|
235 |
|
236 if (blocks == NULL) { |
|
237 PyErr_NoMemory(); |
|
238 return NULL; |
|
239 } |
|
240 memset(blocks, 0, len*sizeof(int)); |
|
241 |
|
242 /* Mark labels in the first pass */ |
|
243 for (i=0 ; i<len ; i+=CODESIZE(opcode)) { |
|
244 opcode = code[i]; |
|
245 switch (opcode) { |
|
246 case FOR_ITER: |
|
247 case JUMP_FORWARD: |
|
248 case JUMP_IF_FALSE: |
|
249 case JUMP_IF_TRUE: |
|
250 case JUMP_ABSOLUTE: |
|
251 case CONTINUE_LOOP: |
|
252 case SETUP_LOOP: |
|
253 case SETUP_EXCEPT: |
|
254 case SETUP_FINALLY: |
|
255 j = GETJUMPTGT(code, i); |
|
256 blocks[j] = 1; |
|
257 break; |
|
258 } |
|
259 } |
|
260 /* Build block numbers in the second pass */ |
|
261 for (i=0 ; i<len ; i++) { |
|
262 blockcnt += blocks[i]; /* increment blockcnt over labels */ |
|
263 blocks[i] = blockcnt; |
|
264 } |
|
265 return blocks; |
|
266 } |
|
267 |
|
268 /* Perform basic peephole optimizations to components of a code object. |
|
269 The consts object should still be in list form to allow new constants |
|
270 to be appended. |
|
271 |
|
272 To keep the optimizer simple, it bails out (does nothing) for code |
|
273 containing extended arguments or that has a length over 32,700. That |
|
274 allows us to avoid overflow and sign issues. Likewise, it bails when |
|
275 the lineno table has complex encoding for gaps >= 255. |
|
276 |
|
277 Optimizations are restricted to simple transformations occuring within a |
|
278 single basic block. All transformations keep the code size the same or |
|
279 smaller. For those that reduce size, the gaps are initially filled with |
|
280 NOPs. Later those NOPs are removed and the jump addresses retargeted in |
|
281 a single pass. Line numbering is adjusted accordingly. */ |
|
282 |
|
283 PyObject * |
|
284 PyCode_Optimize(PyObject *code, PyObject* consts, PyObject *names, |
|
285 PyObject *lineno_obj) |
|
286 { |
|
287 Py_ssize_t i, j, codelen; |
|
288 int nops, h, adj; |
|
289 int tgt, tgttgt, opcode; |
|
290 unsigned char *codestr = NULL; |
|
291 unsigned char *lineno; |
|
292 int *addrmap = NULL; |
|
293 int new_line, cum_orig_line, last_line, tabsiz; |
|
294 int cumlc=0, lastlc=0; /* Count runs of consecutive LOAD_CONSTs */ |
|
295 unsigned int *blocks = NULL; |
|
296 char *name; |
|
297 |
|
298 /* Bail out if an exception is set */ |
|
299 if (PyErr_Occurred()) |
|
300 goto exitUnchanged; |
|
301 |
|
302 /* Bypass optimization when the lineno table is too complex */ |
|
303 assert(PyString_Check(lineno_obj)); |
|
304 lineno = (unsigned char*)PyString_AS_STRING(lineno_obj); |
|
305 tabsiz = PyString_GET_SIZE(lineno_obj); |
|
306 if (memchr(lineno, 255, tabsiz) != NULL) |
|
307 goto exitUnchanged; |
|
308 |
|
309 /* Avoid situations where jump retargeting could overflow */ |
|
310 assert(PyString_Check(code)); |
|
311 codelen = PyString_GET_SIZE(code); |
|
312 if (codelen > 32700) |
|
313 goto exitUnchanged; |
|
314 |
|
315 /* Make a modifiable copy of the code string */ |
|
316 codestr = (unsigned char *)PyMem_Malloc(codelen); |
|
317 if (codestr == NULL) |
|
318 goto exitUnchanged; |
|
319 codestr = (unsigned char *)memcpy(codestr, |
|
320 PyString_AS_STRING(code), codelen); |
|
321 |
|
322 /* Verify that RETURN_VALUE terminates the codestring. This allows |
|
323 the various transformation patterns to look ahead several |
|
324 instructions without additional checks to make sure they are not |
|
325 looking beyond the end of the code string. |
|
326 */ |
|
327 if (codestr[codelen-1] != RETURN_VALUE) |
|
328 goto exitUnchanged; |
|
329 |
|
330 /* Mapping to new jump targets after NOPs are removed */ |
|
331 addrmap = (int *)PyMem_Malloc(codelen * sizeof(int)); |
|
332 if (addrmap == NULL) |
|
333 goto exitUnchanged; |
|
334 |
|
335 blocks = markblocks(codestr, codelen); |
|
336 if (blocks == NULL) |
|
337 goto exitUnchanged; |
|
338 assert(PyList_Check(consts)); |
|
339 |
|
340 for (i=0 ; i<codelen ; i += CODESIZE(codestr[i])) { |
|
341 opcode = codestr[i]; |
|
342 |
|
343 lastlc = cumlc; |
|
344 cumlc = 0; |
|
345 |
|
346 switch (opcode) { |
|
347 |
|
348 /* Replace UNARY_NOT JUMP_IF_FALSE POP_TOP with |
|
349 with JUMP_IF_TRUE POP_TOP */ |
|
350 case UNARY_NOT: |
|
351 if (codestr[i+1] != JUMP_IF_FALSE || |
|
352 codestr[i+4] != POP_TOP || |
|
353 !ISBASICBLOCK(blocks,i,5)) |
|
354 continue; |
|
355 tgt = GETJUMPTGT(codestr, (i+1)); |
|
356 if (codestr[tgt] != POP_TOP) |
|
357 continue; |
|
358 j = GETARG(codestr, i+1) + 1; |
|
359 codestr[i] = JUMP_IF_TRUE; |
|
360 SETARG(codestr, i, j); |
|
361 codestr[i+3] = POP_TOP; |
|
362 codestr[i+4] = NOP; |
|
363 break; |
|
364 |
|
365 /* not a is b --> a is not b |
|
366 not a in b --> a not in b |
|
367 not a is not b --> a is b |
|
368 not a not in b --> a in b |
|
369 */ |
|
370 case COMPARE_OP: |
|
371 j = GETARG(codestr, i); |
|
372 if (j < 6 || j > 9 || |
|
373 codestr[i+3] != UNARY_NOT || |
|
374 !ISBASICBLOCK(blocks,i,4)) |
|
375 continue; |
|
376 SETARG(codestr, i, (j^1)); |
|
377 codestr[i+3] = NOP; |
|
378 break; |
|
379 |
|
380 /* Replace LOAD_GLOBAL/LOAD_NAME None |
|
381 with LOAD_CONST None */ |
|
382 case LOAD_NAME: |
|
383 case LOAD_GLOBAL: |
|
384 j = GETARG(codestr, i); |
|
385 name = PyString_AsString(PyTuple_GET_ITEM(names, j)); |
|
386 if (name == NULL || strcmp(name, "None") != 0) |
|
387 continue; |
|
388 for (j=0 ; j < PyList_GET_SIZE(consts) ; j++) { |
|
389 if (PyList_GET_ITEM(consts, j) == Py_None) |
|
390 break; |
|
391 } |
|
392 if (j == PyList_GET_SIZE(consts)) { |
|
393 if (PyList_Append(consts, Py_None) == -1) |
|
394 goto exitUnchanged; |
|
395 } |
|
396 assert(PyList_GET_ITEM(consts, j) == Py_None); |
|
397 codestr[i] = LOAD_CONST; |
|
398 SETARG(codestr, i, j); |
|
399 cumlc = lastlc + 1; |
|
400 break; |
|
401 |
|
402 /* Skip over LOAD_CONST trueconst |
|
403 JUMP_IF_FALSE xx POP_TOP */ |
|
404 case LOAD_CONST: |
|
405 cumlc = lastlc + 1; |
|
406 j = GETARG(codestr, i); |
|
407 if (codestr[i+3] != JUMP_IF_FALSE || |
|
408 codestr[i+6] != POP_TOP || |
|
409 !ISBASICBLOCK(blocks,i,7) || |
|
410 !PyObject_IsTrue(PyList_GET_ITEM(consts, j))) |
|
411 continue; |
|
412 memset(codestr+i, NOP, 7); |
|
413 cumlc = 0; |
|
414 break; |
|
415 |
|
416 /* Try to fold tuples of constants (includes a case for lists |
|
417 which are only used for "in" and "not in" tests). |
|
418 Skip over BUILD_SEQN 1 UNPACK_SEQN 1. |
|
419 Replace BUILD_SEQN 2 UNPACK_SEQN 2 with ROT2. |
|
420 Replace BUILD_SEQN 3 UNPACK_SEQN 3 with ROT3 ROT2. */ |
|
421 case BUILD_TUPLE: |
|
422 case BUILD_LIST: |
|
423 j = GETARG(codestr, i); |
|
424 h = i - 3 * j; |
|
425 if (h >= 0 && |
|
426 j <= lastlc && |
|
427 ((opcode == BUILD_TUPLE && |
|
428 ISBASICBLOCK(blocks, h, 3*(j+1))) || |
|
429 (opcode == BUILD_LIST && |
|
430 codestr[i+3]==COMPARE_OP && |
|
431 ISBASICBLOCK(blocks, h, 3*(j+2)) && |
|
432 (GETARG(codestr,i+3)==6 || |
|
433 GETARG(codestr,i+3)==7))) && |
|
434 tuple_of_constants(&codestr[h], j, consts)) { |
|
435 assert(codestr[i] == LOAD_CONST); |
|
436 cumlc = 1; |
|
437 break; |
|
438 } |
|
439 if (codestr[i+3] != UNPACK_SEQUENCE || |
|
440 !ISBASICBLOCK(blocks,i,6) || |
|
441 j != GETARG(codestr, i+3)) |
|
442 continue; |
|
443 if (j == 1) { |
|
444 memset(codestr+i, NOP, 6); |
|
445 } else if (j == 2) { |
|
446 codestr[i] = ROT_TWO; |
|
447 memset(codestr+i+1, NOP, 5); |
|
448 } else if (j == 3) { |
|
449 codestr[i] = ROT_THREE; |
|
450 codestr[i+1] = ROT_TWO; |
|
451 memset(codestr+i+2, NOP, 4); |
|
452 } |
|
453 break; |
|
454 |
|
455 /* Fold binary ops on constants. |
|
456 LOAD_CONST c1 LOAD_CONST c2 BINOP --> LOAD_CONST binop(c1,c2) */ |
|
457 case BINARY_POWER: |
|
458 case BINARY_MULTIPLY: |
|
459 case BINARY_TRUE_DIVIDE: |
|
460 case BINARY_FLOOR_DIVIDE: |
|
461 case BINARY_MODULO: |
|
462 case BINARY_ADD: |
|
463 case BINARY_SUBTRACT: |
|
464 case BINARY_SUBSCR: |
|
465 case BINARY_LSHIFT: |
|
466 case BINARY_RSHIFT: |
|
467 case BINARY_AND: |
|
468 case BINARY_XOR: |
|
469 case BINARY_OR: |
|
470 if (lastlc >= 2 && |
|
471 ISBASICBLOCK(blocks, i-6, 7) && |
|
472 fold_binops_on_constants(&codestr[i-6], consts)) { |
|
473 i -= 2; |
|
474 assert(codestr[i] == LOAD_CONST); |
|
475 cumlc = 1; |
|
476 } |
|
477 break; |
|
478 |
|
479 /* Fold unary ops on constants. |
|
480 LOAD_CONST c1 UNARY_OP --> LOAD_CONST unary_op(c) */ |
|
481 case UNARY_NEGATIVE: |
|
482 case UNARY_CONVERT: |
|
483 case UNARY_INVERT: |
|
484 if (lastlc >= 1 && |
|
485 ISBASICBLOCK(blocks, i-3, 4) && |
|
486 fold_unaryops_on_constants(&codestr[i-3], consts)) { |
|
487 i -= 2; |
|
488 assert(codestr[i] == LOAD_CONST); |
|
489 cumlc = 1; |
|
490 } |
|
491 break; |
|
492 |
|
493 /* Simplify conditional jump to conditional jump where the |
|
494 result of the first test implies the success of a similar |
|
495 test or the failure of the opposite test. |
|
496 Arises in code like: |
|
497 "if a and b:" |
|
498 "if a or b:" |
|
499 "a and b or c" |
|
500 "(a and b) and c" |
|
501 x:JUMP_IF_FALSE y y:JUMP_IF_FALSE z --> x:JUMP_IF_FALSE z |
|
502 x:JUMP_IF_FALSE y y:JUMP_IF_TRUE z --> x:JUMP_IF_FALSE y+3 |
|
503 where y+3 is the instruction following the second test. |
|
504 */ |
|
505 case JUMP_IF_FALSE: |
|
506 case JUMP_IF_TRUE: |
|
507 tgt = GETJUMPTGT(codestr, i); |
|
508 j = codestr[tgt]; |
|
509 if (j == JUMP_IF_FALSE || j == JUMP_IF_TRUE) { |
|
510 if (j == opcode) { |
|
511 tgttgt = GETJUMPTGT(codestr, tgt) - i - 3; |
|
512 SETARG(codestr, i, tgttgt); |
|
513 } else { |
|
514 tgt -= i; |
|
515 SETARG(codestr, i, tgt); |
|
516 } |
|
517 break; |
|
518 } |
|
519 /* Intentional fallthrough */ |
|
520 |
|
521 /* Replace jumps to unconditional jumps */ |
|
522 case FOR_ITER: |
|
523 case JUMP_FORWARD: |
|
524 case JUMP_ABSOLUTE: |
|
525 case CONTINUE_LOOP: |
|
526 case SETUP_LOOP: |
|
527 case SETUP_EXCEPT: |
|
528 case SETUP_FINALLY: |
|
529 tgt = GETJUMPTGT(codestr, i); |
|
530 /* Replace JUMP_* to a RETURN into just a RETURN */ |
|
531 if (UNCONDITIONAL_JUMP(opcode) && |
|
532 codestr[tgt] == RETURN_VALUE) { |
|
533 codestr[i] = RETURN_VALUE; |
|
534 memset(codestr+i+1, NOP, 2); |
|
535 continue; |
|
536 } |
|
537 if (!UNCONDITIONAL_JUMP(codestr[tgt])) |
|
538 continue; |
|
539 tgttgt = GETJUMPTGT(codestr, tgt); |
|
540 if (opcode == JUMP_FORWARD) /* JMP_ABS can go backwards */ |
|
541 opcode = JUMP_ABSOLUTE; |
|
542 if (!ABSOLUTE_JUMP(opcode)) |
|
543 tgttgt -= i + 3; /* Calc relative jump addr */ |
|
544 if (tgttgt < 0) /* No backward relative jumps */ |
|
545 continue; |
|
546 codestr[i] = opcode; |
|
547 SETARG(codestr, i, tgttgt); |
|
548 break; |
|
549 |
|
550 case EXTENDED_ARG: |
|
551 goto exitUnchanged; |
|
552 |
|
553 /* Replace RETURN LOAD_CONST None RETURN with just RETURN */ |
|
554 /* Remove unreachable JUMPs after RETURN */ |
|
555 case RETURN_VALUE: |
|
556 if (i+4 >= codelen) |
|
557 continue; |
|
558 if (codestr[i+4] == RETURN_VALUE && |
|
559 ISBASICBLOCK(blocks,i,5)) |
|
560 memset(codestr+i+1, NOP, 4); |
|
561 else if (UNCONDITIONAL_JUMP(codestr[i+1]) && |
|
562 ISBASICBLOCK(blocks,i,4)) |
|
563 memset(codestr+i+1, NOP, 3); |
|
564 break; |
|
565 } |
|
566 } |
|
567 |
|
568 /* Fixup linenotab */ |
|
569 for (i=0, nops=0 ; i<codelen ; i += CODESIZE(codestr[i])) { |
|
570 addrmap[i] = i - nops; |
|
571 if (codestr[i] == NOP) |
|
572 nops++; |
|
573 } |
|
574 cum_orig_line = 0; |
|
575 last_line = 0; |
|
576 for (i=0 ; i < tabsiz ; i+=2) { |
|
577 cum_orig_line += lineno[i]; |
|
578 new_line = addrmap[cum_orig_line]; |
|
579 assert (new_line - last_line < 255); |
|
580 lineno[i] =((unsigned char)(new_line - last_line)); |
|
581 last_line = new_line; |
|
582 } |
|
583 |
|
584 /* Remove NOPs and fixup jump targets */ |
|
585 for (i=0, h=0 ; i<codelen ; ) { |
|
586 opcode = codestr[i]; |
|
587 switch (opcode) { |
|
588 case NOP: |
|
589 i++; |
|
590 continue; |
|
591 |
|
592 case JUMP_ABSOLUTE: |
|
593 case CONTINUE_LOOP: |
|
594 j = addrmap[GETARG(codestr, i)]; |
|
595 SETARG(codestr, i, j); |
|
596 break; |
|
597 |
|
598 case FOR_ITER: |
|
599 case JUMP_FORWARD: |
|
600 case JUMP_IF_FALSE: |
|
601 case JUMP_IF_TRUE: |
|
602 case SETUP_LOOP: |
|
603 case SETUP_EXCEPT: |
|
604 case SETUP_FINALLY: |
|
605 j = addrmap[GETARG(codestr, i) + i + 3] - addrmap[i] - 3; |
|
606 SETARG(codestr, i, j); |
|
607 break; |
|
608 } |
|
609 adj = CODESIZE(opcode); |
|
610 while (adj--) |
|
611 codestr[h++] = codestr[i++]; |
|
612 } |
|
613 assert(h + nops == codelen); |
|
614 |
|
615 code = PyString_FromStringAndSize((char *)codestr, h); |
|
616 PyMem_Free(addrmap); |
|
617 PyMem_Free(codestr); |
|
618 PyMem_Free(blocks); |
|
619 return code; |
|
620 |
|
621 exitUnchanged: |
|
622 if (blocks != NULL) |
|
623 PyMem_Free(blocks); |
|
624 if (addrmap != NULL) |
|
625 PyMem_Free(addrmap); |
|
626 if (codestr != NULL) |
|
627 PyMem_Free(codestr); |
|
628 Py_INCREF(code); |
|
629 return code; |
|
630 } |