STORE_FAST_R instead of more STORE_FASTs. Fixed peepholer to not optimize away copies into locals (only tmps)

iritkatriel · iritkatriel · commit 9ff691180c59 · 2023-01-02T20:14:33.000Z
diff --git a/Python/compile.c b/Python/compile.c
@@ -1733,7 +1733,13 @@ compiler_addop_o(struct compiler *c, location loc,
     if (arg < 0) {
         return ERROR;
     }
-    return cfg_builder_addop_i(CFG_BUILDER(c), opcode, arg, loc);
+    if (c->c_regcode && opcode == STORE_FAST) {
+        return cfg_builder_addop(CFG_BUILDER(c), STORE_FAST_R, arg, loc,
+                                 NAME_OPARG(arg), UNUSED_OPARG, UNUSED_OPARG);
+    }
+    else {
+        return cfg_builder_addop_i(CFG_BUILDER(c), opcode, arg, loc);
+    }
 }
 
 static int
@@ -8683,9 +8689,10 @@ makecode(struct compiler *c, struct assembler *a, PyObject *constslist,
     return co;
 }
 
+#define VV 0
 
 /* For debugging purposes only */
-#if 0
+#if VV
 static void
 dump_instr(struct instr *i)
 {
@@ -10054,6 +10061,7 @@ translate_jump_labels_to_targets(basicblock *entryblock)
 }
 
 
+
 static int
 reduce_traffic_between_registers_and_stack(basicblock *b)
 {
@@ -10065,8 +10073,10 @@ reduce_traffic_between_registers_and_stack(basicblock *b)
         }
     }
     bool changed = true;
+    if (VV) fprintf(stderr, "-----------------------------\n");
     while (changed) {
         changed = false;
+        if (VV) dump_basicblock(b);
         for (int i = 0; i < b->b_iused - 1; i++) {
             struct instr *instr = &b->b_instr[i];
             if (instr->i_opcode == LOAD_CONST_R || instr->i_opcode == LOAD_FAST_R) {
@@ -10079,7 +10089,7 @@ reduce_traffic_between_registers_and_stack(basicblock *b)
                 if (next_i < b->b_iused && b->b_instr[next_i].i_opcode == STORE_FAST_R) {
                     struct instr *next = &b->b_instr[next_i];
                     INSTR_SET_OP2(next, COPY_R, 0, instr->i_oparg1, next->i_oparg1);
-                    if (instr->i_opcode == LOAD_CONST_R) {
+                    if (instr->i_opcode == LOAD_CONST_R || instr->i_oparg1.type == TMP_REG) {
                         INSTR_SET_OP0(instr, NOP);
                     }
                     else {
@@ -10089,8 +10099,22 @@ reduce_traffic_between_registers_and_stack(basicblock *b)
                     changed = true;
                 }
             }
+            else if (instr->i_opcode == STORE_FAST_R && instr->i_oparg1.type == TMP_REG) {
+                int next_i = i + 1;
+                while (next_i < b->b_iused && b->b_instr[next_i].i_opcode == NOP) {
+                    next_i++;
+                }
+                if (next_i < b->b_iused && b->b_instr[next_i].i_opcode == LOAD_FAST_R) {
+                    struct instr *next = &b->b_instr[next_i];
+                    if (SAME_REGISTER(instr->i_oparg1, next->i_oparg1)) {
+                        INSTR_SET_OP0(instr, NOP);
+                        INSTR_SET_OP0(next, NOP);
+                    }
+                }
+            }
         }
     }
+    if (VV) dump_basicblock(b);
     return 0;
 }
 
@@ -10106,7 +10130,13 @@ propagate_register_copies(basicblock *b)
                 struct instr *next = &b->b_instr[j];
                 /* These should all be reads, because SSA */
                 if (SAME_REGISTER(next->i_oparg1, dst)) {
-                    next->i_oparg1 = src;
+                    if (next->i_opcode == CHECK_FAST_R && src.type == TMP_REG) {
+                        INSTR_SET_OP0(next, NOP);  /* no need to check tmps */
+                    }
+                    else if (next->i_opcode != LOAD_FAST_R &&
+                             next->i_opcode != LOAD_CONST_R) {
+                        next->i_oparg1 = src;
+                    }
                 }
                 if (SAME_REGISTER(next->i_oparg2, dst)) {
                     next->i_oparg2 = src;
@@ -10115,9 +10145,16 @@ propagate_register_copies(basicblock *b)
                     next->i_oparg3 = src;
                 }
             }
