ir: use Arg pseudo-instruction. Remove RefList from ir/

Author: bvdberg

generator/ir/ir_generator.c2

@@ -25,7 +25,6 @@ import file_utils;
 import ir local;
 import ir_context local;
 import ir_gen_locals local;
-import ref_list_pool;
 import source_mgr;
 import string_buffer;
 import string_pool;
@@ -49,7 +48,6 @@ type Generator struct {
     u32 num_scopes;
 
     Locals locals;
-    ref_list_pool.Pool ref_pool;
 
     string_buffer.Buf* name_buf;
     bool assert_generated;
@@ -79,7 +77,6 @@ fn void Generator.init(Generator* gen,
     gen.output_dir = output_dir;
     gen.string_idx = 1; // starting at 1 looks nicer
     gen.locals.init();
-    gen.ref_pool.init(4);
     gen.print = print;
     gen.enable_asserts = enable_asserts;
     gen.ptr_type = targetInfo.intWidth == 64 ? ir.Type.U64 : ir.Type.U32;
@@ -88,7 +85,6 @@ fn void Generator.init(Generator* gen,
 }
 
 fn void Generator.free(Generator* gen) {
-    gen.ref_pool.free();
     gen.labels.free();
     gen.ctx.free();
     gen.name_buf.free();

generator/ir/ir_generator_call.c2

@@ -18,6 +18,7 @@ module ir_generator;
 import ast local;
 import ir local;
 import ir_context;
+import ref_list local;
 
 fn void Generator.emitCallExpr(Generator* gen, ir.Ref* result, const Expr* e) {
     CallExpr* call = cast<CallExpr*>(e);
@@ -30,7 +31,7 @@ fn void Generator.emitCallExpr(Generator* gen, ir.Ref* result, const Expr* e) {
     bool has_result = !qt.isVoid();
     bool is_tf = call.isTypeFunc();
 
-    RefList* arg_refs = gen.ref_pool.get();
+    RefList arg_refs.init();
 
     ir.Ref name_ref;
     if (is_tf) {
@@ -52,22 +53,8 @@ fn void Generator.emitCallExpr(Generator* gen, ir.Ref* result, const Expr* e) {
         gen.emitExpr(&ref, args[i]);
         arg_refs.add(ref);
     }
-    // Terminate with Ref.Unspecified
-    if (arg_refs.getCount() != 0) {
-        ir.Ref ref;
-        ref.init(RefKind.None, 0);
-        arg_refs.add(ref);
-    }
-
-    ir.Ref args_ref;
-    if (arg_refs.getCount() == 0) {
-        args_ref.init(RefKind.None, 0);
-    } else {
-        u32 idx = c.addCallArgs(arg_refs);
-        args_ref.init(RefKind.RefList, idx);
-    }
-    gen.ref_pool.put(arg_refs);
 
-    *result = c.addCallInstr(name_ref, args_ref, has_result, call.isNoreturn());
+    *result = c.addCallInstr(name_ref, arg_refs.get(), arg_refs.getCount(), has_result, call.isNoreturn());
+    arg_refs.free();
 }
 

ir/ref_list.c2 renamed to generator/ir/ref_list.c2

@@ -13,60 +13,50 @@
  * limitations under the License.
  */
 
-module ir;
+module ref_list;
+
+import ir;
 
 import string local;
 import stdlib;
 
 public type RefList struct {
     u32 count;
     u32 capacity;
-    Ref* refs;
+    ir.Ref* refs;
+    ir.Ref[4] stack;
 }
 
-public fn void RefList.init(RefList* l, u32 initial_size) {
+public fn void RefList.init(RefList* l) {
     l.count = 0;
-    l.refs = nil;
-    if (initial_size) l.resize(initial_size);
+    l.capacity = elemsof(l.stack);
+    l.refs = l.stack;
 }
 
 public fn void RefList.free(RefList* l) {
-    if (l.refs) stdlib.free(l.refs);
+    if (l.count > elemsof(l.stack)) stdlib.free(l.refs);
 }
 
 fn void RefList.resize(RefList* l, u32 cap) {
+    ir.Ref* refs2 = stdlib.malloc(cap * sizeof(ir.Ref));
+    if (l.count != 0) memcpy(refs2, l.refs, l.count * sizeof(ir.Ref));
+    if (l.capacity > elemsof(l.stack)) stdlib.free(l.refs);
     l.capacity = cap;
-    // TODO only memset new part?
-    Ref* refs2 = stdlib.calloc(l.capacity, sizeof(Ref));
-    if (l.count != 0) memcpy(refs2, l.refs, l.count * sizeof(Ref));
-    if (l.refs) stdlib.free(l.refs);
     l.refs = refs2;
 }
 
-public fn void RefList.add(RefList* l, Ref ref) {
-    if (l.count == l.capacity) l.resize(l.capacity ? l.capacity * 2 : 4);
+public fn void RefList.add(RefList* l, ir.Ref ref) {
+    if (l.count == l.capacity) l.resize(l.capacity * 2);
 
     l.refs[l.count] = ref;
     l.count++;
 }
 
-public fn u32 RefList.addList(RefList* l, const RefList* l2) {
-    u32 start = l.count;
-    if (l.capacity < l.count + l2.count) l.resize(l.count + l2.count);
-    memcpy(&l.refs[l.count], l2.refs, l2.count * sizeof(Ref));
-    l.count += l2.count;
-    return start;
-}
-
-public fn void RefList.clear(RefList* l) {
-    l.count = 0;
-}
-
 public fn u32 RefList.getCount(const RefList* l) {
     return l.count;
 }
 
-public fn Ref* RefList.get(const RefList* l, u32 idx) {
-    return &l.refs[idx];
+public fn const ir.Ref* RefList.get(const RefList* l) {
+    return l.refs;
 }
 

generator/ir/ref_list_pool.c2

@@ -329,10 +329,6 @@ public fn Ref Context.addFuncArg(Context* c, Type t) {
     return ref;
 }
 
-public fn u32 Context.addCallArgs(Context* c, const RefList* refs) {
-    return c.b.tmp_info.refs.addList(refs);
-}
-
 public fn BlockId Context.createBlock(Context* c, BlockKind kind) {
     BlockId id = c.b.tmp_info.blocks.add(kind);
 #if DebugIr
@@ -518,17 +514,22 @@ public fn Ref Context.addBinaryInstr(Context* c, InstrKind k, Ref left, Ref righ
     return out;
 }
 
-public fn Ref Context.addCallInstr(Context* c, Ref name, Ref args, bool has_result, bool noreturn) {
+public fn Ref Context.addCallInstr(Context* c, Ref name, const Ref* args, u32 num_args, bool has_result, bool noreturn) {
 #if DebugIr
     stdio.printf("  call %s%d\n", name.getKindName(), name.value);
 #endif
+    for (u32 i = 0; i < num_args; i++) {
+        Instr* ii = c.b.tmp_info.instructions.add();
+        ii.init1(InstrKind.Arg, args[i]);
+    }
+
     Ref out.init(RefKind.Temp, c.b.tmp_info.instructions.getCount());
 
     Instr* i = c.b.tmp_info.instructions.add();
     if (has_result) {
-        i.init2b(InstrKind.Call, name, args);
+        i.init1b(InstrKind.Call, name);
     } else {
-        i.init2(InstrKind.Call, name, args);
+        i.init1(InstrKind.Call, name);
     }
     if (noreturn) {
         Block* b = c.b.tmp_info.blocks.get(c.b.cur_block);

ir/context.c2

@@ -22,29 +22,26 @@ public type FunctionInfo struct {
     BlockList blocks;
     InstrList instructions;
     CaseList cases;
-    RefList refs;   // for call arguments
     PhiList phis;   // for phi instructions
     u16 num_slots;
     u8 num_args;
     // args[0][low bits] is return type (None if no return value)
     u8[1 + constants.MaxCallArgs/2] args;   // stores 2 ir.Types per u8, first low, then high bits
 }
-static_assert(96, sizeof(FunctionInfo));
+static_assert(80, sizeof(FunctionInfo));
 
 public fn FunctionInfo* FunctionInfo.create(u32 num_blks, u32 num_instr, u32 num_refs) {
     FunctionInfo* fi = stdlib.malloc(sizeof(FunctionInfo));
     fi.blocks.init(num_blks);
     fi.instructions.init(num_instr);
     fi.cases.init();
-    fi.refs.init(num_refs);
     fi.phis.init();
     fi.num_args = 0;
     return fi;
 }
 
 public fn void FunctionInfo.free(FunctionInfo* fi) {
     fi.phis.free();
-    fi.refs.free();
     fi.cases.free();
     fi.instructions.free();
     fi.blocks.free();

ir/function_info.c2

@@ -159,10 +159,6 @@ public fn bool Instr.isSwitch(const Instr* i) {
     return i.getKind() == InstrKind.Switch;
 }
 
-public fn bool Instr.isCall(const Instr* i) {
-    return i.getKind() == InstrKind.Call;
-}
-
 public fn bool Instr.isPhi(const Instr* i) {
     return i.getKind() == InstrKind.Phi;
 }

ir/instr.c2

@@ -60,6 +60,7 @@ public type InstrKind enum u8 {
     Call,
     // Pseudo instructions (must be converted before converting to ASM)
     Param,
+    Arg,
     Switch,
     Phi,
     Copy,
@@ -104,6 +105,7 @@ public fn const char* InstrKind.str(InstrKind k) @(unused) {
     case Halt:      return "halt";
     case Call:      return "call";
     case Param:     return "param";
+    case Arg:       return "arg";
     case Switch:    return "switch";
     case Phi:       return "phi";
     case Copy:      return "copy";

ir/instr_kind.c2

@@ -72,7 +72,7 @@ public fn InterferenceGraph* create(u32 max_elems, u16 num_variables) {
     g.variables = stdlib.calloc(num_variables, sizeof(Variable));
     g.num_variables = num_variables;
     g.max_elems = max_elems;
-    g.register_map = stdlib.malloc(num_variables *sizeof(u16));
+    g.register_map = stdlib.malloc(num_variables * sizeof(u8));
     string.memset(g.register_map, VAR_UNUSED, num_variables);
     g.queue = stdlib.malloc(num_variables * sizeof(u16));
 
@@ -389,6 +389,8 @@ fn void InterferenceGraph.handleQueue(InterferenceGraph* g) {
 
 public fn void InterferenceGraph.allocate(InterferenceGraph* g, u32 num_args) {
     // pre-alloc arguments as R0,R1,..
+
+    assert(num_args < g.num_variables);
     for (u8 v=0; v<num_args; v++) {
         g.register_map[v] = v;
     }