map key to stack

global.c

 		struct node *ptr = sou->expr.args;
 
 		ir_emit_sym_to_reg(prog->ir, BPF_REG_3, ptr->sym);
-		ir_emit_insn(prog->ir, ALU_IMM(BPF_ADD, 0, offset), BPF_REG_3, 0);
+		ir_emit_insn(prog->ir, ALU_IMM(BPF_ADD, offset), BPF_REG_3, 0);
 		goto probe_read;
 	}
 
 	offset += sou->sym->irs.stack;
 
 	if (dst->loc == LOC_REG) {
-		switch (dst->size) {
-		case 1:
-			ir_emit_insn(prog->ir, LDXB(0, offset, 0),
-				     dst->reg, BPF_REG_BP);
-			break;
-		case 2:
-			ir_emit_insn(prog->ir, LDXH(0, offset, 0),
-				     dst->reg, BPF_REG_BP);
-			break;
-		case 4:
-			ir_emit_insn(prog->ir, LDXW(0, offset, 0),
-				     dst->reg, BPF_REG_BP);
-			break;
-		case 8:
-			ir_emit_insn(prog->ir, LDXDW(0, offset, 0),
-				     dst->reg, BPF_REG_BP);
-			break;
-		default:
-			assert(0);
-		}
-
+		ir_emit_insn(prog->ir, LDX(bpf_width(dst->size), offset),
+			     dst->reg, BPF_REG_BP);
 		return 0;
 	}
 
-	ir_emit_insn(prog->ir, ALU_IMM(BPF_ADD, 0, offset), BPF_REG_3, 0);
+	ir_emit_insn(prog->ir, ALU_IMM(BPF_ADD, offset), BPF_REG_3, 0);
 probe_read:
-	ir_emit_insn(prog->ir, MOV_IMM(0, (int32_t)dst->size), BPF_REG_2, 0);
-	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((int32_t)dst->size), BPF_REG_2, 0);
+	ir_emit_insn(prog->ir, MOV, BPF_REG_1, BPF_REG_BP);
+	ir_emit_insn(prog->ir, ALU_IMM(BPF_ADD, dst->stack), BPF_REG_1, 0);
 	ir_emit_insn(prog->ir, CALL(BPF_FUNC_probe_read), 0, 0);
 	/* TODO if (r0) exit(r0); */
 	return 0;
                     be overwritten, so skip the load. */
 		return 0;
 
-	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)dst->size), BPF_REG_2, 0);
+	ir_emit_insn(prog->ir, MOV, BPF_REG_1, BPF_REG_BP);
+	ir_emit_insn(prog->ir, ALU_IMM(BPF_ADD, dst->stack), BPF_REG_1, 0);
+	ir_emit_insn(prog->ir, MOV_IMM((int32_t)dst->size), BPF_REG_2, 0);
 	ir_emit_sym_to_reg(prog->ir, BPF_REG_3, ptr->sym);
 	ir_emit_insn(prog->ir, CALL(BPF_FUNC_probe_read), 0, 0);
 	/* TODO if (r0) exit(r0); */
 
 /* :map */
 