-            INSTR_SET_OP0(instr, NOP);
+            if (dst.type == TMP_REG) {
+                INSTR_SET_OP0(instr, NOP);
+            }
         }
     }
+
+    if (VV) {
+        fprintf(stderr, "after propagate_register_copies:\n");
+        dump_basicblock(b);
+    }
     return 0;
 }
 

Original file line number	Diff line number	Diff line change
`@@ -1733,7 +1733,13 @@ compiler_addop_o(struct compiler *c, location loc,`
`1733`	`1733`	`if (arg < 0) {`
`1734`	`1734`	`return ERROR;`
`1735`	`1735`	`}`
`1736`		`- return cfg_builder_addop_i(CFG_BUILDER(c), opcode, arg, loc);`
	`1736`	`+ if (c->c_regcode && opcode == STORE_FAST) {`
	`1737`	`+ return cfg_builder_addop(CFG_BUILDER(c), STORE_FAST_R, arg, loc,`
	`1738`	`+ NAME_OPARG(arg), UNUSED_OPARG, UNUSED_OPARG);`
	`1739`	`+ }`
	`1740`	`+ else {`
	`1741`	`+ return cfg_builder_addop_i(CFG_BUILDER(c), opcode, arg, loc);`
	`1742`	`+ }`
`1737`	`1743`	`}`
`1738`	`1744`
`1739`	`1745`	`static int`
`@@ -8683,9 +8689,10 @@ makecode(struct compiler c, struct assembler a, PyObject *constslist,`
`8683`	`8689`	`return co;`
`8684`	`8690`	`}`
`8685`	`8691`
	`8692`	`+#define VV 0`
`8686`	`8693`
`8687`	`8694`	`/* For debugging purposes only */`
`8688`		`-#if 0`
	`8695`	`+#if VV`
`8689`	`8696`	`static void`
`8690`	`8697`	`dump_instr(struct instr *i)`
`8691`	`8698`	`{`
`@@ -10054,6 +10061,7 @@ translate_jump_labels_to_targets(basicblock *entryblock)`
`10054`	`10061`	`}`
`10055`	`10062`
`10056`	`10063`
	`10064`	`+`
`10057`	`10065`	`static int`
`10058`	`10066`	`reduce_traffic_between_registers_and_stack(basicblock *b)`
`10059`	`10067`	`{`
`@@ -10065,8 +10073,10 @@ reduce_traffic_between_registers_and_stack(basicblock *b)`
`10065`	`10073`	`}`
`10066`	`10074`	`}`
`10067`	`10075`	`bool changed = true;`
	`10076`	`+ if (VV) fprintf(stderr, "-----------------------------\n");`
`10068`	`10077`	`while (changed) {`
`10069`	`10078`	`changed = false;`
	`10079`	`+ if (VV) dump_basicblock(b);`
`10070`	`10080`	`for (int i = 0; i < b->b_iused - 1; i++) {`
`10071`	`10081`	`struct instr *instr = &b->b_instr[i];`
`10072`	`10082`	`if (instr->i_opcode == LOAD_CONST_R \|\| instr->i_opcode == LOAD_FAST_R) {`
`@@ -10079,7 +10089,7 @@ reduce_traffic_between_registers_and_stack(basicblock *b)`
`10079`	`10089`	`if (next_i < b->b_iused && b->b_instr[next_i].i_opcode == STORE_FAST_R) {`
`10080`	`10090`	`struct instr *next = &b->b_instr[next_i];`
`10081`	`10091`	`INSTR_SET_OP2(next, COPY_R, 0, instr->i_oparg1, next->i_oparg1);`
`10082`		`- if (instr->i_opcode == LOAD_CONST_R) {`
	`10092`	`+ if (instr->i_opcode == LOAD_CONST_R \|\| instr->i_oparg1.type == TMP_REG) {`
