move common code to cfg and more unbreaking

Author: robertmuth

BE/Base/cfg.cc

@@ -477,4 +477,13 @@ void UnitRemoveUnreachableCode(Unit unit, const std::vector<Fun>& seeds) {
   }
 }
 
+std::vector<Fun> UnitGetEntryPoints(Unit unit) {
+  std::vector<Fun> seeds;
+  Fun fun = UnitFunFind(unit, StrNew("main"));
+  if (!fun.isnull()) seeds.push_back(fun);
+  fun = UnitFunFind(unit, StrNew("_start"));
+  if (!fun.isnull()) seeds.push_back(fun);
+  return seeds;
+}
+
 }  // namespace cwerg::base

BE/Base/cfg.h

@@ -1,6 +1,7 @@
 #pragma once
 // (c) Robert Muth - see LICENSE for more info
 
+#include <vector>
 #include "BE/Base/ir.h"
 
 namespace cwerg::base {
@@ -31,4 +32,6 @@ extern Str NewDerivedBblName(Str orig_name, const char* suffix, Fun fun);
 
 extern void UnitRemoveUnreachableCode(Unit unit, const std::vector<Fun>& seeds);
 
+extern std::vector<Fun> UnitGetEntryPoints(Unit unit);
+
 }  // namespace cwerg

BE/Base/cfg.py

@@ -324,3 +324,8 @@ def UnitRemoveUnreachableCode(unit: ir.Unit, seeds: List[ir.Fun]):
                                 ir.FUN_FLAG.REACHACHABLE not in op.flags):
                             reachable.add(op)
     unit.funs = [f for f in unit.funs if ir.FUN_FLAG.REACHACHABLE in f.flags]
+
+
+def UnitGetEntryPoints(unit: ir.Unit) -> list[ir.Fun]:
+    return [f for f in [unit.fun_syms.get("_start"),
+                        unit.fun_syms.get("main")] if f]

BE/CodeGenA64/codegen.py

@@ -8,10 +8,8 @@
 import stat
 import collections
 
-from BE.Base import cfg
 from BE.Base import ir
 from IR import opcode_tab as o
-from BE.Base import sanity
 from BE.Base import serialize
 
 from BE.CpuA64 import opcode_tab as a64
@@ -26,41 +24,6 @@
 from BE.Elf import elf_unit
 
 
-def LegalizeAll(unit, opt_stats, fout, verbose=False):
-    seeds = [f for f in [unit.fun_syms.get("_start"),
-                         unit.fun_syms.get("main")] if f]
-    if seeds:
-        cfg.UnitRemoveUnreachableCode(unit, seeds)
-    for fun in unit.funs:
-        sanity.FunCheck(fun, unit, check_cfg=False,
-                        check_push_pop=True, check_fallthroughs=False)
-
-        if fun.kind is o.FUN_KIND.NORMAL:
-            legalize.PhaseOptimize(fun, unit, opt_stats, fout)
-
-    for fun in unit.funs:
-        legalize.PhaseLegalizationStep1(fun, unit, opt_stats, fout)
-
-    for fun in unit.funs:
-        legalize.PhaseLegalizationStep2(fun, unit, opt_stats, fout)
-
-
-def RegAllocGlobal(unit, opt_stats, fout, verbose=False):
-    for fun in unit.funs:
-        sanity.FunCheck(fun, unit, check_cfg=False,
-                        check_push_pop=False, check_fallthroughs=False)
-        legalize.PhaseGlobalRegAlloc(fun, opt_stats, fout)
-        if verbose:
-            legalize.DumpFun("after global_reg_alloc", fun)
-
-
-def RegAllocLocal(unit, opt_stats, fout, verbose=False):
-    for fun in unit.funs:
-        legalize.PhaseFinalizeStackAndLocalRegAlloc(fun, opt_stats, fout)
-        if verbose:
-            legalize.DumpFun("after stack finalization", fun)
-
-
 ############################################################
 # textual emitter
 ############################################################
@@ -294,9 +257,9 @@ def main():
         if args.mode == "binary":
             # 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.
-            LegalizeAll(unit, opt_stats, None)
-            RegAllocGlobal(unit, opt_stats, None)
-            RegAllocLocal(unit, opt_stats, None)
+            legalize.LegalizeAll(unit, opt_stats, None)
+            legalize.RegAllocGlobal(unit, opt_stats, None)
+            legalize.RegAllocLocal(unit, opt_stats, None)
             armunit = EmitUnitAsBinary(unit)
             exe = assembler.Assemble(armunit, True)
             exe.save(open(args.output, "wb"))
@@ -307,17 +270,17 @@ def main():
 
         # 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.