+static int global_map_ir_pre_key(struct node *n, struct prog *prog)
+{
+	struct node *map = n->expr.args, *arg;
+	struct type *ktype = type_base(map->sym->type->map.ktype);
+	ssize_t stack = map->sym->irs.stack;
+	size_t offset, size, pad;
+	struct tfield *f;
+
+	arg = map->next;
+	tfields_foreach(f, ktype->sou.fields) {
+		offset = type_offsetof(ktype, f->name);
+		size = type_sizeof(f->type);
+
+		if (!arg->sym->irs.loc) {
+			arg->sym->irs.hint.stack = 1;
+			arg->sym->irs.stack = stack + offset;
+		}
+
+		if (arg->next) {
+			pad = type_offsetof(ktype, f[1].name) - (offset + size);
+			if (pad)
+				ir_emit_bzero(prog->ir,
+					      stack + offset + size, pad);
+		}
+		arg = arg->next;
+	}
+
+	pad = type_sizeof(ktype) - (offset + size);
+	if (pad)
+		ir_emit_bzero(prog->ir, stack + offset + size, pad);
+	return 0;
+}
+
+static int global_map_ir_pre(const struct func *func, struct node *n,
+			     struct prog *prog)
+{
+	struct irstate *kirs;
+	struct node *map = n->expr.args;
+	struct type *ktype = type_base(map->sym->type->map.ktype);
+
+	map->sym->irs.hint.stack = 1;
+	ir_init_irs(prog->ir, &map->sym->irs, ktype);
+
+
+	if (ktype->ttype == T_STRUCT)
+		return global_map_ir_pre_key(n, prog);
+
+	kirs = &map->next->sym->irs;
+	if (!kirs->loc) {
+		kirs->hint.stack = 1;
+		kirs->stack = map->sym->irs.stack;
+	}
+	return 0;
+}
+
+static int global_map_ir_post(const struct func *func, struct node *n,
+			      struct prog *prog)
+{
+	struct node *map = n->expr.args, *arg;
+	struct type *ktype = type_base(map->sym->type->map.ktype);
+	ssize_t stack = map->sym->irs.stack;
+	size_t offset;
+	struct tfield *f;
+
+	arg = map->next;
+	tfields_foreach(f, ktype->sou.fields) {
+		offset = type_offsetof(ktype, f->name);
+		ir_emit_sym_to_stack(prog->ir, stack + offset, arg->sym);
+		arg = arg->next;
+	}
+	return 0;
+}
+
 static struct type *global_map_ktype(struct node *n)
 {
 	struct node *map, *key;
 	ir_init_sym(prog->ir, n->sym);
 
 	ir_emit_insn(prog->ir, CALL(BPF_FUNC_get_current_pid_tgid), 0, 0);
-	ir_emit_insn(prog->ir, ALU64_IMM(BPF_RSH, 0, 32), BPF_REG_0, 0);
+	ir_emit_insn(prog->ir, ALU64_IMM(BPF_RSH, 32), BPF_REG_0, 0);
 	ir_emit_reg_to_sym(prog->ir, n->sym, BPF_REG_0);
 	return 0;
 }
 	.func = { .type = &t_time },
 };
 
+
+/*  */
+
 struct type t_block_func = {
 	.ttype = T_FUNC,
 
 		/* .type = t_map_func, */
 		.type_infer = global_map_type_infer,
 		.static_validate = global_map_static_validate,
+
+		.ir_pre  = global_map_ir_pre,
+		.ir_post = global_map_ir_post,
 	},
 
 	{
 	return NULL;
 }
 