`10083`	`10093`	`INSTR_SET_OP0(instr, NOP);`
`10084`	`10094`	`}`
`10085`	`10095`	`else {`
`@@ -10089,8 +10099,22 @@ reduce_traffic_between_registers_and_stack(basicblock *b)`
`10089`	`10099`	`changed = true;`
`10090`	`10100`	`}`
`10091`	`10101`	`}`
	`10102`	`+ else if (instr->i_opcode == STORE_FAST_R && instr->i_oparg1.type == TMP_REG) {`
	`10103`	`+ int next_i = i + 1;`
	`10104`	`+ while (next_i < b->b_iused && b->b_instr[next_i].i_opcode == NOP) {`
	`10105`	`+ next_i++;`
	`10106`	`+ }`
	`10107`	`+ if (next_i < b->b_iused && b->b_instr[next_i].i_opcode == LOAD_FAST_R) {`
	`10108`	`+ struct instr *next = &b->b_instr[next_i];`
	`10109`	`+ if (SAME_REGISTER(instr->i_oparg1, next->i_oparg1)) {`
	`10110`	`+ INSTR_SET_OP0(instr, NOP);`
	`10111`	`+ INSTR_SET_OP0(next, NOP);`
	`10112`	`+ }`
	`10113`	`+ }`
	`10114`	`+ }`
`10092`	`10115`	`}`
`10093`	`10116`	`}`
	`10117`	`+ if (VV) dump_basicblock(b);`
`10094`	`10118`	`return 0;`
`10095`	`10119`	`}`
`10096`	`10120`
`@@ -10106,7 +10130,13 @@ propagate_register_copies(basicblock *b)`
`10106`	`10130`	`struct instr *next = &b->b_instr[j];`
`10107`	`10131`	`/* These should all be reads, because SSA */`
`10108`	`10132`	`if (SAME_REGISTER(next->i_oparg1, dst)) {`
`10109`		`- next->i_oparg1 = src;`
	`10133`	`+ if (next->i_opcode == CHECK_FAST_R && src.type == TMP_REG) {`
	`10134`	`+ INSTR_SET_OP0(next, NOP); /* no need to check tmps */`
	`10135`	`+ }`
	`10136`	`+ else if (next->i_opcode != LOAD_FAST_R &&`
	`10137`	`+ next->i_opcode != LOAD_CONST_R) {`
	`10138`	`+ next->i_oparg1 = src;`
	`10139`	`+ }`
`10110`	`10140`	`}`
`10111`	`10141`	`if (SAME_REGISTER(next->i_oparg2, dst)) {`
`10112`	`10142`	`next->i_oparg2 = src;`
`@@ -10115,9 +10145,16 @@ propagate_register_copies(basicblock *b)`
`10115`	`10145`	`next->i_oparg3 = src;`
`10116`	`10146`	`}`
`10117`	`10147`	`}`
`10118`		`- INSTR_SET_OP0(instr, NOP);`
	`10148`	`+ if (dst.type == TMP_REG) {`
	`10149`	`+ INSTR_SET_OP0(instr, NOP);`
	`10150`	`+ }`
`10119`	`10151`	`}`
`10120`	`10152`	`}`
	`10153`	`+`
	`10154`	`+ if (VV) {`
	`10155`	`+ fprintf(stderr, "after propagate_register_copies:\n");`
	`10156`	`+ dump_basicblock(b);`
	`10157`	`+ }`
`10121`	`10158`	`return 0;`
`10122`	`10159`	`}`
`10123`	`10160`