commit 348691894219089559fd214c5e7b021389dac82d
parent eecbe645ffee51c58fc1be60dc935c7de3a0e58b
Author: erai <erai@omiltem.net>
Date: Tue, 28 Jan 2025 02:24:36 +0000
enough ir to generate code
Diffstat:
| M | .build.yml | | | 4 | ++++ |
| M | cc0.c | | | 94 | ++++++++++++++++++++++++++++++++++++++++++++++++++----------------------------- |
| M | ir.om | | | 100 | +++++++++++++++++++++++++++++++++++++++++++++++++++++-------------------------- |
3 files changed, 131 insertions(+), 67 deletions(-)
diff --git a/.build.yml b/.build.yml
@@ -7,3 +7,7 @@ sources:
tasks:
- bootstrap: "cd os && ./bootstrap.sh"
- build: "cd os && ./build.sh"
+triggers:
+ - action: email
+ condition: always
+ to: erai@omiltem.net
diff --git a/cc0.c b/cc0.c
@@ -131,13 +131,16 @@ struct my_irfunc {
struct my_alloc* my_a;
unsigned char* my_name;
struct my_irloopctx* my_loopctx;
- struct my_irblock* my_top;
+ struct my_irblock** my_blocks;
+ unsigned long my_blocks_len;
+ unsigned long my_blocks_cap;
struct my_irblock* my_cur;
struct my_irlabel* my_labels_tree;
struct my_irvar* my_vars_tree;
struct my_irvar** my_vars;
unsigned long my_vars_len;
unsigned long my_vars_cap;
+ unsigned long my_arg_count;
};
struct my_irlabel {
unsigned char* my_name;
@@ -157,6 +160,7 @@ struct my_irop {
unsigned long my_n;
unsigned char* my_s;
struct my_type* my_t;
+ unsigned long my_mark;
unsigned char* my_filename;
unsigned long my_lineno;
unsigned long my_colno;
@@ -165,7 +169,9 @@ struct my_irvar {
unsigned char* my_name;
struct my_irvar* my_left;
struct my_irvar* my_right;
+ struct my_type* my_t;
unsigned long my_n;
+ unsigned long my_mark;
};
struct my_label {
struct my_fixup* my_fix;
@@ -785,7 +791,7 @@ void( my_iraddvar)(struct my_irfunc* my_ic,unsigned char* my_name,struct my_type
void( my_irbranch)(struct my_irfunc* my_ic,struct my_irop* my_cond,struct my_irblock* my_alt,struct my_irblock* my_next);
struct my_irop*( my_ircall)(struct my_irfunc* my_ic,struct my_node* my_n);
struct my_irblock*( my_irfind_block)(struct my_irfunc* my_ic,unsigned char* my_name,unsigned long my_make);
-struct my_irvar*( my_irfind_var)(struct my_irfunc* my_ic,unsigned char* my_name,unsigned long my_make);
+struct my_irvar**( my_irfind_var)(struct my_irfunc* my_ic,unsigned char* my_name);
void( my_irjump)(struct my_irfunc* my_ic,struct my_irblock* my_to,struct my_irblock* my_next);
void( my_irreturn)(struct my_irfunc* my_ic,struct my_irop* my_value);
void( my_labels_to_ir)(struct my_irfunc* my_ic,struct my_node* my_n);
@@ -804,8 +810,8 @@ struct my_irblock*( my_mkirblock)(struct my_irfunc* my_ic);
struct my_irop*( my_mkirconst)(struct my_irfunc* my_ic,unsigned long my_n);
struct my_irop*( my_mkirop)(struct my_irfunc* my_ic,unsigned long my_kind,struct my_irop* my_a,struct my_irop* my_b);
struct my_irop*( my_mkirstr)(struct my_irfunc* my_ic,unsigned char* my_s);
-struct my_irop*( my_mkirtmp)(struct my_irfunc* my_ic);
-struct my_irvar*( my_mkirvar)(struct my_irfunc* my_ic);
+struct my_irop*( my_mkirtmp)(struct my_irfunc* my_ic,struct my_type* my_t);
+struct my_irvar*( my_mkirvar)(struct my_irfunc* my_ic,unsigned char* my_name,struct my_type* my_t);
struct my_label*( my_mklabel)(struct my_assembler* my_c);
struct my_node*( my_mknode)(struct my_parser* my_c,unsigned long my_kind,struct my_node* my_a,struct my_node* my_b);
struct my_node*( my_mknode0)(struct my_parser* my_c,unsigned long my_kind);
@@ -4440,7 +4446,7 @@ struct my_irop*( my_expr_to_ir)(struct my_irfunc* my_ic,struct my_node* my_n){
(my_o)=((my_mkirconst)((my_ic),((my_v)->my_enum_value)));
return my_o;
}
- (my_iv)=((my_irfind_var)((my_ic),((my_n)->my_s),(0UL)));
+ (my_iv)=(*((my_irfind_var)((my_ic),((my_n)->my_s))));
if (my_iv) {
(my_o)=((my_mkirop)((my_ic),(my_IOP_VAR),((void *)0),((void *)0)));
((my_o)->my_n)=((my_iv)->my_n);
@@ -4510,7 +4516,7 @@ struct my_irop*( my_expr_to_ir)(struct my_irfunc* my_ic,struct my_node* my_n){
(my_bool_body)=((my_mkirblock)((my_ic)));
(my_bool_next)=((my_mkirblock)((my_ic)));
(my_bool_out)=((my_mkirblock)((my_ic)));
- (my_e)=((my_mkirtmp)((my_ic)));
+ (my_e)=((my_mkirtmp)((my_ic),((my_n)->my_t)));
(my_a)=((my_expr_to_ir)((my_ic),((my_n)->my_a)));
(my_irbranch)((my_ic),(my_a),(my_bool_next),(my_bool_body));
(my_a)=((my_mkirconst)((my_ic),(0UL)));
@@ -4529,7 +4535,7 @@ struct my_irop*( my_expr_to_ir)(struct my_irfunc* my_ic,struct my_node* my_n){
(my_bool_next)=((my_mkirblock)((my_ic)));
(my_bool_final)=((my_mkirblock)((my_ic)));
(my_bool_out)=((my_mkirblock)((my_ic)));
- (my_e)=((my_mkirtmp)((my_ic)));
+ (my_e)=((my_mkirtmp)((my_ic),((my_n)->my_t)));
(my_a)=((my_expr_to_ir)((my_ic),((my_n)->my_a)));
(my_irbranch)((my_ic),(my_a),(my_bool_next),(my_bool_body));
(my_a)=((my_mkirconst)((my_ic),(1UL)));
@@ -4555,7 +4561,7 @@ struct my_irop*( my_expr_to_ir)(struct my_irfunc* my_ic,struct my_node* my_n){
(my_bool_next)=((my_mkirblock)((my_ic)));
(my_bool_final)=((my_mkirblock)((my_ic)));
(my_bool_out)=((my_mkirblock)((my_ic)));
- (my_e)=((my_mkirtmp)((my_ic)));
+ (my_e)=((my_mkirtmp)((my_ic),((my_n)->my_t)));
(my_a)=((my_expr_to_ir)((my_ic),((my_n)->my_a)));
(my_irbranch)((my_ic),(my_a),(my_bool_next),(my_bool_body));
(my_a)=((my_expr_to_ir)((my_ic),((my_n)->my_b)));
@@ -5005,11 +5011,11 @@ struct my_irfunc*( my_func_to_ir)(struct my_compiler* my_c,struct my_node* my_n)
if ((unsigned long)(!(my_n))) {
return (void *)0;
}
- (my_ic)=((struct my_irfunc*)(my_alloc)(((my_c)->my_a),(88UL)));
+ (my_ic)=((struct my_irfunc*)(my_alloc)(((my_c)->my_a),(112UL)));
((my_ic)->my_c)=(my_c);
((my_ic)->my_a)=((my_c)->my_a);
- ((my_ic)->my_top)=((my_mkirblock)((my_ic)));
- ((my_ic)->my_cur)=((my_ic)->my_top);
+ (my_mkirblock)((my_ic));
+ ((my_ic)->my_cur)=(((my_ic)->my_blocks)[0UL]);
((my_ic)->my_name)=((((my_n)->my_a)->my_a)->my_s);
(my_args_to_ir)((my_ic),((((my_n)->my_a)->my_b)->my_a));
(my_locals_to_ir)((my_ic),((my_n)->my_b));
@@ -5145,7 +5151,13 @@ unsigned long( my_hoist_locals)(struct my_compiler* my_c,struct my_decl* my_d,st
return my_offset;
}
void( my_iraddarg)(struct my_irfunc* my_ic,unsigned char* my_name,struct my_type* my_t){
- (my_irfind_var)((my_ic),(my_name),(1UL));
+ struct my_irvar** my_iv = 0;
+ (my_iv)=((my_irfind_var)((my_ic),(my_name)));
+ if (*(my_iv)) {
+ (my_cdie)(((my_ic)->my_c),((unsigned char *)"duplicate var"));
+ }
+ (*(my_iv))=((my_mkirvar)((my_ic),(my_name),(my_t)));
+ ((my_ic)->my_arg_count)=((unsigned long)(((unsigned long)((my_ic)->my_arg_count))+((unsigned long)(1UL))));
}
void( my_iraddop)(struct my_irfunc* my_ic,struct my_irop* my_o){
struct my_irblock* my_cur = 0;
@@ -5174,7 +5186,12 @@ void( my_iraddop)(struct my_irfunc* my_ic,struct my_irop* my_o){
((my_cur)->my_ops_len)=((unsigned long)(((unsigned long)((my_cur)->my_ops_len))+((unsigned long)(1UL))));
}
void( my_iraddvar)(struct my_irfunc* my_ic,unsigned char* my_name,struct my_type* my_t){
- (my_irfind_var)((my_ic),(my_name),(1UL));
+ struct my_irvar** my_iv = 0;
+ (my_iv)=((my_irfind_var)((my_ic),(my_name)));
+ if (*(my_iv)) {
+ (my_cdie)(((my_ic)->my_c),((unsigned char *)"duplicate var"));
+ }
+ (*(my_iv))=((my_mkirvar)((my_ic),(my_name),(my_t)));
}
void( my_irbranch)(struct my_irfunc* my_ic,struct my_irop* my_cond,struct my_irblock* my_alt,struct my_irblock* my_next){
struct my_irblock* my_cur = 0;
@@ -5204,7 +5221,7 @@ struct my_irop*( my_ircall)(struct my_irfunc* my_ic,struct my_node* my_n){
struct my_irop* my_fp = 0;
unsigned long my_i = 0;
unsigned long my_count = 0;
- (my_fp)=((my_mkirtmp)((my_ic)));
+ (my_fp)=((my_mkirtmp)((my_ic),(((my_n)->my_a)->my_t)));
(my_b)=((my_expr_to_ir)((my_ic),((my_n)->my_a)));
(my_a)=((my_mkirop)((my_ic),(my_IOP_REF),(my_fp),((void *)0)));
(my_o)=((my_mkirop)((my_ic),(my_IOP_STORE),(my_a),(my_b)));
@@ -5226,7 +5243,7 @@ struct my_irop*( my_ircall)(struct my_irfunc* my_ic,struct my_node* my_n){
if ((unsigned long)(!(my_arg))) {
break;
}
- ((my_tmp)[my_i])=((my_mkirtmp)((my_ic)));
+ ((my_tmp)[my_i])=((my_mkirtmp)((my_ic),(((my_arg)->my_a)->my_t)));
(my_b)=((my_expr_to_ir)((my_ic),((my_arg)->my_a)));
(my_a)=((my_mkirop)((my_ic),(my_IOP_REF),((my_tmp)[my_i]),((void *)0)));
(my_o)=((my_mkirop)((my_ic),(my_IOP_STORE),(my_a),(my_b)));
@@ -5249,7 +5266,7 @@ struct my_irop*( my_ircall)(struct my_irfunc* my_ic,struct my_node* my_n){
(my_i)=((unsigned long)(((unsigned long)(my_i))+((unsigned long)(1UL))));
}
(my_free)(((my_ic)->my_a),((unsigned char*)my_tmp));
- (my_ret)=((my_mkirtmp)((my_ic)));
+ (my_ret)=((my_mkirtmp)((my_ic),((my_n)->my_t)));
(my_b)=((my_mkirop)((my_ic),(my_IOP_REF),(my_ret),((void *)0)));
(my_o)=((my_mkirop)((my_ic),(my_IOP_RETVAL),(my_b),((void *)0)));
((my_o)->my_t)=((my_n)->my_t);
@@ -5302,7 +5319,7 @@ struct my_irblock*( my_irfind_block)(struct my_irfunc* my_ic,unsigned char* my_n
(*(my_link))=(my_l);
return (my_l)->my_block;
}
-struct my_irvar*( my_irfind_var)(struct my_irfunc* my_ic,unsigned char* my_name,unsigned long my_make){
+struct my_irvar**( my_irfind_var)(struct my_irfunc* my_ic,unsigned char* my_name){
struct my_irvar** my_link = 0;
struct my_irvar* my_v = 0;
unsigned long my_dir = 0;
@@ -5310,27 +5327,17 @@ struct my_irvar*( my_irfind_var)(struct my_irfunc* my_ic,unsigned char* my_name,
while (1) {
(my_v)=(*(my_link));
if ((unsigned long)(!(my_v))) {
- break;
+ return my_link;
}
(my_dir)=((my_strcmp)((my_name),((my_v)->my_name)));
if ((unsigned long)(((long)(my_dir))==((long)(0UL)))) {
- if (my_make) {
- (my_cdie)(((my_ic)->my_c),((unsigned char *)"duplicate var"));
- }
- return my_v;
+ return my_link;
} else if ((unsigned long)(((long)(my_dir))<((long)(0UL)))) {
(my_link)=(&((my_v)->my_left));
} else {
(my_link)=(&((my_v)->my_right));
}
}
- if ((unsigned long)(!(my_make))) {
- return (void *)0;
- }
- (my_v)=((my_mkirvar)((my_ic)));
- ((my_v)->my_name)=(my_name);
- (*(my_link))=(my_v);
- return my_v;
}
void( my_irjump)(struct my_irfunc* my_ic,struct my_irblock* my_to,struct my_irblock* my_next){
struct my_irblock* my_cur = 0;
@@ -5807,6 +5814,21 @@ void( my_memset)(unsigned char* my_dest,unsigned long my_c,unsigned long my_size
}
struct my_irblock*( my_mkirblock)(struct my_irfunc* my_ic){
struct my_irblock* my_b = 0;
+ struct my_irblock** my_tmp = 0;
+ unsigned long my_i = 0;
+ if ((unsigned long)(((long)((my_ic)->my_blocks_len))==((long)((my_ic)->my_blocks_cap)))) {
+ ((my_ic)->my_blocks_cap)=((unsigned long)(((unsigned long)((unsigned long)(((long)((my_ic)->my_blocks_cap))*((long)(2UL)))))+((unsigned long)(16UL))));
+ (my_tmp)=((struct my_irblock**)(my_alloc)(((my_ic)->my_a),((unsigned long)(((long)(8UL))*((long)((my_ic)->my_blocks_cap))))));
+ (my_i)=(0UL);
+ while (1) {
+ if ((unsigned long)(((long)(my_i))==((long)((my_ic)->my_blocks_len)))) {
+ break;
+ }
+ ((my_tmp)[my_i])=(((my_ic)->my_blocks)[my_i]);
+ (my_i)=((unsigned long)(((unsigned long)(my_i))+((unsigned long)(1UL))));
+ }
+ ((my_ic)->my_blocks)=(my_tmp);
+ }
(my_b)=((struct my_irblock*)(my_alloc)(((my_ic)->my_a),(56UL)));
((my_b)->my_ops)=((void *)0);
((my_b)->my_ops_len)=(0UL);
@@ -5814,6 +5836,8 @@ struct my_irblock*( my_mkirblock)(struct my_irfunc* my_ic){
((my_b)->my_done)=(0UL);
((my_b)->my_out)=((void *)0);
((my_b)->my_alt)=((void *)0);
+ (((my_ic)->my_blocks)[(my_ic)->my_blocks_len])=(my_b);
+ ((my_ic)->my_blocks_len)=((unsigned long)(((unsigned long)((my_ic)->my_blocks_len))+((unsigned long)(1UL))));
return my_b;
}
struct my_irop*( my_mkirconst)(struct my_irfunc* my_ic,unsigned long my_n){
@@ -5824,7 +5848,7 @@ struct my_irop*( my_mkirconst)(struct my_irfunc* my_ic,unsigned long my_n){
}
struct my_irop*( my_mkirop)(struct my_irfunc* my_ic,unsigned long my_kind,struct my_irop* my_a,struct my_irop* my_b){
struct my_irop* my_o = 0;
- (my_o)=((struct my_irop*)(my_alloc)(((my_ic)->my_a),(72UL)));
+ (my_o)=((struct my_irop*)(my_alloc)(((my_ic)->my_a),(80UL)));
((my_o)->my_kind)=(my_kind);
((my_o)->my_a)=(my_a);
((my_o)->my_b)=(my_b);
@@ -5842,15 +5866,15 @@ struct my_irop*( my_mkirstr)(struct my_irfunc* my_ic,unsigned char* my_s){
((my_o)->my_s)=(my_s);
return my_o;
}
-struct my_irop*( my_mkirtmp)(struct my_irfunc* my_ic){
+struct my_irop*( my_mkirtmp)(struct my_irfunc* my_ic,struct my_type* my_t){
struct my_irop* my_o = 0;
struct my_irvar* my_v = 0;
- (my_v)=((my_mkirvar)((my_ic)));
+ (my_v)=((my_mkirvar)((my_ic),((void *)0),(my_t)));
(my_o)=((my_mkirop)((my_ic),(my_IOP_VAR),((void *)0),((void *)0)));
((my_o)->my_n)=((my_v)->my_n);
return my_o;
}
-struct my_irvar*( my_mkirvar)(struct my_irfunc* my_ic){
+struct my_irvar*( my_mkirvar)(struct my_irfunc* my_ic,unsigned char* my_name,struct my_type* my_t){
struct my_irvar* my_v = 0;
struct my_irvar** my_tmp = 0;
unsigned long my_i = 0;
@@ -5868,8 +5892,10 @@ struct my_irvar*( my_mkirvar)(struct my_irfunc* my_ic){
((my_ic)->my_vars)=(my_tmp);
}
(my_i)=((my_ic)->my_vars_len);
- (my_v)=((struct my_irvar*)(my_alloc)(((my_ic)->my_a),(32UL)));
+ (my_v)=((struct my_irvar*)(my_alloc)(((my_ic)->my_a),(48UL)));
((my_v)->my_n)=(my_i);
+ ((my_v)->my_name)=(my_name);
+ ((my_v)->my_t)=(my_t);
(((my_ic)->my_vars)[my_i])=(my_v);
((my_ic)->my_vars_len)=((unsigned long)(((unsigned long)((my_ic)->my_vars_len))+((unsigned long)(1UL))));
return my_v;
diff --git a/ir.om b/ir.om
@@ -52,7 +52,7 @@ struct irop {
n: int;
s: *byte;
t: *type;
-
+ mark: int;
filename: *byte;
lineno: int;
colno: int;
@@ -86,7 +86,9 @@ struct irvar {
name: *byte;
left: *irvar;
right: *irvar;
+ t: *type;
n: int;
+ mark: int;
}
struct irfunc {
@@ -94,17 +96,41 @@ struct irfunc {
a: *alloc;
name: *byte;
loopctx: *irloopctx;
- top: *irblock;
+ blocks: **irblock;
+ blocks_len: int;
+ blocks_cap: int;
cur: *irblock;
labels_tree: *irlabel;
vars_tree: *irvar;
vars: **irvar;
vars_len: int;
vars_cap: int;
+ arg_count: int;
}
func mkirblock(ic: *irfunc): *irblock {
var b: *irblock;
+ var tmp: **irblock;
+ var i: int;
+
+ if ic.blocks_len == ic.blocks_cap {
+ ic.blocks_cap = ic.blocks_cap * 2 + 16;
+
+ tmp = alloc(ic.a, sizeof(*tmp) * ic.blocks_cap) as **irblock;
+
+ i = 0;
+ loop {
+ if i == ic.blocks_len {
+ break;
+ }
+
+ tmp[i] = ic.blocks[i];
+
+ i = i + 1;
+ }
+
+ ic.blocks = tmp;
+ }
b = alloc(ic.a, sizeof(*b)) as *irblock;
@@ -115,6 +141,9 @@ func mkirblock(ic: *irfunc): *irblock {
b.out = nil;
b.alt = nil;
+ ic.blocks[ic.blocks_len] = b;
+ ic.blocks_len = ic.blocks_len + 1;
+
return b;
}
@@ -157,7 +186,7 @@ func mkirstr(ic: *irfunc, s: *byte): *irop {
return o;
}
-func mkirvar(ic: *irfunc): *irvar {
+func mkirvar(ic: *irfunc, name: *byte, t: *type): *irvar {
var v: *irvar;
var tmp: **irvar;
var i: int;
@@ -186,6 +215,8 @@ func mkirvar(ic: *irfunc): *irvar {
v = alloc(ic.a, sizeof(*v)) as *irvar;
v.n = i;
+ v.name = name;
+ v.t = t;
ic.vars[i] = v;
ic.vars_len = ic.vars_len + 1;
@@ -193,11 +224,11 @@ func mkirvar(ic: *irfunc): *irvar {
return v;
}
-func mkirtmp(ic: *irfunc): *irop {
+func mkirtmp(ic: *irfunc, t: *type): *irop {
var o: *irop;
var v: *irvar;
- v = mkirvar(ic);
+ v = mkirvar(ic, nil, t);
o = mkirop(ic, IOP_VAR, nil, nil);
o.n = v.n;
@@ -205,7 +236,7 @@ func mkirtmp(ic: *irfunc): *irop {
return o;
}
-func irfind_var(ic: *irfunc, name: *byte, make: int): *irvar {
+func irfind_var(ic: *irfunc, name: *byte): **irvar {
var link: **irvar;
var v: *irvar;
var dir: int;
@@ -213,44 +244,46 @@ func irfind_var(ic: *irfunc, name: *byte, make: int): *irvar {
link = &ic.vars_tree;
loop {
v = *link;
-
if !v {
- break;
+ return link;
}
dir = strcmp(name, v.name);
if dir == 0 {
- if make {
- cdie(ic.c, "duplicate var");
- }
-
- return v;
+ return link;
} else if dir < 0 {
link = &v.left;
} else { // dir > 0
link = &v.right;
}
}
+}
- if !make {
- return nil;
- }
+func iraddarg(ic: *irfunc, name: *byte, t: *type) {
+ var iv: **irvar;
- v = mkirvar(ic);
+ iv = irfind_var(ic, name);
- v.name = name;
- *link = v;
+ if *iv {
+ cdie(ic.c, "duplicate var");
+ }
- return v;
-}
+ *iv = mkirvar(ic, name, t);
-func iraddarg(ic: *irfunc, name: *byte, t: *type) {
- irfind_var(ic, name, 1);
+ ic.arg_count = ic.arg_count + 1;
}
func iraddvar(ic: *irfunc, name: *byte, t: *type) {
- irfind_var(ic, name, 1);
+ var iv: **irvar;
+
+ iv = irfind_var(ic, name);
+
+ if *iv {
+ cdie(ic.c, "duplicate var");
+ }
+
+ *iv = mkirvar(ic, name, t);
}
func ircall(ic: *irfunc, n: *node): *irop {
@@ -267,7 +300,7 @@ func ircall(ic: *irfunc, n: *node): *irop {
var count: int;
// Evaluate the expression left to right starting with the function
- fp = mkirtmp(ic);
+ fp = mkirtmp(ic, n.a.t);
b = expr_to_ir(ic, n.a);
a = mkirop(ic, IOP_REF, fp, nil);
o = mkirop(ic, IOP_STORE, a, b);
@@ -298,7 +331,7 @@ func ircall(ic: *irfunc, n: *node): *irop {
}
// Create a temporary for this argument
- tmp[i] = mkirtmp(ic);
+ tmp[i] = mkirtmp(ic, arg.a.t);
// Compute the argument value
b = expr_to_ir(ic, arg.a);
@@ -333,7 +366,7 @@ func ircall(ic: *irfunc, n: *node): *irop {
free(ic.a, tmp as *byte);
// Add a temporary for the return value
- ret = mkirtmp(ic);
+ ret = mkirtmp(ic, n.t);
b = mkirop(ic, IOP_REF, ret, nil);
o = mkirop(ic, IOP_RETVAL, b, nil);
o.t = n.t;
@@ -420,7 +453,7 @@ func expr_to_ir(ic: *irfunc, n: *node): *irop {
}
// variable
- iv = irfind_var(ic, n.s, 0);
+ iv = *irfind_var(ic, n.s);
if iv {
o = mkirop(ic, IOP_VAR, nil, nil);
o.n = iv.n;
@@ -493,7 +526,7 @@ func expr_to_ir(ic: *irfunc, n: *node): *irop {
bool_body = mkirblock(ic);
bool_next = mkirblock(ic);
bool_out = mkirblock(ic);
- e = mkirtmp(ic);
+ e = mkirtmp(ic, n.t);
a = expr_to_ir(ic, n.a);
irbranch(ic, a, bool_next, bool_body);
@@ -516,7 +549,7 @@ func expr_to_ir(ic: *irfunc, n: *node): *irop {
bool_next = mkirblock(ic);
bool_final = mkirblock(ic);
bool_out = mkirblock(ic);
- e = mkirtmp(ic);
+ e = mkirtmp(ic, n.t);
a = expr_to_ir(ic, n.a);
irbranch(ic, a, bool_next, bool_body);
@@ -549,7 +582,7 @@ func expr_to_ir(ic: *irfunc, n: *node): *irop {
bool_next = mkirblock(ic);
bool_final = mkirblock(ic);
bool_out = mkirblock(ic);
- e = mkirtmp(ic);
+ e = mkirtmp(ic, n.t);
a = expr_to_ir(ic, n.a);
irbranch(ic, a, bool_next, bool_body);
@@ -1032,8 +1065,9 @@ func func_to_ir(c: *compiler, n: *node): *irfunc {
ic.c = c;
ic.a = c.a;
- ic.top = mkirblock(ic);
- ic.cur = ic.top;
+ mkirblock(ic);
+
+ ic.cur = ic.blocks[0];
ic.name = n.a.a.s;
