factor out an 'optimize' phase for the X64 backend

Author: robertmuth

BE/CodeGenX64/Makefile_cc

@@ -84,6 +84,7 @@ $(DIR)/isel_test_c: isel_gen.h isel_gen.cc
 
 TEST_MODE = normal
 #TEST_MODE = legalize
+#TEST_MODE = optimize
 #TEST_MODE = reg_alloc_global
 #TEST_MODE = reg_alloc_local
 #TEST_MODE = binary

BE/CodeGenX64/codegen.py

@@ -247,7 +247,7 @@ def EmitUnitAsBinary(unit: ir.Unit) -> elf_unit.Unit:
     import sys
     import argparse
 
-    _ALLOWED_MODES = {"normal", "binary", "legalize", "reg_alloc_global",
+    _ALLOWED_MODES = {"normal", "binary", "optimize", "legalize", "reg_alloc_global",
                       "reg_alloc_local"}
 
     def main():
@@ -284,6 +284,11 @@ def main():
 
         fout = sys.stdout if args.output == "-" else open(args.output, "w")
 
+        legalize.OptimizeAll(unit, opt_stats)
+        if args.mode == "optimize":
+            print("\n".join(serialize.UnitRenderToASM(unit)), file=fout)
+            return
+
         # we need to legalize all functions first as this may change the signature
         # and fills in cpu reg usage which is used by subsequent interprocedural opts.
         legalize.LegalizeAll(unit, opt_stats)

BE/CodeGenX64/codegen_tool.cc

@@ -168,6 +168,12 @@ int main(int argc, const char* argv[]) {
     return 0;
   }
 
+  OptimizeAll(unit, false, log);
+  if (sw_mode.Value() == "optimize") {
+    UnitRenderToAsm(unit, fout);
+    return 0;
+  }
+
   LegalizeAll(unit, false, log);
   if (sw_mode.Value() == "legalize") {
     UnitRenderToAsm(unit, fout);

BE/CodeGenX64/legalize.cc

@@ -532,7 +532,7 @@ void PhaseFinalizeStackAndLocalRegAlloc(Fun fun, Unit unit,
   FunMoveEliminationCpu(fun, &inss);
 }
 
-void LegalizeAll(Unit unit, bool verbose, std::ostream* fout) {
+void OptimizeAll(Unit unit, bool verbose, std::ostream* fout) {
   std::vector<Fun> seeds;
   Fun fun = UnitFunFind(unit, StrNew("main"));
   if (!fun.isnull()) seeds.push_back(fun);
@@ -545,7 +545,11 @@ void LegalizeAll(Unit unit, bool verbose, std::ostream* fout) {
       FunCfgInit(fun);
       FunOptBasic(fun, true);
     }
+  }
+}
 
+void LegalizeAll(Unit unit, bool verbose, std::ostream* fout) {
+  for (Fun fun : UnitFunIter(unit)) {
     FunCheck(fun);
     PhaseLegalization(fun, unit, fout);
   }

BE/CodeGenX64/legalize.h

@@ -21,6 +21,8 @@ extern void PhaseFinalizeStackAndLocalRegAlloc(base::Fun fun,
                                                base::Unit unit,
                                                std::ostream* fout);
 
+                                               void OptimizeAll(base::Unit unit, bool verbose, std::ostream* fout);
+
 void LegalizeAll(base::Unit unit, bool verbose, std::ostream* fout);
 
 void RegAllocGlobal(base::Unit unit, bool verbose, std::ostream* fout);

BE/CodeGenX64/legalize.py

@@ -267,7 +267,7 @@ def PhaseLegalization(fun: ir.Fun, unit: ir.Unit, _opt_stats: Dict[str, int]):
     # optimize.FunOptBasic(fun, opt_stats, allow_conv_conversion=False)
 
 
-def LegalizeAll(unit, opt_stats):
+def OptimizeAll(unit, opt_stats):
     seeds = [f for f in [unit.fun_syms.get("_start"),
                          unit.fun_syms.get("main")] if f]
     if seeds:
@@ -279,8 +279,9 @@ def LegalizeAll(unit, opt_stats):
             optimize.FunCfgInit(fun, unit)
             optimize.FunOptBasic(fun, opt_stats, allow_conv_conversion=True)
 
+
+def LegalizeAll(unit, opt_stats):
     for fun in unit.funs:
-        # pass
         PhaseLegalization(fun, unit, opt_stats)