basic type unittests pass

ply.c

 	/* prog->globals = ctx->globals; */
 
 	prog->probe = "k:SyS_read";
-	/* { @t[0] = time(); @reads[pid()] = quantize(arg2) } */
+
+	/* { 
+	 * 	@t[0] = time();
+	 * 	@reads[pid()] = quantize(arg2)
+	 * }
+	 */
 	prog->ast =
 		node_expr("",
 			  node_expr("=",

type.c

 		fputs("struct ", fp);
 		fputs(t->sou.name, fp);
 		break;
-	case T_UNION:
-		fputs("union ", fp);
-		fputs(t->sou.name, fp);
-		break;
+	/* case T_UNION: */
+	/* 	fputs("union ", fp); */
+	/* 	fputs(t->sou.name, fp); */
+	/* 	break; */
 	case T_FUNC:
 		type_dump_func(t, fp);
 		break;
 		break;
 
 	case T_STRUCT:
-	case T_UNION:
+	/* case T_UNION: */
 		type_dump_cdecl_sou(t, fp);
 		break;
 
 /* 	} */
 /* } */
 
-/* struct type *type_map_of(struct type *ktype, struct type *vtype) */
-/* { */
-/* 	struct type *t; */
-/* 	size_t i; */
-
-/* 	for (i = 0; i < types.len; i++) { */
-/* 		t = types.type[i]; */
-/* 		if ((t->ttype == T_MAP) */
-/* 		    && (t->map.ktype == ktype) */
-/* 		    && (t->map.vtype == vtype)) */
-/* 			return t; */
-/* 	} */
-
-/* 	t = calloc(1, sizeof(*t)); */
-/* 	t->ttype = T_MAP; */
-/* 	t->map.vtype = vtype; */
-/* 	t->map.ktype = ktype; */
-/* 	type_add(t); */
-/* 	return t; */
-/* } */
-
-/* struct type *type_ptr_of(struct type *type) */
-/* { */
-/* 	struct type *t; */
-/* 	size_t i; */
-
-/* 	for (i = 0; i < types.len; i++) { */
-/* 		t = types.type[i]; */
-/* 		if ((t->ttype == T_POINTER) */
-/* 		    && (t->pointer.type == type)) */
-/* 			return t; */
-/* 	} */
-
-/* 	t = calloc(1, sizeof(*t)); */
-/* 	t->ttype = T_POINTER; */
-/* 	t->pointer.type = type; */
-/* 	type_add(t); */
-/* 	return t; */
-/* } */
 
 
 struct type *type_normalize(struct type *t)
 
 		return type_compatible(a->array.type, b->array.type);
 	case T_STRUCT:
-	case T_UNION:
+	/* case T_UNION: */
 		return !strcmp(a->sou.name, b->sou.name);
 	case T_FUNC:
 		return type_compatible(a->func.type, b->func.type);
 	return 0;
 }
 
-/* void type_size_set_sou(struct type *t) */
-/* { */
-/* 	struct tfield *f; */
-/* 	size_t size = 0; */
-
-/* 	if (!t->sou.fields) */
-/* 		return; */
-
-/* 	for (f = t->sou.fields; f->name; f++) { */
-/* 		/\* size of all members is now known yet, abort *\/ */
-/* 		if (!f->type->size) */
-/* 			return; */
-
-/* 		if (!t->sou.packed) */
-/* 			size += size % f->type->size; */
-
-/* 		size += f->type->size; */
-/* 		f->offset = size; */
-/* 	} */
-
-/* 	if (!t->sou.packed && size) { */
-/* 		/\* align complete struct to requirements of first */
-/* 		 * member, if struct keep going downwards *\/ */
-/* 		f = t->sou.fields; */
-/* 		while (f->type->ttype == T_STRUCT) */
-/* 			f = f->type->sou.fields; */
-
-/* 		size += size % f->type->size; */
-/* 	} */
-
-/* 	t->size = size; */
-/* } */
-
-/* void type_size_set(struct type *t) */
-/* { */
-/* 	switch (t->ttype) { */
-/* 	case T_TYPEDEF: */
-/* 		t->size = t->tdef.type->size; */
-/* 		break; */
-/* 	case T_STRUCT: */
-/* 	case T_UNION: */
-/* 		type_size_set_sou(t); */
-/* 		break; */
-/* 	case T_FUNC: */
-/* 		t->size = t->func.type->size; */
-/* 		assert(t->func.generate_ir); */
-/* 		break; */
-/* 	case T_SCALAR: */
-/* 		break; */
-/* 	case T_POINTER: */
-/* 		t->size = sizeof(void *); */
-/* 		break; */
-/* 	case T_ARRAY: */
-/* 		t->size = t->array.len * t->array.type->size; */
-/* 		break; */
-/* 	case T_MAP: */
-/* 		/\* map fds are s64:s *\/ */
-/* 		t->size = 8; */
-/* 		break; */
-/* 	} */
-/* } */
-
-static ssize_t type_alignof_union(struct type *t)
+static ssize_t type_alignof_struct(struct type *t)
 {
-	ssize_t amax = -EINVAL;
 	struct tfield *f;
+	ssize_t falign, align = -EINVAL;
 
-	for (f = t->sou.fields; f->type != T_VOID; f++) {
-		ssize_t a;
+	tfields_foreach(f, t->sou.fields) {
+		falign = type_alignof(f->type);
 
-		a = type_alignof(f->type);
-		if (a < 0)
-			return a;
+		if (falign < 0)
+			return falign;
 
-		if (a > amax)
-			amax = a;
+		if (falign > align)
+			align = falign;
 	}
 
-	return amax;
+	return align;
 }
 
 ssize_t type_alignof(struct type *t)
 	case T_ARRAY:
 		return type_alignof(t->array.type);
 	case T_STRUCT:
-		if (!t->sou.fields)
-			return type_alignof(&t_void);
-		return type_alignof(t->sou.fields->type);
-	case T_UNION:
-		if (!t->sou.fields)
-			return type_alignof(&t_void);
-		return type_alignof_union(t);
+		return type_alignof_struct(t);
 	}
 
 	return -EINVAL;
 }
 
