ir back up, working on rewrite

func.h

 	int static_ret:1; 	/* return type is statically known */
 
 	int (*static_validate)(const struct func *, struct node *);
-	int (*type_infer)(const struct func *, struct node *);
+	int (*type_infer)     (const struct func *, struct node *);
+	int (*rewrite)        (const struct func *, struct node *, struct prog *);
+
+	int (*ir_pre) (const struct func *, struct node *, struct prog *);
+	int (*ir_post)(const struct func *, struct node *, struct prog *);
 };
 
 int func_static_validate(const struct func *func, struct node *n);

ir.c

-#if 0
 #include <assert.h>
 #include <inttypes.h>
 #include <stdio.h>
 	__insn_dump(insn, insn.dst_reg, insn.src_reg, fp);
 }
 
-void vinsn_dump(vinsn_t *vi, FILE *fp)
+void vinsn_dump(struct vinsn *vi, FILE *fp)
 {
 	switch (vi->vitype) {
 	case VI_INSN:
 	}
 }
 
-void ir_dump(ir_t *ir, FILE *fp)
+void ir_dump(struct ir *ir, FILE *fp)
 {
 	size_t i;
 
 	for (i = 0; i < ir->len; i++) {
-		vinsn_t *vi = &ir->vi[i];
+		struct vinsn *vi = &ir->vi[i];
 
 		switch (vi->vitype) {
 		case VI_INSN:
 	}
 }
 
-static void ir_emit(ir_t *ir, vinsn_t *vi)
+static void ir_emit(struct ir *ir, struct vinsn *vi)
 {
 	ir->vi = realloc(ir->vi, (++ir->len)*sizeof(*vi));
 	assert(ir->vi);
 	ir->vi[ir->len - 1] = *vi;
 }
 
-void ir_emit_insn(ir_t *ir, struct bpf_insn bpf, uint16_t dst, uint16_t src)
+void ir_emit_insn(struct ir *ir, struct bpf_insn bpf, uint16_t dst, uint16_t src)
 {
-	vinsn_t vi;
+	struct vinsn vi;
 
 	vi.vitype = VI_INSN;
 	vi.insn.bpf = bpf;
 	ir_emit(ir, &vi);
 }
 
-void ir_emit_ldmap(ir_t *ir, uint16_t dst, sym_t *map)
+void ir_emit_ldmap(struct ir *ir, uint16_t dst, struct sym *map)
 {
-	vinsn_t vi;
+	struct vinsn vi;
 
 	vi.vitype = VI_LDMAP;
 	vi.map.reg = dst;
 	ir_emit(ir, &vi);
 }
 
-void ir_emit_label  (ir_t *ir, int16_t label)
+void ir_emit_label  (struct ir *ir, int16_t label)
 {
-	vinsn_t vi;
+	struct vinsn vi;
 
 	vi.vitype = VI_LABEL;
 	vi.label = label;
 	ir_emit(ir, &vi);
 }
 
-void ir_emit_reg_get(ir_t *ir, uint16_t reg)
+void ir_emit_reg_get(struct ir *ir, uint16_t reg)
 {
-	vinsn_t vi;
+	struct vinsn vi;
 
 	vi.vitype = VI_REG_GET;
 	vi.reg = reg;
 	ir_emit(ir, &vi);
 }
 
-void ir_emit_reg_put(ir_t *ir, uint16_t reg)
+void ir_emit_reg_put(struct ir *ir, uint16_t reg)
 {
-	vinsn_t vi;
+	struct vinsn vi;
 
 	vi.vitype = VI_REG_PUT;
 	vi.reg = reg;
 	ir_emit(ir, &vi);
 }
 
-int16_t ir_alloc_label (ir_t *ir)
+int16_t ir_alloc_label (struct ir *ir)
 {
 	return ir->next_label--;
 }
 
-uint16_t ir_alloc_register(ir_t *ir)
+uint16_t ir_alloc_register(struct ir *ir)
 {
 	return ir->next_reg++;
 }
 
-ir_t *ir_new(void)
+struct ir *ir_new(void)
 {
-	ir_t *ir;
+	struct ir *ir;
 
 	ir = calloc(1, sizeof(*ir));
 	assert(ir);
 	ir->next_label = -1;
 	return ir;
 }
-#endif

ir.h

 #define _PLY_IR_H
 
 #include <stdint.h>
+#include <stdio.h>
 #include <stdlib.h>
 
 #include <linux/bpf.h>
 #define LDXW(_dst, _off, _src)  INSN(BPF_LDX | BPF_SIZE(BPF_W)  | BPF_MEM, _dst, _src, _off, 0)
 #define LDXDW(_dst, _off, _src) INSN(BPF_LDX | BPF_SIZE(BPF_DW) | BPF_MEM, _dst, _src, _off, 0)
 
-typedef struct sym sym_t;
+struct sym;
 
-typedef enum vitype {
+enum vitype {
 	VI_INSN,
 	VI_LDMAP,
 	VI_LABEL,
 	VI_REG_GET,
 	VI_REG_PUT,
-} vitype_t;
+};
 
-typedef struct vinsn {
-	vitype_t vitype;
+struct vinsn {
+	enum vitype vitype;
 
 	union {
 		struct {
 
 		struct {
 			uint16_t reg;
-			sym_t *sym;
+			struct sym *sym;
 		} map;
 	};
-} vinsn_t;
+};
 
-typedef struct ir {
-	vinsn_t *vi;
+struct ir {
+	struct vinsn *vi;
 	size_t len;
 
 	int16_t next_label;
 	uint16_t next_reg;
-} ir_t;
+};
 
 void insn_dump(struct bpf_insn insn, FILE *fp);
-void vinsn_dump(vinsn_t *vi, FILE *fp);
-void ir_dump(ir_t *ir, FILE *fp);
+void vinsn_dump(struct vinsn *vi, FILE *fp);
+void ir_dump(struct ir *ir, FILE *fp);
 
-int16_t  ir_alloc_label   (ir_t *ir);
-uint16_t ir_alloc_register(ir_t *ir);
+int16_t  ir_alloc_label   (struct ir *ir);
+uint16_t ir_alloc_register(struct ir *ir);
 
-void ir_emit_insn   (ir_t *ir, struct bpf_insn bpf, uint16_t dst, uint16_t src);
-void ir_emit_ldmap  (ir_t *ir, uint16_t dst, sym_t *map);
-void ir_emit_label  (ir_t *ir, int16_t label);
-void ir_emit_reg_get(ir_t *ir, uint16_t reg);
-void ir_emit_reg_put(ir_t *ir, uint16_t reg);
+void ir_emit_insn   (struct ir *ir, struct bpf_insn bpf, uint16_t dst, uint16_t src);
+void ir_emit_ldmap  (struct ir *ir, uint16_t dst, struct sym *map);
+void ir_emit_label  (struct ir *ir, int16_t label);
+void ir_emit_reg_get(struct ir *ir, uint16_t reg);
+void ir_emit_reg_put(struct ir *ir, uint16_t reg);
 
-static inline void ir_emit_call(ir_t *ir, enum bpf_func_id func)
+static inline void ir_emit_call(struct ir *ir, enum bpf_func_id func)
 {
 	ir_emit_reg_get(ir, BPF_REG_0);
 	ir_emit_reg_get(ir, BPF_REG_1);
 	ir_emit_reg_put(ir, BPF_REG_0);
 }
 
-ir_t *ir_new(void);
+struct ir *ir_new(void);
 
-typedef enum irloc {
+enum irloc {
 	LOC_IMM   = (1 << 0),
 	LOC_REG   = (1 << 1),
 	LOC_STACK = (1 << 2),
-} irloc_t;
+};
 
-typedef struct irstate {
+struct irstate {
 	int loc;
 
 	uint16_t reg;
 	int16_t stack;
-} irstate_t;
+};
 
-static inline void irs_alloc_reg(irstate_t *irs, ir_t *ir)
+static inline void irs_alloc_reg(struct irstate *irs, struct ir *ir)
 {
 	irs->loc = LOC_REG;
 	irs->reg = ir_alloc_register(ir);

kprobe.c

 
 #include <linux/ptrace.h>
 
+#include "arch.h"
 #include "func.h"
+#include "ir.h"
 #include "node.h"
 #include "ply.h"
 #include "sym.h"
 #include "type.h"
 
 struct kprobe {
+	int use_ctx:1;
+
+	struct irstate ctx_irs;
 };
 
-/* static int kprobe_ir_prologue(prog_t *prog) */
-/* { */
-/* 	sym_t *ctx = sym_get(prog->locals, "ctx"); */
+/* ctx */
+
+static struct type t_pt_regsp = {
+	.ttype = T_POINTER,
+
+	.ptr.type = &t_pt_regs,
+};
 
-/* 	if (!ctx) */
-/* 		return 0; */
+static const struct func kprobe_ctx_func = {
+	.name = "ctx",
+
+	.type = &t_pt_regsp,
+	.static_ret = 1,
+};
 
-/* 	irs_alloc_reg(&ctx->irs, prog->ir); */
 
-/* 	/\* kernel sets r1 to the address of the context *\/ */
-/* 	ir_emit_insn(prog->ir, MOV(0, 0), ctx->irs.reg, BPF_REG_1); */
-/* 	return 0; */
-/* } */
+/* argN */
 
 static inline int is_arg(const char *name)
 {
 		&& (name[3] >= '0' && name[3] <= '9');
 }
 
-/* static int kprobe_rewrite_arg(prog_t *prog, node_t *n) */
-/* { */
-/* 	const char *reg; */
-/* 	int arg = n->ident[3] - '0'; */
-/* 	node_t *new, *ctx; */
-
-/* 	reg = arch_register_argument(arg); */
-/* 	if (!reg) { */
-/* 		node_print(n, stderr); */
-/* 		fputs(": the location of this argument is unknown\n", stderr); */
-/* 		/\* TODO: add ABI mappings for specifying arguments */
-/* 		 * passed on the stack. *\/ */
-/* 		return -EINVAL; */
-/* 	} */
-
-/* 	ctx = node_ident("ctx"); */
-
-/* 	/\* argN => (*ctx).REG *\/ */
-/* 	new = node_vlist(node_keyword('.', 0), */
-/* 			 node_vlist(node_keyword('*', 0), */
-/* 				    ctx, */
-/* 				    NULL), */
-/* 			 node_string(reg), */
-/* 			 NULL); */
-
-/* 	ctx->type = type_ptr_of(&t_pt_regs); */
-/* 	new->type = n->type; */
-/* 	new->list->type = &t_void; */
-/* 	new->list->next->type = &t_pt_regs; */
-/* 	new->list->next->list->type = &t_void; */
-/* 	node_replace(n, new); */
-
-/* 	return sym_add(prog->locals, ctx->ident, ctx->type, &ctx->sym); */
-/* } */
-
-/* static int kprobe_rewrite_node(prog_t *prog, node_t *n) */
-/* { */
-/* 	if ((n->ntype == N_IDENT) && is_arg(n->ident)) */
-/* 		return kprobe_rewrite_arg(prog, n); */
-
-/* 	return 0; */
-/* } */
-
-/* static int kprobe_resolve(prog_t *prog, node_t *n) */
-/* { */
-/* 	type_t *t; */
-
-/* 	if (is_arg(n->ident)) */
-/* 		t = &t_ulong; */
-/* 	else if (!strcmp(n->ident, "ctx")) */
-/* 		t = type_ptr_of(&t_pt_regs); */
-/* 	else */
-/* 		return -ENOENT; */
-
-/* 	n->type = t; */
-/* 	return sym_add(prog->locals, n->ident, t, &n->sym); */
-/* } */
+static int kprobe_arg_rewrite(const struct func *func, struct node *n,
+			      struct prog *prog)
+{
+	struct node *new;
+	const char *reg;
+	int arg;
+
+	arg = n->ident.name[3] - '0';
+	reg = arch_register_argument(arg);
+	if (!reg) {
+		_e("%#N: the location of %N is unknown\n", n, n);
+
+		/* TODO: add ABI mappings for specifying arguments
+		 * passed on the stack. */
+		return -EINVAL;
+	}
+
+	/* argN => (*ctx).REG */
+	new = node_expr(".",
+			node_expr("*", node_ident("ctx"), NULL),
+			node_string((char *)reg),
+			NULL);
+
+	ast_fprint(stdout, n);
+	ast_fprint(stdout, new);
+
+	node_replace(n, new);
+	return 0;
+}
 
 static const struct func kprobe_arg_func = {
 	.name = "argN",
 	 * figure out the real type. */
 	.type = &t_ulong,
 	.static_ret = 1,
+
+	.rewrite = kprobe_arg_rewrite,
 };
 
+
+/*  */
+
+static int kprobe_ir_pre(struct prog *prog)
+{
+	struct kprobe *kp = prog->provider_data;
+
+	if (!kp->use_ctx)
+		return 0;
+
+	irs_alloc_reg(&kp->ctx_irs, prog->ir);
+
+	/* kernel sets r1 to the address of the context */
+	ir_emit_insn(prog->ir, MOV(0, 0), kp->ctx_irs.reg, BPF_REG_1);
+	return 0;
+}
+
 static int kprobe_sym_alloc(struct prog *prog, struct node *n)
 {
+	struct kprobe *kp = prog->provider_data;
 	const struct func *func = NULL;
 	int err;
 
 	case N_EXPR:
 		break;
 	case N_IDENT:
-		if (is_arg(n->ident.name))
-			func = &kprobe_arg_func;
+		if (!is_arg(n->ident.name))
+			break;
+
+		func = &kprobe_arg_func;
+		kp->use_ctx = 1;
 		break;
 	default:
 		break;
 struct provider kprobe = {
 	.name = "kprobe",
 
-	/* .ir_prologue = kprobe_ir_prologue, */
+	.ir_pre = kprobe_ir_pre,
 	/* .rewrite_node = kprobe_rewrite_node, */
 	/* .resolve = kprobe_resolve, */
 	.sym_alloc = kprobe_sym_alloc,

ply.c

 #include <string.h>
 
 #include "func.h"
+#include "ir.h"
 #include "node.h"
 #include "ply.h"
 #include "sym.h"
 
 	prog->provider = provider_get("k");
 	prog->provider->probe(prog);
-	/* prog->ir = ir_new(); */
+	prog->ir = ir_new();
 	ctx->progs[0] = prog;
 
 	/* PROBE1 */
 
 	prog->provider = provider_get("k");
 	prog->provider->probe(prog);
-	/* prog->ir = ir_new(); */
+	prog->ir = ir_new();
 	ctx->progs[1] = prog;
 
 	return ctx;
 	return err;
 }
 
-/* int infer_type_list(struct prog *prog, struct node *n) */
-/* { */
-/* 	type_t *t; */
 
-/* 	/\* list of lists (code block) => void *\/ */
-/* 	if (n->list->ntype == N_LIST) { */
-/* 		n->type = &t_void; */
-/* 		return 0; */
-/* 	} */
-
-/* 	t = n->list->type; */
-/* 	if (!t) */
-/* 		return 0; */
-
-/* 	switch (t->ttype) { */
-/* 	case T_FUNC: */
-/* 		n->type = t->t.func.type; */
-/* 		break; */
-/* 	default: */
-/* 		n->type = t; */
-/* 	} */
-/* 	return 0; */
-/* } */
-
-/* int infer_type_keyword(struct prog *prog, struct node *n) */
-/* { */
-/* 	struct node *dst, *src; */
-
-/* 	switch (n->keyword.class) { */
-/* 	case KW_ASSIGN: */
-/* 		dst = node_next(n); */
-/* 		src = node_next(dst); */
-/* 		assert(dst && src); */
-
-/* 		if (!src->type) */
-/* 			return 0; */
-
-/* 		/\* TODO: assignment is statement for now. do we need */
-/* 		 * c-style assignment expressions? e.g `a = b = 2;` *\/ */
-/* 		n->type = &t_void; */
-
-/* 		if (dst->type) */
-/* 			return 0; */
+int pass_type_infer(struct node *n, void *_prog)
+{
+	struct prog *prog = _prog;
 
-/* 		dst->type = src->type; */
+	if (n->sym->func->type_infer)
+		return n->sym->func->type_infer(n->sym->func, n);
 
-/* 		if (dst->ntype != N_IDENT) */
-/* 			return 0; */
+	/* TODO recurse as long as we're infering new types */
+	return 0;
+}
 
-/* 		return sym_add(dst->sym->st, dst->ident, dst->type, NULL); */
+int pass_rewrite(struct node *n, void *_prog)
+{
+	struct prog *prog = _prog;
 
-/* 	case KW_BINOP: */
-/* 		dst = node_next(n); */
-/* 		src = node_next(dst); */
-/* 		assert(dst && src); */
+	if (n->sym->func->rewrite)
+		return n->sym->func->rewrite(n->sym->func, n, prog);
 
-/* 		if (!(src->type && dst->type && type_equal(src->type, dst->type))) */
-/* 			return 0; */
+	return 0;
+}
 
-/* 		n->type = dst->type; */
-/* 		return 0; */
+int pass_ir_pre(struct node *n, void *_prog)
+{
+	struct prog *prog = _prog;
 
-/* 	default: */
-/* 		n->type = &t_void; */
-/* 		return 0; */
-/* 	} */
+	if (n->sym->func->ir_pre)
+		return n->sym->func->ir_pre(n->sym->func, n, prog);
 
-/* 	return -ENOSYS; */
-/* } */
+	return 0;
+}
 
-/* int infer_type_sym(struct prog *prog, struct node *n) */
-/* { */
-/* 	struct node *parent, *key; */
+int pass_ir_post(struct node *n, void *_prog)
+{
+	struct prog *prog = _prog;
 
-/* 	if (n->sym->type) { */
-/* 		/\* the symbol type could have been inferred in another */
-/* 		 * probe, in that case copy the type to this node. *\/ */
-/* 		if (!n->type) */
-/* 			n->type = n->sym->type; */
+	if (n->sym->func->ir_post)
+		return n->sym->func->ir_post(n->sym->func, n, prog);
 
-/* 		return 0; */
-/* 	} */
+	return 0;
+}
 
-/* 	parent = node_up(n); */
-/* 	key = node_next(n); */
+int run_ir(struct pass *pass, struct ctx *ctx)
+{
+	struct prog **progp;
+	int err;
 
-/* 	/\* match `somemap[somekey]` where the type of the entire */
-/* 	 * expression and the type of the key is known, since that */
-/* 	 * means the type of the map itself is also known. *\/ */
-/* 	if (parent && parent->type */
-/* 	    && (parent->list->ntype == N_KEYWORD) */
-/* 	    && (parent->list->keyword.class == KW_SUBSCRIPT) */
-/* 	    && key && key->type) { */
-/* 		n->type = type_map_of(key->type, parent->type); */
+	for (progp = ctx->progs; *progp; progp++) {
+		struct prog *prog = *progp;
 
-/* 		return sym_add(n->sym->st, n->ident, n->type, NULL); */
-/* 	} */
+		err = prog->provider->ir_pre ?
+			prog->provider->ir_pre(prog) : 0;
+		if (err)
+			return err;
 
-/* 	return 0; */
-/* } */
+		err = node_walk(prog->ast, pass_ir_pre, pass_ir_post, prog);
+		if (err)
+			return err;
 
-int pass_type_infer(struct node *n, void *_prog)
-{
-	struct prog *prog = _prog;
+		err = prog->provider->ir_post ?
+			prog->provider->ir_post(prog) : 0;
+		if (err)
+			return err;
 
-	if (n->sym->func->type_infer)
-		return n->sym->func->type_infer(n->sym->func, n);
+		ir_emit_insn(prog->ir, EXIT, 0, 0);
+	}
 
 	return 0;
 }
 
-/* int validate_func(struct node *n) */
-/* { */
-/* 	struct node *arg; */
-/* 	field_t *f; */
-/* 	int i; */
-
-/* 	for (arg = node_next(n), f = n->type->t.func.args, i = 1; */
-/* 	     arg && f && f->type; arg = node_next(arg), f++, i++) { */
-/* 		if (type_compatible(arg->type, f->type)) */
-/* 			continue; */
-
-/* 		node_print(n, stderr); */
-/* 		fprintf(stderr, ": incompatible type of argument %d (", i); */
-/* 		type_dump(arg->type, stderr); */
-/* 		fputs("), expected ", stderr); */
-/* 		type_dump(f->type, stderr); */
-/* 		fputs("\n", stderr); */
-/* 		return -EINVAL; */
-/* 	} */
-
-/* 	if (!arg && (!f || !f->type)) */
-/* 		return 0; */
-
-/* 	if (arg) { */
-/* 		node_print(n, stderr); */
-/* 		fprintf(stderr, ": too many arguments, expected %d", i); */
-/* 		return -EINVAL; */
-/* 	} */
-
-/* 	if (f->optional) */
-/* 		return 0; */
-
-/* 	node_print(n, stderr); */
-/* 	fputs(": too few arguments", stderr); */
-/* 	return -EINVAL;	 */
-/* } */
-
-/* int pass_validate_types(struct node *n, void *_prog) */
-/* { */
-/* 	struct prog *prog = _prog; */
-
-/* 	node_print(n, stdout); putchar('\n');  */
-/* 	if (!n->type) { */
-/* 		node_print(n, stderr); */
-/* 		fputs(": type unknown\n", stderr); */
-/* 		return -EINVAL; */
-/* 	} */
-
-/* 	if (n->ntype != N_LIST) */
-/* 		return 0; */
-
-/* 	if (n->list->ntype != N_IDENT) */
-/* 		return 0; */
-
-/* 	assert(n->list->type->ttype == T_FUNC); */
-/* 	return validate_func(n->list); */
-/* } */
-
-/* int validate_syms(struct prog *prog) */
-/* { */
-/* 	return 0; */
-/* } */
-
-/* int run_validate_types(struct pass *pass, struct ctx *ctx) */
-/* { */
-/* 	struct prog **prog; */
-/* 	int err; */
-
-/* 	for (prog = ctx->progs; *prog; prog++) { */
-/* 		/\* check syms first to give better error messages. */
-/* 		 * e.g. "i: type unknown", not "b-: type unknown" *\/ */
-/* 		err = validate_syms(*prog); */
-/* 		if (err) */
-/* 			return err; */
-
-/* 		err = node_walk((*prog)->ast, pass->pre, pass->post, *prog); */
-/* 		if (err) */
-/* 			return err; */
-/* 	} */
-
-/* 	return 0; */
-
-/* } */
-
-/* int rewrite_const_math(struct node *n) */
-/* { */
-/* 	int64_t result; */
-/* 	struct node *a, *b, *new; */
-/* 	int op; */
-
-/* 	/\* TODO: handle L/UL/ULL correctly *\/ */
-	
-/* 	op = n->list->keyword.op; */
-/* 	a = node_next(n->list); */
-/* 	b = node_next(a); */
-
-/* 	switch (op) { */
-/* 	case '*': result = a->num *  b->num; break; */
-/* 	case '/': result = a->num /  b->num; break; */
-/* 	case '%': result = a->num %  b->num; break; */
-/* 	case '+': result = a->num +  b->num; break; */
-/* 	case '-': result = a->num -  b->num; break; */
-/* 	case '<': result = a->num << b->num; break; */
-/* 	case '>': result = a->num >> b->num; break; */
-/* 	default: return 0; */
-/* 	} */
-
-/* 	new = node_num(result); */
-/* 	new->type = n->type; */
-/* 	return node_replace(n, new); */
-/* } */
-
-/* int pass_rewrite_ast(struct node *n, void *_prog) */
-/* { */
-/* 	struct prog *prog = _prog; */
-/* 	provider_t *global = provider_get(":"); */
-/* 	int err; */
-
-/* 	if (prog->provider->rewrite_node) { */
-/* 		err = prog->provider->rewrite_node(prog, n); */
-/* 		if (err) */
-/* 			return err; */
-/* 	} */
-
-/* 	if (global->rewrite_node) { */
-/* 		err = global->rewrite_node(prog, n); */
-/* 		if (err) */
-/* 			return err; */
-/* 	} */
-
-/* 	/\* pre-compute binops where both sides are constants *\/ */
-/* 	if ((n->ntype == N_LIST) */
-/* 	    && (n->list->ntype == N_KEYWORD) */
-/* 	    && (n->list->keyword.class == KW_BINOP) */
-/* 	    && (node_next(n->list)->ntype == N_NUM) */
-/* 	    && (node_next(node_next(n->list))->ntype == N_NUM)) */
-/* 		return rewrite_const_math(n); */
-
-/* 	return 0; */
-/* } */
-
-/* int generate_ir_ident(struct prog *prog, struct node *n) */
-/* { */
-
-/* 	switch (n->sym->type->ttype) { */
-/* 	case T_FUNC: */
-/* 		return n->sym->type->t.func.generate_ir(prog, n); */
-/* 	case T_MAP: */
-/* 		ir_emit_ldmap(prog->ir, BPF_REG_0, n->sym); */
-/* 		return 0; */
-/* 	default: */
-/* 		break; */
-/* 	} */
-
-/* 	return 0; */
-/* } */
-
-/* int pass_generate_ir(struct node *n, void *_prog) */
-/* { */
-/* 	struct prog *prog = _prog; */
-
-/* 	switch (n->ntype) { */
-/* 	case N_LIST: */
-/* 		return 0; */
-/* 	case N_IDENT: */
-/* 		return generate_ir_ident(prog, n); */
-
-/* 	default: */
-/* 		break; */
-/* 	} */
-/* 	return 0; */
-/* } */
-
-/* int run_generate_ir(struct pass *pass, struct ctx *ctx) */
-/* { */
-/* 	struct prog **progp; */
-/* 	int err; */
-
-/* 	for (progp = ctx->progs; *progp; progp++) { */
-/* 		struct prog *prog = *progp; */
-
-/* 		int return_label = ir_alloc_label(prog->ir); */
-
-/* 		err = prog->provider->ir_prologue ? */
-/* 			prog->provider->ir_prologue(prog) : 0; */
-/* 		if (err) */
-/* 			return err; */
-
-/* 		err = node_walk(prog->ast, NULL, pass_generate_ir, prog); */
-/* 		if (err) */
-/* 			return err; */
-
-/* 		err = prog->provider->ir_epilogue ? */
-/* 			prog->provider->ir_epilogue(prog) : 0; */
-/* 		if (err) */
-/* 			return err; */
-
-/* 		ir_emit_label(prog->ir, return_label); */
-/* 		ir_emit_insn(prog->ir, EXIT, 0, 0); */
-/* 	} */
-
-/* 	return 0; */
-/* } */
-
 int run_walk(struct pass *pass, struct ctx *ctx)
 {
 	struct prog **prog;
 
 struct pass passes[] = {
 	{ .run = run_walk, .post = pass_sym_alloc },
+	/* node->sym ok */
 	{ .run = run_walk, .post = pass_type_infer },
-	/* { .run = run_walk, .post = pass_infer_types }, */
-	/* { .run = run_walk, .post = pass_infer_types }, */
-	/* { .run = run_validate_types, .post = pass_validate_types }, */
-	/* { .run = run_walk, .post = pass_rewrite_ast }, */
-	/* { .run = run_generate_ir }, */
-
+	/* node->sym->type ok */
+	/* user input is accepted. we'll now start rewriting the ast,
+	 * so errors beyond this point are internal errors. */
+	{ .run = run_walk, .post = pass_rewrite },
+	{ .run = run_ir },
+	/* program flattened to vBPF instructions, now rewrite it to
+	 * fit into the actual hw/vm. */
+
+	/* BPF program ready */
 	{ NULL }
 };
 
 		ast_fprint(stdout, (*prog)->ast);
 		printf("\n-- locals\n");
 		symtab_dump((*prog)->locals, stdout);
-		/* printf("-- ir\n"); */
-		/* ir_dump((*prog)->ir, stdout); */
+		printf("-- ir\n");
+		ir_dump((*prog)->ir, stdout);
 	}
 
 	printf("\n\n-- globals\n");

ply.h

 
 struct node;
 struct symtab;
+struct ir;
 
 struct prog {
 	const char *probe;
 	struct provider *provider;
 	void *provider_data;
 
-	/* ir_t *ir; */
+	struct ir *ir;
 };
 
 struct ctx {
 	int (*sym_alloc)(struct prog *, struct node *);
 	/* int (*resolve)(struct prog *, struct node *); */
 	/* int (*rewrite_node)(struct prog *, struct node *); */
-	/* int (*ir_prologue)(struct prog *); */
-	/* int (*ir_epilogue)(struct prog *); */
+	int (*ir_pre)(struct prog *);
+	int (*ir_post)(struct prog *);
 };
 
 void provider_register(struct provider *p);

sym.h

 
 #include <stdint.h>
 
-struct symtab;
-
-struct type;
 struct func;
+struct node;
+struct type;
+
+struct symtab;
 
 struct sym {
 	struct symtab *st;