save before ast rework

Makefile

 CFLAGS ?= -Wall -Wextra -Werror -Wno-unused -O0 -g
 
 objs := $(patsubst %.c,%.o,$(wildcard *.c))
-headers := $(wildcard *.c)
+deps := $(wildcard *.c) $(wildcard *.h)
 
-$(objs): $(headers)
+$(objs): $(deps)
 
 ply: $(objs)

global.c

 
 /* pid */
 
+int pid_generate_ir(prog_t *prog, node_t *node)
+{
+	/* TODO */
+	return 0;
+}
+
 type_t t_pid_t = {
 	.ttype = T_TYPEDEF,
 
 		.name = "pid",
 		.type = &t_pid_t,
 		.args = NULL,
+		.generate_ir = pid_generate_ir,
 	},
 };
 
 
 /* quantize */
 
+int quantize_generate_ir(prog_t *prog, node_t *node)
+{
+	/* TODO */
+	return 0;
+}
+
 type_t t_u64_64 = {
 	.ttype = T_ARRAY,
 	.t.array = {
 		.name = "quantize",
 		.type = &t_quantize_t,
 		.args = f_quantize_args,
+		.generate_ir = quantize_generate_ir,
 	},
 };
 
 
 /* time */
 
+int time_generate_ir(prog_t *prog, node_t *node)
+{
+	ir_emit_call(prog->ir, BPF_FUNC_ktime_get_ns);
+
+	irs_alloc_reg(&node->irs, prog->ir);
+	ir_emit_insn(prog->ir, MOV(0, 0), node->irs.reg, BPF_REG_0);
+	return 0;
+}
+
 type_t t_time_t = {
 	.ttype = T_TYPEDEF,
 
 	.t.tdef = {
 		.name = "__ply_time_t",
-		.type = &t_u32,
+		.type = &t_s64,
 	},
 };
 
 		.name = "time",
 		.type = &t_time_t,
 		.args = NULL,
+		.generate_ir = time_generate_ir,
 	},
 };
 

ir.c

 #include <linux/bpf.h>
 
 #include "ir.h"
+#include "sym.h"
 
 const uint16_t vreg_base = 0x8000;
 
 	case VI_INSN:
 		__insn_dump(vi->insn.bpf, vi->insn.dst, vi->insn.src, fp);
 		return;
+	case VI_LDMAP:
+		fputs("ldmap\t", fp); reg_dump(vi->map.reg, 0, fp);
+		fprintf(fp, ", %s", vi->map.sym->name);
+		return;
 	case VI_LABEL:
 		offset_dump(vi->label, fp);
 		fputc(':', fp);
 	size_t i;
 
 	for (i = 0; i < ir->len; i++) {
-		if (ir->vi[i].vitype == VI_INSN)
+		vinsn_t *vi = &ir->vi[i];
+
+		switch (vi->vitype) {
+		case VI_INSN:
+		case VI_LDMAP:
 			fputc('\t', fp);
+			break;
+		case VI_REG_GET:
+		case VI_REG_PUT:
+			fputs("\e[2m", fp);
+		case VI_LABEL:
+		default:
+			break;
+		}
+
+		vinsn_dump(vi, fp);
+
+		/* print multiple gets/puts on one line */
+		switch (vi->vitype) {
+		case VI_REG_GET:
+			for (; (vi + 1)->vitype == VI_REG_GET; vi++, i++) {
+				fputs(", ", fp);
+				reg_dump((vi + 1)->reg, 0, fp);
+			}
+			fputs("\e[0m", fp);
+			break;
+		case VI_REG_PUT:
+			for (; (vi + 1)->vitype == VI_REG_PUT; vi++, i++) {
+				fputs(", ", fp);
+				reg_dump((vi + 1)->reg, 0, fp);
+			}
+			fputs("\e[0m", fp);
+			break;
+		default:
+			break;
+		}
 
-		vinsn_dump(&ir->vi[i], fp);
 		fputc('\n', fp);
 	}
 }
 	ir_emit(ir, &vi);
 }
 