-static ssize_t type_sizeof_struct(struct type *t)
+ssize_t type_offset_size_of(struct type *t, const char *field)
 {
 	struct tfield *f;
-	size_t size = 0;
-	ssize_t fsize;
+	size_t offset = 0;
+	ssize_t fsize, falign;
+
+	assert(t->ttype == T_STRUCT);
 
 	if (!t->sou.fields)
-		return 0;
+		return -ENOENT;
 
-	for (f = t->sou.fields; f->name; f++) {
-		/* size of all members is now known yet, abort */
+	tfields_foreach(f, t->sou.fields) {
 		fsize = type_sizeof(f->type);
 		if (fsize < 0)
 			return fsize;
 
-		size += fsize;
+		falign = type_alignof(f->type);
+		if (falign < 0)
+			return falign;
 
-		if (!t->sou.packed)
-			size += size % type_alignof(f->type);
-	}
+		if (!t->sou.packed && (falign > 1))
+			offset += falign - (offset % falign);
 
-	if (!t->sou.packed && size)
-		size += size % type_alignof(t);
+		if (field && !strcmp(f->name, field))
+			return offset;
 
-	return size;
-}
+		offset += fsize;
+	}
 
-static ssize_t type_sizeof_union(struct type *t)
-{
-	struct tfield *f;
-	ssize_t size = 0;
+	if (field)
+		return -ENOENT;
 
-	if (!t->sou.fields)
-		return 0;
+	if (!t->sou.packed && offset && (falign > 1))
+		offset += falign - (offset % falign);
 
-	for (f = t->sou.fields; f->name; f++) {
-		ssize_t z, a;
-
-		z = type_sizeof(f->type);
-		a = t->sou.packed ? type_alignof(f->type) : 0;
-		if ((z < 0) || (a < 0))
-			return -EINVAL;
+	return offset;
+	
+}
 
-		z += z % a;
-		if (z > size)
-			size = z;
-	}
+ssize_t type_offsetof(struct type *t, const char *field)
+{
+	return type_offset_size_of(t, field);
+}
 
