Run register renaming pass after receiving the info which pc's should be

moved past side exits. Otherwise it is not safe to copy those
instructions.
Ideally, this approach is just as good as a more fine-grained appraoch,
assuming that the register allocation "nops" the non-exploited renames.

1 files changed, 45 insertions, 9 deletions

diff --git a/scheduling/MyRTLpathScheduleraux.ml b/scheduling/MyRTLpathScheduleraux.ml
index 7e0e5838..fd5583bd 100644
--- a/scheduling/MyRTLpathScheduleraux.ml
+++ b/scheduling/MyRTLpathScheduleraux.ml
@@ -869,7 +869,7 @@ let downschedule_compensation_code sb code pm live_renames ~next_free_pc ~next_f
   in
 
   debug_flag := old_debug_flag;
-  (to_insert, to_rename, code)
+  to_insert_pcs
 
 let my_merge_no_overwrite m1 m2 =
   PTree.combine (fun x y -> match (x, y) with
@@ -1201,20 +1201,56 @@ let scheduler f =
   (* TODO: Insert final restoration code before downschedule_compensation_code *)
 
   (* WARNING: mutation *)
-  let code = ref code in
-  let sb_tocompensate_liverenames =
+  let sb_tocompensatepcs_liverenames =
     ListLabels.map sb_renamings
     ~f:(fun (sb, live_renames) ->
-      let (to_insert_compensation, _to_rename, code') =
+      let (to_insert_compensation_pcs, live_renames) =
         if !Clflags.option_prepass_past_side_exits then
-          downschedule_compensation_code sb !code pm live_renames ~next_free_pc ~next_free_reg
+          (downschedule_compensation_code sb code pm live_renames ~next_free_pc ~next_free_reg
+          , live_renames )
         else
-          (InsertPositionMap.empty, Regset.empty, !code)
+          (InsertPositionMap.empty, live_renames)
+        in
+      (sb, to_insert_compensation_pcs, live_renames ) )
+  in
+
+  let (sb_tocompensate_liverenames, code, next_free_reg) = ListLabels.fold_left sb_tocompensatepcs_liverenames
+    ~init:([], code, next_free_reg)
+    ~f:(fun (sbs, code, next_free_reg) (sb, to_compensate_pcs, live_renames) ->
+      if !Clflags.option_fpoormansssa then (
+        let to_compensate = InsertPositionMap.map (fun pcs ->
+          let insts = List.map (fun pc -> get_some @@ PTree.get pc code) pcs in
+          insts)
+          to_compensate_pcs
+        in
+        let code = InsertPositionMap.fold
+          (fun _pos pcs code->
+            List.fold_left (fun code pc -> PTree.set pc (Inop Camlcoq.P.one) code)
+              code
+              pcs)
+          to_compensate_pcs
+          code
+        in
+        ((sb, to_compensate, live_renames)::sbs, code, next_free_reg)
+      ) else (
+        assert (PTree.elements live_renames |> List.for_all (fun (_, l) -> l = []));
+        let pi = get_some @@ PTree.get sb.instructions.(0) pm in
+        let (code, live_renames, next_free_reg) = local_single_assignment sb code pi.input_regs ~next_free_reg in
+        let to_compensate = InsertPositionMap.map (fun pcs ->
+          let insts = List.map (fun pc -> get_some @@ PTree.get pc code) pcs in
+          insts)
+          to_compensate_pcs
+        in
+        let code = InsertPositionMap.fold
+          (fun _pos pcs code->
+            List.fold_left (fun code pc -> PTree.set pc (Inop Camlcoq.P.one) code)
+              code
+              pcs)
+          to_compensate_pcs
+          code
         in
-      code := code';
-      (sb, to_insert_compensation, live_renames) )
+        ((sb, to_compensate, live_renames)::sbs, code, next_free_reg) ))
   in
-  let code = !code in
 
   (* Insert the compensation code (downward scheduling) and update the restoration code
    * information to reflect the new pcs. *)