separate IR graph parts of Proc into a Graph struct

1 files changed, 21 insertions, 128 deletions

diff --git a/ir.c b/ir.c
index e3cb679..12b641b 100644
--- a/ir.c
+++ b/ir.c
@@ -15,12 +15,12 @@ const char *node_type_name(NodeType t) {
 	return names[t];
 }
 
-void node_die(Node *n, Proc *p) {
+void node_die(Node *n, Graph *p) {
 	assert(n->refs == 0);
 	assert(n->op != N_DEAD);
 	n->op = N_DEAD;
-	n->prev_free = p->free_list;
-	p->free_list = n;
+	n->prev_free = p->pool->free_list;
+	p->pool->free_list = n;
 }
 
 void node_del_out(Node *n, Node *p) {
@@ -49,7 +49,7 @@ void node_del_in(Node *n, Node *p) {
 	}
 }
 
-void node_kill(Node *n, Proc *p) {
+void node_kill(Node *n, Graph *p) {
 	if (p->ctrl == n) {
 		/* probably this is fine */
 		p->ctrl = CTRL(n);
@@ -59,17 +59,17 @@ void node_kill(Node *n, Proc *p) {
 	assert(n->refs == 0);
 }
 
-void node_add_out(Proc *p, Node *a, Node *b) {
-	ZDA_PUSH(&p->perm, &a->out, b);
+void node_add_out(Graph *p, Node *a, Node *b) {
+	ZDA_PUSH(p->pool->arena, &a->out, b);
 	if (b) b->refs++;
 }
 
-void node_add_in(Proc *p, Node *a, Node *b) {
-	ZDA_PUSH(&p->perm, &a->in, b);
+void node_add_in(Graph *p, Node *a, Node *b) {
+	ZDA_PUSH(p->pool->arena, &a->in, b);
 	if (b) b->refs++;
 }
 
-void node_set_in(Proc *p, Node *n, int idx, Node *to) {
+void node_set_in(Graph *p, Node *n, int idx, Node *to) {
 	Node *in = n->in.data[idx];
 	if (in) in->refs--;
 	node_add_out(p, to, n);
@@ -78,7 +78,7 @@ void node_set_in(Proc *p, Node *n, int idx, Node *to) {
 	if (in->out.len < 1) node_kill(in, p);
 }
 
-void node_add(Proc *p, Node *src, Node *dest) {
+void node_add(Graph *p, Node *src, Node *dest) {
 	if (src) assert(src->op != N_DEAD);
 	if (dest) assert(dest->op != N_DEAD);
 	node_add_in(p, dest, src);
@@ -92,7 +92,7 @@ void node_add(Proc *p, Node *src, Node *dest) {
 	}
 }
 
-void node_remove(Proc *p, Node *src, Node *dest) {
+void node_remove(Graph *p, Node *src, Node *dest) {
 	assert(dest->op != N_DEAD);
 	node_del_in(dest, src);
 	if (dest->refs < 1) node_die(dest, p);
@@ -105,22 +105,22 @@ void node_remove(Proc *p, Node *src, Node *dest) {
 
 static int global_node_count = 0;
 
-Node *node_new_empty(Proc *p, NodeType t) {
+Node *node_new_empty(Graph *p, NodeType t) {
 	Node *n;
-	if (p->free_list) {
-		n = p->free_list;
+	if (p->pool->free_list) {
+		n = p->pool->free_list;
 		assert(n->op == N_DEAD);
-		p->free_list = n->prev_free;
+		p->pool->free_list = n->prev_free;
 		memset(n, 0, sizeof(Node));
 	} else {
-		n = new(&p->perm, Node);
+		n = new(p->pool->arena, Node);
 	}
 	n->op = t;
 	n->id = global_node_count++;
 	return n;
 }
 
-Node *node_newv(Proc *p, NodeType t, Node *ctrl, ...) {
+Node *node_newv(Graph *p, NodeType t, Node *ctrl, ...) {
 	Node *node = node_new_empty(p, t);
 	va_list ap;
 	va_start(ap, ctrl);
@@ -134,7 +134,7 @@ Node *node_newv(Proc *p, NodeType t, Node *ctrl, ...) {
 	return node;
 }
 
-Node *node_dedup_lit(Proc *p, Value v) {
+Node *node_dedup_lit(Graph *p, Value v) {
 	/* TODO: this is probably real inefficient for large procedure graphs,
 	 * but does it matter? how many nodes are direct children of the start node?
 	 * how many literals even usually occur in a procedure? */
@@ -147,7 +147,7 @@ Node *node_dedup_lit(Proc *p, Value v) {
 	return NULL;
 }
 
-Node *node_new_lit(Proc *p, Value v) {
+Node *node_new_lit(Graph *p, Value v) {
 	Node *t = node_dedup_lit(p, v);
 	if (t) return t;
 	Node *n = node_new(p, N_LIT, NULL, p->start);
@@ -155,121 +155,14 @@ Node *node_new_lit(Proc *p, Value v) {
 	return n;
 }
 
-Node *node_new_lit_i64(Proc *p, int64_t i) {
+Node *node_new_lit_i64(Graph *p, int64_t i) {
 	return node_new_lit(p, (Value) { { .lvl = T_CONST, .t = T_INT }, { .i = i } });
 }
 
-Node *node_new_lit_bool(Proc *p, int b) {
+Node *node_new_lit_bool(Graph *p, int b) {
 	return node_new_lit(p, (Value) { { .lvl = T_CONST, .t = T_BOOL }, { .i = b } });
 }
 
-/* procedures */
-
-void proc_init(Proc *proc, Str name) {
-	memset(proc, 0, sizeof(Proc));
-	proc->start = node_new(proc, N_START, NULL);
-	proc->start->type = (Type) {
-		.lvl = T_BOT,
-		.t = T_TUPLE,
-		.next = NULL
-	};
-	proc->stop = node_new_empty(proc, N_STOP);
-	proc->ctrl = proc->start;
-	proc->keepalive = node_new(proc, N_KEEPALIVE, NULL);
-	proc->name = name;
-}
-
-void proc_free(Proc *proc) {
-	arena_free(&proc->perm);
-	arena_free(&proc->scratch);
-}
-
-/* scope */
-
-NameBinding *scope_find(Scope *scope, Str name) {
-	for (ScopeFrame *f = scope->tail; f; f = f->prev) {
-		for (NameBinding *b = f->latest; b; b = b->prev) {
-			if (str_eql(b->name, name)) {
-				return b;
-			}
-		}
-	}
-	return NULL;
-}
-
-ScopeFrame *scope_push(Scope *scope, Proc *proc) {
-	ScopeFrame *f;
-	if (scope->free_scope) {
-		f = scope->free_scope;
-		*f = (ScopeFrame) { 0 };
-		scope->free_scope = f->prev;
-	} else {
-		f = new(&proc->perm, ScopeFrame);
-	}
-	f->prev = scope->tail;
-	scope->tail = f;
-	return f;
-}
-
-ScopeFrame *scope_pop(Scope *scope, Proc *proc) {
-	ScopeFrame *f = scope->tail;
-	scope->tail = f->prev;
-	f->prev = scope->free_scope;
-	scope->free_scope = f;
-	for (NameBinding *b = f->latest; b; ) {
-		NameBinding *p = b->prev;
-		b->prev = scope->free_bind;
-		scope->free_bind = b;
-		node_remove(proc, b->node, proc->keepalive);
-		b = p;
-	}
-	return scope->tail;
-}
-
-/* returns previous value */
-NameBinding *scope_bind(Scope *scope, Str name, Node *value, LexSpan pos, Proc *proc) {
-	NameBinding *prev = scope_find(scope, name);
-	NameBinding *b;
-	if (scope->free_bind) {
-		b = scope->free_bind;
-		*b = (NameBinding) { 0 };
-		scope->free_bind = b->prev;
-	} else {
-		b = new(&proc->perm, NameBinding);
-	}
-	b->name = name;
-	b->prev = scope->tail->latest;
-	scope->tail->latest = b;
-	b->node = value;
-	b->src_pos = pos;
-	node_add(proc, value, proc->keepalive);
-	return prev;
-}
-
-NameBinding *scope_update(NameBinding *b, Node *to, Proc *proc) {
-	Node *n = b->node;
-	node_add(proc, to, proc->keepalive);
-	b->node = to;
-	node_remove(proc, n, proc->keepalive);
-	return b;
-}
-
-/* adds to keepalive so these aren't invalidated */
-void scope_collect(Scope *scope, Proc *proc, ScopeNameList *nl, Arena *arena) {
-	for (ScopeFrame *f = scope->tail; f; f = f->prev) {
-		for (NameBinding *b = f->latest; b; b = b->prev) {
-			node_add(proc, b->node, proc->keepalive);
-			ZDA_PUSH(arena, nl, (ScopeName) { b->name, b->node });
-		}
-	}
-}
-
-void scope_uncollect(Scope *scope, Proc *proc, ScopeNameList *nl) {
-	for (int i = 0; i < nl->len; i++) {
-		node_remove(proc, nl->data[i].node, proc->keepalive);
-	}
-}
-
 /* types */
 
 int type_eql(Type *a, Type *b) {