all files compile again with new ast

Makefile

 CFLAGS ?= -Wall -Wextra -Werror -Wno-unused -O0 -g
 
-srcs := ply.c node.c type.c
-hdrs := node.h ply.h type.h
+csrcs  := $(wildcard *_test.c)
+cprogs := $(patsubst %.c,%,$(csrcs))
 
-#srcs := $(wildcard *.c)
-#hdrs := $(wildcard *.h)
+srcs := $(filter-out %_test.c,$(wildcard *.c))
+hdrs := $(wildcard *.h)
 objs := $(patsubst %.c,%.o,$(srcs))
 deps := $(srcs) $(hdrs)
 
 
 ply: $(objs)
 
+arch-x86_64_test: arch-x86_64_test.o arch-x86_64.o type.o
 type_test: type_test.o type.o
+
+check: $(cprogs)
+	$(foreach prog,$(cprogs),./$(prog);)

arch-x86_64.c

 #include <assert.h>
-#include <linux/ptrace.h>
 
 #include "type.h"
 
 #define arch_typedef(_a, _t) {					\
 		.ttype = T_TYPEDEF,				\
-		.t = { .tdef = { .name = #_a, .type = _t } },	\
+		.tdef = { .name = #_a, .type = _t },		\
 	}
 
-type_t t_s8  = arch_typedef(s8,  &t_schar);
-type_t t_u8  = arch_typedef(u8,  &t_uchar);
-type_t t_s16 = arch_typedef(s16, &t_sshort);
-type_t t_u16 = arch_typedef(u16, &t_ushort);
-type_t t_s32 = arch_typedef(s32, &t_sint);
-type_t t_u32 = arch_typedef(u32, &t_uint);
-type_t t_s64 = arch_typedef(s64, &t_slong);
-type_t t_u64 = arch_typedef(u64, &t_ulong);
+struct type t_s8  = arch_typedef(s8,  &t_schar);
+struct type t_u8  = arch_typedef(u8,  &t_uchar);
+struct type t_s16 = arch_typedef(s16, &t_sshort);
+struct type t_u16 = arch_typedef(u16, &t_ushort);
+struct type t_s32 = arch_typedef(s32, &t_sint);
+struct type t_u32 = arch_typedef(u32, &t_uint);
+struct type t_s64 = arch_typedef(s64, &t_slong);
+struct type t_u64 = arch_typedef(u64, &t_ulong);
 
-field_t f_pt_regs_fields[] = {
+struct tfield f_pt_regs_fields[] = {
 	{ .name = "r15",      .type = &t_ulong },
 	{ .name = "r14",      .type = &t_ulong },
 	{ .name = "r13",      .type = &t_ulong },
 	{ .type = &t_void }
 };
 
-type_t t_pt_regs = {
+struct type t_pt_regs = {
 	.ttype = T_STRUCT,
 
 	.sou = {
 	},
 };
 
-type_t *arch_types[] = {
+struct type *arch_types[] = {
 	&t_s8, &t_u8,
 	&t_s16, &t_u16,
 	&t_s32, &t_u32,
 static void arch_init(void)
 {
 	type_add_list(arch_types);
-
-	assert(t_pt_regs.size == sizeof(struct pt_regs));
 }

arch-x86_64_test.c

+#include <linux/ptrace.h>
+#include <stdint.h>
+
+#include "unittest.h"
+
+#include "arch.h"
+#include "type.h"
+
+static int arch_x86_64_sizeof(void *_null)
+{
+	unittest_eq(type_sizeof(&t_s8), sizeof(int8_t));
+	unittest_eq(type_sizeof(&t_u8), sizeof(uint8_t));
+
+	unittest_eq(type_sizeof(&t_s16), sizeof(int16_t));
+	unittest_eq(type_sizeof(&t_u16), sizeof(uint16_t));
+
+	unittest_eq(type_sizeof(&t_s32), sizeof(int32_t));
+	unittest_eq(type_sizeof(&t_u32), sizeof(uint32_t));
+
+	unittest_eq(type_sizeof(&t_s64), sizeof(int64_t));
+	unittest_eq(type_sizeof(&t_u64), sizeof(uint64_t));
+	return 0;
+}
+UNITTEST(arch_x86_64_sizeof);
+
+static int arch_x86_64_pt_regs(void *_null)
+{
+	unittest_eq(type_offsetof(&t_pt_regs, "r15"), offsetof(struct pt_regs, r15));
+	unittest_eq(type_offsetof(&t_pt_regs, "r14"), offsetof(struct pt_regs, r14));
+	unittest_eq(type_offsetof(&t_pt_regs, "r13"), offsetof(struct pt_regs, r13));
+	unittest_eq(type_offsetof(&t_pt_regs, "r12"), offsetof(struct pt_regs, r12));
+	unittest_eq(type_offsetof(&t_pt_regs, "rbp"), offsetof(struct pt_regs, rbp));
+	unittest_eq(type_offsetof(&t_pt_regs, "rbx"), offsetof(struct pt_regs, rbx));
+	unittest_eq(type_offsetof(&t_pt_regs, "r11"), offsetof(struct pt_regs, r11));
+	unittest_eq(type_offsetof(&t_pt_regs, "r10"), offsetof(struct pt_regs, r10));
+	unittest_eq(type_offsetof(&t_pt_regs, "r9"),  offsetof(struct pt_regs, r9));
+	unittest_eq(type_offsetof(&t_pt_regs, "r8"),  offsetof(struct pt_regs, r8));
+	unittest_eq(type_offsetof(&t_pt_regs, "rax"), offsetof(struct pt_regs, rax));
+	unittest_eq(type_offsetof(&t_pt_regs, "rcx"), offsetof(struct pt_regs, rcx));
+	unittest_eq(type_offsetof(&t_pt_regs, "rdx"), offsetof(struct pt_regs, rdx));
+	unittest_eq(type_offsetof(&t_pt_regs, "rsi"), offsetof(struct pt_regs, rsi));
+	unittest_eq(type_offsetof(&t_pt_regs, "rdi"), offsetof(struct pt_regs, rdi));
+	unittest_eq(type_offsetof(&t_pt_regs, "orig_rax"), offsetof(struct pt_regs, orig_rax));
+	unittest_eq(type_offsetof(&t_pt_regs, "rip"), offsetof(struct pt_regs, rip));
+	unittest_eq(type_offsetof(&t_pt_regs, "cs"),  offsetof(struct pt_regs, cs));
+	unittest_eq(type_offsetof(&t_pt_regs, "eflags"), offsetof(struct pt_regs, eflags));
+	unittest_eq(type_offsetof(&t_pt_regs, "rsp"), offsetof(struct pt_regs, rsp));
+	unittest_eq(type_offsetof(&t_pt_regs, "ss"),  offsetof(struct pt_regs, ss));
+
+	unittest_eq(type_alignof(&t_pt_regs),  __alignof__(struct pt_regs));
+	unittest_eq(type_sizeof(&t_pt_regs),  sizeof(struct pt_regs));	
+	return 0;
+}
+UNITTEST(arch_x86_64_pt_regs);
+
+
+int main(void)
+{
+	struct unittest_ctx ctx = {
+		.keep_going = 1,
+		.verbose = 1,
+
+		.ctx = NULL,
+	};
+
+	return unittests_run(&ctx) ? 1 : 0;
+}

arch.h

 #ifndef _PLY_ARCH_H
 #define _PLY_ARCH_H
 
-#include "type.h"
+struct type;
 
 /* fixed length integers */
-extern type_t t_s8;
-extern type_t t_u8;
-extern type_t t_s16;
-extern type_t t_u16;
-extern type_t t_s32;
-extern type_t t_u32;
-extern type_t t_s64;
-extern type_t t_u64;
+extern struct type t_s8;
+extern struct type t_u8;
+extern struct type t_s16;
+extern struct type t_u16;
+extern struct type t_s32;
+extern struct type t_u32;
+extern struct type t_s64;
+extern struct type t_u64;
 
 /* layout of captured registers */
-extern type_t t_pt_regs;
+extern struct type t_pt_regs;
 
 /* ABI mapping of registers to arguments/return value */
 const char *arch_register_argument(int num);

global.c

 #include <errno.h>
 #include <string.h>
 
+#include "func.h"
+#include "node.h"
 #include "ply.h"
+#include "sym.h"
 
+#if 0
 /* pid */
 
 int pid_generate_ir(prog_t *prog, node_t *node)
 
 type_t *ts_time[] = { &t_time_t, &t_time_func, NULL };
 
+#endif
+
+/* int global_resolve(prog_t *prog, node_t *n) */
+/* { */
+/* 	type_t **ts = NULL; */
+/* 	type_t *t; */
+/* 	int err; */
+
+/* 	if (!strcmp(n->ident, "pid")) { */
+/* 		ts = ts_pid; */
+/* 		t = &t_pid_func; */
+/* 	} else if (!strcmp(n->ident, "quantize")) { */
+/* 		ts = ts_quantize; */
+/* 		t = &t_quantize_func; */
+/* 	} else if (!strcmp(n->ident, "time")) { */
+/* 		ts = ts_time; */
+/* 		t = &t_time_func; */
+/* 	} else { */
+/* 		return -ENOENT; */
+/* 	} */
+
+/* 	if (ts) { */
+/* 		err = type_add_list(ts); */
+/* 		if (err) */
+/* 			return err; */
+/* 	} */
+
+/* 	n->type = t; */
+/* 	return sym_add(prog->locals, n->ident, t, &n->sym); */
+/* } */
+
+static const struct func global_funcs[] = {
+
+	/* block */
+	{ .name = "{}", },
+
+	{ .name = "+", },
+	{ .name = "-", },
+	
+	{ .name = "=", },
+	{ .name = "[]", },
+
+	{ .name = "pid", },
+	{ .name = "time", },
+
+	{ .name = "quantize", },
+	
+	{ .name = NULL }
+};
+
+static const struct func global_num_func = {
+	.name = ":num",
+};
+
+static const struct func global_string_func = {
+	.name = ":string",
+};
+
+static const struct func global_ident_func = {
+	.name = ":ident",
+};
 
-int global_resolve(prog_t *prog, node_t *n)
+int global_sym_alloc(struct prog *prog, struct node *n)
 {
-	type_t **ts = NULL;
-	type_t *t;
-	int err;
-
-	if (!strcmp(n->ident, "pid")) {
-		ts = ts_pid;
-		t = &t_pid_func;
-	} else if (!strcmp(n->ident, "quantize")) {
-		ts = ts_quantize;
-		t = &t_quantize_func;
-	} else if (!strcmp(n->ident, "time")) {
-		ts = ts_time;
-		t = &t_time_func;
-	} else {
-		return -ENOENT;
-	}
+	const struct func *func;
 
-	if (ts) {
-		err = type_add_list(ts);
-		if (err)
-			return err;
+	switch (n->ntype) {
+	case N_EXPR:
+		for (func = global_funcs; func->name; func++) {
+			if (strcmp(func->name, n->expr.func))
+				continue;
+
+			n->sym = sym_alloc(prog->locals, n, func);
+			return 0;
+		}
+
+		return -ENOENT;
+	case N_IDENT:
+		n->sym = sym_alloc(prog->globals, n, &global_ident_func);
+		return 0;
+	case N_NUM:
+		n->sym = sym_alloc(prog->locals, n, &global_num_func);
+		return 0;
+	case N_STRING:
+		n->sym = sym_alloc(prog->locals, n, &global_string_func);
+		return 0;
 	}
 
-	n->type = t;
-	return sym_add(prog->locals, n->ident, t, &n->sym);
+	return -ENOENT;
 }
 
-int global_probe(prog_t *prog)
+int global_probe(struct prog *prog)
 {
 	return 0;
 }
 
-provider_t global = {
+struct provider global = {
 	.name = ":",
 
-	.resolve = global_resolve,
+	.sym_alloc = global_sym_alloc,
 	.probe = global_probe,
 };
 

ir.c

+#if 0
 #include <assert.h>
 #include <inttypes.h>
 #include <stdio.h>
 	ir->next_label = -1;
 	return ir;
 }
+#endif

kprobe.c

 struct kprobe {
 };
 
-static int kprobe_ir_prologue(prog_t *prog)
+/* static int kprobe_ir_prologue(prog_t *prog) */
+/* { */
+/* 	sym_t *ctx = sym_get(prog->locals, "ctx"); */
+
+/* 	if (!ctx) */
+/* 		return 0; */
+
+/* 	irs_alloc_reg(&ctx->irs, prog->ir); */
+
+/* 	/\* kernel sets r1 to the address of the context *\/ */
+/* 	ir_emit_insn(prog->ir, MOV(0, 0), ctx->irs.reg, BPF_REG_1); */
+/* 	return 0; */
+/* } */
+
+/* static inline int is_arg(const char *name) */
+/* { */
+/* 	return (strstr(name, "arg") == name) */
+/* 		&& (strlen(name) == 4) */
+/* 		&& (name[3] >= '0' && name[3] <= '9'); */
+/* } */
+
+/* static int kprobe_rewrite_arg(prog_t *prog, node_t *n) */
+/* { */
+/* 	const char *reg; */
+/* 	int arg = n->ident[3] - '0'; */
+/* 	node_t *new, *ctx; */
+
+/* 	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; */
+/* 	} */
+
+/* 	ctx = node_ident("ctx"); */
+
+/* 	/\* argN => (*ctx).REG *\/ */
+/* 	new = node_vlist(node_keyword('.', 0), */
+/* 			 node_vlist(node_keyword('*', 0), */
+/* 				    ctx, */
+/* 				    NULL), */
+/* 			 node_string(reg), */
+/* 			 NULL); */
+
+/* 	ctx->type = type_ptr_of(&t_pt_regs); */
+/* 	new->type = n->type; */
+/* 	new->list->type = &t_void; */
+/* 	new->list->next->type = &t_pt_regs; */
+/* 	new->list->next->list->type = &t_void; */
+/* 	node_replace(n, new); */
+
+/* 	return sym_add(prog->locals, ctx->ident, ctx->type, &ctx->sym); */
+/* } */
+
+/* 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; */
+
+/* 	if (is_arg(n->ident)) */
+/* 		t = &t_ulong; */
+/* 	else if (!strcmp(n->ident, "ctx")) */
+/* 		t = type_ptr_of(&t_pt_regs); */
+/* 	else */
+/* 		return -ENOENT; */
+
+/* 	n->type = t; */
+/* 	return sym_add(prog->locals, n->ident, t, &n->sym); */
+/* } */
+
+static int kprobe_sym_alloc(struct prog *prog, struct node *n)
 {
-	sym_t *ctx = sym_get(prog->locals, "ctx");
-
-	if (!ctx)
-		return 0;
-
-	irs_alloc_reg(&ctx->irs, prog->ir);
-
-	/* kernel sets r1 to the address of the context */
-	ir_emit_insn(prog->ir, MOV(0, 0), ctx->irs.reg, BPF_REG_1);
-	return 0;
-}
-
-static inline int is_arg(const char *name)
-{
-	return (strstr(name, "arg") == name)
-		&& (strlen(name) == 4)
-		&& (name[3] >= '0' && name[3] <= '9');
-}
-
-static int kprobe_rewrite_arg(prog_t *prog, node_t *n)
-{
-	const char *reg;
-	int arg = n->ident[3] - '0';
-	node_t *new, *ctx;
-
-	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;
-	}
-
-	ctx = node_ident("ctx");
-
-	/* argN => (*ctx).REG */
-	new = node_vlist(node_keyword('.', 0),
-			 node_vlist(node_keyword('*', 0),
-				    ctx,
-				    NULL),
-			 node_string(reg),
-			 NULL);
-
-	ctx->type = type_ptr_of(&t_pt_regs);
-	new->type = n->type;
-	new->list->type = &t_void;
-	new->list->next->type = &t_pt_regs;
-	new->list->next->list->type = &t_void;
-	node_replace(n, new);
-
-	return sym_add(prog->locals, ctx->ident, ctx->type, &ctx->sym);
-}
-
-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;
-
-	if (is_arg(n->ident))
-		t = &t_ulong;
-	else if (!strcmp(n->ident, "ctx"))
-		t = type_ptr_of(&t_pt_regs);
-	else
-		return -ENOENT;
-
-	n->type = t;
-	return sym_add(prog->locals, n->ident, t, &n->sym);
+	return -ENOENT;
 }
 
-static int kprobe_probe(prog_t *prog)
+static int kprobe_probe(struct prog *prog)
 {
 	struct kprobe *kp;
 
 	return 0;
 }
 
-provider_t kprobe = {
+struct provider kprobe = {
 	.name = "kprobe",
 
-	.ir_prologue = kprobe_ir_prologue,
-	.rewrite_node = kprobe_rewrite_node,
-	.resolve = kprobe_resolve,
+	/* .ir_prologue = kprobe_ir_prologue, */
+	/* .rewrite_node = kprobe_rewrite_node, */
+	/* .resolve = kprobe_resolve, */
+	.sym_alloc = kprobe_sym_alloc,
 	.probe = kprobe_probe,
 };
 

node.c

 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "node.h"
 
 	fputc('\n', fp);		
 }
 
+void node_error(struct node *n, FILE *fp, const char *fmt, ...)
+{
+	va_list ap;
+
+	node_print(n, fp);
+	fputs(": ", fp);
+
+	va_start(ap, fmt);
+	vfprintf(fp, fmt, ap);
+	va_end(ap);
+}
 
 int node_walk(struct node *n,
 	      int (*pre)(struct node *, void *),
 	return 0;
 }
 
+/* helpers */
+
+int node_is_block(struct node *n)
+{
+	if (!n || (n->ntype != N_EXPR))
+		return 0;
+
+	return !strcmp(n->expr.func, "{}");
+}
+
+
 /* constructors */
 
 static struct node *node_new(enum ntype ntype)

node.h

 struct node {
 	struct node *next, *prev, *up;
 
+	struct sym *sym;
+
 	enum ntype ntype;
 
 	union {
 void node_print(struct node *n, FILE *fp);
 void node_dump (struct node *n, FILE *fp);
 
+void node_error(struct node *n, FILE *fp, const char *fmt, ...);
 
 typedef int (*nwalk_fn)(struct node *, void *);
 int node_walk(struct node *n, nwalk_fn pre, nwalk_fn post, void *ctx);
 
 /* helpers */
 
-static inline int node_is_block(struct node *n)
-{
-	if (!n || (n->ntype != N_EXPR))
-		return 0;
-
-	return n->expr.func[0] == '\0';
-}
+int node_is_block(struct node *n);
 
 #define node_expr_foreach(_expr, _arg) \
 	for ((_arg) = (_expr)->expr.args; (_arg); (_arg) = (_arg)->next)

ply.c

 #include <stdlib.h>
 #include <string.h>
 
-#include "ply.h"
 #include "node.h"
+#include "ply.h"
+#include "sym.h"
 
-/* struct providers { */
-/* 	provider_t **prov; */
-/* 	size_t len; */
-/* } providers; */
+struct providers {
+	struct provider **ps;
+	size_t len;
+} providers;
 
-/* provider_t *provider_get(const char *name) */
-/* { */
-/* 	size_t i; */
+#define providers_foreach(_ps, _p) \
+	for((_p) = (_ps)->ps; (_p) < &(_ps)->ps[(_ps)->len]; (_p)++)
 
-/* 	for (i = 0; i < providers.len; i++) { */
-/* 		if (strstr(providers.prov[i]->name, name) */
-/* 		    == providers.prov[i]->name) */
-/* 			return providers.prov[i]; */
-/* 	} */
+struct provider *provider_get(const char *name)
+{
+	struct provider **p;
 
-/* 	return NULL; */
-/* } */
+	providers_foreach(&providers, p) {
+		if (strstr((*p)->name, name) == (*p)->name)
+			return *p;
+	}
 
-/* void provider_register(provider_t *prov) */
-/* { */
-/* 	assert(prov); */
-/* 	assert(prov->probe); */
-/* 	assert(prov->resolve); */
+	return NULL;
+}
+
+void provider_register(struct provider *p)
+{
+	assert(p);
+	assert(p->probe);
+	assert(p->sym_alloc);
 
-/* 	providers.prov = realloc(providers.prov, */
-/* 				 ++providers.len * sizeof(*providers.prov)); */
+	providers.ps = realloc(providers.ps,
+				 ++providers.len * sizeof(*providers.ps));
 
-/* 	providers.prov[providers.len - 1] = prov; */
-/* } */
+	providers.ps[providers.len - 1] = p;
+}
 
 struct pass {
 	int (*run)(struct pass *, struct ctx *);
 };
 
 
-/* symtab_t globals = { .sym = NULL, .len = 0 }; */
+struct symtab syms = { .syms = NULL, .len = 0 };
 /* symtab_t locals = { .sym = NULL, .len = 0 }; */
 
 struct ctx *ctx_get(void)
 	struct prog *prog;
 
 	ctx = calloc(1, sizeof(*ctx));
-	/* ctx->globals = calloc(1, sizeof(*ctx->globals)); */
+	ctx->globals = calloc(1, sizeof(*ctx->globals));
 
 	ctx->progs = calloc(3, sizeof(*ctx->progs));
 
 	/* PROBE0 */
 	prog = calloc(1, sizeof(*prog));
-	/* prog->locals = calloc(1, sizeof(*prog->locals)); */
-	/* prog->globals = ctx->globals; */
+	prog->locals = calloc(1, sizeof(*prog->locals));
+	prog->globals = ctx->globals;
 
 	prog->probe = "k:SyS_read";
 
 	 * }
 	 */
 	prog->ast =
-		node_expr("",
+		node_expr("{}",
 			  node_expr("=",
 				    node_expr("[]",
 					      node_ident("@t"),
 				    NULL),
 			  NULL);
 
-	/* prog->provider = provider_get("k"); */
-	/* prog->provider->probe(prog); */
+	prog->provider = provider_get("k");
+	prog->provider->probe(prog);
 	/* prog->ir = ir_new(); */
 	ctx->progs[0] = prog;
 
 	/* PROBE1 */
 	prog = calloc(1, sizeof(*prog));
-	/* prog->locals = calloc(1, sizeof(*prog->locals)); */
-	/* prog->globals = ctx->globals; */
+	prog->locals = calloc(1, sizeof(*prog->locals));
+	prog->globals = ctx->globals;
 
 	/* TODO: k -> kret */
 	prog->probe = "k:SyS_read2"; 
 				    NULL),
 			  NULL);
 
-	/* prog->provider = provider_get("k"); */
-	/* prog->provider->probe(prog); */
+	prog->provider = provider_get("k");
+	prog->provider->probe(prog);
 	/* prog->ir = ir_new(); */
 	ctx->progs[1] = prog;
 
 }
 
 
-/* int pass_resolve_symbols(node_t *n, void *_prog) */
-/* { */
-/* 	struct prog *prog = _prog; */
-/* 	provider_t *global = provider_get(":"); */
-/* 	node_t *op; */
-/* 	int err; */
+int pass_sym_alloc(struct node *n, void *_prog)
+{
+	struct prog *prog = _prog;
+	struct provider *global = provider_get(":");
+	int err = 0;
 
-/* 	if (n->ntype != N_IDENT) */
-/* 		return 0; */
+	switch (n->ntype) {
+	case N_EXPR:
+	case N_IDENT:
+		err = prog->provider->sym_alloc(prog, n);
+		if (!err || (err != -ENOENT))
+			break;
 
-/* 	err = prog->provider->resolve(prog, n); */
-/* 	if (!err || (err != -ENOENT)) */
-/* 		return err; */
+		err = global->sym_alloc(prog, n);
+		break;
+	case N_NUM:
+	case N_STRING:
+		err = global->sym_alloc(prog, n);
+	}
 
-/* 	err = global->resolve(prog, n); */
-/* 	if (!err || (err != -ENOENT)) */
-/* 		return err; */
+	if (err) {
+		if (n->ntype == N_EXPR)
+			node_error(n, stderr, "unknown function '%s'",
+				   n->expr.func);
+		else
+			assert(0);
+	}
 
-/* 	/\* neither provider identifier nor global ditto => user */
-/* 	 * variable, add it as a global symbol of unknown type. *\/ */
-/* 	return sym_add(prog->globals, n->ident, NULL, &n->sym); */
-/* } */
+	return err;
+}
 
 /* int infer_type_list(struct prog *prog, node_t *n) */
 /* { */
 }
 
 struct pass passes[] = {
-	/* { .run = run_walk, .post = pass_resolve_symbols }, */
+	{ .run = run_walk, .post = pass_sym_alloc },
 	/* { .run = run_walk, .post = pass_infer_types }, */
 	/* { .run = run_walk, .post = pass_infer_types }, */
 	/* { .run = run_walk, .post = pass_infer_types }, */

ply.h

 #define _PLY_H
 
 struct node;
+struct symtab;
 
 struct prog {
 	const char *probe;
 	struct node *ast;
 
+	struct symtab *locals;
+	struct symtab *globals;
+
 	/* symtab_t *locals; */
 	/* symtab_t *globals; */
 
-	/* provider_t *provider; */
-	/* void *provider_data; */
+	struct provider *provider;
+	void *provider_data;
 
 	/* ir_t *ir; */
 };
 struct ctx {
 	struct prog **progs;
 
-	/* symtab_t *globals; */
+	struct symtab *globals;
 };
 
-/* struct provider { */
-/* 	const char *name; */
 
-/* 	int (*probe)(prog_t *); */
-/* 	int (*resolve)(prog_t *, node_t *); */
-/* 	int (*rewrite_node)(prog_t *, node_t *); */
-/* 	int (*ir_prologue)(prog_t *); */
-/* 	int (*ir_epilogue)(prog_t *); */
-/* }; */
+struct func;
+
+struct provider {
+	const char *name;
+
+	int (*probe)(struct prog *);
+	int (*sym_alloc)(struct prog *, struct node *);
+	/* int (*resolve)(struct prog *, struct node *); */
+	/* int (*rewrite_node)(struct prog *, struct node *); */
+	/* int (*ir_prologue)(struct prog *); */
+	/* int (*ir_epilogue)(struct prog *); */
+};
 
-/* void provider_register(provider_t *prov); */
+void provider_register(struct provider *p);
 
 #endif	/* _PLY_H */

sym.c

 #include <stdlib.h>
 #include <string.h>
 
+#include "node.h"
 #include "sym.h"
+#include "type.h"
 
-sym_t *sym_get(symtab_t *st, const char *name)
+static struct sym *__sym_alloc(struct symtab *st, const char *name,
+			       const struct func *func)
 {
-	size_t i;
+	struct sym *sym;
 
-	for (i = 0; i < st->len; i++) {
-		if (!strcmp(st->sym[i]->name, name))
-			return st->sym[i];
-	}
+	st->syms = realloc(st->syms, ++st->len * sizeof(*st->syms));
+	assert(st->syms);
 
-	return NULL;
+	st->syms[st->len - 1] = calloc(1, sizeof(struct sym));
+	sym = st->syms[st->len - 1];
+	sym->st   = st;
+	sym->name = name;
+	sym->func = func;
+	return 0;
 }
 
-int sym_add(symtab_t *st, const char *name, type_t *type, sym_t **new)
+static struct sym *sym_alloc_ident(struct symtab *st, struct node *n,
+				   const struct func *func)
 {
-	sym_t *sym;
-
-	sym = sym_get(st, name);
-	if (sym) {
-		/* if there is no type info, accept anything */
-		if (!sym->type)
-			sym->type = type;
-		/* otherwise, if specified, it must match */
-		else if (type && !type_equal(sym->type, type))
-			return -EINVAL;
+	struct sym **sym;
 
-		goto found;
+	symtab_foreach(st, sym) {
+		if (!strcmp((*sym)->name, n->ident.name))
+			return *sym;
 	}
 
-	st->sym = realloc(st->sym, ++st->len * sizeof(*st->sym));
-	assert(st->sym);
+	return __sym_alloc(st, n->ident.name, func);
+}
 
-	st->sym[st->len - 1] = calloc(1, sizeof(sym_t));
-	sym = st->sym[st->len - 1];
-	sym->st   = st;
-	sym->name = name;
-	sym->type = type;
-found:
-	if (new)
-		*new = sym;
-	return 0;
+struct sym *sym_alloc(struct symtab *st, struct node *n,
+		      const struct func *func)
+{
+	switch (n->ntype) {
+	case N_EXPR:
+	case N_NUM:
+	case N_STRING:
+		return __sym_alloc(st, NULL, func);
+	case N_IDENT:
+		return sym_alloc_ident(st, n, func);
+	}
+
+	assert(0);
+	return NULL;
 }
 
-void sym_dump(sym_t *sym, FILE *fp)
+void sym_dump(struct sym *sym, FILE *fp)
 {
-	fputs("\e[2m", fp);
-	type_dump(sym->type, fp);
-	fputs("\e[0m ", fp);
-	fputs(sym->name, fp);
+	type_dump(sym->type, sym->name, fp);
 }
 
-void symtab_dump(symtab_t *st, FILE *fp)
+void symtab_dump(struct symtab *st, FILE *fp)
 {
-	size_t i;
+	struct sym **sym;
+
+	symtab_foreach(st, sym) {
+		if (!(*sym)->name)
+			continue;
 
-	for (i = 0; i < st->len; i++) {
-		sym_dump(st->sym[i], fp);
+		sym_dump(*sym, fp);
 		fputc('\n', fp);
 	}
 }

sym.h

 
 #include <stdint.h>
 
-#include "ir.h"
-#include "type.h"
+struct symtab;
 
-typedef struct symtab symtab_t;
+struct type;
+struct func;
+
+struct sym {
+	struct symtab *st;
 
-typedef struct sym {
-	symtab_t *st;
 	const char *name;
-	type_t *type;
+	const struct func *func;
 
-	irstate_t irs;
-} sym_t;
+	struct type *type;
+	/* irstate_t irs; */
+};
 
 struct symtab {
-	sym_t **sym;
+	struct sym **syms;
 	size_t len;
 };
 
-sym_t *sym_get(symtab_t *st, const char *name);
-int    sym_add(symtab_t *st, const char *name, type_t *type, sym_t **new);
+#define symtab_foreach(_st, _sym) \
+	for((_sym) = (_st)->syms; (_sym) < &(_st)->syms[(_st)->len]; (_sym)++)
+
+struct sym *sym_alloc(struct symtab *st, struct node *n,
+		      const struct func *func);
 
-void sym_dump(sym_t *sym, FILE *fp);
-void symtab_dump(symtab_t *st, FILE *fp);
+void sym_dump(struct sym *sym, FILE *fp);
+void symtab_dump(struct symtab *st, FILE *fp);
 
-//#define symtab_foreach(_st, _sym) for((_sym) = (_st)->sym; (_sym) < (_st)->sym[(_st)->len]; (_sym)++)
 
 #endif	/* _PLY_SYM_H */

type.c

 
 #include "type.h"
 
-void type_dump_func(struct type *t, FILE *fp)
+static void type_dump_func(struct type *t, const char *name, FILE *fp)
 {
 	struct tfield *arg;
 
-	type_dump(t->func.type, fp);
-	fputs(" (*)(", fp);
+	type_dump(t->func.type, NULL, fp);
+	fprintf(fp, " (*%s)(", name ? : "");
 
 	if (!t->func.args) {
 		fputs("void)", fp);
 		if (arg != t->func.args)
 			fputs(", ", fp);
 
-		type_dump(arg->type, fp);
+		type_dump(arg->type, NULL, fp);
 	}
 
 	fputc(')', fp);
 }
 
-void type_dump(struct type *t, FILE *fp)
+void type_dump(struct type *t, const char *name, FILE *fp)
 {
 	if (!t) {
 		fputs("<NONE>", fp);
 
 	switch (t->ttype){
 	case T_VOID:
-		fputs("void", fp);
+		fprintf(fp, "void%s%s", name? " " : "", name ? : "");
 		break;
 	case T_TYPEDEF:
-		fputs(t->tdef.name, fp);
+		fprintf(fp, "%s%s%s", t->tdef.name, name? " " : "", name ? : "");
 		break;
 	case T_SCALAR:
-		fputs(t->scalar.name, fp);
+		fprintf(fp, "%s%s%s", t->scalar.name, name? " " : "", name ? : "");
 		break;
 	case T_POINTER:
-		type_dump(t->ptr.type, fp);
-		fputs(" *", fp);
+		type_dump(t->ptr.type, NULL, fp);
+		fprintf(fp, " *%s", name ? : "");
 		break;
 	case T_ARRAY:
-		type_dump(t->array.type, fp);
-		fprintf(fp, "[%zu]", t->array.len);
+		type_dump(t->array.type, NULL, fp);
+		fprintf(fp, "%s%s[%zu]", name ? " " : "", name? : "", t->array.len);
 		break;
 	case T_STRUCT:
-		fputs("struct ", fp);
-		fputs(t->sou.name, fp);
+		fprintf(fp, "struct %s%s%s", t->sou.name, name? " " : "", name? : "");
 		break;
-	/* case T_UNION: */
-	/* 	fputs("union ", fp); */
-	/* 	fputs(t->sou.name, fp); */
-	/* 	break; */
 	case T_FUNC:
-		type_dump_func(t, fp);
+		type_dump_func(t, name, fp);
 		break;
 	case T_MAP:
-		fputs("map [", fp);
-		type_dump(t->map.ktype, fp);
+		fprintf(fp, "map %s[", name ? : "");
+		type_dump(t->map.ktype, NULL, fp);
 		fputs("] ", fp);
-		type_dump(t->map.vtype, fp);
+		type_dump(t->map.vtype, NULL, fp);
 		break;
 	}
 }
 
-void type_dump_cdecl_sou(struct type *t, FILE *fp)
+static void type_dump_decl_sou(struct type *t, FILE *fp)
 {
 	struct tfield *f;
 
-	type_dump(t, fp);
+	type_dump(t, NULL, fp);
 	fputs(" {\n", fp);
 	for (f = t->sou.fields; f->type; f++) {
 		fputc('\t', fp);
-		type_dump(f->type, fp);
+		type_dump(f->type, NULL, fp);
 		fprintf(fp, " %s;\n", f->name);
 	}
 	fputs("}", fp);
 }
 
-void type_dump_cdecl(struct type *t, FILE *fp)
+void type_dump_decl(struct type *t, FILE *fp)
 {
 	switch (t->ttype) {
 	case T_TYPEDEF:
 		fputs("typedef ", fp);
-		type_dump(t->tdef.type, fp);
+		type_dump(t->tdef.type, NULL, fp);
 		fprintf(fp, " %s", t->tdef.name);
 		break;
 
 	case T_STRUCT:
-	/* case T_UNION: */
-		type_dump_cdecl_sou(t, fp);
+		type_dump_decl_sou(t, fp);
 		break;
 
 	case T_VOID:
 	case T_ARRAY:
 	case T_MAP:
 	case T_FUNC:
-		type_dump(t, fp);
+		type_dump(t, NULL, fp);
 		break;
 	}
 }
 
-/* void types_dump_cdecl(FILE *fp) */
-/* { */
-/* 	size_t i; */
-
-/* 	for (i = 0; i < types.len; i++) { */
-/* 		struct type *t = types.type[i]; */
-
-/* 		type_dump_cdecl(t, stdout); */
-/* 		printf(" <sz:0x%zx>\n", t->size); */
-/* 	} */
-/* } */
-
-
 
 struct type *type_normalize(struct type *t)
 {
 	return -EINVAL;
 }
 
+static size_t __padding(size_t offset, size_t align)
+{
+	size_t pad = align - (offset & (align - 1));
+
+	return (pad == align) ? 0 : pad;
+}
+
 ssize_t type_offset_size_of(struct type *t, const char *field)
 {
 	struct tfield *f;
 		if (falign < 0)
 			return falign;
 
-		if (!t->sou.packed && (falign > 1))
-			offset += falign - (offset % falign);
+		if (!t->sou.packed)
+			offset += __padding(offset, falign);
 
 		if (field && !strcmp(f->name, field))
 			return offset;
 	if (field)
 		return -ENOENT;
 
-	if (!t->sou.packed && offset && (falign > 1))
-		offset += falign - (offset % falign);
+	if (!t->sou.packed)
+		offset += __padding(offset, type_alignof(t));
 
 	return offset;
 	

type.h

 int type_equal     (struct type *a, struct type *b);
 int type_compatible(struct type *a, struct type *b);
 
-void type_dump      (struct type *t, FILE *fp);
-void type_dump_cdecl(struct type *t, FILE *fp);
+void type_dump     (struct type *t, const char *name, FILE *fp);
+void type_dump_decl(struct type *t, FILE *fp);
 
 ssize_t type_alignof(struct type *t);
 ssize_t type_offsetof(struct type *t, const char *field);

type_test.c

-#include "type.h"
 #include "unittest.h"
 
+#include "type.h"
+
 static int sizeof_basic(void *_null)
 {
 	struct type *voidp, *map;