+static int global_num_ir_post(const struct func *func, struct node *n,
+			      struct prog *prog)
+{
+	struct irstate *irs = &n->sym->irs;
+
+	if ((n->num.unsignd && (n->num.u64 <= INT32_MAX)) ||
+	    (n->num.s64 >= INT32_MIN && n->num.s64 <= INT32_MAX)) {
+		irs->loc = LOC_IMM;
+		irs->imm = n->num.s64;
+		irs->size = 4;
+		return 0;
+	}
+
+	/* we need to build the constant in a register, so ignore any
+	 * advise about stack allocation. */
+	irs->hint.stack = 0;
+
+	ir_init_sym(prog->ir, n->sym);
+
+	if (n->num.u64 > 0x3fffffffffffffff) {
+		ir_emit_insn(prog->ir, MOV64_IMM(n->num.u64 >> 33), irs->reg, 0);
+		ir_emit_insn(prog->ir, ALU64_IMM(BPF_LSH, 31), irs->reg, 0);
+
+		if ((n->num.u64 >> 2) & 0x7fffffff)
+			ir_emit_insn(prog->ir,
+				     ALU64_IMM(BPF_OR, (n->num.u64 >> 2) & 0x7fffffff),
+				     irs->reg, 0);
+		ir_emit_insn(prog->ir, ALU64_IMM(BPF_LSH, 2), irs->reg, 0);
+
+		if (n->num.u64 & 0x3)
+			ir_emit_insn(prog->ir, ALU64_IMM(BPF_OR, n->num.u64 & 0x3),
+				     irs->reg, 0);
+	} else if (n->num.u64 > 0x7fffffff) {
+		ir_emit_insn(prog->ir, MOV64_IMM(n->num.u64 >> 31), irs->reg, 0);
+		ir_emit_insn(prog->ir, ALU64_IMM(BPF_LSH, 31), irs->reg, 0);
+
+		if (n->num.u64 & 0x7fffffff)
+			ir_emit_insn(prog->ir,
+				     ALU64_IMM(BPF_OR, n->num.u64 & 0x7fffffff),
+				     irs->reg, 0);
+	}
+	return 0;
+}
+
 static const struct func global_num_func = {
 	.name = ":num",
+
+	.ir_post = global_num_ir_post,
 };
 
 static const struct func global_string_func = {

ir.c

 	ir_emit(ir, &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); */
-/* } */
-
-/* void ir_emit_reg_put(struct ir *ir, uint16_t reg) */
-/* { */
-/* 	struct vinsn vi; */
-
-/* 	vi.vitype = VI_REG_PUT; */
-/* 	vi.reg = reg; */
-/* 	ir_emit(ir, &vi); */
-/* } */
-
 void ir_emit_sym_to_reg(struct ir *ir, uint16_t dst, struct sym *src)
 {
 	struct irstate *irs = &src->irs;
 
 	switch (irs->loc) {
 	case LOC_IMM:
-		ir_emit_insn(ir, MOV_IMM(0, irs->imm), dst, 0);
+		ir_emit_insn(ir, MOV_IMM(irs->imm), dst, 0);
 		break;
 	case LOC_REG:
-		ir_emit_insn(ir, MOV(0, 0), dst, irs->reg);
+		if (dst == irs->reg)
+			break;
+
+		if (irs->size == 8)
+			ir_emit_insn(ir, MOV64, dst, irs->reg);
+		else
+			ir_emit_insn(ir, MOV, dst, irs->reg);
 		break;
 	case LOC_STACK:
-		switch (irs->size) {
-		case 1:
-			ir_emit_insn(ir, LDXB(0, irs->stack, 0),
-				     dst, BPF_REG_BP);
-			break;
-		case 2:
-			ir_emit_insn(ir, LDXH(0, irs->stack, 0),
-				     dst, BPF_REG_BP);
-			break;
-		case 4:
-			ir_emit_insn(ir, LDXW(0, irs->stack, 0),
-				     dst, BPF_REG_BP);
-			break;
-		case 8:
-			ir_emit_insn(ir, LDXDW(0, irs->stack, 0),
-				     dst, BPF_REG_BP);
-			break;
-		default:
-			assert(0);
-		}
+		ir_emit_insn(ir, LDX(bpf_width(irs->size), irs->stack),
+			     dst, BPF_REG_BP);
 		break;
 	default:
 		assert(0);
 
 	switch (irs->loc) {
 	case LOC_REG:
-		ir_emit_insn(ir, MOV(0, 0), irs->reg, src);
+		if (irs->reg == src)
+			break;
+
+		if (irs->size == 8)
+			ir_emit_insn(ir, MOV64, irs->reg, src);
+		else
+			ir_emit_insn(ir, MOV, irs->reg, src);
 		break;
 	case LOC_STACK:
-		switch (irs->size) {
-		case 1:
-			ir_emit_insn(ir, STXB(0, irs->stack, 0),
-				     BPF_REG_BP, src);
-			break;
-		case 2:
-			ir_emit_insn(ir, STXH(0, irs->stack, 0),
-				     BPF_REG_BP, src);
-			break;
-		case 4:
-			ir_emit_insn(ir, STXW(0, irs->stack, 0),
-				     BPF_REG_BP, src);
-			break;
-		case 8:
-			ir_emit_insn(ir, STXDW(0, irs->stack, 0),
-				     BPF_REG_BP, src);
-			break;
-		default:
-			assert(0);
-		}
+		ir_emit_insn(ir, STX(bpf_width(irs->size), irs->stack),
+			     BPF_REG_BP, src);
 		break;
 	default:
 		assert(0);
 	}
 }
+#include "ply.h"
+void ir_emit_sym_to_stack(struct ir *ir, ssize_t offset, struct sym *src)
+{
+	struct irstate *irs = &src->irs;
 
-/* void ir_emit_xfer(struct ir *ir,  */
+	switch (irs->loc) {
+	case LOC_IMM:
+		_d("WKZ %zu @ %zd (%d)\n", irs->size, offset, irs->imm);
+		ir_emit_insn(ir, ST_IMM(bpf_width(irs->size), offset, irs->imm),
+			     BPF_REG_BP, 0);
+		break;
+	case LOC_REG:
+		ir_emit_insn(ir, STX(bpf_width(irs->size), offset),
+			     BPF_REG_BP, irs->reg);
+	case LOC_STACK:
+		ir_emit_memcpy(ir, offset, irs->stack, irs->size);
+		break;
+	default:
+		assert(0);
+	}
+}
+
+void ir_emit_memcpy(struct ir *ir, ssize_t dst, ssize_t src, size_t size)
+{
+	if (dst == src)
+		return;
+
+	for (; size >= 8; size -= 8, dst += 8, src += 8) {
+		ir_emit_insn(ir, LDX(BPF_DW, src), BPF_REG_0, BPF_REG_BP);
+		ir_emit_insn(ir, STX(BPF_DW, dst), BPF_REG_BP, BPF_REG_0);
+	}
+
+	if (size >= 4) {
+		ir_emit_insn(ir, LDX(BPF_W, src), BPF_REG_0, BPF_REG_BP);
+		ir_emit_insn(ir, STX(BPF_W, dst), BPF_REG_BP, BPF_REG_0);
+		size -= 4, dst += 4, src += 4;
+	}
+
+	if (size >= 2) {
+		ir_emit_insn(ir, LDX(BPF_H, src), BPF_REG_0, BPF_REG_BP);
+		ir_emit_insn(ir, STX(BPF_H, dst), BPF_REG_BP, BPF_REG_0);
+		size -= 2, dst += 2, src += 2;
+	}
+
+	if (size >= 1) {
+		ir_emit_insn(ir, LDX(BPF_B, src), BPF_REG_0, BPF_REG_BP);
+		ir_emit_insn(ir, STX(BPF_B, dst), BPF_REG_BP, BPF_REG_0);
+		size -= 1, dst += 1, src += 1;
+	}
+
+	assert(size == 0);
+}
+
+void ir_emit_bzero(struct ir *ir, ssize_t offset, size_t size)
+{
+	for (; size >= 8; size -= 8)
+		ir_emit_insn(ir, ST_IMM(BPF_DW, offset, 0), BPF_REG_BP, 0);
+
+	if (size >= 4) {
+		ir_emit_insn(ir, ST_IMM(BPF_W, offset, 0), BPF_REG_BP, 0);
+		size -= 4;
+	}
+
+	if (size >= 2) {
+		ir_emit_insn(ir, ST_IMM(BPF_H, offset, 0), BPF_REG_BP, 0);
+		size -= 2;
+	}
+
+	if (size >= 1) {
+		ir_emit_insn(ir, ST_IMM(BPF_B, offset, 0), BPF_REG_BP, 0);
+		size -= 1;
+	}
+
+	assert(size == 0);
+}
 
 int16_t ir_alloc_label (struct ir *ir)
 {
 	return ir->next_reg++;
 }
 
-ssize_t ir_alloc_stack(struct ir *ir, size_t size)
+ssize_t ir_alloc_stack(struct ir *ir, size_t size, size_t align)
 {
 	ir->sp -= size;
-	assert(ir->sp > INT32_MIN);
+
+	if (ir->sp % align)
+		ir->sp -= align - (ir->sp & align);
+
+	assert(ir->sp > INT16_MIN);
 
 	return ir->sp;
 }
 
-void ir_init_sym(struct ir *ir, struct sym *sym)
+void ir_init_irs(struct ir *ir, struct irstate *irs, struct type *t)
 {
-	struct irstate *irs = &sym->irs;
-	struct type *t = type_base(sym->type);
+	t = type_base(t);
 
 	if (irs->loc)
 		return;
 
 	irs->size = type_sizeof(t);
 
-	if (irs->hint.stack)
+	if (irs->hint.stack) {
+		if (irs->stack) {
+			irs->loc = LOC_STACK;
+			return;
+		}
 		goto alloc_stack;
+	}
 
 	switch (t->ttype) {
 	case T_SCALAR:
 	default:
 	alloc_stack:
 		irs->loc = LOC_STACK;
-		irs->stack = ir_alloc_stack(ir, irs->size);
+		irs->stack = ir_alloc_stack(ir, irs->size, type_alignof(t));
 	}
 }
 
+void ir_init_sym(struct ir *ir, struct sym *sym)
+{
+	return ir_init_irs(ir, &sym->irs, sym->type);
+}
+
 struct ir *ir_new(void)
 {
 	struct ir *ir;

ir.h

 		.imm   = _imm			\
 	})
 
-#define MOV(_dst, _src)     INSN(BPF_ALU64 | BPF_MOV | BPF_X, _dst, _src, 0, 0)
-#define MOV_IMM(_dst, _imm) INSN(BPF_ALU64 | BPF_MOV | BPF_K, _dst, 0, 0, _imm)
+#define MOV32     INSN(BPF_ALU | BPF_MOV | BPF_X, 0, 0, 0, 0)
+#define MOV32_IMM(_imm) INSN(BPF_ALU | BPF_MOV | BPF_K, 0, 0, 0, _imm)
+
+#define MOV64     INSN(BPF_ALU64 | BPF_MOV | BPF_X, 0, 0, 0, 0)
+#define MOV64_IMM(_imm) INSN(BPF_ALU64 | BPF_MOV | BPF_K, 0, 0, 0, _imm)
 
 #define EXIT INSN(BPF_JMP | BPF_EXIT, 0, 0, 0, 0)
 #define CALL(_imm) INSN(BPF_JMP | BPF_CALL, 0, 0, 0, _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 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 JMP(_op, _off)     INSN(BPF_JMP | BPF_OP((_op)) | BPF_X, 0, 0, _off, 0)
+#define JMP_IMM(_op, _imm, _off) INSN(BPF_JMP | BPF_OP((_op)) | BPF_K, 0, 0, _off, _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 ALU32(_op)     INSN(BPF_ALU | BPF_OP((_op)) | BPF_X, 0, 0, 0, 0)
+#define ALU32_IMM(_op, _imm) INSN(BPF_ALU | BPF_OP((_op)) | BPF_K, 0, 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 STXH(_dst, _off, _src)   INSN(BPF_STX | BPF_SIZE(BPF_H) | BPF_MEM, _dst, _src, _off, 0)
-#define STXW(_dst, _off, _src)   INSN(BPF_STX | BPF_SIZE(BPF_W) | BPF_MEM, _dst, _src, _off, 0)
-#define STXDW(_dst, _off, _src)   INSN(BPF_STX | BPF_SIZE(BPF_DW) | BPF_MEM, _dst, _src, _off, 0)
+#define ALU64(_op)     INSN(BPF_ALU64 | BPF_OP((_op)) | BPF_X, 0, 0, 0, 0)
+#define ALU64_IMM(_op, _imm) INSN(BPF_ALU64 | BPF_OP((_op)) | BPF_K, 0, 0, 0, _imm)
 
-#define LDXB(_dst, _off, _src)  INSN(BPF_LDX | BPF_SIZE(BPF_B)  | BPF_MEM, _dst, _src, _off, 0)
-#define LDXH(_dst, _off, _src)  INSN(BPF_LDX | BPF_SIZE(BPF_H)  | 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)
+#define ST_IMM(_width, _off, _imm) INSN(BPF_ST | BPF_SIZE(_width) | BPF_MEM, 0, 0, _off, _imm)
+#define STX(_width, _off) INSN(BPF_STX | BPF_SIZE(_width) | BPF_MEM, 0, 0, _off, 0)
+#define LDX(_width, _off) INSN(BPF_LDX | BPF_SIZE(_width) | BPF_MEM, 0, 0, _off, 0)
 
 #if __WORDSIZE == 64
+#  define MOV MOV64
+#  define MOV_IMM MOV64_IMM
 #  define ALU ALU64
 #  define ALU_IMM ALU64_IMM
-#  define STX STXDW
-#  define LDX LDXDW
 #else
+#  define MOV MOV32
+#  define MOV_IMM MOV32_IMM
 #  define ALU ALU32
 #  define ALU_IMM ALU32_IMM
-#  define STX STXW
-#  define LDX LDXW
 #endif
 
 #define BPF_REG_BP BPF_REG_10
 
+static inline int bpf_width(size_t size)
+{
+	switch (size) {
+	case 1: return BPF_B;
+	case 2: return BPF_H;
+	case 4: return BPF_W;
+	case 8: return BPF_DW;
+	}
+
+	return -1;
+}
+
 struct sym;
+struct type;
 
 enum vitype {
 	VI_INSN,
 void ir_dump(struct ir *ir, 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_init_irs(struct ir *ir, struct irstate *irs, struct type *t);
 void ir_init_sym(struct ir *ir, struct sym *sym);
 
 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); */
+
 void ir_emit_sym_to_reg(struct ir *ir, uint16_t dst, struct sym *src);
 void ir_emit_reg_to_sym(struct ir *ir, struct sym *dst, uint16_t src);
+void ir_emit_sym_to_stack(struct ir *ir, ssize_t offset, struct sym *src);
+
+void ir_emit_memcpy(struct ir *ir, ssize_t dst, ssize_t src, size_t size);
+void ir_emit_bzero(struct ir *ir, ssize_t offset, size_t size);
 
 struct ir *ir_new(void);
 

kprobe.c

 			 * 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),
-				     (*sym)->irs.reg, BPF_REG_1);
+			ir_emit_insn(prog->ir, MOV, (*sym)->irs.reg, BPF_REG_1);
 		}
 	}
 

