os

ir.om (41430B)

---

 enum {
 	// Places
 	IOP_VAR,
 	IOP_VARREF,
 	IOP_FUNC,
 	IOP_CONST,
 	IOP_STR,
 
 	// Memory operations
 	IOP_LOAD,
 	IOP_STORE,
 
 	// Calling convention
 	IOP_RETVAL,
 	IOP_ARG,
 
 	// Unary arithmetic
 	IOP_NEG,
 	IOP_NOT,
 
 	// Binary arithmetic
 	IOP_ADD,
 	IOP_AND,
 	IOP_OR,
 	IOP_XOR,
 	IOP_DIV,
 	IOP_MOD,
 	IOP_LSH,
 	IOP_RSH,
 	IOP_MUL,
 	IOP_SUB,
 
 	// Comparison
 	IOP_EQ,
 	IOP_NE,
 	IOP_GT,
 	IOP_GE,
 	IOP_LT,
 	IOP_LE,
 
 	// End of block
 	IOP_CALL,
 	IOP_JUMP,
 	IOP_BRANCH,
 	IOP_RETURN,
 }
 
 struct irop {
 	kind: int;
 	a: *irop;
 	b: *irop;
 	n: int;
 	s: *byte;
 	slen: int;
 	t: *type;
 	mark: int;
 	filename: *byte;
 	lineno: int;
 	colno: int;
 }
 
 // A basic block is a sequence of expressions that end with a branch
 struct irblock {
 	n: int;
 	ops: **irop;
 	ops_len: int;
 	ops_cap: int;
 	done: int;
 	back: **irblock; // WARNING: if the flow graph changes, this is stale.
 	back_len: int;
 	out: *irblock;
 	alt: *irblock;
 	label: *label;
 	mark: int;
 }
 
 struct irloopctx {
 	up: *irloopctx;
 	top: *irblock;
 	out: *irblock;
 }
 
 struct irlabel {
 	name: *byte;
 	left: *irlabel;
 	right: *irlabel;
 	block: *irblock;
 }
 
 struct irvar {
 	name: *byte;
 	left: *irvar;
 	right: *irvar;
 	t: *type;
 	n: int;
 	offset: int;
 	dead: int;
 	used_ref: int;
 	mark: int;
 }
 
 struct irfunc {
 	c: *compiler;
 	s: *assembler;
 	a: *alloc;
 	name: *byte;
 	filename: *byte;
 	lineno: int;
 	colno: int;
 	loopctx: *irloopctx;
 	blocks: **irblock;
 	blocks_len: int;
 	blocks_cap: int;
 	returns: **irblock; // WARNING: if the flow graph changes, this is stale.
 	returns_len: int;
 	cur: *irblock;
 	labels_tree: *irlabel;
 	vars_tree: *irvar;
 	vars: **irvar;
 	vars_len: int;
 	vars_cap: int;
 	arg_count: int;
 	frame_size: 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;
 
 	b.n = ic.blocks_len;
 	b.label = mklabel(ic.s);
 	b.ops = nil;
 	b.ops_len = 0;
 	b.ops_cap = 0;
 	b.done = 0;
 	b.out = nil;
 	b.alt = nil;
 
 	ic.blocks[ic.blocks_len] = b;
 	ic.blocks_len = ic.blocks_len + 1;
 
 	return b;
 }
 
 func ircopyloc(dst: *irop, src: *irop) {
 	dst.filename = src.filename;
 	dst.lineno = src.lineno;
 	dst.colno = src.colno;
 }
 
 func mkirop(ic: *irfunc, kind: int, a: *irop, b: *irop): *irop {
 	var o: *irop;
 
 	o = alloc(ic.a, sizeof(*o)) as *irop;
 
 	o.kind = kind;
 	o.a = a;
 	o.b = b;
 
 	o.filename = ic.c.filename;
 	o.lineno = ic.c.lineno;
 	o.colno = ic.c.colno;
 
 	return o;
 }
 
 func mkirconst(ic: *irfunc, n: int): *irop {
 	var o: *irop;
 
 	o = mkirop(ic, IOP_CONST, nil, nil);
 
 	o.n = n;
 
 	return o;
 }
 
 func mkirarg(ic: *irfunc, n: int, a: *irop): *irop {
 	var o: *irop;
 
 	o = mkirop(ic, IOP_ARG, a, nil);
 
 	o.n = n;
 
 	return o;
 }
 
 func mkirvarop(ic: *irfunc, name: *byte): *irop {
 	var iv: *irvar;
 	var o: *irop;
 
 	iv = *irfind_var(ic, name);
 	if !iv {
 		fputs(nil, name);
 		cdie(ic.c, "no such variable");
 	}
 
 	o = mkirop(ic, IOP_VAR, nil, nil);
 
 	o.n = iv.n;
 
 	return o;
 }
 
 func mkirretval(ic: *irfunc, a: *irop, t: *type): *irop {
 	var o: *irop;
 
 	o = mkirop(ic, IOP_RETVAL, a, nil);
 
 	o.t = t;
 
 	return o;
 }
 
 func mkirstr(ic: *irfunc, s: *byte, slen: int): *irop {
 	var o: *irop;
 
 	o = mkirop(ic, IOP_STR, nil, nil);
 
 	o.s = s;
 	o.slen = slen;
 
 	return o;
 }
 
 func mkirfuncref(ic: *irfunc, name: *byte): *irop {
 	var o: *irop;
 
 	o = mkirop(ic, IOP_FUNC, nil, nil);
 
 	o.s = name;
 	o.slen = strlen(name);
 
 	return o;
 }
 
 func mkirvar(ic: *irfunc, name: *byte, t: *type): *irvar {
 	var v: *irvar;
 	var tmp: **irvar;
 	var i: int;
 
 	if ic.vars_len == ic.vars_cap {
 		ic.vars_cap = ic.vars_cap * 2 + 16;
 
 		tmp = alloc(ic.a, sizeof(*tmp) * ic.vars_cap) as **irvar;
 
 		i = 0;
 		loop {
 			if i == ic.vars_len {
 				break;
 			}
 
 			tmp[i] = ic.vars[i];
 
 			i = i + 1;
 		}
 
 		ic.vars = tmp;
 	}
 
 	i = ic.vars_len;
 
 	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;
 
 	return v;
 }
 
 func mkirtmp(ic: *irfunc, t: *type): *irop {
 	var o: *irop;
 	var v: *irvar;
 
 	v = mkirvar(ic, nil, t);
 
 	o = mkirop(ic, IOP_VAR, nil, nil);
 	o.n = v.n;
 
 	return o;
 }
 
 func irfind_var(ic: *irfunc, name: *byte): **irvar {
 	var link: **irvar;
 	var v: *irvar;
 	var dir: int;
 
 	link = &ic.vars_tree;
 	loop {
 		v = *link;
 		if !v {
 			return link;
 		}
 
 		dir = strcmp(name, v.name);
 
 		if dir == 0 {
 			return link;
 		} else if dir < 0 {
 			link = &v.left;
 		} else { // dir > 0
 			link = &v.right;
 		}
 	}
 }
 
 func iraddarg(ic: *irfunc, name: *byte, t: *type): *irvar {
 	var iv: **irvar;
 
 	iv = irfind_var(ic, name);
 
 	if *iv {
 		cdie(ic.c, "duplicate var");
 	}
 
 	*iv = mkirvar(ic, name, t);
 
 	ic.arg_count = ic.arg_count + 1;
 
 	return *iv;
 }
 
 func iraddvar(ic: *irfunc, name: *byte, t: *type) {
 	var iv: **irvar;
 
 	iv = irfind_var(ic, name);
 
 	if *iv {
 		cdie(ic.c, "duplicate var");
 	}
 
 	*iv = mkirvar(ic, name, t);
 }
 
 func ircall(ic: *irfunc, fp: *irop, nargs: int) {
 	var o: *irop;
 	var cur: *irblock;
 	var next: *irblock;
 
 	// Emit the call
 	o = mkirop(ic, IOP_CALL, fp, nil);
 	o.n = nargs;
 	iraddop(ic, o);
 
 	// Link the return path
 	next = mkirblock(ic);
 
 	cur = ic.cur;
 	if cur {
 		if cur.done {
 			cdie(ic.c, "block already done");
 		}
 
 		cur.done = 1;
 		cur.out = next;
 	}
 
 	ic.cur = next;
 }
 
 func call_to_ir(ic: *irfunc, n: *node): *irop {
 	var o: *irop;
 	var a: *irop;
 	var b: *irop;
 	var ret: *irop;
 	var next: *irblock;
 	var cur: *irblock;
 	var arg: *node;
 	var tmp: **irop;
 	var fp: *irop;
 	var i: int;
 	var count: int;
 	var slen: int;
 	var blob: *byte;
 
 	if n.a.kind == N_IDENT && strcmp(n.a.s, "_include") == 0 {
 		if n.b.a.kind != N_STR {
 			cdie(ic.c, "non literal include");
 		}
 
 		blob = gather_include(ic.c, n.b.a.s, &slen);
 
 		a = expr_to_ir(ic, n.b.b.a);
 		b = mkirconst(ic, slen);
 		o = mkirop(ic, IOP_STORE, a, b);
 		o.t = n.b.b.a.t.val;
 		iraddop(ic, o);
 
 		o = mkirstr(ic, blob, slen);
 		return o;
 	}
 
 	// Evaluate the expression left to right starting with the function
 	fp = mkirtmp(ic, n.a.t);
 	b = expr_to_ir(ic, n.a);
 	o = mkirop(ic, IOP_STORE, fp, b);
 	o.t = n.a.t;
 	iraddop(ic, o);
 
 	// Count the number of arguments
 	arg = n.b;
 	count = 0;
 	loop {
 		if !arg {
 			break;
 		}
 
 		count = count + 1;
 
 		arg = arg.b;
 	}
 
 	tmp = alloc(ic.a, sizeof(*tmp) * count) as **irop;
 
 	// Evaluate the arguments left to right
 	arg = n.b;
 	i = 0;
 	loop {
 		if !arg {
 			break;
 		}
 
 		// Create a temporary for this argument
 		tmp[i] = mkirtmp(ic, arg.a.t);
 
 		// Compute the argument value
 		b = expr_to_ir(ic, arg.a);
 
 		// Save the value
 		o = mkirop(ic, IOP_STORE, tmp[i], b);
 		o.t = arg.a.t;
 		iraddop(ic, o);
 
 		arg = arg.b;
 		i = i + 1;
 	}
 
 	// Emit arg nodes just before the call left to right
 	arg = n.b;
 	i = 0;
 	loop {
 		if i == count {
 			break;
 		}
 
 		o = mkirarg(ic, i, tmp[i]);
 		iraddop(ic, o);
 
 		arg = arg.b;
 		i = i + 1;
 	}
 
 	free(ic.a, tmp as *byte);
 
 	// Add a temporary for the return value
 	ret = mkirtmp(ic, n.t);
 	o = mkirretval(ic, ret, n.t);
 	iraddop(ic, o);
 
 	ircall(ic, fp, count);
 
 	// Return an expression that contains the return value
 	return ret;
 }
 
 func expr_to_ir(ic: *irfunc, n: *node): *irop {
 	var a: *irop;
 	var b: *irop;
 	var c: *irop;
 	var d: *irop;
 	var e: *irop;
 	var o: *irop;
 	var bool_body: *irblock;
 	var bool_next: *irblock;
 	var bool_final: *irblock;
 	var bool_out: *irblock;
 	var v: *decl;
 	var iv: *irvar;
 	var kind: int;
 	var size: int;
 
 	assert(!!n, "expected node");
 
 	ic.c.filename = n.filename;
 	ic.c.lineno = n.lineno;
 	ic.c.colno = n.colno;
 
 	kind = n.kind;
 	if kind == N_NIL {
 		o = mkirconst(ic, 0);
 		return o;
 	} else if kind == N_NUM {
 		o = mkirconst(ic, n.n);
 		return o;
 	} else if kind == N_CHAR {
 		o = mkirconst(ic, n.n);
 		return o;
 	} else if kind == N_SIZEOF {
 		if n.a.t.kind == TY_BYTE {
 			size = 1;
 		} else {
 			size = type_sizeof(ic.c, n.a.t);
 		}
 
 		o = mkirconst(ic, size);
 		return o;
 	} else if kind == N_STR {
 		o = mkirstr(ic, n.s, strlen(n.s));
 		return o;
 	} else if kind == N_CALL {
 		o = call_to_ir(ic, n);
 		return o;
 	} else if kind == N_IDENT {
 		v = find(ic.c, n.s, nil, 0);
 
 		// enum constant
 		if v && v.enum_defined {
 			o = mkirconst(ic, v.enum_value);
 			return o;
 		}
 
 		// variable
 		iv = *irfind_var(ic, n.s);
 		if iv {
 			o = mkirop(ic, IOP_VAR, nil, nil);
 			o.n = iv.n;
 			return o;
 		}
 
 		// function
 		if v && v.func_defined {
 			o = mkirfuncref(ic, n.s);
 			return o;
 		}
 
 		cdie(ic.c, "no such symbol");
 		return nil;
 	} else if kind == N_DOT {
 		if n.a.t.kind == TY_PTR {
 			b = expr_to_ir(ic, n.a);
 			v = find(ic.c, n.a.t.val.st.name, n.b.s, 0);
 		} else {
 			a = expr_to_ir(ic, n.a);
 			if a.kind == IOP_VAR {
 				b = mkirop(ic, IOP_VARREF, nil, nil);
 				b.n = a.n;
 				ic.vars[a.n].used_ref = 1;
 			} else if a.kind == IOP_LOAD {
 				b = a.a;
 			} else {
 				die("invalid ref");
 			}
 			v = find(ic.c, n.a.t.st.name, n.b.s, 0);
 		}
 		c = mkirconst(ic, v.member_offset);
 		d = mkirop(ic, IOP_ADD, b, c);
 		o = mkirop(ic, IOP_LOAD, d, nil);
 		o.t = n.t;
 		return o;
 	} else if kind == N_REF {
 		a = expr_to_ir(ic, n.a);
 		if a.kind == IOP_VAR {
 			o = mkirop(ic, IOP_VARREF, nil, nil);
 			o.n = a.n;
 			ic.vars[a.n].used_ref = 1;
 			return o;
 		} else if a.kind == IOP_LOAD {
 			return a.a;
 		} else {
 			die("invalid ref");
 			return nil;
 		}
 	} else if kind == N_DEREF {
 		a = expr_to_ir(ic, n.a);
 		o = mkirop(ic, IOP_LOAD, a, nil);
 		o.t = n.t;
 		return o;
 	} else if kind == N_INDEX {
 		a = expr_to_ir(ic, n.a);
 		b = expr_to_ir(ic, n.b);
 		if n.t.kind == TY_BYTE {
 			size = 1;
 		} else {
 			size = type_sizeof(ic.c, n.t);
 		}
 		c = mkirconst(ic, size);
 		d = mkirop(ic, IOP_MUL, b, c);
 		e = mkirop(ic, IOP_ADD, a, d);
 		o = mkirop(ic, IOP_LOAD, e, nil);
 		o.t = n.t;
 		return o;
 	} else if kind == N_ASSIGN {
 		a = expr_to_ir(ic, n.a);
 		b = expr_to_ir(ic, n.b);
 		o = mkirop(ic, IOP_STORE, a, b);
 		o.t = n.t;
 		return o;
 	} else if kind == N_POS {
 		o = expr_to_ir(ic, n.a);
 		return o;
 	} else if kind == N_CAST {
 		o = expr_to_ir(ic, n.a);
 		return o;
 	} else if kind == N_NEG {
 		a = expr_to_ir(ic, n.a);
 		o = mkirop(ic, IOP_NEG, a, nil);
 		return o;
 	} else if kind == N_NOT {
 		a = expr_to_ir(ic, n.a);
 		o = mkirop(ic, IOP_NOT, a, nil);
 		return o;
 	} else if kind == N_BNOT {
 		bool_body = mkirblock(ic);
 		bool_next = mkirblock(ic);
 		bool_out = mkirblock(ic);
 		e = mkirtmp(ic, n.t);
 
 		a = expr_to_ir(ic, n.a);
 		irbranch(ic, a, bool_next, bool_body);
 
 		b = mkirconst(ic, 0);
 		o = mkirop(ic, IOP_STORE, e, b);
 		o.t = n.t;
 		iraddop(ic, o);
 		irjump(ic, bool_out, bool_next);
 
 		b = mkirconst(ic, 1);
 		o = mkirop(ic, IOP_STORE, e, b);
 		o.t = n.t;
 		iraddop(ic, o);
 		irjump(ic, bool_out, bool_out);
 
 		return e;
 	} else if kind == N_BOR {
 		bool_body = mkirblock(ic);
 		bool_next = mkirblock(ic);
 		bool_final = mkirblock(ic);
 		bool_out = mkirblock(ic);
 		e = mkirtmp(ic, n.t);
 
 		a = expr_to_ir(ic, n.a);
 		irbranch(ic, a, bool_next, bool_body);
 
 		b = mkirconst(ic, 1);
 		o = mkirop(ic, IOP_STORE, e, b);
 		o.t = n.t;
 		iraddop(ic, o);
 		irjump(ic, bool_out, bool_next);
 
 		bool_next = mkirblock(ic);
 
 		a = expr_to_ir(ic, n.b);
 		irbranch(ic, a, bool_next, bool_final);
 
 		b = mkirconst(ic, 1);
 		o = mkirop(ic, IOP_STORE, e, b);
 		o.t = n.t;
 		iraddop(ic, o);
 		irjump(ic, bool_out, bool_next);
 
 		b = mkirconst(ic, 0);
 		o = mkirop(ic, IOP_STORE, e, b);
 		o.t = n.t;
 		iraddop(ic, o);
 		irjump(ic, bool_out, bool_out);
 
 		return e;
 	} else if kind == N_BAND {
 		bool_body = mkirblock(ic);
 		bool_next = mkirblock(ic);
 		bool_final = mkirblock(ic);
 		bool_out = mkirblock(ic);
 		e = mkirtmp(ic, n.t);
 
 		a = expr_to_ir(ic, n.a);
 		irbranch(ic, a, bool_next, bool_body);
 
 		a = expr_to_ir(ic, n.b);
 		irbranch(ic, a, bool_next, bool_final);
 
 		b = mkirconst(ic, 1);
 		o = mkirop(ic, IOP_STORE, e, b);
 		o.t = n.t;
 		iraddop(ic, o);
 		irjump(ic, bool_out, bool_next);
 
 		b = mkirconst(ic, 0);
 		o = mkirop(ic, IOP_STORE, e, b);
 		o.t = n.t;
 		iraddop(ic, o);
 		irjump(ic, bool_out, bool_out);
 
 		return e;
 	} else if kind == N_LT {
 		a = expr_to_ir(ic, n.a);
 		b = expr_to_ir(ic, n.b);
 		o = mkirop(ic, IOP_LT, a, b);
 		return o;
 	} else if kind == N_GT {
 		a = expr_to_ir(ic, n.a);
 		b = expr_to_ir(ic, n.b);
 		o = mkirop(ic, IOP_GT, a, b);
 		return o;
 	} else if kind == N_LE {
 		a = expr_to_ir(ic, n.a);
 		b = expr_to_ir(ic, n.b);
 		o = mkirop(ic, IOP_LE, a, b);
 		return o;
 	} else if kind == N_GE {
 		a = expr_to_ir(ic, n.a);
 		b = expr_to_ir(ic, n.b);
 		o = mkirop(ic, IOP_GE, a, b);
 		return o;
 	} else if kind == N_EQ {
 		a = expr_to_ir(ic, n.a);
 		b = expr_to_ir(ic, n.b);
 		o = mkirop(ic, IOP_EQ, a, b);
 		return o;
 	} else if kind == N_NE {
 		a = expr_to_ir(ic, n.a);
 		b = expr_to_ir(ic, n.b);
 		o = mkirop(ic, IOP_NE, a, b);
 		return o;
 	} else if kind == N_ADD {
 		a = expr_to_ir(ic, n.a);
 		b = expr_to_ir(ic, n.b);
 		o = mkirop(ic, IOP_ADD, a, b);
 		return o;
 	} else if kind == N_SUB {
 		a = expr_to_ir(ic, n.a);
 		b = expr_to_ir(ic, n.b);
 		o = mkirop(ic, IOP_SUB, a, b);
 		return o;
 	} else if kind == N_MUL {
 		a = expr_to_ir(ic, n.a);
 		b = expr_to_ir(ic, n.b);
 		o = mkirop(ic, IOP_MUL, a, b);
 		return o;
 	} else if kind == N_DIV {
 		a = expr_to_ir(ic, n.a);
 		b = expr_to_ir(ic, n.b);
 		o = mkirop(ic, IOP_DIV, a, b);
 		return o;
 	} else if kind == N_MOD {
 		a = expr_to_ir(ic, n.a);
 		b = expr_to_ir(ic, n.b);
 		o = mkirop(ic, IOP_MOD, a, b);
 		return o;
 	} else if kind == N_LSH {
 		a = expr_to_ir(ic, n.a);
 		b = expr_to_ir(ic, n.b);
 		o = mkirop(ic, IOP_LSH, a, b);
 		return o;
 	} else if kind == N_RSH {
 		a = expr_to_ir(ic, n.a);
 		b = expr_to_ir(ic, n.b);
 		o = mkirop(ic, IOP_RSH, a, b);
 		return o;
 	} else if kind == N_AND {
 		a = expr_to_ir(ic, n.a);
 		b = expr_to_ir(ic, n.b);
 		o = mkirop(ic, IOP_AND, a, b);
 		return o;
 	} else if kind == N_OR {
 		a = expr_to_ir(ic, n.a);
 		b = expr_to_ir(ic, n.b);
 		o = mkirop(ic, IOP_OR, a, b);
 		return o;
 	} else if kind == N_XOR {
 		a = expr_to_ir(ic, n.a);
 		b = expr_to_ir(ic, n.b);
 		o = mkirop(ic, IOP_XOR, a, b);
 		return o;
 	} else {
 		cdie(ic.c, "unknown expression");
 		return nil;
 	}
 }
 
 func iraddop(ic: *irfunc, o: *irop) {
 	var cur: *irblock;
 	var ops: **irop;
 	var i: int;
 
 	cur = ic.cur;
 	if !cur {
 		return;
 	}
 
 	assert(!!o, "expected op to add");
 	assert(!cur.done, "block already closed");
 
 	if cur.ops_len == cur.ops_cap {
 		cur.ops_cap = cur.ops_cap * 2 + 16;
 
 		ops = alloc(ic.a, cur.ops_cap * sizeof(*ops)) as **irop;
 
 		i = 0;
 		loop {
 			if i == cur.ops_len {
 				break;
 			}
 
 			ops[i] = cur.ops[i];
 
 			i = i + 1;
 		}
 
 		cur.ops = ops;
 	}
 
 	cur.ops[cur.ops_len] = o;
 	cur.ops_len = cur.ops_len + 1;
 }
 
 func irjump(ic: *irfunc, to: *irblock, next: *irblock) {
 	var cur: *irblock;
 	var o: *irop;
 
 	o = mkirop(ic, IOP_JUMP, nil, nil);
 	iraddop(ic, o);
 
 	cur = ic.cur;
 	if cur {
 		if cur.done {
 			cdie(ic.c, "block already done");
 		}
 
 		cur.done = 1;
 		cur.out = to;
 	}
 
 	ic.cur = next;
 }
 
 func irbranch(ic: *irfunc, cond: *irop, alt: *irblock, next: *irblock) {
 	var cur: *irblock;
 	var o: *irop;
 
 	o = mkirop(ic, IOP_BRANCH, cond, nil);
 	iraddop(ic, o);
 
 	cur = ic.cur;
 	if cur {
 		if cur.done {
 			cdie(ic.c, "block already done");
 		}
 
 		cur.done = 1;
 		cur.alt = alt;
 		cur.out = next;
 	}
 
 	ic.cur = next;
 }
 
 func irreturn(ic: *irfunc, value: *irop) {
 	var cur: *irblock;
 	var o: *irop;
 
 	o = mkirop(ic, IOP_RETURN, value, nil);
 	iraddop(ic, o);
 
 	cur = ic.cur;
 	if cur {
 		if cur.done {
 			cdie(ic.c, "block already done");
 		}
 
 		cur.done = 1;
 	}
 
 	ic.cur = nil;
 }
 
 func stmt_to_ir(ic: *irfunc, n: *node) {
 	var loopctx: irloopctx;
 	var cond_body: *irblock;
 	var cond_next: *irblock;
 	var cond_out: *irblock;
 	var label: *irblock;
 	var value: *irop;
 	var kind: int;
 
 	if !n {
 		return;
 	}
 
 	ic.c.filename = n.filename;
 	ic.c.lineno = n.lineno;
 	ic.c.colno = n.colno;
 
 	kind = n.kind;
 	if kind == N_CONDLIST {
 		// Create join point for out
 		cond_out = mkirblock(ic);
 
 		loop {
 			// No more conditions
 			if !n {
 				break;
 			}
 
 			// Final else branch
 			if !n.a.a {
 				stmt_to_ir(ic, n.a.b);
 				break;
 			}
 
 			cond_body = mkirblock(ic);
 			cond_next = mkirblock(ic);
 
 			// Compile condition, else branch to out
 			value = expr_to_ir(ic, n.a.a);
 			irbranch(ic, value, cond_next, cond_body);
 
 			// Compile body on the taken branch
 			stmt_to_ir(ic, n.a.b);
 			irjump(ic, cond_out, cond_next);
 
 			n = n.b;
 		}
 
 		// Jump to out
 		irjump(ic, cond_out, cond_out);
 	} else if kind == N_STMTLIST {
 		loop {
 			if !n {
 				break;
 			}
 
 			// Compile each statement in the list
 			stmt_to_ir(ic, n.a);
 
 			n = n.b;
 		}
 	} else if kind == N_LOOP {
 		// Push a new loopctx onto the stack
 		loopctx.up = ic.loopctx;
 		loopctx.top = mkirblock(ic);
 		loopctx.out = mkirblock(ic);
 		ic.loopctx = &loopctx;
 
 		// Jump to top
 		irjump(ic, loopctx.top, loopctx.top);
 
 		// Compile the body
 		stmt_to_ir(ic, n.a);
 
 		// Jump to top
 		irjump(ic, loopctx.top, loopctx.out);
 
 		// Pop the loopctx
 		ic.loopctx = loopctx.up;
 	} else if kind == N_BREAK {
 		if !ic.loopctx {
 			cdie(ic.c, "break not in loop");
 		}
 
 		// jump to out
 		irjump(ic, ic.loopctx.out, nil);
 	} else if kind == N_CONTINUE {
 		if !ic.loopctx {
 			cdie(ic.c, "continue not in loop");
 		}
 
 		// jump to top
 		irjump(ic, ic.loopctx.top, nil);
 	} else if kind == N_RETURN {
 		if n.a {
 			value = expr_to_ir(ic, n.a);
 		} else {
 			value = mkirconst(ic, 0);
 		}
 		irreturn(ic, value);
 	} else if kind == N_LABEL {
 		// jump to label and fill in it's definition
 		label = irfind_block(ic, n.a.s, 0);
 		irjump(ic, label, label);
 	} else if kind == N_GOTO {
 		// jump
 		label = irfind_block(ic, n.a.s, 0);
 		irjump(ic, label, nil);
 	} else if kind == N_VARDECL {
 		// Nothing to do.
 		// Vardecl creates a variable for the whole function.
 		// Crossing the declaration itself does nothing.
 	} else {
 		value = expr_to_ir(ic, n);
 		iraddop(ic, value);
 	}
 }
 
 func irfind_block(ic: *irfunc, name: *byte, make: int): *irblock {
 	var link: **irlabel;
 	var l: *irlabel;
 	var dir: int;
 
 	link = &ic.labels_tree;
 	loop {
 		l = *link;
 
 		if !l {
 			break;
 		}
 
 		dir = strcmp(name, l.name);
 
 		if dir == 0 {
 			if make {
 				cdie(ic.c, "duplicate label");
 			}
 
 			return l.block;
 		} else if dir < 0 {
 			link = &l.left;
 		} else { // dir > 0
 			link = &l.right;
 		}
 	}
 
 	if !make {
 		cdie(ic.c, "no such label");
 	}
 
 	l = alloc(ic.a, sizeof(*l)) as *irlabel;
 
 	l.name = name;
 	l.left = nil;
 	l.right = nil;
 	l.block = mkirblock(ic);
 
 	*link = l;
 
 	return l.block;
 }
 
 func labels_to_ir(ic: *irfunc, n: *node) {
 	var kind: int;
 	var name: *byte;
 
 	if !n {
 		return;
 	}
 
 	ic.c.filename = n.filename;
 	ic.c.lineno = n.lineno;
 	ic.c.colno = n.colno;
 
 	kind = n.kind;
 	if kind == N_CONDLIST {
 		loop {
 			if !n {
 				break;
 			}
 
 			labels_to_ir(ic, n.a.b);
 
 			n = n.b;
 		}
 	} else if kind == N_STMTLIST {
 		loop {
 			if !n {
 				break;
 			}
 
 			labels_to_ir(ic, n.a);
 
 			n = n.b;
 		}
 	} else if kind == N_LOOP {
 		labels_to_ir(ic, n.a);
 	} else if kind == N_LABEL {
 		name = n.a.s;
 		irfind_block(ic, name, 1);
 	}
 }
 
 func args_to_ir(ic: *irfunc, n: *node) {
 	var name: *byte;
 	var t: *type;
 
 	loop {
 		if !n {
 			break;
 		}
 
 		name = n.a.a.s;
 
 		t = prototype(ic.c, n.a.b);
 
 		iraddarg(ic, name, t);
 
 		n = n.b;
 	}
 }
 
 func locals_to_ir(ic: *irfunc, n: *node) {
 	var name: *byte;
 	var t: *type;
 	var kind: int;
 
 	if !n {
 		return;
 	}
 
 	ic.c.filename = n.filename;
 	ic.c.lineno = n.lineno;
 	ic.c.colno = n.colno;
 
 	kind = n.kind;
 	if kind == N_CONDLIST {
 		loop {
 			if !n {
 				break;
 			}
 
 			locals_to_ir(ic, n.a.b);
 
 			n = n.b;
 		}
 	} else if kind == N_STMTLIST {
 		loop {
 			if !n {
 				break;
 			}
 
 			locals_to_ir(ic, n.a);
 
 			n = n.b;
 		}
 	} else if kind == N_LOOP {
 		locals_to_ir(ic, n.a);
 	} else if kind == N_VARDECL {
 		name = n.a.s;
 
 		t = prototype(ic.c, n.b);
 
 		iraddvar(ic, name, t);
 	}
 }
 
 func mkirfunc(c: *compiler, name: *byte): *irfunc {
 	var ic: *irfunc;
 
 	ic = alloc(c.a, sizeof(*ic)) as *irfunc;
 
 	ic.c = c;
 	ic.a = c.a;
 	ic.s = c.s;
 
 	mkirblock(ic);
 	ic.cur = ic.blocks[0];
 
 	ic.name = name;
 
 	return ic;
 }
 
 func func_to_ir(c: *compiler, n: *node): *irfunc {
 	var ic: *irfunc;
 	var value: *irop;
 	var t: *type;
 
 	if !n {
 		return nil;
 	}
 
 	ic = mkirfunc(c, n.a.a.s);
 
 	ic.filename = n.filename;
 	ic.lineno = n.lineno;
 	ic.colno = n.colno;
 
 	args_to_ir(ic, n.a.b.a);
 
 	locals_to_ir(ic, n.b);
 
 	labels_to_ir(ic, n.b);
 
 	stmt_to_ir(ic, n.b);
 
 	t = prototype(c, n.a.b);
 	if t.val.kind == TY_VOID {
 		value = mkirconst(ic, 0);
 		irreturn(ic, value);
 	}
 
 	return ic;
 }
 
 // Depth-first reset all the marks
 func irreset(b: *irblock) {
 	if !b {
 		return;
 	}
 
 	if !b.mark {
 		return;
 	}
 
 	b.mark = 0;
 
 	irreset(b.out);
 	irreset(b.alt);
 }
 
 func irshow4(out: *file, o: *irop) {
 	var kind: int;
 
 	if !o {
 		fputs(out, "(nil)");
 		return;
 	}
 
 	kind = o.kind;
 	if kind == IOP_VAR {
 		fputs(out, "(var ");
 		fputd(out, o.n);
 		fputs(out, ")");
 	} else if kind == IOP_VARREF {
 		fputs(out, "(varref ");
 		fputd(out, o.n);
 		fputs(out, ")");
 	} else if kind == IOP_FUNC {
 		fputs(out, "(func ");
 		fputs(out, o.s);
 		fputs(out, ")");
 	} else if kind == IOP_CONST {
 		fputs(out, "(const ");
 		fputd(out, o.n);
 		fputs(out, ")");
 	} else if kind == IOP_STR {
 		fputs(out, "(str)");
 	} else if kind == IOP_LOAD {
 		fputs(out, "(load ");
 		irshow4(out, o.a);
 		fputs(out, ")");
 	} else if kind == IOP_STORE {
 		fputs(out, "(store ");
 		irshow4(out, o.a);
 		fputs(out, " ");
 		irshow4(out, o.b);
 		fputs(out, ")");
 	} else if kind == IOP_RETVAL {
 		fputs(out, "(retval ");
 		irshow4(out, o.a);
 		fputs(out, ")");
 	} else if kind == IOP_ARG {
 		fputs(out, "(arg ");
 		fputd(out, o.n);
 		fputs(out, " ");
 		irshow4(out, o.a);
 		fputs(out, ")");
 	} else if kind == IOP_NEG {
 		fputs(out, "(neg ");
 		irshow4(out, o.a);
 		fputs(out, ")");
 	} else if kind == IOP_NOT {
 		fputs(out, "(not ");
 		irshow4(out, o.a);
 		fputs(out, ")");
 	} else if kind == IOP_ADD {
 		fputs(out, "(add ");
 		irshow4(out, o.a);
 		fputs(out, " ");
 		irshow4(out, o.b);
 		fputs(out, ")");
 	} else if kind == IOP_AND {
 		fputs(out, "(and ");
 		irshow4(out, o.a);
 		fputs(out, " ");
 		irshow4(out, o.b);
 		fputs(out, ")");
 	} else if kind == IOP_OR {
 		fputs(out, "(or ");
 		irshow4(out, o.a);
 		fputs(out, " ");
 		irshow4(out, o.b);
 		fputs(out, ")");
 	} else if kind == IOP_XOR {
 		fputs(out, "(xor ");
 		irshow4(out, o.a);
 		fputs(out, " ");
 		irshow4(out, o.b);
 		fputs(out, ")");
 	} else if kind == IOP_DIV {
 		fputs(out, "(div ");
 		irshow4(out, o.a);
 		fputs(out, " ");
 		irshow4(out, o.b);
 		fputs(out, ")");
 	} else if kind == IOP_MOD {
 		fputs(out, "(mod ");
 		irshow4(out, o.a);
 		fputs(out, " ");
 		irshow4(out, o.b);
 		fputs(out, ")");
 	} else if kind == IOP_LSH {
 		fputs(out, "(lsh ");
 		irshow4(out, o.a);
 		fputs(out, " ");
 		irshow4(out, o.b);
 		fputs(out, ")");
 	} else if kind == IOP_RSH {
 		fputs(out, "(rsh ");
 		irshow4(out, o.a);
 		fputs(out, " ");
 		irshow4(out, o.b);
 		fputs(out, ")");
 	} else if kind == IOP_MUL {
 		fputs(out, "(mul ");
 		irshow4(out, o.a);
 		fputs(out, " ");
 		irshow4(out, o.b);
 		fputs(out, ")");
 	} else if kind == IOP_SUB {
 		fputs(out, "(sub ");
 		irshow4(out, o.a);
 		fputs(out, " ");
 		irshow4(out, o.b);
 		fputs(out, ")");
 	} else if kind == IOP_EQ {
 		fputs(out, "(eq ");
 		irshow4(out, o.a);
 		fputs(out, " ");
 		irshow4(out, o.b);
 		fputs(out, ")");
 	} else if kind == IOP_NE {
 		fputs(out, "(ne ");
 		irshow4(out, o.a);
 		fputs(out, " ");
 		irshow4(out, o.b);
 		fputs(out, ")");
 	} else if kind == IOP_GT {
 		fputs(out, "(gt ");
 		irshow4(out, o.a);
 		fputs(out, " ");
 		irshow4(out, o.b);
 		fputs(out, ")");
 	} else if kind == IOP_GE {
 		fputs(out, "(ge ");
 		irshow4(out, o.a);
 		fputs(out, " ");
 		irshow4(out, o.b);
 		fputs(out, ")");
 	} else if kind == IOP_LT {
 		fputs(out, "(lt ");
 		irshow4(out, o.a);
 		fputs(out, " ");
 		irshow4(out, o.b);
 		fputs(out, ")");
 	} else if kind == IOP_LE {
 		fputs(out, "(le ");
 		irshow4(out, o.a);
 		fputs(out, " ");
 		irshow4(out, o.b);
 		fputs(out, ")");
 	} else if kind == IOP_CALL {
 		fputs(out, "(call ");
 		irshow4(out, o.a);
 		fputs(out, ")");
 	} else if kind == IOP_JUMP {
 		fputs(out, "(jump)");
 	} else if kind == IOP_BRANCH {
 		fputs(out, "(branch ");
 		irshow4(out, o.a);
 		fputs(out, ")");
 	} else if kind == IOP_RETURN {
 		fputs(out, "(return ");
 		irshow4(out, o.a);
 		fputs(out, ")");
 	} else {
 		fputd(nil, kind);
 		die("invalid iop");
 	}
 }
 
 func irshow3(out: *file, b: *irblock) {
 	var i: int;
 
 	fputd(out, b.mark);
 	fputs(out, "{\n");
 
 	i = 0;
 	loop {
 		if i == b.ops_len {
 			break;
 		}
 
 		fputs(out, "  ");
 		irshow4(out, b.ops[i]);
 		fputs(out, "\n");
 
 		i = i + 1;
 	}
 
 	fputs(out, "}\n");
 }
 
 // Depth-first visit all nodes
 func irshow2(out: *file, b: *irblock, id: *int) {
 	if !b {
 		return;
 	}
 
 	if b.mark {
 		return;
 	}
 
 	b.mark = *id;
 	*id = *id + 1;
 
 	irshow3(out, b);
 
 	if b.out {
 		irshow2(out, b.out, id);
 	}
 
 	if b.alt {
 		irshow2(out, b.alt, id);
 	}
 }
 
 func irshow(out: *file, b: *irblock) {
 	var id: int;
 	id = 1;
 	irshow2(out, b, &id);
 	irreset(b);
 }
 
 func iruseop(ic: *irfunc, ib: *irblock, op: *irop) {
 	var kind: int;
 
 	kind = op.kind;
 	if kind == IOP_VAR || kind == IOP_VARREF {
 		ic.vars[op.n].mark = 1;
 	} else if kind == IOP_STORE {
 		if op.a.kind != IOP_VAR {
 			iruseop(ic, ib, op.a);
 		}
 		iruseop(ic, ib, op.b);
 	} else if kind == IOP_ADD || kind == IOP_AND
 			|| kind == IOP_OR || kind == IOP_XOR || kind == IOP_DIV
 			|| kind == IOP_MOD || kind == IOP_LSH || kind == IOP_RSH
 			|| kind == IOP_MUL || kind == IOP_SUB || kind == IOP_EQ
 			|| kind == IOP_NE || kind == IOP_GT || kind == IOP_GE
 			|| kind == IOP_LT || kind == IOP_LE {
 		// Binary operators
 		iruseop(ic, ib, op.a);
 		iruseop(ic, ib, op.b);
 	} else if kind == IOP_NEG || kind == IOP_NOT || kind == IOP_LOAD
 			|| kind == IOP_ARG || kind == IOP_CALL || kind == IOP_BRANCH
 			|| kind == IOP_RETURN {
 		// Unary operators
 		iruseop(ic, ib, op.a);
 	} else if kind == IOP_RETVAL {
 		if op.a.kind != IOP_VAR {
 			iruseop(ic, ib, op.a);
 		}
 	} else if kind == IOP_FUNC || kind == IOP_CONST || kind == IOP_STR || kind == IOP_JUMP {
 		// No variable possible
 	} else {
 		die("invalid op");
 	}
 }
 
 // Find dead variables
 func irblock_dead_var(ic: *irfunc, ib: *irblock) {
 	var op: *irop;
 	var kind: int;
 	var i: int;
 
 	if ib.mark {
 		return;
 	}
 
 	ib.mark = 1;
 
 	if !ib.done {
 		die("block not closed");
 	}
 
 	loop {
 		if i == ib.ops_len {
 			break;
 		}
 
 		iruseop(ic, ib, ib.ops[i]);
 
 		i = i + 1;
 	}
 
 	op = ib.ops[ib.ops_len - 1];
 	kind = op.kind;
 
 	// Convert useless branches to jumps
 	if kind == IOP_BRANCH {
 		irblock_dead_var(ic, ib.out);
 		irblock_dead_var(ic, ib.alt);
 	} else if kind == IOP_CALL {
 		irblock_dead_var(ic, ib.out);
 	} else if kind == IOP_JUMP {
 		irblock_dead_var(ic, ib.out);
 	} else if kind != IOP_RETURN {
 		die("invalid block");
 	}
 }
 
 // Eliminate expressions which have no possible side effects
 func irblock_dead_expr(ic: *irfunc, b: *irblock) {
 	var i: int;
 	var j: int;
 	var o: *irop;
 	var kind: int;
 
 	if !b.done {
 		return;
 	}
 
 	i = 0;
 	j = 0;
 	loop {
 		if i == b.ops_len {
 			break;
 		}
 
 		o = b.ops[i];
 
 		kind = o.kind;
 		if kind == IOP_STORE || kind == IOP_RETVAL {
 			if o.a.kind != IOP_VAR || !ic.vars[o.a.n].dead {
 				b.ops[j] = o;
 				j = j + 1;
 			}
 		} else if kind == IOP_ARG || kind == IOP_CALL || kind == IOP_JUMP
 				|| kind == IOP_BRANCH || kind == IOP_RETURN {
 			b.ops[j] = o;
 			j = j + 1;
 		}
 
 
 		i = i + 1;
 	}
 
 	b.ops_len = j;
 }
 
 func mkirfold(ic: *irfunc, s: *irop, n: int): *irop {
 	var o: *irop;
 
 	o = mkirop(ic, IOP_CONST, nil, nil);
 
 	o.filename = s.filename;
 	o.lineno = s.lineno;
 	o.colno = s.colno;
 	o.n = n;
 
 	return o;
 }
 
 func irexpr_fold(ic: *irfunc, o: *irop): *irop {
 	var a: *irop;
 	var b: *irop;
 	var c: *irop;
 	var n: int;
 	var kind: int;
 	var ret: *irop;
 
 	// Recursive fold the first operand
 	if o.a {
 		a = o.a;
 		a = irexpr_fold(ic, o.a);
 	} else {
 		// If the op has zero operands, there's nothing to do.
 		return o;
 	}
 
 	// Recursive fold the second operand
 	if o.b {
 		b = o.b;
 		b = irexpr_fold(ic, o.b);
 	}
 
 	kind = o.kind;
 
 	// Eliminate *& redundant operations
 	if (kind == IOP_LOAD && a.kind == IOP_VARREF) {
 		ret = mkirop(ic, IOP_VAR, nil, nil);
 		ret.n = a.n;
 		ret.filename = o.filename;
 		ret.lineno = o.lineno;
 		ret.colno = o.colno;
 		return ret;
 	}
 
 	// Check if a is a constant
 	if a.kind != IOP_CONST {
 		goto out;
 	}
 
 	// Simplify unary operations
 	if kind == IOP_NEG {
 		return mkirfold(ic, o, -a.n);
 	} else if kind == IOP_NOT {
 		return mkirfold(ic, o, ~a.n);
 	}
 
 	// Check if b is a constant
 	if !b || b.kind != IOP_CONST {
 		goto out;
 	}
 
 	// Simplify binary operations
 	if kind == IOP_ADD {
 		return mkirfold(ic, o, a.n + b.n);
 	} else if kind == IOP_AND {
 		return mkirfold(ic, o, a.n & b.n);
 	} else if kind == IOP_OR {
 		return mkirfold(ic, o, a.n | b.n);
 	} else if kind == IOP_XOR {
 		return mkirfold(ic, o, a.n ^ b.n);
 	} else if kind == IOP_DIV {
 		return mkirfold(ic, o, a.n / b.n);
 	} else if kind == IOP_MOD {
 		return mkirfold(ic, o, a.n % b.n);
 	} else if kind == IOP_LSH {
 		return mkirfold(ic, o, a.n << b.n);
 	} else if kind == IOP_RSH {
 		return mkirfold(ic, o, a.n >> b.n);
 	} else if kind == IOP_MUL {
 		return mkirfold(ic, o, a.n * b.n);
 	} else if kind == IOP_SUB {
 		return mkirfold(ic, o, a.n - b.n);
 	} else if kind == IOP_EQ {
 		return mkirfold(ic, o, a.n == b.n);
 	} else if kind == IOP_NE {
 		return mkirfold(ic, o, a.n != b.n);
 	} else if kind == IOP_GT {
 		return mkirfold(ic, o, a.n > b.n);
 	} else if kind == IOP_GE {
 		return mkirfold(ic, o, a.n >= b.n);
 	} else if kind == IOP_LT {
 		return mkirfold(ic, o, a.n < b.n);
 	} else if kind == IOP_LE {
 		return mkirfold(ic, o, a.n <= b.n);
 	} else {
 		goto out;
 	}
 
 out:
 
 	// Do some simple algebraic identities on a
 	if a && a.kind == IOP_CONST {
 		n = a.n;
 
 		if n == 0 {
 			if kind == IOP_ADD || kind == IOP_OR || kind == IOP_XOR {
 				return b;
 			}
 
 			if kind == IOP_SUB {
 				ret = mkirop(ic, IOP_NEG, b, nil);
 				ret.filename = o.filename;
 				ret.lineno = o.lineno;
 				ret.colno = o.colno;
 				return ret;
 			}
 
 			if kind == IOP_AND || kind == IOP_MUL || kind == IOP_LSH || kind == IOP_RSH {
 				return mkirfold(ic, o, 0);
 			}
 		} else if n == 1 {
 			if kind == IOP_MUL {
 				return b;
 			}
 		} else if n == -1 {
 			if kind == IOP_MUL {
 				ret = mkirop(ic, IOP_NEG, b, nil);
 				ret.filename = o.filename;
 				ret.lineno = o.lineno;
 				ret.colno = o.colno;
 				return ret;
 			}
 
 			if kind == IOP_XOR {
 				ret = mkirop(ic, IOP_NOT, b, nil);
 				ret.filename = o.filename;
 				ret.lineno = o.lineno;
 				ret.colno = o.colno;
 				return ret;
 			}
 
 			if kind == IOP_AND {
 				return b;
 			}
 		}
 	}
 
 	// Do some simple algebraic identities on b
 	if b && b.kind == IOP_CONST {
 		n = b.n;
 
 		if n == 0 {
 			if kind == IOP_ADD || kind == IOP_OR || kind == IOP_XOR
 					|| kind == IOP_SUB || kind == IOP_LSH || kind == IOP_RSH {
 				return a;
 			}
 
 			if kind == IOP_AND || kind == IOP_MUL {
 				return mkirfold(ic, o, 0);
 			}
 		} else if n == 1 {
 			if kind == IOP_DIV || kind == IOP_MUL {
 				return a;
 			}
 		} else if n == -1 {
 			if kind == IOP_MUL {
 				ret = mkirop(ic, IOP_NEG, a, nil);
 				ret.filename = o.filename;
 				ret.lineno = o.lineno;
 				ret.colno = o.colno;
 				return ret;
 			}
 
 			if kind == IOP_XOR {
 				ret = mkirop(ic, IOP_NOT, a, nil);
 				ret.filename = o.filename;
 				ret.lineno = o.lineno;
 				ret.colno = o.colno;
 				return ret;
 			}
 
 			if kind == IOP_AND {
 				return a;
 			}
 		}
 	}
 
 	// If neither side folded, then just return the op unmodified
 	if o.a == a && o.b == b {
 		return o;
 	}
 
 	// Otherwise, make a new one with the folded operands
 	ret = mkirop(ic, kind, a, b);
 	ret.filename = o.filename;
 	ret.lineno = o.lineno;
 	ret.colno = o.colno;
 	ret.t = o.t;
 	ret.n = o.n;
 	return ret;
 }
 
 // Fold constant expressions
 func irblock_fold(ic: *irfunc, b: *irblock) {
 	var i: int;
 	var o: *irop;
 	var ret: *irop;
 
 	if b.mark {
 		return;
 	}
 
 	if !b.done {
 		die("block not closed");
 	}
 
 	b.mark = 1;
 
 	i = 0;
 	loop {
 		if i == b.ops_len {
 			break;
 		}
 
 		o = irexpr_fold(ic, b.ops[i]);
 		b.ops[i] = o;
 
 		i = i + 1;
 	}
 
 	i = b.ops_len - 1;
 	o = b.ops[i];
 
 	// Fold constant branches into jumps
 	if o.kind == IOP_BRANCH && o.a.kind == IOP_CONST {
 		ret = mkirop(ic, IOP_JUMP, nil, nil);
 		ret.filename = o.filename;
 		ret.lineno = o.lineno;
 		ret.colno = o.colno;
 
 		b.ops[i] = ret;
 
 		if !o.a.n {
 			b.out = b.alt;
 		}
 
 		b.alt = nil;
 	}
 
 	// Remove useless branches
 	if o.kind == IOP_BRANCH && b.out == b.alt {
 		ret = mkirop(ic, IOP_JUMP, nil, nil);
 		ret.filename = o.filename;
 		ret.lineno = o.lineno;
 		ret.colno = o.colno;
 
 		b.ops[i] = ret;
 
 		b.alt = nil;
 	}
 
 	// Continue
 	if o.kind == IOP_BRANCH {
 		irblock_fold(ic, b.out);
 		irblock_fold(ic, b.alt);
 	} else if o.kind == IOP_JUMP || o.kind == IOP_CALL {
 		irblock_fold(ic, b.out);
 	} else if o.kind == IOP_RETURN {
 		// End of block.
 	} else {
 		die("invalid block");
 	}
 }
 
 func irblock_flow2(ic: *irfunc, ib: *irblock) {
 	var kind: int;
 	var op: *irop;
 
 	// If we visit a block twice, mark it as having two incoming links
 	if ib.mark {
 		ib.mark = 2;
 		return;
 	}
 	ib.mark = 1;
 
 	op = ib.ops[ib.ops_len - 1];
 	kind = op.kind;
 
 	// Convert useless branches to jumps
 	if kind == IOP_BRANCH && ib.out == ib.alt {
 		kind = IOP_JUMP;
 		op = mkirop(ic, IOP_JUMP, nil, nil);
 		ib.ops[ib.ops_len - 1] = op;
 		ib.alt = nil;
 	}
 
 	// Follow the alt link of a branch
 	if kind == IOP_BRANCH {
 		irblock_flow2(ic, ib.alt);
 
 		if ib.alt.ops_len == 1 && ib.alt.ops[0].kind == IOP_JUMP {
 			ib.alt = ib.alt.out;
 		}
 	}
 
 	// Follow the out link of a jump/call/branch
 	if kind == IOP_BRANCH || kind == IOP_CALL || kind == IOP_JUMP {
 		irblock_flow2(ic, ib.out);
 
 		if ib.out.ops_len == 1 && ib.out.ops[0].kind == IOP_JUMP {
 			ib.out = ib.out.out;
 		}
 	}
 }
 
 func irblock_flow3(ic: *irfunc, ib: *irblock) {
 	var out: *irblock;
 	var kind: int;
 	var i: int;
 
 	// Attempt to merge once
 	if ib.mark == 3 {
 		return;
 	}
 	ib.mark = 3;
 
 	loop {
 		kind = ib.ops[ib.ops_len - 1].kind;
 
 		// Merge down the alt branch first
 		if kind == IOP_BRANCH {
 			irblock_flow3(ic, ib.alt);
 			break;
 		}
 
 		// Only merge blocks that end in a jump
 		if kind != IOP_JUMP {
 			break;
 		}
 
 		out = ib.out;
 
 		// If a block has two incoming edges, then don't merge.
 		// But continue attempting to merge down the chain.
 		if out.mark == 2 {
 			ib = out;
 			ib.mark = 3;
 			continue;
 		}
 
 		// If this chain reached a merge point then go to the next chain.
 		if out.mark == 3 {
 			break;
 		}
 
 		// Delete the jump.
 		ib.out = nil;
 		ib.ops_len = ib.ops_len - 1;
 		ib.done = 0;
 
 		// Concatenate the blocks.
 		i = 0;
 		loop {
 			if i == out.ops_len {
 				break;
 			}
 
 			iraddop(ic, out.ops[i]);
 
 			i = i + 1;
 		}
 
 		// Update our links.
 		ib.out = out.out;
 		ib.alt = out.alt;
 		ib.done = 1;
 	}
 }
 
 func irfunc_flow(ic: *irfunc) {
 	// Merge blocks that have one incoming edge
 	irblock_flow2(ic, ic.blocks[0]);
 	irblock_flow3(ic, ic.blocks[0]);
 	irreset(ic.blocks[0]);
 }
 
 func irfunc_dead(ic: *irfunc) {
 	var i: int;
 
 	// Find dead variables
 	irblock_dead_var(ic, ic.blocks[0]);
 	irreset(ic.blocks[0]);
 
 	i = 0;
 	loop {
 		if i == ic.vars_len {
 			break;
 		}
 
 		if i >= ic.arg_count && !ic.vars[i].mark {
 			ic.vars[i].dead = 1;
 		}
 
 		ic.vars[i].mark = 0;
 
 		i = i + 1;
 	}
 
 	// Eliminate dead operations
 	i = 0;
 	loop {
 		if i == ic.blocks_len {
 			break;
 		}
 
 		irblock_dead_expr(ic, ic.blocks[i]);
 
 		i = i + 1;
 	}
 }
 
 func irfunc_fold(ic: *irfunc) {
 	var i: int;
 
 	// Try to evaluate constants as much as possible
 	irblock_fold(ic, ic.blocks[0]);
 	irreset(ic.blocks[0]);
 }
 
 func irop_occurs(op: *irop, n: int): int {
 	if !op {
 		return 0;
 	}
 
 	if op.kind == IOP_VAR {
 		if op.n == n {
 			return 1;
 		} else {
 			return 0;
 		}
 	}
 
 	if irop_occurs(op.a, n) {
 		return 1;
 	}
 
 	if irop_occurs(op.b, n) {
 		return 1;
 	}
 
 	return 0;
 }
 
 func irop_kill(ic: *irfunc, vals: **irop, n: int) {
 	var i: int;
 
 	loop {
 		if i == ic.vars_len {
 			break;
 		}
 
 		if irop_occurs(vals[i], n) {
 			vals[i] = nil;
 		}
 
 		i = i + 1;
 	}
 }
 
 func irop_basic_value(ic: *irfunc, vals: **irop, op: *irop): *irop {
 	var a: *irop;
 	var b: *irop;
 	var v: *irop;
 	var ret: *irop;
 	var kind: int;
 	var i: int;
 
 	kind = op.kind;
 	a = op.a;
 	b = op.b;
 
 	if kind == IOP_STORE {
 		if a.kind == IOP_VAR {
 			// Record stores to variables
 			irop_kill(ic, vals, a.n);
 
 			// Compute the new value
 			b = irop_basic_value(ic, vals, b);
 
 			if a.n < 0 || a.n >= ic.vars_len {
 				die("WTF");
 			}
 
 			// Record the new value
 			vals[a.n] = b;
 
 			// Kill all values that referred to the old value
 			irop_kill(ic, vals, a.n);
 
 			// If the value didn't then reuse op.
 			if b == op.b {
 				return op;
 			}
 
 			ret = mkirop(ic, IOP_STORE, a, b);
 			ircopyloc(ret, op);
 			ret.t = op.t;
 			return ret;
 		} else if a.kind == IOP_LOAD {
 			i = 0;
 			loop {
 				if i == ic.vars_len {
 					break;
 				}
 				vals[i] = nil;
 				i = i + 1;
 			}
 			return op;
 		} else {
 			die("invalid store");
 		}
 	} else if kind == IOP_VAR {
 		v = vals[op.n];
 		if !v {
 			return op;
 		}
 		return v;
 		vals[op.n] = nil;
 		ret = irop_basic_value(ic, vals, v);
 		vals[op.n] = v;
 		return ret;
 	} else if kind == IOP_RETVAL {
 		return op;
 	} else if kind == IOP_ARG || kind == IOP_LOAD || kind == IOP_NEG
 			|| kind == IOP_NOT || kind == IOP_CALL || kind == IOP_BRANCH
 			|| kind == IOP_RETURN {
 		// Unary operators
 		a = irop_basic_value(ic, vals, a);
 		if a == op.a {
 			return op;
 		}
 
 		ret = mkirop(ic, kind, a, nil);
 		ircopyloc(ret, op);
 		ret.t = op.t;
 		ret.n = op.n;
 
 		return ret;
 	} else if kind == IOP_VARREF || kind == IOP_FUNC || kind == IOP_CONST
 			|| kind == IOP_STR || kind == IOP_JUMP {
 		// Null operators
 		return op;
 	} else if kind == IOP_ADD || kind == IOP_AND || kind == IOP_OR
 			|| kind == IOP_XOR || kind == IOP_DIV || kind == IOP_MOD
 			|| kind == IOP_LSH || kind == IOP_RSH || kind == IOP_MUL
 			|| kind == IOP_SUB || kind == IOP_EQ || kind == IOP_NE
 			|| kind == IOP_GT || kind == IOP_GE || kind == IOP_LT
 			|| kind == IOP_LE {
 		// Binary operators
 		a = irop_basic_value(ic, vals, a);
 		b = irop_basic_value(ic, vals, b);
 		if a == op.a && b == op.b {
 			return op;
 		}
 
 		ret = mkirop(ic, kind, a, b);
 		ircopyloc(ret, op);
 		ret.t = op.t;
 
 		return ret;
 	} else {
 		die("invalid op");
 		return nil;
 	}
 	return nil;
 }
 
 // This is a VERY dumb way to do this.
 func irblock_basic_value(ic: *irfunc, ib: *irblock) {
 	var i: int;
 	var nvals: int;
 	var vals: **irop;
 	var op: *irop;
 
 	if !ib.done {
 		die("block not closed");
 	}
 
 	if ib.mark {
 		return;
 	}
 
 	ib.mark = 1;
 
 	nvals = ic.vars_len;
 	vals = alloc(ic.a, 8 * nvals) as **irop;
 
 	assert_zero(vals as *byte, 8 * nvals);
 
 	i = 0;
 	loop {
 		if i == ib.ops_len {
 			break;
 		}
 
 		op = ib.ops[i];
 		op = irop_basic_value(ic, vals, op);
 		ib.ops[i] = op;
 
 		i = i + 1;
 	}
 
 	free(ic.a, vals as *byte);
 	alloc(ic.a, 16);
 
 	op = ib.ops[ib.ops_len - 1];
 
 	// Continue
 	if op.kind == IOP_BRANCH {
 		irblock_basic_value(ic, ib.out);
 		irblock_basic_value(ic, ib.alt);
 	} else if op.kind == IOP_JUMP || op.kind == IOP_CALL {
 		irblock_basic_value(ic, ib.out);
 	} else if op.kind == IOP_RETURN {
 		// End of block.
 	} else {
 		die("invalid block");
 	}
 }
 
 func irfunc_basic_value(ic: *irfunc) {
 	// Forward simple stores to their use
 	irblock_basic_value(ic, ic.blocks[0]);
 	irreset(ic.blocks[0]);
 }
 
 func irblock_backlink(ic: *irfunc, ib: *irblock, from: *irblock) {
 	var kind: int;
 
 	// Add an incoming edge.
 	if from {
 		if ib.back {
 			ib.back[ib.back_len] = from;
 		}
 		ib.back_len = ib.back_len + 1;
 	}
 
 	// Descend to out/alt blocks once.
 	if ib.mark {
 		return;
 	}
 	ib.mark = 1;
 
 	// Add incoming edges for unique blocks.
 	kind = ib.ops[ib.ops_len - 1].kind;
 	if kind == IOP_CALL || kind == IOP_JUMP {
 		irblock_backlink(ic, ib.out, ib);
 	} else if kind == IOP_BRANCH {
 		irblock_backlink(ic, ib.out, ib);
 		if ib.out != ib.alt {
 			irblock_backlink(ic, ib.alt, ib);
 		}
 	} else if kind == IOP_RETURN {
 		if ic.returns {
 			ic.returns[ic.returns_len] = ib;
 		}
 		ic.returns_len = ic.returns_len + 1;
 	} else {
 		die("invalid block");
 	}
 }
 
 func irfunc_backlink(ic: *irfunc) {
 	var ib: *irblock;
 	var i: int;
 	var j: int;
 
 	// Clear the reachable returns
 	if ic.returns {
 		free(ic.a, ic.returns as *byte);
 	}
 	ic.returns = nil;
 	ic.returns_len = 0;
 
 	// Clear the known backlinks
 	i = 0;
 	loop {
 		if i == ic.blocks_len {
 			break;
 		}
 
 		ib = ic.blocks[i];
 
 		if ib.back {
 			free(ic.a, ib.back as *byte);
 		}
 		ib.back = nil;
 		ib.back_len = 0;
 
 		i = i + 1;
 	}
 
 	// Walk the call graph to find the reachable blocks
 	irblock_backlink(ic, ic.blocks[0], nil);
 
 	// Allocate space for returns
 	ic.returns = alloc(ic.a, ic.returns_len * sizeof(*ic.returns)) as **irblock;
 
 	// Find returns, clear marks, and allocate backlinks
 	i = 0;
 	j = 0;
 	loop {
 		if i == ic.blocks_len {
 			break;
 		}
 
 		ib = ic.blocks[i];
 
 		if ib.back_len {
 			ib.back = alloc(ic.a, ib.back_len * sizeof(*ib.back)) as **irblock;
 		}
 
 		ib.back_len = 0;
 		ib.mark = 0;
 
 		i = i + 1;
 	}
 
 	// Fill in the backlink arrays
 	irblock_backlink(ic, ic.blocks[0], nil);
 	irreset(ic.blocks[0]);
 }
 
 func ir_optimize(ic: *irfunc) {
 	// Too many bugs...
 	return;
 
 	// Do the easy simplifications first.
 	irfunc_dead(ic);
 	irfunc_fold(ic);
 	irfunc_flow(ic);
 	irfunc_backlink(ic);
 
 	// Do some data flow analysis within a basic block
 	irfunc_basic_value(ic);
 
 	// Do them again.
 	irfunc_dead(ic);
 	irfunc_fold(ic);
 	irfunc_flow(ic);
 	//irfunc_backlink(ic);
 
 	// Do instruction selection
 	// Do register allocation
 }