ir for assign

global.c

 		arg = arg->next;
 	}
 
+	n->sym->irs.hint.stack = 1;
+	ir_init_sym(prog->ir, n->sym);
+
 	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);
 
 /* :assign */
 
+static int global_assign_ir_pre(const struct func *func, struct node *n,
+				struct prog *prog)
+{
+	struct node *lval, *rval;
+
+	lval = n->expr.args;
+	rval = lval->next;
+
+	n->sym->irs.hint.stack = 1;
+	ir_init_irs(prog->ir, &n->sym->irs, lval->sym->type);
+
+	lval->sym->irs.hint.lval = 1;
+	lval->sym->irs.hint.stack = 1;
+	lval->sym->irs.stack = n->sym->irs.stack;
+
+	rval->sym->irs.hint.stack = 1;
+	rval->sym->irs.stack = n->sym->irs.stack;
+	return 0;
+}
+
+static int global_assign_ir_post(const struct func *func, struct node *n,
+				 struct prog *prog)
+{
+	struct node *lval, *rval, *map;
+
+	lval = n->expr.args;
+	rval = lval->next;
+
+	ir_emit_sym_to_sym(prog->ir, lval->sym, rval->sym);
+	if (!node_is(lval, "{}"))
+		return 0;
+
+	map = lval->expr.args;
+
+	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, map->sym->irs.stack), BPF_REG_2, 0);
+	ir_emit_insn(prog->ir, MOV, BPF_REG_3, BPF_REG_BP);
+	ir_emit_insn(prog->ir, ALU_IMM(BPF_ADD, lval->sym->irs.stack), BPF_REG_3, 0);
+	ir_emit_insn(prog->ir, MOV_IMM(0), BPF_REG_4, 0);
+	ir_emit_insn(prog->ir, CALL(BPF_FUNC_map_update_elem), 0, 0);
+	/* TODO: if (r0) exit(r0); */
+	return 0;
+}
+
 static int global_assign_type_infer_map(struct node *n)
 {
 	struct node *map, *key;
 		.type = &t_2args_func,
 		.type_infer = global_assign_type_infer,
 		.static_validate = global_assign_static_validate,
+
+		.ir_pre  = global_assign_ir_pre,
+		.ir_post = global_assign_ir_post,
 	},
 	{
 		.name = "{}",

ir.c

 	assert(size == 0);
 }
 
+void ir_emit_sym_to_sym(struct ir *ir, struct sym *dst, struct sym *src)
+{
+	switch (dst->irs.loc) {
+	case LOC_REG:
+		ir_emit_sym_to_reg(ir, dst->irs.reg, src);
+		break;
+	case LOC_STACK:
+		ir_emit_sym_to_stack(ir, dst->irs.stack, src);
+		break;
+	default:
+		assert(0);
+		break;
+	}
+}
+
 int16_t ir_alloc_label (struct ir *ir)
 {
 	return ir->next_label--;
 	}
 	
 	irs->loc = LOC_STACK;
+
+	/* a parent may already have filled in a stack position.
+	 * usually this is when we're part of a map key. */
 	if (!irs->stack)
 		irs->stack = ir_alloc_stack(ir, irs->size, type_alignof(t));
 }

ir.h

 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_sym_to_sym(struct ir *ir, struct sym *dst, struct sym *src);
 
 void ir_emit_read_to_sym(struct ir *ir, struct sym *dst, uint16_t src);