working on deref compilation

global.c

 		}
 	}
 
-	_e("%#N: type '%T' has no member named '%s'.\n",
-	   n, t, member->string.data);
+	_e("%#N: type '%T' has no member named %N.\n", n, t, member);
 	return -EINVAL;
 }
 
 
 /* :deref */
 
+static int global_deref_ir_post(const struct func *func, struct node *n,
+				struct prog *prog)
+{
+	struct node *ptr = n->expr.args;
+	struct irstate *dst;
+	size_t size;
+
+	dst = &n->sym->irs;
+	if (dst->hint.dot)
+		/* (*ptr).member, ptr points to a struct and our
+		 * parent is only interested in one member. don't load
+		 * the struct, let the dot operaton steal the address
+		 * from our argument */
+		return 0;
+
+	if (dst->loc)
+		return 0;
+
+	size = type_sizeof(type_base(ptr->sym->type)->ptr.type);
+	/* parent might have already allocated stack for us. typically
+	 * when the value is one part of a map key or value. */
+	if (!dst->hint.stack)
+		irs_alloc_stack(dst, prog->ir, size);
+
+	ir_emit_insn(prog->ir, MOV(0, 0), BPF_REG_1, BPF_REG_BP);
+	ir_emit_insn(prog->ir, ALU_IMM(BPF_ADD, 0, dst->stack), BPF_REG_1, 0);
+	ir_emit_insn(prog->ir, MOV_IMM(0, (int32_t)size), BPF_REG_2, 0);
+	ir_emit_mov_irs(prog->ir, BPF_REG_3, &ptr->sym->irs);
+	ir_emit_insn(prog->ir, CALL(BPF_FUNC_probe_read), 0, 0);
+	return 0;
+}
+
+
 static int global_deref_type_infer(const struct func *func, struct node *n)
 {
 	struct node *ptr = n->expr.args;
 
 		/* TODO do we need assignment expressions? */
 		n->sym->type = &t_void;
-
+		
 		if (node_is_map(lval))
 			return global_assign_type_infer_map(lval);
 
 		.name = ":deref",
 		.type = &t_1arg_func,
 		.type_infer = global_deref_type_infer,
+
+		.ir_post = global_deref_ir_post,
 	},
 
 	{

ir.c

 	ir_emit(ir, &vi);
 }
 
-void ir_emit_reg_get(struct ir *ir, uint16_t reg)
-{
-	struct vinsn vi;
+/* void ir_emit_reg_get(struct ir *ir, uint16_t reg) */
+/* { */
+/* 	struct vinsn vi; */
 
-	vi.vitype = VI_REG_GET;
-	vi.reg = reg;
-	ir_emit(ir, &vi);
-}
+/* 	vi.vitype = VI_REG_GET; */
+/* 	vi.reg = reg; */
+/* 	ir_emit(ir, &vi); */
+/* } */
+
+/* void ir_emit_reg_put(struct ir *ir, uint16_t reg) */
+/* { */
+/* 	struct vinsn vi; */
 
-void ir_emit_reg_put(struct ir *ir, uint16_t reg)
+/* 	vi.vitype = VI_REG_PUT; */
+/* 	vi.reg = reg; */
+/* 	ir_emit(ir, &vi); */
+/* } */
+
+void ir_emit_mov_irs(struct ir *ir, uint16_t dst, struct irstate *src)
 {
-	struct vinsn vi;
+	switch (src->loc) {
+	case LOC_IMM:
+		ir_emit_insn(ir, MOV_IMM(0, src->imm), dst, 0);
+		break;
+	case LOC_REG:
+		ir_emit_insn(ir, MOV(0, 0), dst, src->reg);
+		break;
+	case LOC_STACK:
+		ir_emit_insn(ir, LDX(0, src->stack, 0), dst, BPF_REG_BP);
+		break;
 
-	vi.vitype = VI_REG_PUT;
-	vi.reg = reg;
-	ir_emit(ir, &vi);
+	default:
+		assert(0);
+	}
 }
 
 int16_t ir_alloc_label (struct ir *ir)
 	return ir->next_reg++;
 }
 
