[Python-checkins] GH-93678: refactor compiler so that optimizer does not need the assembler and compiler structs (GH-93842)

iritkatriel webhook-mailer at python.org
Tue Jun 21 04:22:24 EDT 2022

• Previous message (by thread): [Python-checkins] gh-94021: Address unreachable code warning in specialize code (GH-94022)
• Next message (by thread): [Python-checkins] gh-93839: Move Lib/ctypes/test/ to Lib/test/test_ctypes/ (#94041)
• Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

---

https://github.com/python/cpython/commit/889772fb568f14aacb9127e98e92ec2e34110b10
commit: 889772fb568f14aacb9127e98e92ec2e34110b10
branch: main
author: Irit Katriel <1055913+iritkatriel at users.noreply.github.com>
committer: iritkatriel <1055913+iritkatriel at users.noreply.github.com>
date: 2022年06月21日T09:22:17+01:00
summary:
GH-93678: refactor compiler so that optimizer does not need the assembler and compiler structs (GH-93842)
files:
A Misc/NEWS.d/next/Core and Builtins/2022-06-15-16-45-53.gh-issue-93678.1I_ZT3.rst
M Python/compile.c
diff --git a/Misc/NEWS.d/next/Core and Builtins/2022-06-15-16-45-53.gh-issue-93678.1I_ZT3.rst b/Misc/NEWS.d/next/Core and Builtins/2022-06-15-16-45-53.gh-issue-93678.1I_ZT3.rst
new file mode 100644
index 0000000000000..3c99fd2ecf663
--- /dev/null
+++ b/Misc/NEWS.d/next/Core and Builtins/2022-06-15-16-45-53.gh-issue-93678.1I_ZT3.rst	
@@ -0,0 +1 @@
+Refactor compiler optimisation code so that it no longer needs the ``struct assembler`` and ``struct compiler`` passed around. Instead, each function takes the CFG and other data that it actually needs. This will make it possible to test this code directly.
diff --git a/Python/compile.c b/Python/compile.c
index 87d9037ea2891..3946aac8c9943 100644
--- a/Python/compile.c
+++ b/Python/compile.c
@@ -854,20 +854,26 @@ compiler_set_qualname(struct compiler *c)
 /* Allocate a new block and return a pointer to it.
 Returns NULL on error.
 */
+static basicblock *
+new_basicblock()
+{
+ basicblock *b = (basicblock *)PyObject_Calloc(1, sizeof(basicblock));
+ if (b == NULL) {
+ PyErr_NoMemory();
+ return NULL;
+ }
+ return b;
+}
 
 static basicblock *
 compiler_new_block(struct compiler *c)
 {
- basicblock *b;
- struct compiler_unit *u;
-
- u = c->u;
- b = (basicblock *)PyObject_Calloc(1, sizeof(basicblock));
+ basicblock *b = new_basicblock();
 if (b == NULL) {
- PyErr_NoMemory();
 return NULL;
 }
 /* Extend the singly linked list of blocks with new block. */
+ struct compiler_unit *u = c->u;
 b->b_list = u->u_blocks;
 u->u_blocks = b;
 return b;
@@ -883,13 +889,25 @@ compiler_use_next_block(struct compiler *c, basicblock *block)
 }
 
 static basicblock *
-compiler_copy_block(struct compiler *c, basicblock *block)
+basicblock_new_b_list_successor(basicblock *prev)
+{
+ basicblock *result = new_basicblock();
+ if (result == NULL) {
+ return NULL;
+ }
+ result->b_list = prev->b_list;
+ prev->b_list = result;
+ return result;
+}
+
+static basicblock *
+copy_basicblock(basicblock *block)
 {
 /* Cannot copy a block if it has a fallthrough, since
 * a block can only have one fallthrough predecessor.
 */
 assert(BB_NO_FALLTHROUGH(block));
- basicblock *result = compiler_new_block(c);
+ basicblock *result = basicblock_new_b_list_successor(block);
 if (result == NULL) {
 return NULL;
 }
@@ -1340,8 +1358,9 @@ compiler_add_o(PyObject *dict, PyObject *o)
 
 // Merge const *o* recursively and return constant key object.
 static PyObject*
-merge_consts_recursive(struct compiler *c, PyObject *o)
+merge_consts_recursive(PyObject *const_cache, PyObject *o)
 {
+ assert(PyDict_CheckExact(const_cache));
 // None and Ellipsis are singleton, and key is the singleton.
 // No need to merge object and key.
 if (o == Py_None || o == Py_Ellipsis) {
@@ -1355,22 +1374,22 @@ merge_consts_recursive(struct compiler *c, PyObject *o)
 }
 
 // t is borrowed reference
- PyObject *t = PyDict_SetDefault(c->c_const_cache, key, key);
+ PyObject *t = PyDict_SetDefault(const_cache, key, key);
 if (t != key) {
- // o is registered in c_const_cache. Just use it.
+ // o is registered in const_cache. Just use it.
 Py_XINCREF(t);
 Py_DECREF(key);
 return t;
 }
 
- // We registered o in c_const_cache.
+ // We registered o in const_cache.
 // When o is a tuple or frozenset, we want to merge its
 // items too.
 if (PyTuple_CheckExact(o)) {
 Py_ssize_t len = PyTuple_GET_SIZE(o);
 for (Py_ssize_t i = 0; i < len; i++) {
 PyObject *item = PyTuple_GET_ITEM(o, i);
- PyObject *u = merge_consts_recursive(c, item);
+ PyObject *u = merge_consts_recursive(const_cache, item);
 if (u == NULL) {
 Py_DECREF(key);
 return NULL;
@@ -1413,7 +1432,7 @@ merge_consts_recursive(struct compiler *c, PyObject *o)
 PyObject *item;
 Py_hash_t hash;
 while (_PySet_NextEntry(o, &pos, &item, &hash)) {
- PyObject *k = merge_consts_recursive(c, item);
+ PyObject *k = merge_consts_recursive(const_cache, item);
 if (k == NULL) {
 Py_DECREF(tuple);
 Py_DECREF(key);
@@ -1451,7 +1470,7 @@ merge_consts_recursive(struct compiler *c, PyObject *o)
 static Py_ssize_t
 compiler_add_const(struct compiler *c, PyObject *o)
 {
- PyObject *key = merge_consts_recursive(c, o);
+ PyObject *key = merge_consts_recursive(c->c_const_cache, o);
 if (key == NULL) {
 return -1;
 }
@@ -6994,34 +7013,25 @@ compiler_match(struct compiler *c, stmt_ty s)
 #undef WILDCARD_CHECK
 #undef WILDCARD_STAR_CHECK
 
-/* End of the compiler section, beginning of the assembler section */
-
-/* do depth-first search of basic block graph, starting with block.
- post records the block indices in post-order.
 
- XXX must handle implicit jumps from one block to next
-*/
+/* End of the compiler section, beginning of the assembler section */
 
 
 struct assembler {
 PyObject *a_bytecode; /* bytes containing bytecode */
- PyObject *a_except_table; /* bytes containing exception table */
- basicblock *a_entry;
 int a_offset; /* offset into bytecode */
+ PyObject *a_except_table; /* bytes containing exception table */
 int a_except_table_off; /* offset into exception table */
- int a_lineno; /* lineno of last emitted instruction */
- int a_end_lineno; /* end_lineno of last emitted instruction */
- int a_lineno_start; /* bytecode start offset of current lineno */
- int a_end_lineno_start; /* bytecode start offset of current end_lineno */
 /* Location Info */
+ int a_lineno; /* lineno of last emitted instruction */
 PyObject* a_linetable; /* bytes containing location info */
 int a_location_off; /* offset of last written location info frame */
 };
 
 static basicblock**
-make_cfg_traversal_stack(basicblock *entry) {
+make_cfg_traversal_stack(basicblock *entryblock) {
 int nblocks = 0;
- for (basicblock *b = entry; b != NULL; b = b->b_next) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 b->b_visited = 0;
 nblocks++;
 }
@@ -7047,22 +7057,22 @@ stackdepth_push(basicblock ***sp, basicblock *b, int depth)
 * cycles in the flow graph have no net effect on the stack depth.
 */
 static int
-stackdepth(struct compiler *c, basicblock *entry)
+stackdepth(basicblock *entryblock, int code_flags)
 {
- for (basicblock *b = entry; b != NULL; b = b->b_next) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 b->b_startdepth = INT_MIN;
 }
- basicblock **stack = make_cfg_traversal_stack(entry);
+ basicblock **stack = make_cfg_traversal_stack(entryblock);
 if (!stack) {
 return -1;
 }
 
 int maxdepth = 0;
 basicblock **sp = stack;
- if (c->u->u_ste->ste_generator || c->u->u_ste->ste_coroutine) {
- stackdepth_push(&sp, entry, 1);
+ if (code_flags & (CO_GENERATOR | CO_COROUTINE | CO_ASYNC_GENERATOR)) {
+ stackdepth_push(&sp, entryblock, 1);
 } else {
- stackdepth_push(&sp, entry, 0);
+ stackdepth_push(&sp, entryblock, 0);
 }
 
 while (sp != stack) {
@@ -7117,11 +7127,10 @@ stackdepth(struct compiler *c, basicblock *entry)
 }
 
 static int
-assemble_init(struct assembler *a, int nblocks, int firstlineno)
+assemble_init(struct assembler *a, int firstlineno)
 {
 memset(a, 0, sizeof(struct assembler));
 a->a_lineno = firstlineno;
- a->a_end_lineno = firstlineno;
 a->a_linetable = NULL;
 a->a_location_off = 0;
 a->a_except_table = NULL;
@@ -7137,10 +7146,6 @@ assemble_init(struct assembler *a, int nblocks, int firstlineno)
 if (a->a_except_table == NULL) {
 goto error;
 }
- if ((size_t)nblocks > SIZE_MAX / sizeof(basicblock *)) {
- PyErr_NoMemory();
- goto error;
- }
 return 1;
 error:
 Py_XDECREF(a->a_bytecode);
@@ -7216,8 +7221,8 @@ copy_except_stack(ExceptStack *stack) {
 }
 
 static int
-label_exception_targets(basicblock *entry) {
- basicblock **todo_stack = make_cfg_traversal_stack(entry);
+label_exception_targets(basicblock *entryblock) {
+ basicblock **todo_stack = make_cfg_traversal_stack(entryblock);
 if (todo_stack == NULL) {
 return -1;
 }
@@ -7228,9 +7233,9 @@ label_exception_targets(basicblock *entry) {
 return -1;
 }
 except_stack->depth = 0;
- todo_stack[0] = entry;
- entry->b_visited = 1;
- entry->b_exceptstack = except_stack;
+ todo_stack[0] = entryblock;
+ entryblock->b_visited = 1;
+ entryblock->b_exceptstack = except_stack;
 basicblock **todo = &todo_stack[1];
 basicblock *handler = NULL;
 while (todo > todo_stack) {
@@ -7295,7 +7300,7 @@ label_exception_targets(basicblock *entry) {
 }
 }
 #ifdef Py_DEBUG
- for (basicblock *b = entry; b != NULL; b = b->b_next) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 assert(b->b_exceptstack == NULL);
 }
 #endif
@@ -7308,15 +7313,15 @@ label_exception_targets(basicblock *entry) {
 }
 
 static int
-mark_warm(basicblock *entry) {
- basicblock **stack = make_cfg_traversal_stack(entry);
+mark_warm(basicblock *entryblock) {
+ basicblock **stack = make_cfg_traversal_stack(entryblock);
 if (stack == NULL) {
 return -1;
 }
 basicblock **sp = stack;
 
- *sp++ = entry;
- entry->b_visited = 1;
+ *sp++ = entryblock;
+ entryblock->b_visited = 1;
 while (sp > stack) {
 basicblock *b = *(--sp);
 assert(!b->b_except_predecessors);
@@ -7339,21 +7344,21 @@ mark_warm(basicblock *entry) {
 }
 
 static int
-mark_cold(basicblock *entry) {
- for (basicblock *b = entry; b != NULL; b = b->b_next) {
+mark_cold(basicblock *entryblock) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 assert(!b->b_cold && !b->b_warm);
 }
- if (mark_warm(entry) < 0) {
+ if (mark_warm(entryblock) < 0) {
 return -1;
 }
 
- basicblock **stack = make_cfg_traversal_stack(entry);
+ basicblock **stack = make_cfg_traversal_stack(entryblock);
 if (stack == NULL) {
 return -1;
 }
 
 basicblock **sp = stack;
- for (basicblock *b = entry; b != NULL; b = b->b_next) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 if (b->b_except_predecessors) {
 assert(b->b_except_predecessors == b->b_predecessors);
 assert(!b->b_warm);
@@ -7389,20 +7394,20 @@ mark_cold(basicblock *entry) {
 }
 
 static int
-push_cold_blocks_to_end(struct compiler *c, basicblock *entry, int code_flags) {
- if (entry->b_next == NULL) {
+push_cold_blocks_to_end(basicblock *entryblock, int code_flags) {
+ if (entryblock->b_next == NULL) {
 /* single basicblock, no need to reorder */
 return 0;
 }
- if (mark_cold(entry) < 0) {
+ if (mark_cold(entryblock) < 0) {
 return -1;
 }
 
 /* If we have a cold block with fallthrough to a warm block, add */
 /* an explicit jump instead of fallthrough */
- for (basicblock *b = entry; b != NULL; b = b->b_next) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 if (b->b_cold && BB_HAS_FALLTHROUGH(b) && b->b_next && b->b_next->b_warm) {
- basicblock *explicit_jump = compiler_new_block(c);
+ basicblock *explicit_jump = basicblock_new_b_list_successor(b);
 if (explicit_jump == NULL) {
 return -1;
 }
@@ -7414,11 +7419,11 @@ push_cold_blocks_to_end(struct compiler *c, basicblock *entry, int code_flags) {
 }
 }
 
- assert(!entry->b_cold); /* First block can't be cold */
+ assert(!entryblock->b_cold); /* First block can't be cold */
 basicblock *cold_blocks = NULL;
 basicblock *cold_blocks_tail = NULL;
 
- basicblock *b = entry;
+ basicblock *b = entryblock;
 while(b->b_next) {
 assert(!b->b_cold);
 while (b->b_next && !b->b_next->b_cold) {
@@ -7457,8 +7462,8 @@ push_cold_blocks_to_end(struct compiler *c, basicblock *entry, int code_flags) {
 }
 
 static void
-convert_exception_handlers_to_nops(basicblock *entry) {
- for (basicblock *b = entry; b != NULL; b = b->b_next) {
+convert_exception_handlers_to_nops(basicblock *entryblock) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 for (int i = 0; i < b->b_iused; i++) {
 struct instr *instr = &b->b_instr[i];
 if (is_block_push(instr) || instr->i_opcode == POP_BLOCK) {
@@ -7528,13 +7533,13 @@ assemble_emit_exception_table_entry(struct assembler *a, int start, int end, bas
 }
 
 static int
-assemble_exception_table(struct assembler *a)
+assemble_exception_table(struct assembler *a, basicblock *entryblock)
 {
 basicblock *b;
 int ioffset = 0;
 basicblock *handler = NULL;
 int start = -1;
- for (b = a->a_entry; b != NULL; b = b->b_next) {
+ for (b = entryblock; b != NULL; b = b->b_next) {
 ioffset = b->b_offset;
 for (int i = 0; i < b->b_iused; i++) {
 struct instr *instr = &b->b_instr[i];
@@ -7727,12 +7732,12 @@ assemble_emit(struct assembler *a, struct instr *i)
 }
 
 static void
-normalize_jumps(struct assembler *a)
+normalize_jumps(basicblock *entryblock)
 {
- for (basicblock *b = a->a_entry; b != NULL; b = b->b_next) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 b->b_visited = 0;
 }
- for (basicblock *b = a->a_entry; b != NULL; b = b->b_next) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 b->b_visited = 1;
 if (b->b_iused == 0) {
 continue;
@@ -7786,25 +7791,23 @@ normalize_jumps(struct assembler *a)
 }
 
 static void
-assemble_jump_offsets(struct assembler *a, struct compiler *c)
+assemble_jump_offsets(basicblock *entryblock)
 {
- basicblock *b;
 int bsize, totsize, extended_arg_recompile;
- int i;
 
 /* Compute the size of each block and fixup jump args.
 Replace block pointer with position in bytecode. */
 do {
 totsize = 0;
- for (basicblock *b = a->a_entry; b != NULL; b = b->b_next) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 bsize = blocksize(b);
 b->b_offset = totsize;
 totsize += bsize;
 }
 extended_arg_recompile = 0;
- for (b = c->u->u_blocks; b != NULL; b = b->b_list) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 bsize = b->b_offset;
- for (i = 0; i < b->b_iused; i++) {
+ for (int i = 0; i < b->b_iused; i++) {
 struct instr *instr = &b->b_instr[i];
 int isize = instr_size(instr);
 /* Relative jumps are computed relative to
@@ -7917,17 +7920,17 @@ scan_block_for_local(int target, basicblock *b, bool unsafe_to_start,
 #undef MAYBE_PUSH
 
 static int
-add_checks_for_loads_of_unknown_variables(struct assembler *a,
+add_checks_for_loads_of_unknown_variables(basicblock *entryblock,
 struct compiler *c)
 {
- basicblock **stack = make_cfg_traversal_stack(a->a_entry);
+ basicblock **stack = make_cfg_traversal_stack(entryblock);
 if (stack == NULL) {
 return -1;
 }
 Py_ssize_t nparams = PyList_GET_SIZE(c->u->u_ste->ste_varnames);
 int nlocals = (int)PyDict_GET_SIZE(c->u->u_varnames);
 for (int target = 0; target < nlocals; target++) {
- for (basicblock *b = a->a_entry; b != NULL; b = b->b_next) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 b->b_visited = 0;
 }
 basicblock **stack_top = stack;
@@ -7937,10 +7940,10 @@ add_checks_for_loads_of_unknown_variables(struct assembler *a,
 // which are the entry block and any DELETE_FAST statements.
 if (target >= nparams) {
 // only non-parameter locals start out uninitialized.
- *(stack_top++) = a->a_entry;
- a->a_entry->b_visited = 1;
+ *(stack_top++) = entryblock;
+ entryblock->b_visited = 1;
 }
- for (basicblock *b = a->a_entry; b != NULL; b = b->b_next) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 scan_block_for_local(target, b, false, &stack_top);
 }
 
@@ -8034,15 +8037,16 @@ compute_code_flags(struct compiler *c)
 // Merge *obj* with constant cache.
 // Unlike merge_consts_recursive(), this function doesn't work recursively.
 static int
-merge_const_one(struct compiler *c, PyObject **obj)
+merge_const_one(PyObject *const_cache, PyObject **obj)
 {
+ PyDict_CheckExact(const_cache);
 PyObject *key = _PyCode_ConstantKey(*obj);
 if (key == NULL) {
 return 0;
 }
 
 // t is borrowed reference
- PyObject *t = PyDict_SetDefault(c->c_const_cache, key, key);
+ PyObject *t = PyDict_SetDefault(const_cache, key, key);
 Py_DECREF(key);
 if (t == NULL) {
 return 0;
@@ -8125,7 +8129,7 @@ makecode(struct compiler *c, struct assembler *a, PyObject *constslist,
 if (!names) {
 goto error;
 }
- if (!merge_const_one(c, &names)) {
+ if (!merge_const_one(c->c_const_cache, &names)) {
 goto error;
 }
 
@@ -8133,7 +8137,7 @@ makecode(struct compiler *c, struct assembler *a, PyObject *constslist,
 if (consts == NULL) {
 goto error;
 }
- if (!merge_const_one(c, &consts)) {
+ if (!merge_const_one(c->c_const_cache, &consts)) {
 goto error;
 }
 
@@ -8184,7 +8188,7 @@ makecode(struct compiler *c, struct assembler *a, PyObject *constslist,
 goto error;
 }
 
- if (!merge_const_one(c, &localsplusnames)) {
+ if (!merge_const_one(c->c_const_cache, &localsplusnames)) {
 goto error;
 }
 con.localsplusnames = localsplusnames;
@@ -8249,14 +8253,14 @@ static int
 normalize_basic_block(basicblock *bb);
 
 static int
-optimize_cfg(struct compiler *c, struct assembler *a, PyObject *consts);
+optimize_cfg(basicblock *entryblock, PyObject *consts, PyObject *const_cache);
 
 static int
-trim_unused_consts(struct assembler *a, PyObject *consts);
+trim_unused_consts(basicblock *entryblock, PyObject *consts);
 
 /* Duplicates exit BBs, so that line numbers can be propagated to them */
 static int
-duplicate_exits_without_lineno(struct compiler *c);
+duplicate_exits_without_lineno(basicblock *entryblock);
 
 static int
 extend_block(basicblock *bb);
@@ -8390,10 +8394,10 @@ insert_prefix_instructions(struct compiler *c, basicblock *entryblock,
 * The resulting line number may not be correct according to PEP 626,
 * but should be "good enough", and no worse than in older versions. */
 static void
-guarantee_lineno_for_exits(struct assembler *a, int firstlineno) {
+guarantee_lineno_for_exits(basicblock *entryblock, int firstlineno) {
 int lineno = firstlineno;
 assert(lineno > 0);
- for (basicblock *b = a->a_entry; b != NULL; b = b->b_next) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 if (b->b_iused == 0) {
 continue;
 }
@@ -8460,21 +8464,21 @@ fix_cell_offsets(struct compiler *c, basicblock *entryblock, int *fixedmap)
 }
 
 static void
-propagate_line_numbers(struct assembler *a);
+propagate_line_numbers(basicblock *entryblock);
 
 static void
-eliminate_empty_basic_blocks(basicblock *entry);
+eliminate_empty_basic_blocks(basicblock *entryblock);
 
 
 static void
-remove_redundant_jumps(basicblock *entry) {
+remove_redundant_jumps(basicblock *entryblock) {
 /* If a non-empty block ends with a jump instruction, check if the next
 * non-empty block reached through normal flow control is the target
 * of that jump. If it is, then the jump instruction is redundant and
 * can be deleted.
 */
 int removed = 0;
- for (basicblock *b = entry; b != NULL; b = b->b_next) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 if (b->b_iused > 0) {
 struct instr *b_last_instr = &b->b_instr[b->b_iused - 1];
 assert(!IS_ASSEMBLER_OPCODE(b_last_instr->i_opcode));
@@ -8489,16 +8493,13 @@ remove_redundant_jumps(basicblock *entry) {
 }
 }
 if (removed) {
- eliminate_empty_basic_blocks(entry);
+ eliminate_empty_basic_blocks(entryblock);
 }
 }
 
 static PyCodeObject *
 assemble(struct compiler *c, int addNone)
 {
- basicblock *b, *entryblock;
- struct assembler a;
- int j, nblocks;
 PyCodeObject *co = NULL;
 PyObject *consts = NULL;
 
@@ -8527,15 +8528,6 @@ assemble(struct compiler *c, int addNone)
 }
 }
 
- nblocks = 0;
- entryblock = NULL;
- for (b = c->u->u_blocks; b != NULL; b = b->b_list) {
- nblocks++;
- entryblock = b;
- assert(b->b_warm == 0 && b->b_cold == 0);
- }
- assert(entryblock != NULL);
-
 assert(PyDict_GET_SIZE(c->u->u_varnames) < INT_MAX);
 assert(PyDict_GET_SIZE(c->u->u_cellvars) < INT_MAX);
 assert(PyDict_GET_SIZE(c->u->u_freevars) < INT_MAX);
@@ -8550,6 +8542,18 @@ assemble(struct compiler *c, int addNone)
 goto error;
 }
 
+ int nblocks = 0;
+ basicblock *entryblock = NULL;
+ for (basicblock *b = c->u->u_blocks; b != NULL; b = b->b_list) {
+ nblocks++;
+ entryblock = b;
+ }
+ assert(entryblock != NULL);
+ if ((size_t)nblocks > SIZE_MAX / sizeof(basicblock *)) {
+ PyErr_NoMemory();
+ goto error;
+ }
+
 /* Set firstlineno if it wasn't explicitly set. */
 if (!c->u->u_firstlineno) {
 if (entryblock->b_instr && entryblock->b_instr->i_loc.lineno) {
@@ -8565,10 +8569,6 @@ assemble(struct compiler *c, int addNone)
 goto error;
 }
 
- if (!assemble_init(&a, nblocks, c->u->u_firstlineno))
- goto error;
- a.a_entry = entryblock;
-
 int numdropped = fix_cell_offsets(c, entryblock, cellfixedoffsets);
 PyMem_Free(cellfixedoffsets); // At this point we're done with it.
 cellfixedoffsets = NULL;
@@ -8582,18 +8582,19 @@ assemble(struct compiler *c, int addNone)
 goto error;
 }
 
- if (optimize_cfg(c, &a, consts)) {
+ if (optimize_cfg(entryblock, consts, c->c_const_cache)) {
 goto error;
 }
- if (duplicate_exits_without_lineno(c)) {
+ if (duplicate_exits_without_lineno(entryblock)) {
 return NULL;
 }
- if (trim_unused_consts(&a, consts)) {
+ if (trim_unused_consts(entryblock, consts)) {
 goto error;
 }
- propagate_line_numbers(&a);
- guarantee_lineno_for_exits(&a, c->u->u_firstlineno);
- int maxdepth = stackdepth(c, entryblock);
+ propagate_line_numbers(entryblock);
+ guarantee_lineno_for_exits(entryblock, c->u->u_firstlineno);
+
+ int maxdepth = stackdepth(entryblock, code_flags);
 if (maxdepth < 0) {
 goto error;
 }
@@ -8609,62 +8610,67 @@ assemble(struct compiler *c, int addNone)
 }
 convert_exception_handlers_to_nops(entryblock);
 
- if (push_cold_blocks_to_end(c, entryblock, code_flags) < 0) {
+ if (push_cold_blocks_to_end(entryblock, code_flags) < 0) {
 goto error;
 }
 
 remove_redundant_jumps(entryblock);
- assert(a.a_entry == entryblock);
 for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 clean_basic_block(b);
 }
 
 /* Order of basic blocks must have been determined by now */
- normalize_jumps(&a);
+ normalize_jumps(entryblock);
 
- if (add_checks_for_loads_of_unknown_variables(&a, c) < 0) {
+ if (add_checks_for_loads_of_unknown_variables(entryblock, c) < 0) {
 goto error;
 }
 
 /* Can't modify the bytecode after computing jump offsets. */
- assemble_jump_offsets(&a, c);
+ assemble_jump_offsets(entryblock);
+
+
+ /* Create assembler */
+ struct assembler a;
+ if (!assemble_init(&a, c->u->u_firstlineno))
+ goto error;
 
 /* Emit code. */
- for(b = entryblock; b != NULL; b = b->b_next) {
- for (j = 0; j < b->b_iused; j++)
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
+ for (int j = 0; j < b->b_iused; j++)
 if (!assemble_emit(&a, &b->b_instr[j]))
 goto error;
 }
 
 /* Emit location info */
 a.a_lineno = c->u->u_firstlineno;
- for(b = entryblock; b != NULL; b = b->b_next) {
- for (j = 0; j < b->b_iused; j++)
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
+ for (int j = 0; j < b->b_iused; j++)
 if (!assemble_emit_location(&a, &b->b_instr[j]))
 goto error;
 }
 
- if (!assemble_exception_table(&a)) {
+ if (!assemble_exception_table(&a, entryblock)) {
 goto error;
 }
 if (_PyBytes_Resize(&a.a_except_table, a.a_except_table_off) < 0) {
 goto error;
 }
- if (!merge_const_one(c, &a.a_except_table)) {
+ if (!merge_const_one(c->c_const_cache, &a.a_except_table)) {
 goto error;
 }
 
 if (_PyBytes_Resize(&a.a_linetable, a.a_location_off) < 0) {
 goto error;
 }
- if (!merge_const_one(c, &a.a_linetable)) {
+ if (!merge_const_one(c->c_const_cache, &a.a_linetable)) {
 goto error;
 }
 
 if (_PyBytes_Resize(&a.a_bytecode, a.a_offset * sizeof(_Py_CODEUNIT)) < 0) {
 goto error;
 }
- if (!merge_const_one(c, &a.a_bytecode)) {
+ if (!merge_const_one(c->c_const_cache, &a.a_bytecode)) {
 goto error;
 }
 
@@ -8703,11 +8709,12 @@ get_const_value(int opcode, int oparg, PyObject *co_consts)
 Called with codestr pointing to the first LOAD_CONST.
 */
 static int
-fold_tuple_on_constants(struct compiler *c,
+fold_tuple_on_constants(PyObject *const_cache,
 struct instr *inst,
 int n, PyObject *consts)
 {
 /* Pre-conditions */
+ assert(PyDict_CheckExact(const_cache));
 assert(PyList_CheckExact(consts));
 assert(inst[n].i_opcode == BUILD_TUPLE);
 assert(inst[n].i_oparg == n);
@@ -8732,7 +8739,7 @@ fold_tuple_on_constants(struct compiler *c,
 }
 PyTuple_SET_ITEM(newconst, i, constant);
 }
- if (merge_const_one(c, &newconst) == 0) {
+ if (merge_const_one(const_cache, &newconst) == 0) {
 Py_DECREF(newconst);
 return -1;
 }
@@ -8955,8 +8962,9 @@ jump_thread(struct instr *inst, struct instr *target, int opcode)
 
 /* Optimization */
 static int
-optimize_basic_block(struct compiler *c, basicblock *bb, PyObject *consts)
+optimize_basic_block(PyObject *const_cache, basicblock *bb, PyObject *consts)
 {
+ assert(PyDict_CheckExact(const_cache));
 assert(PyList_CheckExact(consts));
 struct instr nop;
 nop.i_opcode = NOP;
@@ -9063,7 +9071,7 @@ optimize_basic_block(struct compiler *c, basicblock *bb, PyObject *consts)
 }
 }
 if (i >= oparg) {
- if (fold_tuple_on_constants(c, inst-oparg, oparg, consts)) {
+ if (fold_tuple_on_constants(const_cache, inst-oparg, oparg, consts)) {
 goto error;
 }
 }
@@ -9295,14 +9303,14 @@ normalize_basic_block(basicblock *bb) {
 }
 
 static int
-mark_reachable(struct assembler *a) {
- basicblock **stack = make_cfg_traversal_stack(a->a_entry);
+mark_reachable(basicblock *entryblock) {
+ basicblock **stack = make_cfg_traversal_stack(entryblock);
 if (stack == NULL) {
 return -1;
 }
 basicblock **sp = stack;
- a->a_entry->b_predecessors = 1;
- *sp++ = a->a_entry;
+ entryblock->b_predecessors = 1;
+ *sp++ = entryblock;
 while (sp > stack) {
 basicblock *b = *(--sp);
 b->b_visited = 1;
@@ -9336,9 +9344,9 @@ mark_reachable(struct assembler *a) {
 }
 
 static void
-eliminate_empty_basic_blocks(basicblock *entry) {
+eliminate_empty_basic_blocks(basicblock *entryblock) {
 /* Eliminate empty blocks */
- for (basicblock *b = entry; b != NULL; b = b->b_next) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 basicblock *next = b->b_next;
 if (next) {
 while (next->b_iused == 0 && next->b_next) {
@@ -9347,7 +9355,7 @@ eliminate_empty_basic_blocks(basicblock *entry) {
 b->b_next = next;
 }
 }
- for (basicblock *b = entry; b != NULL; b = b->b_next) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 if (b->b_iused == 0) {
 continue;
 }
@@ -9373,8 +9381,8 @@ eliminate_empty_basic_blocks(basicblock *entry) {
 * but has no impact on the generated line number events.
 */
 static void
-propagate_line_numbers(struct assembler *a) {
- for (basicblock *b = a->a_entry; b != NULL; b = b->b_next) {
+propagate_line_numbers(basicblock *entryblock) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 if (b->b_iused == 0) {
 continue;
 }
@@ -9415,31 +9423,32 @@ propagate_line_numbers(struct assembler *a) {
 */
 
 static int
-optimize_cfg(struct compiler *c, struct assembler *a, PyObject *consts)
+optimize_cfg(basicblock *entryblock, PyObject *consts, PyObject *const_cache)
 {
- for (basicblock *b = a->a_entry; b != NULL; b = b->b_next) {
- if (optimize_basic_block(c, b, consts)) {
+ assert(PyDict_CheckExact(const_cache));
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
+ if (optimize_basic_block(const_cache, b, consts)) {
 return -1;
 }
 clean_basic_block(b);
 assert(b->b_predecessors == 0);
 }
- for (basicblock *b = c->u->u_blocks; b != NULL; b = b->b_list) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 if (extend_block(b)) {
 return -1;
 }
 }
- if (mark_reachable(a)) {
+ if (mark_reachable(entryblock)) {
 return -1;
 }
 /* Delete unreachable instructions */
- for (basicblock *b = a->a_entry; b != NULL; b = b->b_next) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 if (b->b_predecessors == 0) {
 b->b_iused = 0;
 }
 }
- eliminate_empty_basic_blocks(a->a_entry);
- for (basicblock *b = a->a_entry; b != NULL; b = b->b_next) {
+ eliminate_empty_basic_blocks(entryblock);
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 clean_basic_block(b);
 }
 return 0;
@@ -9447,13 +9456,13 @@ optimize_cfg(struct compiler *c, struct assembler *a, PyObject *consts)
 
 // Remove trailing unused constants.
 static int
-trim_unused_consts(struct assembler *a, PyObject *consts)
+trim_unused_consts(basicblock *entryblock, PyObject *consts)
 {
 assert(PyList_CheckExact(consts));
 
 // The first constant may be docstring; keep it always.
 int max_const_index = 0;
- for (basicblock *b = a->a_entry; b != NULL; b = b->b_next) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 for (int i = 0; i < b->b_iused; i++) {
 if ((b->b_instr[i].i_opcode == LOAD_CONST ||
 b->b_instr[i].i_opcode == KW_NAMES) &&
@@ -9496,15 +9505,15 @@ is_exit_without_lineno(basicblock *b) {
 * copy the line number from the sole predecessor block.
 */
 static int
-duplicate_exits_without_lineno(struct compiler *c)
+duplicate_exits_without_lineno(basicblock *entryblock)
 {
 /* Copy all exit blocks without line number that are targets of a jump.
 */
- for (basicblock *b = c->u->u_blocks; b != NULL; b = b->b_list) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 if (b->b_iused > 0 && is_jump(&b->b_instr[b->b_iused-1])) {
 basicblock *target = b->b_instr[b->b_iused-1].i_target;
 if (is_exit_without_lineno(target) && target->b_predecessors > 1) {
- basicblock *new_target = compiler_copy_block(c, target);
+ basicblock *new_target = copy_basicblock(target);
 if (new_target == NULL) {
 return -1;
 }
@@ -9518,14 +9527,14 @@ duplicate_exits_without_lineno(struct compiler *c)
 }
 }
 /* Eliminate empty blocks */
- for (basicblock *b = c->u->u_blocks; b != NULL; b = b->b_list) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 while (b->b_next && b->b_next->b_iused == 0) {
 b->b_next = b->b_next->b_next;
 }
 }
 /* Any remaining reachable exit blocks without line number can only be reached by
 * fall through, and thus can only have a single predecessor */
- for (basicblock *b = c->u->u_blocks; b != NULL; b = b->b_list) {
+ for (basicblock *b = entryblock; b != NULL; b = b->b_next) {
 if (BB_HAS_FALLTHROUGH(b) && b->b_next && b->b_iused > 0) {
 if (is_exit_without_lineno(b->b_next)) {
 assert(b->b_next->b_iused > 0);

---

• Previous message (by thread): [Python-checkins] gh-94021: Address unreachable code warning in specialize code (GH-94022)
• Next message (by thread): [Python-checkins] gh-93839: Move Lib/ctypes/test/ to Lib/test/test_ctypes/ (#94041)
• Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

---

More information about the Python-checkins mailing list