argN -> regs rewrite done

global.c

 #include "sym.h"
 #include "type.h"
 
+/* . */
+
+static int global_dot_type_infer(const struct func *func, struct node *n)
+{
+	struct node *sou, *member;
+	struct type *t;
+	struct tfield *f;
+
+	if (n->sym->type)
+		return 0;
+
+	sou = n->expr.args;
+	member = sou->next;
+	if (!sou->sym->type)
+		return 0;
+
+	t = type_base(sou->sym->type);
+
+	/* TODO: add union */
+	if (t->ttype != T_STRUCT) {
+		_e("%#N: %N is neither struct nor union (type '%T').\n",
+		   n, sou, sou->sym->type);
+		return -EINVAL;
+	}
+
+	tfields_foreach(f, t->sou.fields) {
+		if (!strcmp(f->name, member->string.data)) {
+			/* given `sou.member` where sou is a
+			 * struct/union, infer that the expression's
+			 * type is equal to member's type. */
+			n->sym->type = f->type;
+			return 0;
+		}
+	}
+
+	_e("%#N: type '%T' has no member named '%s'.\n",
+	   n, t, member->string.data);
+	return -EINVAL;
+}
+
+
+/* :deref */
+
+static int global_deref_type_infer(const struct func *func, struct node *n)
+{
+	struct node *ptr = n->expr.args;
+	struct type *t;
+
+	if (n->sym->type || !ptr->sym->type)
+		return 0;
+
+	t = type_base(ptr->sym->type);
+	if (t->ttype != T_POINTER) {
+		_e("%#N: can't dereference %N (type '%T').\n",
+		   n, ptr, ptr->sym->type);
+		return -EINVAL;
+	}
+
+	/* given `*p` where p is a pointer, infer that the
+	 * expression's type is equal to p's concrete type. */
+	n->sym->type = t->ptr.type;
+	return 0;
+}
+
 
 /* :map */
 
 static int global_map_static_validate(const struct func *func, struct node *n)
 {
 	if (n->expr.args->ntype != N_IDENT) {
-		_e("%#N: trying to lookup a key in %N, which is not a map.\n",
+		_e("%#N: can't lookup a key in %N, which is not a map.\n",
 		   n, n);
 		return -EINVAL;
 	}
 	.func = { .type = &t_void, .vargs = 1 },
 };
 
+struct type t_string_array = {
+	.ttype = T_ARRAY,
+
+	.array = { .type = &t_char, .len = 64 }, /* TODO: tunable */
+};
+
+struct type t_string = {
+	.ttype = T_TYPEDEF,
+
+	.tdef = { .name = ":string", .type = &t_string_array },
+};
+
+struct tfield f_dot[] = {
+	{ .type = &t_void },
+	{ .type = &t_string },
+
+	{ .type = NULL }
+};
+
+struct type t_dot_func = {
+	.ttype = T_FUNC,
+
+	.func = { .type = &t_void, .args = f_dot },
+};
+
 struct tfield f_2args[] = {
 	{ .type = &t_void },
 	{ .type = &t_void },
 		.static_ret = 1,
 	},
 
+	{
+		.name = ".",
+		.type = &t_dot_func,
+		.type_infer = global_dot_type_infer,
+	},
+	{
+		.name = ":deref",
+		.type = &t_1arg_func,
+		.type_infer = global_deref_type_infer,
+	},
+
 	{
 		.name = "+",
 		.type = &t_2args_func,
 	.name = ":num",
 };
 
-struct type t_string_array = {
-	.ttype = T_ARRAY,
-
-	.array = { .type = &t_char, .len = 64 }, /* TODO: tunable */
-};
-
-struct type t_string = {
-	.ttype = T_TYPEDEF,
-
-	.tdef = { .name = ":string", .type = &t_string_array },
-};
-
 static const struct func global_string_func = {
 	.name = ":string",
 	.type = &t_string,

kprobe.c

 #include "type.h"
 
 struct kprobe {
-	int use_ctx:1;
-
-	struct irstate ctx_irs;
+	struct irstate regs_irs;
 };
 
-/* ctx */
+/* regs */
 
 static struct type t_pt_regsp = {
 	.ttype = T_POINTER,
 	.ptr.type = &t_pt_regs,
 };
 
-static const struct func kprobe_ctx_func = {
-	.name = "ctx",
+static const struct func kprobe_regs_func = {
+	.name = "regs",
 
 	.type = &t_pt_regsp,
 	.static_ret = 1,
 		return -EINVAL;
 	}
 
-	/* argN => (*ctx).REG */
+	/* argN => (*regs).REG */
 	new = node_expr(".",
-			node_expr("*", node_ident("ctx"), NULL),
+			node_expr(":deref", node_ident("regs"), NULL),
 			node_string((char *)reg),
 			NULL);
 
-	ast_fprint(stdout, n);
-	ast_fprint(stdout, new);
-
 	node_replace(n, new);
 	return 0;
 }
 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);
+
+			/* 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);
+		}
+	}
 
-	if (!kp->use_ctx)
-		return 0;
-
-	irs_alloc_reg(&kp->ctx_irs, prog->ir);
-
-	/* kernel sets r1 to the address of the context */
-	ir_emit_insn(prog->ir, MOV(0, 0), kp->ctx_irs.reg, BPF_REG_1);
 	return 0;
 }
 
 static int kprobe_sym_alloc(struct prog *prog, struct node *n)
 {
-	struct kprobe *kp = prog->provider_data;
 	const struct func *func = NULL;
 	int err;
 
 	case N_EXPR:
 		break;
 	case N_IDENT:
-		if (!is_arg(n->ident.name))
-			break;
-
-		func = &kprobe_arg_func;
-		kp->use_ctx = 1;
+		if (!strcmp(n->ident.name, "regs"))
+			func = &kprobe_regs_func;
+		else if (is_arg(n->ident.name))
+			func = &kprobe_arg_func;
 		break;
 	default:
 		break;

node.c

 		n->next->prev = new;
 	}
 
+	if (new->up
+	    && (new->up->ntype == N_EXPR)
+	    && (new->up->expr.args == n))
+		new->up->expr.args = new;
+
 	/* TODO: don't leak memory */
 	return 0;
 }

ply.c

 
 struct pass passes[] = {
 	{ .run = run_walk, .post = pass_sym_alloc },
-	/* node->sym ok */
 	{ .run = run_walk, .post = pass_type_infer },
-	/* node->sym->type ok */
-	/* user input is accepted. we'll now start rewriting the ast,
-	 * so errors beyond this point are internal errors. */
+
 	{ .run = run_walk, .post = pass_rewrite },
+
+	{ .run = run_walk, .post = pass_sym_alloc },
+	{ .run = run_walk, .post = pass_type_infer },
+
 	{ .run = run_ir },
 	/* program flattened to vBPF instructions, now rewrite it to
 	 * fit into the actual hw/vm. */