map lookup/bzero

global.c

                     be overwritten, so skip the load. */
 		return 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); */
+	ir_emit_read_to_sym(prog->ir, n->sym, BPF_REG_3);
 	return 0;
 }
 
 	ssize_t stack = map->sym->irs.stack;
 	size_t offset;
 	struct tfield *f;
+	int16_t lmiss, lhit;
 
 	arg = map->next;
 	tfields_foreach(f, ktype->sou.fields) {
 		ir_emit_sym_to_stack(prog->ir, stack + offset, arg->sym);
 		arg = arg->next;
 	}
+
+	if (n->sym->irs.hint.lval)
+		/* map[key] = val, whatever is in our storage now it
+                    will be overwritten, so skip the load. */
+		return 0;
+
+	n->sym->irs.hint.stack = 1;
+	ir_init_sym(prog->ir, n->sym);
+
+	ir_emit_ldmap(prog->ir, BPF_REG_1, map->sym);
+	ir_emit_insn(prog->ir, MOV, BPF_REG_2, BPF_REG_BP);
+	ir_emit_insn(prog->ir, ALU_IMM(BPF_ADD, stack), BPF_REG_BP, 0);
+	ir_emit_insn(prog->ir, CALL(BPF_FUNC_map_lookup_elem), 0, 0);
+
+	lmiss = ir_alloc_label(prog->ir);
+	lhit  = ir_alloc_label(prog->ir);
+
+	ir_emit_insn(prog->ir, JMP_IMM(BPF_JEQ, 0, lmiss), BPF_REG_0, 0);
+	ir_emit_read_to_sym(prog->ir, n->sym, BPF_REG_0);
+	ir_emit_insn(prog->ir, JMP(BPF_JA, lhit), 0, 0);
+
+	ir_emit_label(prog->ir, lmiss);
+	ir_emit_bzero(prog->ir, n->sym->irs.stack, n->sym->irs.size);
+	
+	ir_emit_label(prog->ir, lhit);
 	return 0;
 }
 

ir.c

 		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;
 
 	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;
 	}
 }
 
+void ir_emit_read_to_sym(struct ir *ir, struct sym *dst, uint16_t src)
+{
+	struct irstate *irs = &dst->irs;
+
+	assert(irs->loc == LOC_STACK);
+
+	ir_emit_insn(ir, MOV, BPF_REG_1, BPF_REG_BP);
+	ir_emit_insn(ir, ALU_IMM(BPF_ADD, irs->stack), BPF_REG_1, 0);
+	ir_emit_insn(ir, MOV_IMM((int32_t)irs->size), BPF_REG_2, 0);
+	if (src != BPF_REG_3)
+		ir_emit_insn(ir, MOV, BPF_REG_3, src);
+
+	ir_emit_insn(ir, CALL(BPF_FUNC_probe_read), 0, 0);
+	/* TODO if (r0) exit(r0); */
+}
+
 void ir_emit_memcpy(struct ir *ir, ssize_t dst, ssize_t src, size_t size)
 {
 	if (dst == src)
 
 	irs->size = type_sizeof(t);
 
-	if (irs->hint.stack) {
-		if (irs->stack) {
-			irs->loc = LOC_STACK;
-			return;
-		}
-		goto alloc_stack;
-	}
-
-	switch (t->ttype) {
-	case T_SCALAR:
-	case T_POINTER:
+	if ((!irs->hint.stack)
+	    && ((t->ttype == T_SCALAR) || (t->ttype == T_POINTER))) {
 		irs->loc = LOC_REG;
 		irs->reg = ir_alloc_register(ir);
 		return;
-
-	default:
-	alloc_stack:
-		irs->loc = LOC_STACK;
-		irs->stack = ir_alloc_stack(ir, irs->size, type_alignof(t));
 	}
+	
+	irs->loc = LOC_STACK;
+	if (!irs->stack)
+		irs->stack = ir_alloc_stack(ir, irs->size, type_alignof(t));
 }
 
 void ir_init_sym(struct ir *ir, struct sym *sym)

ir.h

 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_read_to_sym(struct ir *ir, struct sym *dst, uint16_t 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);