-	return size;
+ssize_t type_sizeof_struct(struct type *t)
+{
+	return type_offset_size_of(t, NULL);
 }
 
 ssize_t type_sizeof(struct type *t)
 		return t->array.len * type_sizeof(t->array.type);
 	case T_STRUCT:
 		return type_sizeof_struct(t);
-	case T_UNION:
-		return type_sizeof_union(t);
 	case T_MAP:
 		return sizeof(int);
 	}
 	return -EINVAL;
 }
 
-/* int type_walk_fields(struct tfield *f, twalk_fn pre, twalk_fn post, void *ctx) */
-/* { */
-/* 	if (!f) */
-/* 		return 0; */
-
-/* 	while (f->type != T_VOID) { */
-/* 		if (pre && (err = pre(f->type, ctx))) */
-/* 			return err; */
-
-/* 		err = type_walk(f->type, pre, post, ctx); */
-/* 		if (err) */
-/* 			return err; */
-
-/* 		if (post && (err = post(f->type, ctx))) */
-/* 			return err; */
-/* 	} */
-/* } */
-
-/* int type_walk(struct type *t, twalk_fn pre, twalk_fn post, void *ctx) */
-/* { */
-/* 	int err; */
-
-/* 	if (pre && (err = pre(t, ctx))) */
-/* 		return err; */
-		
-/* 	switch (t->ttype){ */
-/* 	case T_VOID: */
-/* 	case T_SCALAR: */
-/* 		break; */
-/* 	case T_TYPEDEF: */
-/* 		err = type_walk(t->tdef.type, pre, post, ctx); */
-/* 		break; */
-/* 	case T_POINTER: */
-/* 		err = type_walk(t->ptr.type, pre, post, ctx); */
-/* 		break; */
-/* 	case T_ARRAY: */
-/* 		err = type_walk(t->array.type, pre, post, ctx); */
-/* 		break; */
-/* 	case T_STRUCT: */
-/* 	case T_UNION: */
-/* 		err = type_walk_fields(t->sou.fields, pre, post, ctx); */
-/* 		break; */
-/* 	case T_FUNC: */
-/* 		err = type_walk_fields(t->func.args, pre, post, ctx); */
-/* 		break; */
-/* 	case T_MAP: */
-/* 		err = type_walk(t->map.ktype, pre, post, ctx); */
-/* 		if (err) */
-/* 			break; */
-
-/* 		err = type_walk(t->map.vtype, pre, post, ctx); */
-/* 		break; */
-/* 	} */
-
-/* 	if (err) */
-/* 		return err; */
-	
-/* 	if (post && (err = post(t, ctx))) */
-/* 		return err; */
-/* } */
 
 
 int all_types_cmp(const void *_a, const void *_b)
 	size_t len;
 } all_types;
 
