ir: added usage counter (not used yet)

Author: bvdberg

ir/context.c2

@@ -20,6 +20,7 @@ import index_list;
 import instr_inserter;
 import lookup_table;
 import string_pool;
+import usage_counter;
 
 import stdlib;
 import string;
@@ -54,6 +55,7 @@ public type Context struct @(opaque) {
     instr_inserter.InstrInserter inserter;
     bit_array.BitArray active_blocks;
     CopyList copies;
+    usage_counter.Counter usage;
 }
 
 public fn Context* create() {
@@ -71,10 +73,12 @@ public fn Context* create() {
     c.revlist.create(256);
     c.inserter.create();
     c.copies.init(1024);
+    c.usage.init(1024);
     return c;
 }
 
 public fn void Context.free(Context* c) {
+    c.usage.free();
     c.copies.free();
     c.inserter.free();
     c.revlist.free();
@@ -700,6 +704,13 @@ fn void Context.finalizeFunction(Context* c, SymbolId id) {
     //c.dump_function(fi2, name);
     if (print) c.print_function(id, fi2, "after eliminate copies");
 
+
+    //c.propagateConstants(fi2);
+    //if (print) c.print_function(id, fi2, "after propagate constants");
+    c.fillUsage(fi2);
+    //if (print) c.print_function(id, fi2, "after fill usage");
+
+
     c.removeNone(fi2);
     if (print) c.print_function(id, fi2, "after remove none");
 }

ir/instr.c2

@@ -118,6 +118,11 @@ fn bool Instr.isCopy(const Instr* i) {
     return k == InstrKind.Copy;
 }
 
+fn bool Instr.isArithmetic(const Instr* i) @(unused) {
+    InstrKind k = i.getKind();
+    return k >= InstrKind.Add && k <= InstrKind.Shl;
+}
+
 fn bool Instr.isLoad(const Instr* i) {
     InstrKind k = i.getKind();
     return k >= InstrKind.Load1 && k <= InstrKind.Load8;

ir/instr_kind.c2

@@ -15,29 +15,19 @@
 
 module ir;
 
-// NOTE keep in same order as Token!
 public type InstrKind enum u8 {
     None,   // used when removing instructions
 
     // Arithmetic and Bits
-    //Neg,     // KEEP THIS THE FIRST OPERATION!
     Add,
     Sub,
     Div,
     Rem,
-#if 0
-    Udiv,
-    Fdiv,
-    Urem,
-#endif
     Mul,
     IDiv,
     And,
     Or,
     Xor,
-#if 0
-    Sar,
-#endif
     Shr,
     Shl,
 
@@ -48,45 +38,6 @@ public type InstrKind enum u8 {
     CmpGt,
     CmpLe,
     CmpGe,
-#if 0
-    Ceqd,
-    Ceql,
-    Ceqs,
-    Ceqw,
-    Cged,
-    Cges,
-    Cgtd,
-    Cgts,
-    Cled,
-    Cles,
-    Cltd,
-    Clts,
-    Cned,
-    Cnel,
-    Cnes,
-    Cnew,
-    Cod,
-    Cos,
-    Csgel,
-    Csgew,
-    Csgtl,
-    Csgtw,
-    Cslel,
-    Cslew,
-    Csltl,
-    Csltw,
-    Cugel,
-    Cugew,
-    Cugtl,
-    Cugtw,
-    Culel,
-    Culew,
-    Cultl,
-    Cultw,
-    Cuod,
-    Cuos,
-
-#endif
     // Memory
     Load1,
     Load2,
@@ -96,97 +47,11 @@ public type InstrKind enum u8 {
     Store2,
     Store4,
     Store8,
-#if 0
-    // Extensions and Truncations
-    Cast,
-    Dtosi,
-    Dtoui,
-    Exts,
-    Extsb,
-    Extsh,
-    Extsw,
-    Extub,
-    Extuh,
-    Extuw,
-    Sltof,
-    Stosi,       // single to signed integer
-    Stoui,       // single to unsigned integer
-    Swtof,
-    Truncd,      // truncate double
-    Ultof,
-    Uwtof,
-
     // Stack Allocation
-#endif
     Alloc1,
     Alloc2,
     Alloc4,
     Alloc8,
-#if 0
-    Alloc16,
-
-    // Variadic Function Helpers
-    Copy,
-    Vaarg,
-    Vastart,
-
-    // Miscellaneous and Architecture-Specific Operations
-    Acmn,
-    Acmp,
-    Addr,
-    Afcmp,
-    Blit,
-    Blit0,
-    Blit1,
-    Nop,
-    Reqz,
-    Rnez,
-    Salloc,
-    Sign,
-    Swap,
-    Xcmp,
-    Xdiv,
-    Xidiv,
-    Xtest,
-
-    // Arguments, Parameters, and Calls
-    Arg,
-    Argc,
-    Arge,
-    Argsb,
-    Argsh,
-    Argub,
-    Arguh,
-    Argv,
-
-    Par,
-    Parc,
-    Pare,
-    Parsb,
-    Parsh,
-    Parub,
-    Paruh,
-
-    // Flags Setting
-    Flagfeq,
-    Flagfge,
-    Flagfgt,
-    Flagfle,
-    Flagflt,
-    Flagfne,
-    Flagfo,
-    Flagfuo,
-    Flagieq,
-    Flagine,
-    Flagisge,
-    Flagisgt,
-    Flagisle,
-    Flagislt,
-    Flagiuge,
-    Flagiugt,
-    Flagiule,
-    Flagiult,
-#endif
     // Jump instructions
     Jmp,
     JmpIf,

ir/print.c2

@@ -542,9 +542,9 @@ fn void dump_function_info(string_buffer.Buf* out, const FunctionInfo* info) @(u
     const Instr* instr = info.instructions.get(0);
     for (u32 i=0; i<info.instructions.getCount(); i++) {
         const Instr* r = &instr[i];
-        out.print("    [%3d] %7s", i, r.getKindName());
+        out.print("    [%3d] %c  %7s", i, r.hasResult() ? 'r' : ' ', r.getKindName());
         if (r.isPhi()) {
-            out.print("  clauses: start %d  count %d", r.phi_clauses.start, r.phi_clauses.count);
+            out.print("  clauses %d-%d", r.phi_clauses.start, r.phi_clauses.start + r.phi_clauses.count - 1);
         } else {
             out.print("  %8s %3d  ", r.args[0].getKindName(), r.args[0].value);
             out.print("  %8s %3d", r.args[01].getKindName(), r.args[1].value);
@@ -605,20 +605,24 @@ public fn void Context.dump(const Context* c) @(unused) {
     }
     out.newline();
 
-    out.print("constants: (%d)\n", c.constants.getCount());
-    for (u32 i=0; i<c.constants.getCount(); i++) {
-        const Constant* con = c.constants.get(i);
-        // TODO need to know type, for now print as ivalue
-        out.print("  [%2d] %d\n", i, con.ivalue);
+    if (c.constants.getCount()) {
+        out.print("constants: (%d)\n", c.constants.getCount());
+        for (u32 i=0; i<c.constants.getCount(); i++) {
+            const Constant* con = c.constants.get(i);
+            // TODO need to know type, for now print as ivalue
+            out.print("  [%2d] %d\n", i, con.ivalue);
+        }
+        out.newline();
     }
-    out.newline();
 
-    out.print("init values: (%d)\n", c.init_values.getCount());
-    for (u32 i=0; i<c.init_values.getCount(); i++) {
-        const InitValue* v = c.init_values.get(i);
-        out.print("  [%2d] %6s  %d\n", i, v.getKindName(), v.value);
+    if (c.init_values.getCount()) {
+        out.print("init values: (%d)\n", c.init_values.getCount());
+        for (u32 i=0; i<c.init_values.getCount(); i++) {
+            const InitValue* v = c.init_values.get(i);
+            out.print("  [%2d] %6s  %d\n", i, v.getKindName(), v.value);
+        }
+        out.newline();
     }
-    out.newline();
 
     stdio.puts(out.data());
     out.free();

ir/ref.c2

@@ -63,6 +63,10 @@ fn bool Ref.isSlot(const Ref* r) {
     return r.kind == RefKind.Slot;
 }
 
+fn bool Ref.isConstant(const Ref* r) @(unused) {
+    return r.kind >= RefKind.Value && r.kind <= RefKind.Double;
+}
+
 fn bool Ref.isRefList(const Ref* r) {
     return r.kind == RefKind.RefList;
 }

ir/ssa.c2

@@ -380,6 +380,54 @@ fn void Context.eliminateCopies(Context* c, FunctionInfo* fi) {
     }
 }
 
+fn void Context.fillUsage(Context* c, FunctionInfo* fi) {
+    c.usage.clear(fi.instructions.getCount());
+
+    // Usage: counter both usage and if it has a result.
+    // count 0 means: has no result, (of course) not used
+    // count 1 means: has result, not used (could still have side effects)
+    // count 2+ means: used
+    Instr* all = fi.instructions.get(0);
+    for (u32 i=0; i<fi.instructions.getCount(); i++) {
+        Instr* is = &all[i];
+        if (is.hasResult()) c.usage.incr(i);
+        if (is.isPhi()) {
+            PhiClause* clauses = fi.phis.get(is.phi_clauses.start);
+            for (u32 p=0; p<is.phi_clauses.count; p++) {
+                Ref* r = &clauses[p].ref;
+                if (r.isTemp()) c.usage.incr(r.value);
+            }
+        } else {
+            Ref* r = &is.args[0];
+            if (r.isTemp()) c.usage.incr(r.value);
+            r = &is.args[1];
+            if (r.isTemp()) c.usage.incr(r.value);
+        }
+    }
+}
+
+#if 0
+// return true if changed
+fn bool Context.propagateConstants(Context* c, FunctionInfo* fi) {
+    // look for add x, y where x, y are both constants, replace with copy
+    bool changed = false;
+
+    c.dump_function(fi, "temp");
+    Instr* all = fi.instructions.get(0);
+    for (u32 i=0; i<fi.instructions.getCount(); i++) {
+        Instr* instr = &all[i];
+        if (!instr.isArithmetic()) continue;
+        if (!instr.args[0].isConstant()) continue;
+        if (!instr.args[1].isConstant()) continue;
+
+        // only 17 matches in c2c!
+        changed = true;
+    }
+
+    return changed;
+}
+#endif
+
 fn void Context.removeNone(Context* c, FunctionInfo* fi) {
     c.inserter.clear();
     c.fixup_function(fi);