+ssize_t ir_alloc_stack(struct ir *ir, size_t size)
+{
+	ir->sp -= size;
+	assert(ir->sp > INT32_MIN);
+
+	return ir->sp;
+}
+
 struct ir *ir_new(void)
 {
 	struct ir *ir;

ir.h

 #include <stdio.h>
 #include <stdlib.h>
 
+#include <bits/wordsize.h>
 #include <linux/bpf.h>
 
 #define INSN(_code, _dst, _src, _off, _imm)	\
 #define JMP(_op, _dst, _src, _off)     INSN(BPF_JMP | BPF_OP((_op)) | BPF_X, _dst, _src, _off, 0)
 #define JMP_IMM(_op, _dst, _imm, _off) INSN(BPF_JMP | BPF_OP((_op)) | BPF_K, _dst, 0, _off, _imm)
 
-#define ALU(_op, _dst, _src)     INSN(BPF_ALU64 | BPF_OP((_op)) | BPF_X, _dst, _src, 0, 0)
-#define ALU_IMM(_op, _dst, _imm) INSN(BPF_ALU64 | BPF_OP((_op)) | BPF_K, _dst, 0, 0, _imm)
+#define ALU32(_op, _dst, _src)     INSN(BPF_ALU | BPF_OP((_op)) | BPF_X, _dst, _src, 0, 0)
+#define ALU32_IMM(_op, _dst, _imm) INSN(BPF_ALU | BPF_OP((_op)) | BPF_K, _dst, 0, 0, _imm)
+
+#define ALU64(_op, _dst, _src)     INSN(BPF_ALU64 | BPF_OP((_op)) | BPF_X, _dst, _src, 0, 0)
+#define ALU64_IMM(_op, _dst, _imm) INSN(BPF_ALU64 | BPF_OP((_op)) | BPF_K, _dst, 0, 0, _imm)
 
 #define STW_IMM(_dst, _off, _imm) INSN(BPF_ST  | BPF_SIZE(BPF_W)  | BPF_MEM, _dst, 0, _off, _imm)
 #define STXB(_dst, _off, _src)   INSN(BPF_STX | BPF_SIZE(BPF_B) | BPF_MEM, _dst, _src, _off, 0)
 #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)
 
+#if __WORDSIZE == 64
+#  define ALU ALU64
+#  define ALU_IMM ALU64_IMM
+#  define STX STXDW
+#  define LDX LDXDW
+#else
+#  define ALU ALU32
+#  define ALU_IMM ALU32_IMM
+#  define STX STXW
+#  define LDX LDXW
+#endif
+
+#define BPF_REG_BP BPF_REG_10
+
 struct sym;
 
 enum vitype {
 
 	int16_t next_label;
 	uint16_t next_reg;
+
+	ssize_t sp;
+};
+
+enum irloc {
+	LOC_IMM   = (1 << 0),
+	LOC_REG   = (1 << 1),
+	LOC_STACK = (1 << 2),
+};
+
+
+struct irstate {
+	int loc;
+
+	uint16_t reg;
+	int32_t  stack;
+	int32_t  imm;
+
+	struct {
+		int dot:1;
+		int stack:1;
+	} hint;
 };
 
 void insn_dump(struct bpf_insn insn, FILE *fp);
 
 int16_t  ir_alloc_label   (struct ir *ir);
 uint16_t ir_alloc_register(struct ir *ir);
+ssize_t  ir_alloc_stack   (struct ir *ir, size_t size);
 
 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(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_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);
-}
+/* void ir_emit_reg_get(struct ir *ir, uint16_t reg); */
+/* void ir_emit_reg_put(struct ir *ir, uint16_t reg); */
+void ir_emit_mov_irs(struct ir *ir, uint16_t dst, struct irstate *src);
 
 struct ir *ir_new(void);
 
-enum irloc {
-	LOC_IMM   = (1 << 0),
-	LOC_REG   = (1 << 1),
-	LOC_STACK = (1 << 2),
-};
 
-struct irstate {
-	int loc;
-
-	uint16_t reg;
-	int16_t stack;
-};
-
-static inline void irs_alloc_reg(struct irstate *irs, struct ir *ir)
+static inline void irs_alloc_register(struct irstate *irs, struct ir *ir)
 {
 	irs->loc = LOC_REG;
 	irs->reg = ir_alloc_register(ir);
-	ir_emit_reg_get(ir, irs->reg);
+}
+
+static inline void irs_alloc_stack(struct irstate *irs, struct ir *ir,
+				   size_t size)
+{
+	irs->loc = LOC_STACK;
+	irs->stack = ir_alloc_stack(ir, size);
 }
 
 #endif	/* _PLY_IR_H */

kprobe.c

 #include "type.h"
 
 struct kprobe {
-	struct irstate regs_irs;
 };
 
 /* regs */
 
 static int kprobe_ir_pre(struct prog *prog)
 {
-	struct kprobe *kp = prog->provider_data;
 	struct sym **sym;
 
 	symtab_foreach(prog->locals, sym) {
 		if ((*sym)->name && !strcmp((*sym)->name, "regs")) {
-			irs_alloc_reg(&kp->regs_irs, prog->ir);
+			irs_alloc_register(&(*sym)->irs, prog->ir);
 
 			/* kernel sets r1 to the address of the
 			 * pt_regs struct, which ply denotes as
 			 * 'regs'. if we're using it we need to get a
 			 * reference to it before it is clobbered. */
 			ir_emit_insn(prog->ir, MOV(0, 0),
-				     kp->regs_irs.reg, BPF_REG_1);
+				     (*sym)->irs.reg, BPF_REG_1);
 		}
 	}
 

ply.c

 	struct provider *global = provider_get(":");
 	int err = 0;
 
+	if (n->sym)
+		return 0;
+
 	switch (n->ntype) {
 	case N_EXPR:
 	case N_IDENT:

sym.h

 
 #include <stdint.h>
 
+#include "ir.h"
+
 struct func;
 struct node;
 struct type;
 	const struct func *func;
 
 	struct type *type;
-	/* irstate_t irs; */
+	struct irstate irs;
 };
 
 struct symtab {