+#define types_foreach(_t) \
+	for ((_t) = all_types.types[0]; (_t) <= all_types.types[all_types.len]; (_t)++)
+
 int type_add(struct type *t)
 {
 	if (bsearch(t, all_types.types, all_types.len,
 	return 0;
 }
 
+struct type *type_array_of(struct type *type, size_t len)
+{
+	struct type *t;
+
+	types_foreach(t) {
+		if ((t->ttype == T_ARRAY)
+		    && (t->array.type == type)
+		    && (t->array.len == len))
+			return t;
+	}
+
+	t = calloc(1, sizeof(*t));
+	t->ttype = T_ARRAY;
+	t->array.type = type;
+	t->array.len = len;
+	type_add(t);
+	return t;
+}
+
+struct type *type_map_of(struct type *ktype, struct type *vtype)
+{
+	struct type *t;
+
+	types_foreach(t) {
+		if ((t->ttype == T_MAP)
+		    && (t->map.ktype == ktype)
+		    && (t->map.vtype == vtype))
+			return t;
+	}
+
+	t = calloc(1, sizeof(*t));
+	t->ttype = T_MAP;
+	t->map.vtype = vtype;
+	t->map.ktype = ktype;
+	type_add(t);
+	return t;
+}
+
+struct type *type_ptr_of(struct type *type)
+{
+	struct type *t;
+
+	types_foreach(t) {
+		if ((t->ttype == T_POINTER)
+		    && (t->ptr.type == type))
+			return t;
+	}
+
+	t = calloc(1, sizeof(*t));
+	t->ttype = T_POINTER;
+	t->ptr.type = type;
+	type_add(t);
+	return t;
+}
+
 #define is_signed(_t) (((_t)(-1)) < 0)
 
 #define builtin_scalar(_t) {				\

type.h

 	int optional:1;
 };
 
+#define tfields_foreach(_f, _fields) \
+	for ((_f) = (_fields); (_f)->type->ttype != T_VOID; (_f)++)
+
 struct tstruct {
 	char *name;
 
 	T_ARRAY,
 	T_MAP,
 	T_STRUCT,
-	T_UNION,
+	/* T_UNION, TODO */
 	T_FUNC,
 };
 
 	};
 };
 
-/* struct type *type_map_of(struct type *ktype, struct type *vtype); */
-/* struct type *type_ptr_of(struct type *type); */
-
 int type_equal     (struct type *a, struct type *b);
 int type_compatible(struct type *a, struct type *b);
 
 void type_dump_cdecl(struct type *t, FILE *fp);
 
 ssize_t type_alignof(struct type *t);
+ssize_t type_offsetof(struct type *t, const char *field);
 ssize_t type_sizeof(struct type *t);
 
-/* typedef int (*twalk_fn)(struct type *, void *); */
-/* int type_walk(struct type *t, twalk_fn pre, twalk_fn post, void *ctx); */
-
 
 int type_add(struct type *t);
 int type_add_list(struct type **ts);
 
+struct type *type_array_of(struct type *type, size_t len);
+struct type *type_map_of(struct type *ktype, struct type *vtype);
+struct type *type_ptr_of(struct type *type);
+
 
 /* built-in types */
 

type_test.c

-#include <assert.h>
-
 #include "type.h"
+#include "unittest.h"
+
+static int sizeof_basic(void *_null)
+{
+	struct type *voidp, *map;
+
+	unittest_eq(type_sizeof(&t_void),  sizeof(void));
+	unittest_eq(type_sizeof(&t_char),  sizeof(char));
+	unittest_eq(type_sizeof(&t_short), sizeof(short));
+	unittest_eq(type_sizeof(&t_int),   sizeof(int));
+	unittest_eq(type_sizeof(&t_long),  sizeof(long));
+	unittest_eq(type_sizeof(&t_llong), sizeof(long long));
+
+	voidp = type_ptr_of(&t_void);
+	unittest_eq(type_sizeof(voidp), sizeof(void *));
+
+	map = type_map_of(&t_short, &t_short);
+	unittest_eq(type_sizeof(map), sizeof(int));
+	
+	return 0;
+}
+UNITTEST(sizeof_basic);
+
+static int alignof_basic(void *_null)
+{
+	struct type *voidp, *map, *array;
+
+	unittest_eq(type_alignof(&t_void),  __alignof__(void));
+	unittest_eq(type_alignof(&t_char),  __alignof__(char));
+	unittest_eq(type_alignof(&t_short), __alignof__(short));
+	unittest_eq(type_alignof(&t_int),   __alignof__(int));
+	unittest_eq(type_alignof(&t_long),  __alignof__(long));
+	unittest_eq(type_alignof(&t_llong), __alignof__(long long));
 
-typedef void (*unittest_fn)(void)
-#define unittest __attribute__((section("unittest"))) static void
+	voidp = type_ptr_of(&t_void);
+	unittest_eq(type_alignof(voidp), __alignof__(void *));
 
-unittest test_sizeof_builtins(void)
+	map = type_map_of(&t_short, &t_short);
+	unittest_eq(type_alignof(map), __alignof__(int));
+
+	array = type_array_of(&t_int, 5);
+	unittest_eq(type_alignof(array), __alignof__(int[5]));
+
+	return 0;
+}
+UNITTEST(alignof_basic);
+
+struct t1 {
+	char  a;
+	int   b[5];
+	char  c[3];
+	short d;
+} *t1 = NULL;
+
+static int struct_basic(void *_null)
 {
-	assert(type_sizeof(&t_void) == sizeof(int));
+	struct tfield t1_fields[] = {
+		{ .name = "a", .type = &t_char },
+		{ .name = "b", .type = type_array_of(&t_int, 5) },
+		{ .name = "c", .type = type_array_of(&t_char, 3) },
+		{ .name = "d", .type = &t_short },
+
+		{ .type = &t_void }
+	};
+	struct type t_t1 = {
+		.ttype = T_STRUCT,
+		.sou = { .name = "t1", .fields = t1_fields },
+	};
+
+	unittest_eq(type_offsetof(&t_t1, "a"), offsetof(struct t1, a));
+	unittest_eq(type_offsetof(&t_t1, "b"), offsetof(struct t1, b));
+	unittest_eq(type_offsetof(&t_t1, "c"), offsetof(struct t1, c));
+	unittest_eq(type_offsetof(&t_t1, "d"), offsetof(struct t1, d));
+
+	unittest_eq(type_alignof(&t_t1), __alignof__(struct t1));
+	unittest_eq(type_sizeof(&t_t1), sizeof(struct t1));
+	return 0;
 }
