From bc55ddf11821f9812bd6bc2e516a6e38c2045c61 Mon Sep 17 00:00:00 2001
From: static <kmc7468@naver.com>
Date: Thu, 8 May 2025 11:15:59 +0000
Subject: [PATCH] HW3 (4)

---
 src/opt/simplify_cfg.rs | 61 +++++++++++++----------------------------
 1 file changed, 19 insertions(+), 42 deletions(-)

diff --git a/src/opt/simplify_cfg.rs b/src/opt/simplify_cfg.rs
index a3764c9..7810e88 100644
--- a/src/opt/simplify_cfg.rs
+++ b/src/opt/simplify_cfg.rs
@@ -77,35 +77,20 @@ impl Optimize<FunctionDefinition> for SimplifyCfgMerge {
             }
         }
 
-        let mut merged_from = HashMap::new();
         let mut merged_to = HashMap::new();
         let mut replaces = HashMap::new();
 
         for (bid_from, block_from) in &code.blocks {
             if let BlockExit::Jump { arg } = &block_from.exit {
                 let bid_to = arg.bid;
-                if *bid_from != bid_to && indegrees.get(&bid_to) == Some(&1) {
-                    let bid_from = *merged_to.get(bid_from).unwrap_or(bid_from);
-                    merged_from
-                        .entry(bid_from)
-                        .or_insert(Vec::new())
-                        .push(bid_to);
-                    let _ = merged_to.insert(bid_to, bid_from);
-
-                    if let Some(mut bids_merged) = merged_from.remove(&bid_to) {
-                        merged_from
-                            .get_mut(&bid_from)
-                            .unwrap()
-                            .append(&mut bids_merged);
-                        merged_to.values_mut().for_each(|merged_to| {
-                            if *merged_to == bid_to {
-                                *merged_to = bid_from;
-                            }
-                        });
-                    }
-
+                if *bid_from != bid_to
+                    && !merged_to.contains_key(bid_from)
+                    && indegrees.get(&bid_to) == Some(&1)
+                {
                     let block_to = &code.blocks[&bid_to];
-                    for (i, (a, p)) in izip!(&arg.args, block_to.phinodes.iter()).enumerate() {
+                    let _ = merged_to.insert(bid_to, *bid_from);
+
+                    for (i, (a, p)) in izip!(&arg.args, &block_to.phinodes).enumerate() {
                         let from = RegisterId::arg(bid_to, i);
                         let _unused = replaces.insert(from, a.clone());
                     }
@@ -113,30 +98,22 @@ impl Optimize<FunctionDefinition> for SimplifyCfgMerge {
             }
         }
 
-        for (bid_merge_to, bids_merge_from) in &merged_from {
-            let blocks_merge_from = bids_merge_from
-                .iter()
-                .map(|bid| code.blocks.get(bid).unwrap().clone())
-                .collect::<Vec<_>>();
-            let block_merge_to = code.blocks.get_mut(bid_merge_to).unwrap();
-            let mut i = block_merge_to.instructions.len();
+        for (bid_to, bid_from) in &merged_to {
+            let block_to = code.blocks.remove(bid_to).unwrap();
+            let block_from = code.blocks.get_mut(bid_from).unwrap();
+            let len = block_from.instructions.len();
 
-            for (bid, block) in bids_merge_from.iter().zip(blocks_merge_from) {
-                for (j, inst) in block.instructions.iter().enumerate() {
-                    let dtype = inst.dtype();
-                    block_merge_to.instructions.push(inst.clone());
+            for (i, inst) in block_to.instructions.into_iter().enumerate() {
+                let dtype = inst.dtype();
+                block_from.instructions.push(inst);
 
-                    let from = RegisterId::temp(*bid, j);
-                    let to = Operand::register(RegisterId::temp(*bid_merge_to, i), dtype);
-                    let _unused = replaces.insert(from, to);
-                    i += 1;
-                }
-
-                block_merge_to.exit = block.exit;
+                let from = RegisterId::temp(*bid_to, i);
+                let to = Operand::register(RegisterId::temp(*bid_from, len + i), dtype);
+                let _unused = replaces.insert(from, to);
             }
-        }
 
-        code.blocks.retain(|bid, _| !merged_to.contains_key(bid));
+            block_from.exit = block_to.exit;
+        }
 
         for (bid, block) in &mut code.blocks {
             for inst in block.instructions.iter_mut() {