-        LegalizeAll(unit, opt_stats, fout)
+        legalize.LegalizeAll(unit, opt_stats, fout)
         if args.mode == "legalize":
             print("\n".join(serialize.UnitRenderToASM(unit)), file=fout)
             return
 
-        RegAllocGlobal(unit, opt_stats, fout)
+        legalize.RegAllocGlobal(unit, opt_stats, fout)
         if args.mode == "reg_alloc_global":
             print("\n".join(serialize.UnitRenderToASM(unit)), file=fout)
             return
 
-        RegAllocLocal(unit, opt_stats, fout)
+        legalize.RegAllocLocal(unit, opt_stats, fout)
         if args.mode == "reg_alloc_local":
             print("\n".join(serialize.UnitRenderToASM(unit)), file=fout)
             return

BE/CodeGenA64/legalize.cc

@@ -363,25 +363,18 @@ void PhaseFinalizeStackAndLocalRegAlloc(Fun fun, Unit unit,
   FunMoveEliminationCpu(fun, &inss);
 }
 
-std::vector<Fun> GetSeeds(Unit unit) {
-  std::vector<Fun> seeds;
-  Fun fun = UnitFunFind(unit, StrNew("main"));
-  if (!fun.isnull()) seeds.push_back(fun);
-  fun = UnitFunFind(unit, StrNew("_start"));
-  if (!fun.isnull()) seeds.push_back(fun);
-  return seeds;
-}
-
 void LegalizeAll(Unit unit, bool verbose, std::ostream* fout) {
-  std::vector<Fun> seeds = GetSeeds(unit);
+  std::vector<Fun> seeds = UnitGetEntryPoints(unit);
   if (!seeds.empty()) UnitRemoveUnreachableCode(unit, seeds);
   for (Fun fun : UnitFunIter(unit)) {
     FunCheck(fun, false, true, false);
     if (FunKind(fun) == FUN_KIND::NORMAL) {
       FunCfgInit(fun);
       FunOptBasic(fun, true);
     }
+  }
 
+  for (Fun fun : UnitFunIter(unit)) {
     PhaseLegalizationStep1(fun, unit, fout);
     PhaseLegalizationStep2(fun, unit, fout);
   }

BE/CodeGenA64/legalize.py

@@ -2,6 +2,7 @@
 import dataclasses
 from typing import List, Dict, Optional, Tuple
 
+from BE.Base import cfg
 from BE.Base import canonicalize
 from BE.Base import reg_alloc
 from BE.Base import ir
@@ -275,7 +276,8 @@ def PhaseLegalizationStep2(fun: ir.Fun, unit: ir.Unit, _opt_stats: Dict[str, int
     # This excludes immediates related to stack offsets which have not been determined yet
     _FunRewriteOutOfBoundsImmediates(fun, unit)
 
-    sanity.FunCheck(fun, None, check_cfg=True, check_push_pop=False, check_fallthroughs=False)
+    sanity.FunCheck(fun, None, check_cfg=True,
+                    check_push_pop=False, check_fallthroughs=False)
     # optimize.FunOptBasic(fun, opt_stats, allow_conv_conversion=False)
 
 
@@ -404,3 +406,37 @@ def PhaseFinalizeStackAndLocalRegAlloc(fun: ir.Fun,
     # cleanup
     _FunMoveEliminationCpu(fun)
     # print ("@@@@@@\n", "\n".join(serialize.FunRenderToAsm(fun)))
+
+
+def LegalizeAll(unit, opt_stats, fout, verbose=False):
+    seeds = cfg.UnitGetEntryPoints(unit)
+    if seeds:
+        cfg.UnitRemoveUnreachableCode(unit, seeds)
+    for fun in unit.funs:
+        sanity.FunCheck(fun, unit, check_cfg=False,
+                        check_push_pop=True, check_fallthroughs=False)
+
+        if fun.kind is o.FUN_KIND.NORMAL:
+            PhaseOptimize(fun, unit, opt_stats, fout)
+
+    for fun in unit.funs:
+        PhaseLegalizationStep1(fun, unit, opt_stats, fout)
+
+    for fun in unit.funs:
+        PhaseLegalizationStep2(fun, unit, opt_stats, fout)
+
+
+def RegAllocGlobal(unit, opt_stats, fout, verbose=False):
+    for fun in unit.funs:
+        sanity.FunCheck(fun, unit, check_cfg=False,
+                        check_push_pop=False, check_fallthroughs=False)
+        PhaseGlobalRegAlloc(fun, opt_stats, fout)
+        if verbose:
+            DumpFun("after global_reg_alloc", fun)
+
+
+def RegAllocLocal(unit, opt_stats, fout, verbose=False):
+    for fun in unit.funs:
+        PhaseFinalizeStackAndLocalRegAlloc(fun, opt_stats, fout)
+        if verbose:
+            DumpFun("after stack finalization", fun)