+UNITTEST(struct_basic);
 
 int main(void)
 {
-	unittest_fn test_fn;
-	int err;
+	struct unittest_ctx ctx = {
+		.keep_going = 1,
+		.verbose = 1,
 
-	for (test_fn = &__start_unittest; test_fn < &__stop_unittest; testfn++) {
-		test_fn();
-	}
+		.ctx = NULL,
+	};
 
-	return 0;
+	return unittests_run(&ctx) ? 1 : 0;
 }

unittest.h

+#ifndef _UNITTEST_H
+#define _UNITTEST_H
+
+#include <stdio.h>
+
+struct unittest {
+	const char *name;
+	int (*fn)(void *ctx);
+};
+
+#define UNITTEST(_fn) __attribute__((section("unittests"))) \
+	static struct unittest _fn ## _desc = {		    \
+		.name = #_fn,				    \
+		.fn = _fn,				    \
+	}
+
+extern struct unittest __start_unittests;
+extern struct unittest __stop_unittests;
+
+#define unittest_foreach(_t) \
+	for ((_t) = &__start_unittests; (_t) < &__stop_unittests; (_t)++)
+
+struct unittest_ctx {
+	int keep_going:1;
+	int verbose:1;
+
+	void *ctx;
+};
+
+static inline int unittests_run(struct unittest_ctx *ctx)
+{
+	struct unittest *t;
+	int err, ret = 0;
+
+	unittest_foreach(t) {
+		if (ctx->verbose) {
+			printf("%-40s\t", t->name);
+			fflush(stdout);
+		}
+
+		err = t->fn(ctx->ctx);
+
+		if (!err) {
+			if (ctx->verbose)
+				printf("pass\n");
+			continue;
+		} 
+
+		if (!ctx->verbose) {
+			printf("%-40s\t", t->name);
+			fflush(stdout);
+		}
+
+		printf("\n%40s\tFAIL\n", "");
+
+		if (!ctx->keep_going)
+			return err;
+		else if (!ret)
+			ret = err;
+	}
+
+	return ret;
+}
+
+#define unittest_eq(_a, _b) if ((_a) != (_b)) {				\
+		printf("\n\t%s == %s (%lld != %lld)",			\
+		       #_a, #_b, (long long)(_a), (long long)(_b));	\
+		return -1;						\
+	}
+
+#endif	/* _UNITTEST_H */