+void ir_emit_ldmap(ir_t *ir, uint16_t dst, sym_t *map)
+{
+	vinsn_t vi;
+
+	vi.vitype = VI_LDMAP;
+	vi.map.reg = dst;
+	vi.map.sym = map;
+	ir_emit(ir, &vi);
+}
+
 void ir_emit_label  (ir_t *ir, int16_t label)
 {
 	vinsn_t vi;

ir.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;
+
 typedef enum vitype {
 	VI_INSN,
+	VI_LDMAP,
 	VI_LABEL,
 	VI_REG_GET,
 	VI_REG_PUT,
 
 		int16_t label;
 		uint16_t reg;
+
+		struct {
+			uint16_t reg;
+			sym_t *sym;
+		} map;
 	};
 } vinsn_t;
 
 uint16_t ir_alloc_register(ir_t *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);
 
+static inline void ir_emit_call(ir_t *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_get(ir, BPF_REG_2);
+	ir_emit_reg_get(ir, BPF_REG_3);
+	ir_emit_reg_get(ir, BPF_REG_4);
+	ir_emit_reg_get(ir, BPF_REG_5);
+	ir_emit_insn(ir, CALL(func), 0, 0);
+	ir_emit_reg_put(ir, BPF_REG_5);
+	ir_emit_reg_put(ir, BPF_REG_4);
+	ir_emit_reg_put(ir, BPF_REG_3);
+	ir_emit_reg_put(ir, BPF_REG_2);
+	ir_emit_reg_put(ir, BPF_REG_1);
+	ir_emit_reg_put(ir, BPF_REG_0);
+}
+
 ir_t *ir_new(void);
 
+typedef enum irloc {
+	LOC_IMM   = (1 << 0),
+	LOC_REG   = (1 << 1),
+	LOC_STACK = (1 << 2),
+} irloc_t;
+
+typedef struct irstate {
+	int loc;
+
+	uint16_t reg;
+	int16_t stack;
+} irstate_t;
+
+static inline void irs_alloc_reg(irstate_t *irs, ir_t *ir)
+{
+	irs->loc = LOC_REG;
+	irs->reg = ir_alloc_register(ir);
+	ir_emit_reg_get(ir, irs->reg);
+}
+
 #endif	/* _PLY_IR_H */

kprobe.c

 	if (!ctx)
 		return 0;
 
-	ctx->reg = ir_alloc_register(prog->ir);
-	ir_emit_reg_get(prog->ir, ctx->reg);
+	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->reg, BPF_REG_1);
+	ir_emit_insn(prog->ir, MOV(0, 0), ctx->irs.reg, BPF_REG_1);
 	return 0;
 }
 

node.c

 	n->type = type_ptr_of(&t_char);
 	return n;
 }
+
+/* static struct node *node_new(enum ntype ntype) */
+/* { */
+/* 	struct node *n; */
+
+/* 	n = calloc(1, sizeof(*n)); */
+/* 	assert(n); */
+
+/* 	n->ntype = N_IDENT; */
+/* 	n->ident.name = name; */
+/* 	return n; */
+/* } */
+
+/* struct node *node_string(char *data) */
+/* { */
+/* 	struct node *n = node_new(N_STRING); */
+
+/* 	n->string.data = data; */
+/* 	return n; */
+/* } */
+
+/* struct node *node_num(int64_t num) */
+/* { */
+/* 	struct node *n = node_new(N_NUM); */
+
+/* 	n->num.num = num; */
+/* 	return n; */
+/* } */
+
+/* struct node *node_ident(char *name) */
+/* { */
+/* 	struct node *n = node_new(N_IDENT); */
+
+/* 	n->ident.name = name; */
+/* 	return n; */
+/* } */
+
+/* struct node *node_append(struct node *n, struct node *arg) */
+/* { */
+/* 	struct node *last; */
+/* 	assert(n->ntype == N_EXPR); */
+
+/* 	arg->up = n; */
+
+/* 	if (!n->expr.args) { */
+/* 		n->expr.args = arg; */
+/* 		return n; */
+/* 	} */
+
+/* 	for (last = n->expr.args; last->next; last = last->next); */
+
+/* 	last->next = arg; */
+/* 	arg->prev = last; */
+/* 	return n; */
+/* } */
+
+/* struct node *node_expr(char *func, ...) */
+/* { */
+/*         va_list ap; */
+/* 	struct node *n, *arg; */
+
+/* 	n = node_new(N_EXPR); */
+
+/* 	n->expr.func = func; */
+
+/*         va_start(ap, func); */
+
+/*         while ((arg = va_arg(ap, struct node *))) */
+/* 		append(n, arg); */
+
+/*         va_end(ap); */
+
+/* 	return n; */
+	
+/* } */

