function verifier done, started on rewrites

arch-x86_64.c

 	NULL
 };
 
+const char *arch_register_argument(int num)
+{
+	switch (num) {
+	case 0: return "di";
+	case 1: return "si";
+	case 2: return "dx";
+	case 3: return "r10";
+	case 4: return "r8";
+	case 5: return "r9";
+	}
+
+	return NULL;
+}
+
+const char *arch_register_pc(void) 
+{
+	return "ip";
+}
+
+const char *arch_register_return(void)
+{
+	return "ax";
+}
+
 __attribute__((constructor))
 static void arch_init(void)
 {

arch.h

 
 #include "type.h"
 
+/* fixed length integers */
 extern type_t t_s8;
 extern type_t t_u8;
 extern type_t t_s16;
 extern type_t t_s64;
 extern type_t t_u64;
 
+/* layout of captured registers */
 extern type_t t_pt_regs;
 
+/* ABI mapping of registers to arguments/return value */
+const char *arch_register_argument(int num);
+const char *arch_register_pc      (void);
+const char *arch_register_return  (void);
+
 #endif	/* _PLY_ARCH_H */

kprobe.c

 		&& (name[3] >= '0' && name[3] <= '9');
 }
 
-int kprobe_resolve(prog_t *prog, node_t *n)
+static int kprobe_rewrite_arg(prog_t *prog, node_t *n)
+{
+	const char *reg;
+	int arg = n->ident[3] - '0';
+	node_t *new;
+
+	reg = arch_register_argument(arg);
+	if (!reg) {
+		node_print(n, stderr);
+		fputs(": the location of this argument is unknown\n", stderr);
+		/* TODO: add ABI mappings for specifying arguments
+		 * passed on the stack. */
+		return -EINVAL;
+	}
+
+	/* argN => (*ctx).REG */
+	new = node_vlist(node_keyword('.', 0),
+			 node_vlist(node_keyword('*', 0),
+				    node_ident("ctx"),
+				    NULL),
+			 node_string(reg),
+			 NULL);
+
+	return node_replace(n, new);
+}
+
+static int kprobe_rewrite_node(prog_t *prog, node_t *n)
+{
+	if ((n->ntype == N_IDENT) && is_arg(n->ident))
+		return kprobe_rewrite_arg(prog, n);
+
+	return 0;
+}
+
+static int kprobe_resolve(prog_t *prog, node_t *n)
 {
 	type_t *t;
 
 	return sym_add(prog->locals, n->ident, t, &n->sym);
 }
 
-int kprobe_probe(prog_t *prog)
+static int kprobe_probe(prog_t *prog)
 {
 	struct kprobe *kp;
 
 provider_t kprobe = {
 	.name = "kprobe",
 
+	.rewrite_node = kprobe_rewrite_node,
 	.resolve = kprobe_resolve,
 	.probe = kprobe_probe,
 };

node.c

 	return 0;
 }
 
+int node_replace(node_t *n, node_t *new)
+{
+	new->up = n->up;
+
+	if (n->prev) {
+		new->prev = n->prev;
+		n->prev->next = new;
+	}
+
+	if (n->next) {
+		new->next = n->next;
+		n->next->prev = new;
+	}
+
+	/* TODO: don't leak memory */
+	return 0;
+}
 
 /* constructors */
 
 	return n;
 }
 
-node_t *node_ident(char *name)
+node_t *node_ident(const char *name)
 {
 	node_t *n = __node(N_IDENT);
 	n->ident = name;
 	return n;
 }
 
