ir: remove instructions marked as None, fix crash in print

bvdberg · bvdberg · commit d4903f8d711d · 2025-06-21T07:52:33.000+02:00
diff --git a/ir/context.c2 b/ir/context.c2
@@ -53,6 +53,7 @@ public type Context struct @(opaque) {
     RevList revlist;
     instr_inserter.InstrInserter inserter;
     bit_array.BitArray active_blocks;
+    CopyList copies;
 }
 
 public fn Context* create() {
@@ -69,10 +70,12 @@ public fn Context* create() {
     c.collector.create();
     c.revlist.create(256);
     c.inserter.create();
+    c.copies.init(1024);
     return c;
 }
 
 public fn void Context.free(Context* c) {
+    c.copies.free();
     c.inserter.free();
     c.revlist.free();
     c.collector.free();
@@ -557,15 +560,18 @@ fn void Context.finalizeFunction(Context* c, SymbolId id) {
     c.tmp_info.num_slots = cast<u16>(c.slot_idx);
 
     const char* name = c.pool.idx2str(s.name);
+    bool print = false;
 
     //c.dump_function(c.tmp_info, name);
-    //c.print_function(id, c.tmp_info);
+    // causes crash
+    if (print) c.print_function(id, c.tmp_info, "after generation");
 
     // prune unused and empty blocks, possible convert jmp_if to jmp
     c.checkDest(0);
 
     //c.dump_function(c.tmp_info, name);
-    //c.print_function(id, c.tmp_info);
+    // causes crash
+    if (print) c.print_function(id, c.tmp_info, "after check dest");
 
     // move used blocks to new list, drop unused blocks
 
@@ -679,16 +685,22 @@ fn void Context.finalizeFunction(Context* c, SymbolId id) {
 
     //c.dump_function(fi2, name);
     //c.generate_graphviz(fi2, name);
-    //c.print_function(id, fi2);
+    if (print) c.print_function(id, fi2, "after reorder");
 
-    c.create_ssa(fi2, name);
+    c.create_ssa(id, fi2, name, print);
 
-    if (c.inserter.needsFixup()) c.fixup_function(fi2);
+    if (print) c.print_function(id, fi2, "after create SSA");
+    if (c.inserter.needsFixup()) {
+        c.fixup_function(fi2);
+        if (print) c.print_function(id, fi2, "after fixup");
+    }
 
-    //c.print_function(id, fi2);
     c.eliminateCopies(fi2);
     //c.dump_function(fi2, name);
-    //c.print_function(id, fi2);
+    if (print) c.print_function(id, fi2, "after eliminate copies");
+
+    c.removeNone(fi2);
+    if (print) c.print_function(id, fi2, "remove none");
 }
 
 fn bool empty_block(const Block* b, const InstrList* instructions) {
diff --git a/ir/copy_list.c2 b/ir/copy_list.c2
@@ -0,0 +1,72 @@
+/* Copyright 2022-2025 Bas van den Berg
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+module ir;
+
+import stdlib local;
+import string local;
+
+type CopyInfo struct {
+    u32 instr_idx;
+    Ref ref;
+}
+
+type CopyList struct {
+    CopyInfo* copies;
+    u32 count;
+    u32 capacity;
+}
+
+fn void CopyList.init(CopyList* l, u32 capacity) {
+    l.count = 0;
+    l.resize(capacity);
+}
+
+fn void CopyList.resize(CopyList* l, u32 capacity) {
+    l.capacity = capacity;
+    CopyInfo* copies2 = malloc(capacity * sizeof(CopyInfo));
+    if (l.count) {
+        memcpy(copies2, l.copies, l.count * sizeof(CopyInfo));
+        free(l.copies);
+    }
+    l.copies = copies2;
+}
+
+fn void CopyList.free(CopyList* l) {
+    free(l.copies);
+}
+
+fn void CopyList.clear(CopyList* l) {
+    l.count = 0;
+}
+
+fn void CopyList.add(CopyList* l, u32 idx, Ref ref) {
+    if (l.count == l.capacity) l.resize(l.capacity * 2);
+
+    CopyInfo* info = &l.copies[l.count];
+    info.instr_idx = idx;
+    info.ref = ref;
+    l.count++;
+
+}
+
+fn Ref* CopyList.find(CopyList* l, u32 idx) {
+    // TODO can do binary search (since instr_idxs are ordered)
+    for (u32 i=0; i<l.count; i++) {
+        if (l.copies[i].instr_idx == idx) return &l.copies[i].ref;
+    }
+    return nil;
+}
+
diff --git a/ir/print.c2 b/ir/print.c2
@@ -174,15 +174,15 @@ fn void PrintHelper.print_func(PrintHelper* ph, const Symbol* s, const FunctionI
     ph.collect_temps();
 
     const Block* blks = ph.blocks.get(0);
-    u32 last = 0;
+    u32 max = 0;
     for (u32 i=0; i<num_blks; i++) {
         ph.cur_block = &blks[i];
         const Block* b = ph.cur_block;
         out.color(color.Yellow);
         out.print("%s.%d:", b.getKindName(), i);
         if (!b.used) {
             out.color(color.Grey);
-            out.add(" unused");
+            out.add("  # unused");
         }
         Index i_idx = b.getInstructions();
 #if DebugIr
@@ -202,29 +202,36 @@ fn void PrintHelper.print_func(PrintHelper* ph, const Symbol* s, const FunctionI
         for (u32 j=0; j<i_idx.count; j++) {
             ph.printInstr(instrs, j, i_idx.start + j);
         }
-        last = i_idx.start + i_idx.count;
+        u32 last = i_idx.start + i_idx.count;
+        if (last > max) max = last;
         ph.cur_block = nil;
     }
 
     // there can be inserted, trailing instructions (outside any block)
     u32 instr_count = info.instructions.getCount();
-    if (last != instr_count) {
+    if (max != instr_count) {
         out.color(col_Fixup);
-        out.print("Inserted (%d)\n", instr_count - last);
+        out.print("Inserted (%d)\n", instr_count - max);
         const Instr* instrs = info.instructions.get(0);
-        while (last != instr_count) {
-            ph.printInstr(instrs, last, last);
-            last++;
+        while (max != instr_count) {
+            ph.printInstr(instrs, max, max);
+            max++;
         }
     }
 
     out.color(color.Normal);
-    out.add("}\n\n");
+    out.add("}\n");
 }
 
-fn void Context.print_function(const Context* c, SymbolId id, const FunctionInfo* info) @(unused) {
+fn void Context.print_function(const Context* c,
+                               SymbolId id,
+                               const FunctionInfo* info,
+                               const char* version) @(unused) {
     PrintHelper ph.init(c);
 
+    ph.out.add("------ ");
+    ph.out.add(version);
+    ph.out.add(" ------\n");
     ph.print_func(c.symbols.get(id), info);
 
     ph.print();
@@ -241,6 +248,7 @@ public fn void Context.print(const Context* c) {
         if (s.is_function) {
             if (prev_is_var) out.newline();
             ph.print_func(s, s.f.info);
+            out.newline();
         } else {
             if (s.is_external) {
                 out.color(col_Attr);
@@ -458,6 +466,7 @@ fn void PrintHelper.printRef(PrintHelper* ph, Ref r, bool print_type) {
 #endif
         break;
     case JmpDest:
+        assert(ph.cur_block);
         const Block* b = ph.cur_block;
         out.color(col_Block);
         assert(b.dests[0]);
diff --git a/ir/slot_collector.c2 b/ir/slot_collector.c2
@@ -16,7 +16,7 @@
 module ir;
 
 import stdlib;
-import string;
+import string local;
 import stdio local;
 
 type ReadSlotAccess struct {
@@ -59,7 +59,7 @@ fn BlockIndex* SlotCollector.getBlock(const SlotCollector* c, BlockId blk_id) {
 }
 
 fn void SlotCollector.create(SlotCollector* c) {
-    string.memset(c, 0, sizeof(SlotCollector));
+    memset(c, 0, sizeof(SlotCollector));
     // TEMP hardcoded max
     c.reads = stdlib.malloc(SlotMax * sizeof(ReadSlotAccess));
     c.writes = stdlib.malloc(SlotMax * sizeof(WriteSlotAccess));
@@ -209,7 +209,7 @@ fn void SlotCollector.insertWrite(SlotCollector* c, BlockId blk_id, u16 slot, Re
     BlockIndex* bi = &c.indexes[blk_id];
     assert(c.write_idx + bi.wr_count + 1 < SlotMax);
     if (bi.wr_count) {
-        string.memcpy(&c.writes[c.write_idx], &c.writes[bi.wr_start], bi.wr_count * sizeof(WriteSlotAccess));
+        memcpy(&c.writes[c.write_idx], &c.writes[bi.wr_start], bi.wr_count * sizeof(WriteSlotAccess));
     }
     bi.wr_start = cast<u16>(c.write_idx);
     c.write_idx += bi.wr_count;
@@ -223,13 +223,14 @@ fn void SlotCollector.insertWrite(SlotCollector* c, BlockId blk_id, u16 slot, Re
     if (c.write_idx > c.num_writes + 200) c.defragWrites();
 }
 
+// when adding writes, they are copied to tail, so gaps appear. Defrag removes these
 fn void SlotCollector.defragWrites(SlotCollector* c) {
     u16 out_idx = 0;
     for (u32 i=0; i<c.num_blocks; i++) {
         BlockIndex* bi = &c.indexes[i];
         if (bi.wr_count == 0) continue;
 
-        string.memcpy(&c.writes2[out_idx], &c.writes[bi.wr_start], bi.wr_count * sizeof(WriteSlotAccess));
+        memcpy(&c.writes2[out_idx], &c.writes[bi.wr_start], bi.wr_count * sizeof(WriteSlotAccess));
         bi.wr_start = out_idx;
         out_idx += bi.wr_count;
     }
diff --git a/ir/ssa.c2 b/ir/ssa.c2
diff --git a/recipe.txt b/recipe.txt