node.h

 #include <stdint.h>
 #include <stdio.h>
 
+#include "ir.h"
 #include "sym.h"
 #include "type.h"
 
+/* enum ntype { */
+/* 	N_EXPR, */
+/* 	N_IDENT, */
+/* 	N_NUM, */
+/* 	N_STRING, */
+/* }; */
+
+/* struct node { */
+/* 	struct node *next, *prev, *up; */
+
+/* 	enum ntype ntype; */
+
+/* 	union { */
+/* 		struct { */
+/* 			char *func; */
+/* 			struct node *args; */
+/* 		} expr; */
+/* 		struct { */
+/* 			char *name; */
+/* 		} ident; */
+/* 		struct { */
+/* 			int64_t num; */
+/* 		} num; */
+/* 		struct { */
+/* 			char *data; */
+/* 		} string; */
+/* 	}; */
+/* }; */
+	
 typedef struct node node_t;
 
 typedef enum kwclass {
 
 	type_t *type;
 	sym_t *sym;
+
+	irstate_t irs;
 };
 
 /* debug */

ply.c

 	prog->globals = ctx->globals;
 
 	prog->probe = "k:SyS_read";
-	/* { t0 = time(); @reads[pid()] = quantize(arg2) } */
+	/* { @t[0] = time(); @reads[pid()] = quantize(arg2) } */
 	prog->ast =
 		node_vlist(
 			node_vlist(node_keyword('=', 0),
-				   node_ident("t0"),
+				   node_vlist(node_keyword('[', 0),
+					      node_ident("@t"),
+					      node_num(0),
+					      NULL),
 				   node_list(node_ident("time")),
 				   NULL),
 			node_vlist(node_keyword('=', 0),
 {
 	prog_t *prog = _prog;
 
+	node_print(n, stdout); putchar('\n'); 
 	if (!n->type) {
 		node_print(n, stderr);
-		fputs(": is of unknown type\n", stderr);
+		fputs(": type unknown\n", stderr);
 		return -EINVAL;
 	}
 
 	return validate_func(n->list);
 }
 
+int validate_syms(prog_t *prog)
+{
+	return 0;
+}
+
+int run_validate_types(pass_t *pass, ctx_t *ctx)
+{
+	prog_t **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(node_t *n)
 {
 	int64_t result;
 	node_t *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);
 	return 0;
 }
 
+int generate_ir_ident(prog_t *prog, node_t *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(node_t *n, void *_prog)
 {
 	prog_t *prog = _prog;
 
+	switch (n->ntype) {
+	case N_LIST:
+		return 0;
+	case N_IDENT:
+		return generate_ir_ident(prog, n);
+
+	default:
+		break;
+	}
 	return 0;
 }
 
 		if (err)
 			return err;
 
-		err = node_walk(prog->ast, pass->pre, pass->post, prog);
+		err = node_walk(prog->ast, NULL, pass_generate_ir, prog);
 		if (err)
 			return err;
 
 	{ .run = run_walk, .post = pass_infer_types },
 	{ .run = run_walk, .post = pass_infer_types },
 	{ .run = run_walk, .post = pass_infer_types },
-	{ .run = run_walk, .post = pass_validate_types },
+	{ .run = run_validate_types, .post = pass_validate_types },
 	{ .run = run_walk, .post = pass_rewrite_ast },
 	{ .run = run_generate_ir },
 

sym.h

 
 #include <stdint.h>
 
+#include "ir.h"
 #include "type.h"
 
 typedef struct symtab symtab_t;
 	const char *name;
 	type_t *type;
 
-	uint16_t reg;
+	irstate_t irs;
 } sym_t;
 
 struct symtab {

type.c

 		break;
 	case T_FUNC:
 		t->size = t->t.func.type->size;
+		assert(t->t.func.generate_ir);
 		break;
 	case T_SCALAR:
 		break;

type.h

 #include <stddef.h>
 #include <stdio.h>
 
+typedef struct prog prog_t;
+typedef struct node node_t;
+
 typedef struct type type_t;
 
 struct t_tdef {
 	type_t *type;
 
 	field_t *args;
+
+	int (*generate_ir)(prog_t *prog, node_t *n);
 };
 
 typedef enum ttype {