-node_t *node_string(char *string)
+node_t *node_string(const char *string)
 {
 	node_t *n = __node(N_STRING);
 	n->string = string;

node.h

 	union {
 		node_t *list;
 		keyword_t keyword;
-		char *ident;
+		const char *ident;
 		int64_t num;
-		char *string;
+		const char *string;
 	};
 
 	type_t *type;
 typedef int (*walk_fn)(node_t *, void *);
 int node_walk(node_t *n, walk_fn pre, walk_fn post, void *ctx);
 
+int node_replace(node_t *n, node_t *new);
+
 
 /* constructors */
 node_t *node_list  (node_t *head);
 node_t *node_vlist (node_t *head, ...);
 
 node_t *node_keyword(kwclass_t class, int op);
-node_t *node_ident  (char *name);
+node_t *node_ident  (const char *name);
 node_t *node_num    (int64_t num);
-node_t *node_string (char *string);
+node_t *node_string (const char *string);
 
 static inline node_t *node_head(node_t *n)
 {

ply.c

 	if (n->ntype != N_IDENT)
 		return 0;
 
-	/* .IDENT/->IDENT is a struct/union member, skip */
-	/* op = node_prev(node_prev(n)); */
-	/* if (op && (op->ntype == N_IDENT) && !strcmp(".", op->ident)) */
-	/* 	return 0; */
-
 	err = prog->provider->resolve(prog, n);
 	if (!err || (err != -ENOENT))
 		return err;
 
 int validate_func(node_t *n)
 {
-	return 0;
+	node_t *arg;
+	field_t *f;
+	int i;
+
+	for (arg = node_next(n), f = n->type->t.func.args, i = 1;
+	     arg && f && f->type; arg = node_next(arg), f++, i++) {
+		if (type_compatible(arg->type, f->type))
+			continue;
+
+		node_print(n, stderr);
+		fprintf(stderr, ": incompatible type of argument %d (", i);
+		type_dump(arg->type, stderr);
+		fputs("), expected ", stderr);
+		type_dump(f->type, stderr);
+		fputs("\n", stderr);
+		return -EINVAL;
+	}
+
+	if (!arg && (!f || !f->type))
+		return 0;
+
+	if (arg) {
+		node_print(n, stderr);
+		fprintf(stderr, ": too many arguments, expected %d", i);
+		return -EINVAL;
+	}
+
+	if (f->optional)
+		return 0;
+
+	node_print(n, stderr);
+	fputs(": too few arguments", stderr);
+	return -EINVAL;	
 }
 
 int pass_validate_types(node_t *n, void *_prog)
 	return validate_func(n->list);
 }
 
+int pass_rewrite_ast(node_t *n, void *_prog)
+{
+	prog_t *prog = _prog;
+	provider_t *global = provider_get(":");
+	int err;
+
+	if (prog->provider->rewrite_node) {
+		err = prog->provider->rewrite_node(prog, n);
+		if (err)
+			return err;
+	}
+
+	if (global->rewrite_node) {
+		err = global->rewrite_node(prog, n);
+		if (err)
+			return err;
+	}
+
+	return 0;
+}
+
 int pass_walk(pass_t *pass, ctx_t *ctx)
 {
 	prog_t **prog;
 	{ .run = pass_walk, .post = pass_infer_types },
 	{ .run = pass_walk, .post = pass_infer_types },
 	{ .run = pass_walk, .post = pass_validate_types },
+	{ .run = pass_walk, .post = pass_rewrite_ast },
 
 	{ NULL }
 };
 
 	printf("\n\n-- globals\n");
 	symtab_dump(ctx->globals, stdout);
+
+	if (err)
+		printf("ERR: %d\n", err);
+
 	return err;
 }

ply.h

 struct provider {
 	const char *name;
 
-	int (*resolve)(prog_t *, node_t *);
 	int (*probe)(prog_t *);
+	int (*resolve)(prog_t *, node_t *);
+	int (*rewrite_node)(prog_t *, node_t *);
 };
 
 void provider_register(provider_t *prov);

type.c

 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "type.h"
 
 	return t;
 }
 
+type_t *type_normalize(type_t *t)
+{
+	while (t->ttype == T_TYPEDEF)
+		t = t->t.tdef.type;
+
+	return t;
+}
+
 int type_equal(type_t *a, type_t *b)
 {
 	/* TODO */
 	return a == b;
 }
 
+int type_compatible(type_t *a, type_t *b)
+{
+
+	a = type_normalize(a);
+	b = type_normalize(b);
+
+	if (a->ttype != b->ttype)
+		return 0;
+
+	switch (a->ttype){
+	case T_SCALAR:
+		return 1;
+	case T_POINTER:
+		return 1;
+	case T_ARRAY:
+		if (a->t.array.len != b->t.array.len)
+			return 0;
+
+		return type_compatible(a->t.array.type, b->t.array.type);
+	case T_STRUCT:
+	case T_UNION:
+		return !strcmp(a->t.sou.name, b->t.sou.name);
+	case T_FUNC:
+		return type_compatible(a->t.func.type, b->t.func.type);
+	case T_MAP:
+		return type_compatible(a->t.map.vtype, b->t.map.vtype);
+
+	case T_TYPEDEF:
+		assert(0);
+	}
+
+	assert(0);
+	return 0;
+}
+
 void type_size_set_sou(type_t *t)
 {
 	field_t *f;

type.h

 	char *name;
 	type_t *type;
 	size_t offset;
+
+	/* function arguments */
+	int optional:1;
 } field_t;
 
 struct t_sou {
 type_t *type_map_of(type_t *ktype, type_t *vtype);
 type_t *type_ptr_of(type_t *type);
 
-int type_equal(type_t *a, type_t *b);
+int type_equal     (type_t *a, type_t *b);
+int type_compatible(type_t *a, type_t *b);
+
 int type_add(type_t *t);
 int type_add_list(type_t **ts);