ply.c

 			  node_expr("=",
 				    node_expr("{}",
 					      node_ident("t"),
-					      node_num("0"),
 					      node_expr("pid", NULL),
+					      node_num("0x10000000"),
 					      NULL),
 				    node_expr("time", NULL),
 				    NULL),
-			  node_expr("=",
-				    node_expr("{}",
-					      node_ident("reads"),
-					      node_expr("pid", NULL),
-					      NULL),
-				    node_expr("quantize", node_ident("arg2"), NULL),
-				    NULL),
+			  /* node_expr("=", */
+			  /* 	    node_expr("{}", */
+			  /* 		      node_ident("reads"), */
+			  /* 		      node_expr("pid", NULL), */
+			  /* 		      NULL), */
+			  /* 	    node_expr("quantize", node_ident("arg2"), NULL), */
+			  /* 	    NULL), */
 			  NULL);
 
 	prog->provider = provider_get("k");
 	ctx->progs[0] = prog;
 
 	/* PROBE1 */
-	prog = calloc(1, sizeof(*prog));
-	prog->locals = calloc(1, sizeof(*prog->locals));
-	prog->globals = ctx->globals;
-
-	/* TODO: k -> kret */
-	prog->probe = "k:SyS_read2"; 
-	/* { times[pid()] = quantize(time() - t[0, pid()]) } */
-	prog->ast =
-		node_expr("=",
-			  node_expr("{}",
-				    node_ident("times"),
-				    node_expr("pid", NULL),
-				    NULL),
-			  node_expr("quantize",
-				    node_expr("-",
-					      node_expr("time", NULL),
-					      node_expr("{}",
-							node_ident("t"),
-							node_num("0"),
-							node_expr("time", NULL),
-							node_expr("pid", NULL),
-							NULL),
-					      NULL),
-				    NULL),
-			  NULL);
-
-	prog->provider = provider_get("k");
-	prog->provider->probe(prog);
-	prog->ir = ir_new();
-	ctx->progs[1] = prog;
+	/* prog = calloc(1, sizeof(*prog)); */
+	/* prog->locals = calloc(1, sizeof(*prog->locals)); */
+	/* prog->globals = ctx->globals; */
+
+	/* /\* TODO: k -> kret *\/ */
+	/* prog->probe = "k:SyS_read2";  */
+	/* /\* { times[pid()] = quantize(time() - t[0, pid()]) } *\/ */
+	/* prog->ast = */
+	/* 	node_expr("=", */
+	/* 		  node_expr("{}", */
+	/* 			    node_ident("times"), */
+	/* 			    node_expr("pid", NULL), */
+	/* 			    NULL), */
+	/* 		  node_expr("quantize", */
+	/* 			    node_expr("-", */
+	/* 				      node_expr("time", NULL), */
+	/* 				      node_expr("{}", */
+	/* 						node_ident("t"), */
+	/* 						node_num("0"), */
+	/* 						node_expr("time", NULL), */
+	/* 						node_expr("pid", NULL), */
+	/* 						NULL), */
+	/* 				      NULL), */
+	/* 			    NULL), */
+	/* 		  NULL); */
+
+	/* prog->provider = provider_get("k"); */
+	/* prog->provider->probe(prog); */
+	/* prog->ir = ir_new(); */
+	/* ctx->progs[1] = prog; */
 
 	return ctx;
 }