aboutsummaryrefslogtreecommitdiff
path: root/src/lower.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/lower.c')
-rw-r--r--src/lower.c1072
1 files changed, 645 insertions, 427 deletions
diff --git a/src/lower.c b/src/lower.c
index 89d9aca..a31564f 100644
--- a/src/lower.c
+++ b/src/lower.c
@@ -5,18 +5,112 @@
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
+#include <stdint.h>
#include <assert.h>
#include <fwd/lower.h>
#include <fwd/scope.h>
+#include <fwd/mod.h>
+
+/* stuff to be careful of:
+ *
+ * + Really easy to forget to pass the stack argument via reference, since it's
+ * just a void* we don't get a warning for it
+ *
+ * + lower_call() and lower_closure_call() share a lot of the same stuff, might
+ * want to try and merge them somehow, otherwise too easy to make a change in
+ * one and forget the other
+ */
+
+/* placeholder, should probably scale according to biggest need */
+#define FWD_FRAME_SIZE 1024
+
+static inline void mangle(FILE *f, struct ast *id)
+{
+ assert(id->k == AST_PROC_DEF || id->k == AST_VAR_DEF || id->k == AST_ID);
+ assert(id->s && id->scope);
+ fprintf(f, "%s_s%zu", id->s, id->scope->number);
+}
+
+static inline char *mangle2(struct ast *id)
+{
+ char *buf = NULL; size_t size = 0;
+ FILE *f = open_memstream(&buf, &size);
+ assert(f);
+
+ mangle(f, id);
+ fclose(f);
+ assert(buf);
+
+ return buf;
+}
+
+static inline __attribute__((format (printf, 1, 2)))
+char *buildstr(const char *fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+
+ char *buf = NULL; size_t size = 0;
+ FILE *f = open_memstream(&buf, &size);
+ assert(f);
+
+ vfprintf(f, fmt, args);
+ fclose(f);
+
+ va_end(args);
+ assert(buf);
+ return buf;
+}
/** @todo semantics in this file are a bit unclear, should probably do some kind
* of "each function starts and ends on an indented empty line" or something */
+#define VEC_NAME string_vec
+#define VEC_TYPE char *
+#include <conts/vec.h>
+
+#define MAP_NAME proc_set
+#define MAP_KEY struct ast *
+#define MAP_TYPE struct ast *
+#define MAP_CMP(a, b) ((uintptr_t)(a) - (uintptr_t)(b))
+#define MAP_HASH(a) ((uintptr_t)(a))
+#include <conts/map.h>
+
struct state {
+ char *prefix;
long indent;
+ size_t uniq;
+ FILE *ctx;
+ FILE *code;
+ struct ast *current;
+ struct string_vec *decls;
+ struct string_vec *defns;
+ struct string_vec *types;
+ struct proc_set *procs;
};
+static struct state create_state(struct state *parent)
+{
+ return (struct state){
+ .uniq = parent->uniq,
+ .prefix = parent->prefix,
+ .indent = parent->indent,
+ .current = parent->current,
+ .ctx = parent->ctx,
+ .code = parent->code,
+ .decls = parent->decls,
+ .defns = parent->defns,
+ .types = parent->types,
+ .procs = parent->procs,
+ };
+}
+
+static size_t uniq(struct state *state)
+{
+ return state->uniq++;
+}
+
static void increase_indent(struct state *state)
{
state->indent++;
@@ -30,624 +124,748 @@ static void decrease_indent(struct state *state)
static void indent(struct state *state)
{
if (state->indent != 0)
- printf("%*c", (int)(2 * state->indent), ' ');
+ fprintf(state->code, "%*c", (int)(2 * state->indent), ' ');
}
-static int lower_var(struct ast *expr);
+static bool proc_lowered(struct state *state, struct ast *proc)
+{
+ assert(proc->k == AST_PROC_DEF);
+ return proc_set_find(state->procs, proc) != NULL;
+}
-static int lower_expr(struct state *state, struct ast *expr);
-static int lower_closure(struct state *state, struct ast *closure);
+static void add_proc(struct state *state, struct ast *proc)
+{
+ assert(proc->k == AST_PROC_DEF);
+ struct ast **p = proc_set_insert(state->procs, proc, proc);
+ assert(p && *p == proc);
+}
-static int lower_block(struct state *state, struct ast *block, bool ret);
-static int lower_statement(struct state *state, struct ast *stmt, bool ret);
+static void add_decl(struct state *state, char *decl)
+{
+ string_vec_append(state->decls, decl);
+}
-static int lower_type(struct type *type);
-static int lower_types(struct type *types);
+static void add_defn(struct state *state, char *defn)
+{
+ string_vec_append(state->defns, defn);
+}
-static int lower_binop(struct state *state, struct ast *binop)
+static void add_type(struct state *state, char *type)
{
- printf("(");
- if (lower_expr(state, binop_left(binop)))
- return -1;
+ string_vec_append(state->types, type);
+}
- switch (binop->k) {
- case AST_ADD: printf(" + "); break;
- case AST_SUB: printf(" - "); break;
- case AST_MUL: printf(" * "); break;
- case AST_DIV: printf(" / "); break;
- case AST_REM: printf(" %% "); break;
- case AST_LSHIFT: printf(" << "); break;
- case AST_RSHIFT: printf(" >> "); break;
- default:
- internal_error("missing binop lowering");
- return -1;
- }
+static int lower_stmt_list(struct state *state, struct ast *stmt_list, bool last);
+static int lower_block(struct state *state, struct ast *block, bool last);
+static int lower_params(struct state *state, struct ast *params);
+static int lower_expr(struct state *state, struct ast *expr);
+static int lower_proc(struct state *state, struct ast *proc);
- if (lower_expr(state, binop_right(binop)))
- return -1;
+static void _type_str(FILE *f, struct type *type)
+{
+ assert(type);
+ switch (type->k) {
+ case TYPE_I8:
+ fprintf(f, "int8_t");
+ break;
- printf(")");
- return 0;
-}
+ case TYPE_U8:
+ fprintf(f, "uint8_t");
+ break;
-static int lower_comparison(struct state *state, struct ast *comp)
-{
- printf("(");
- if (lower_expr(state, comparison_left(comp)))
- return -1;
+ case TYPE_I16:
+ fprintf(f, "int16_t");
+ break;
- switch (comp->k) {
- case AST_LT: printf(" < "); break;
- case AST_GT: printf(" > "); break;
- case AST_LE: printf(" <= "); break;
- case AST_GE: printf(" <= "); break;
- case AST_NE: printf(" != "); break;
- case AST_EQ: printf(" == "); break;
- default:
- internal_error("missing comparison lowering");
- return -1;
- }
+ case TYPE_U16:
+ fprintf(f, "uint16_t");
+ break;
- if (lower_expr(state, comparison_right(comp)))
- return -1;
+ case TYPE_I32:
+ fprintf(f, "int32_t");
+ break;
- printf(")");
- return 0;
-}
+ case TYPE_U32:
+ fprintf(f, "uint32_t");
+ break;
-static int lower_exprs(struct state *state, struct ast *exprs)
-{
- if (!exprs)
- return 0;
+ case TYPE_I64:
+ fprintf(f, "int64_t");
+ break;
- if (lower_expr(state, exprs))
- return -1;
+ case TYPE_U64:
+ fprintf(f, "uint64_t");
+ break;
- foreach_node(expr, exprs->n) {
- printf(", ");
- if (lower_expr(state, expr))
- return -1;
- }
+ case TYPE_CLOSURE:
+ fprintf(f, "fwd_closure_t");
+ break;
- return 0;
+ default:
+ internal_error("unhandled type lowering for %s", type_str(type));
+ abort();
+ break;
+ }
}
-static int lower_type_construct(struct type *type)
+static char *lower_type_str(struct type *type)
{
- printf("%s", tconstruct_id(type));
- printf("<");
+ assert(type);
- if (lower_types(tconstruct_args(type)))
- return -1;
+ char *type_buf = NULL; size_t type_len = 0;
+ FILE *f = open_memstream(&type_buf, &type_len);
+ assert(f);
- printf(">");
- return 0;
+ _type_str(f, type);
+ fclose(f);
+ assert(type_buf);
+ return type_buf;
}
-static int lower_type_callable(struct type *type)
+static int lower_closure_call(struct state *state, struct ast *call, struct ast *def, bool last)
{
- /* std::function has a slight overhead compared to just using auto here,
- * but auto doesn't play well with recursive templates like with our
- * fib.fwd example, so use std::function for now. Eventually I might
- * instead write a C backend or something to have more control over the
- * exact semantics, but for now this is good enough. */
- printf("std::function<fwd_err_t(");
+ char *q = buildstr("%s_call%zu", state->prefix, uniq(state));
+ char *args = mangle2(def);
- if (lower_types(type->t0))
- return -1;
+ char *ctx_buf = NULL; size_t ctx_size = 0;
+ FILE *ctx = open_memstream(&ctx_buf, &ctx_size);
+ fprintf(ctx, "struct %s {\n fwd_start_t start;\n", q);
- printf(")>");
- return 0;
-}
+ indent(state);
+ fprintf(state->code, "fwd_call_t %s = ctx->%s.call;\n", q, args);
-static int lower_type_ref(struct type *type)
-{
- if (lower_type(tref_base(type)))
- return -1;
+ indent(state);
+ fprintf(state->code, "struct %s *%s_ctx = ctx->%s.args;\n", q, q, args);
- printf("&");
- return 0;
-}
+ int ret = 0;
+ size_t idx = 0;
+ bool returning = false;
+ foreach_node(a, call_args(call)) {
+ returning |= a->k == AST_CLOSURE;
-static int lower_type_ptr(struct type *type)
-{
- /* would I need parentheses in some cases? */
- if (lower_type(tptr_base(type)))
- return -1;
+ char *type = lower_type_str(a->t);
+ fprintf(ctx, " %s a%zu;\n", type, idx);
+ free(type);
- printf("*");
- return 0;
-}
+ indent(state);
+ fprintf(state->code, "%s_ctx->a%zu = ", q, idx);
+ int ret = lower_expr(state, a);
+ fprintf(state->code, ";\n");
+ if (ret)
+ goto out;
-static int lower_type(struct type *type)
-{
- switch (type->k) {
- case TYPE_ID: printf("%s", tid_str(type)); return 0;
- case TYPE_CONSTRUCT: return lower_type_construct(type);
- case TYPE_CLOSURE: return lower_type_callable(type);
- case TYPE_FUNC_PTR: return lower_type_callable(type);
- case TYPE_PURE_CLOSURE: return lower_type_callable(type);
- case TYPE_REF: return lower_type_ref(type);
- case TYPE_PTR: return lower_type_ptr(type);
- default:
- internal_error("missing type lowering");
- return -1;
+ idx++;
}
- return 0;
+out:
+ if (!returning && last && ast_flags(state->current, AST_REQ_FRAME)) {
+ indent(state);
+ fprintf(state->code, "fwd_stack_free(&stack, ctx);\n");
+ }
+
+ indent(state);
+ if (last) {
+ fprintf(state->code, "FWD_MUSTTAIL return %s(stack, %s_ctx);\n",
+ q, q);
+ }
+ else {
+ fprintf(state->code, "stack = %s_call(stack, %s_ctx);\n",
+ q, q);
+ }
+
+ fprintf(ctx, "};\n\n");
+ fclose(ctx);
+ assert(ctx_buf);
+
+ add_type(state, ctx_buf);
+ free(args);
+ free(q);
+ return ret;
}
-static int lower_types(struct type *types)
+static int lower_closure(struct state *state, struct ast *closure, char **name_out, char **args_out)
{
- if (!types)
- return 0;
+ char *name = buildstr("%s_closure%zu", state->prefix, uniq(state));
+ char *proto = buildstr("static fwd_stack_t %s(fwd_stack_t stack, fwd_args_t args)", name);
+ char *decl = buildstr("%s;\n", proto);
+ char *start_of = buildstr("%s_start", name);
+ add_decl(state, decl);
- if (lower_type(types))
- return -1;
+ char *code_buf = NULL;
+ size_t code_size = 0;
- foreach_type(type, types->n) {
- printf(", ");
- if (lower_type(type))
- return -1;
- }
+ struct state new_state = create_state(state);
+ new_state.code = open_memstream(&code_buf, &code_size);
+ new_state.indent = 0;
+ assert(new_state.code);
- return 0;
-}
+ fprintf(new_state.code, "%s\n{\n", proto);
-static int lower_init(struct state *state, struct ast *init)
-{
- printf("%s", init_id(init));
+ /** @todo unsure if this has the same address as the first element in
+ * the frame or the last in the previous, I guess we shall soon see */
+ fprintf(new_state.ctx, " fwd_start_t %s;\n", start_of);
- if (init_args(init)) {
- printf("<");
- if (lower_types(init_args(init)))
- return -1;
+ int ret = lower_params(&new_state, closure_bindings(closure));
+ assert(ret == 0);
- printf(">");
- }
+ increase_indent(&new_state);
+ indent(&new_state);
+ fprintf(new_state.code, "struct %s_ctx *ctx = FWD_CONTAINER_OF(args, struct %s_ctx, %s);\n",
+ state->prefix, state->prefix, start_of);
- printf("{");
+ struct ast *block = closure_body(closure);
+ ret = lower_stmt_list(&new_state, block_body(block), true);
- if (lower_exprs(state, init_body(init)))
- return -1;
+ fprintf(new_state.code, "}\n\n");
+ fclose(new_state.code);
+ assert(code_buf);
- printf("}");
- return 0;
+ add_defn(state, code_buf);
+ free(proto);
+
+ assert(name_out);
+ assert(args_out);
+ *name_out = name;
+ *args_out = start_of;
+ return ret;
}
-static int lower_unop(struct state *state, struct ast *expr)
+static int lower_comparison(struct state *state, struct ast *expr)
{
+ if (lower_expr(state, comparison_left(expr)))
+ return -1;
+
switch (expr->k) {
- case AST_LNOT: printf("-"); break;
- case AST_NOT: printf("~"); break;
- case AST_NEG: printf("-"); break;
+ case AST_LE:
+ fprintf(state->code, " <= ");
+ break;
+
+ case AST_LT:
+ fprintf(state->code, " < ");
+ break;
+
default:
- internal_error("missing unop lowering");
- return -1;
+ internal_error("unhandled lowering for comparison %s", ast_str(expr->k));
+ abort();
}
- return lower_expr(state, unop_expr(expr));
+ return lower_expr(state, comparison_right(expr));
}
-static int lower_expr(struct state *state, struct ast *expr)
+static int lower_binop(struct state *state, struct ast *expr)
{
- if (is_unop(expr))
- return lower_unop(state, expr);
-
- if (is_binop(expr))
- return lower_binop(state, expr);
-
- if (is_comparison(expr))
- return lower_comparison(state, expr);
+ if (lower_expr(state, binop_left(expr)))
+ return -1;
switch (expr->k) {
- case AST_ID: printf("%s", id_str(expr)); break;
- case AST_CONST_INT: printf("%lld", int_val(expr)); break;
- case AST_CONST_FLOAT: printf("%f", float_val(expr)); break;
- case AST_CONST_BOOL: printf("%s", bool_val(expr) ? "true" : "false");
+ case AST_SUB:
+ fprintf(state->code, " - ");
break;
- case AST_CONST_STR: printf("\"%s\"", str_val(expr)); break;
- case AST_CONST_CHAR: printf("'%c'", (char)char_val(expr)); break;
- case AST_INIT: return lower_init(state, expr);
- case AST_CLOSURE: return lower_closure(state, expr);
- case AST_REF: return lower_expr(state, ref_base(expr));
- case AST_DEREF: return lower_expr(state, deref_base(expr));
- default:
- internal_error("missing expr lowering");
- return -1;
- }
- return 0;
-}
+ case AST_ADD:
+ fprintf(state->code, " + ");
+ break;
-static int lower_move(struct state *state, struct ast *move)
-{
- if (move->k == AST_ID) {
- /** @todo once I start messing about with references, moves
- * should only be outputted for parameters that take ownership
- */
- printf("move(%s)", id_str(move));
- return 0;
+ default:
+ internal_error("unhandled comparison %s", ast_str(expr->k));
+ abort();
}
- return lower_expr(state, move);
+ return lower_expr(state, binop_right(expr));
}
-static int lower_moves(struct state *state, struct ast *moves)
+static int lower_expr(struct state *state, struct ast *expr)
{
- if (!moves)
- return 0;
+ if (is_comparison(expr))
+ return lower_comparison(state, expr);
- if (lower_move(state, moves))
- return -1;
+ if (is_binop(expr))
+ return lower_binop(state, expr);
- foreach_node(move, moves->n) {
- printf(", ");
- if (lower_move(state, move))
+ switch (expr->k) {
+ case AST_CLOSURE: {
+ char *name = NULL, *args = NULL;
+ if (lower_closure(state, expr, &name, &args))
return -1;
+
+ fprintf(state->code, "(fwd_closure_t){%s, &ctx->%s}", name, args);
+ free(name);
+ free(args);
+ break;
}
- return 0;
-}
+ case AST_ID: {
+ struct ast *def = file_scope_find_symbol(expr->scope, id_str(expr));
+ char *name = mangle2(def);
+ fprintf(state->code, "ctx->%s", name);
+ free(name);
+ break;
+ }
-static int lower_err_branch(struct state *state, struct ast *err)
-{
- if (lower_block(state, err_branch_body(err), false))
- return -1;
+ case AST_CONST_INT: {
+ fprintf(state->code, "%lld", (long long)int_val(expr));
+ break;
+ }
+ default:
+ internal_error("unhandled expr lowering: %s", ast_str(expr->k));
+ abort();
+ }
- printf("\n");
return 0;
}
-static int lower_mark_moved(struct state *state, struct ast *moves)
+static int lower_call(struct state *state, struct ast *call, bool last)
{
- if (!moves)
- return 0;
+ struct ast *expr = call_expr(call);
+ assert(expr->k == AST_ID);
- foreach_node(move, moves) {
- if (move->k != AST_ID)
- continue;
+ struct ast *def = file_scope_find_symbol(call->scope, id_str(expr));
+ assert(def);
- if (is_trivially_copyable(move->t))
- continue;
+ if (def->k == AST_VAR_DEF)
+ return lower_closure_call(state, call, def, last);
- if (is_callable(move->t))
- continue;
+ if (lower_proc(state, def))
+ return -1;
- printf("%s_owned = false;\n", id_str(move));
- indent(state);
- }
+ char *q = buildstr("%s_call%zu", state->prefix, uniq(state));
- return 0;
-}
+ struct state ctx_state = create_state(state);
-/** @todo this is probably more complicated than it really needs to be, maybe
- * refactor into lower_checked_call and lower_implicit_call or something for
- * explicit and implicit error handling cases? */
-static int lower_call(struct state *state, struct ast *call, bool ret)
-{
- struct ast *err = call_err(call);
- /** @todo better default error name? */
- const char *err_str = err ? err_branch_id(err) : "_fwd_err";
+ char *ctx_buf = NULL; size_t ctx_size = 0;
+ FILE *ctx = open_memstream(&ctx_buf, &ctx_size);
+ fprintf(ctx, "struct %s {\n fwd_start_t start;\n", q);
- if (lower_mark_moved(state, call_args(call)))
- return -1;
+ indent(state);
+ fprintf(state->code, "struct %s *%s = ctx->global_args;\n", q, q);
- bool direct_ret = ret && !err;
- if (direct_ret)
- printf("return ");
- else
- printf("if (auto %s = ", err_str);
+ int ret = 0;
+ size_t idx = 0;
+ bool returning = false;
+ foreach_node(a, call_args(call)) {
+ returning |= a->k == AST_CLOSURE;
- if (lower_expr(state, call_expr(call)))
- return -1;
+ char *type = lower_type_str(a->t);
+ fprintf(ctx, " %s a%zu;\n", type, idx);
+ free(type);
- printf("(");
+ indent(&ctx_state);
+ fprintf(ctx_state.code, "%s->a%zu = ", q, idx);
+ int ret = lower_expr(&ctx_state, a);
+ fprintf(ctx_state.code, ";\n");
- if (lower_moves(state, call_args(call)))
- return -1;
+ if (ret)
+ goto out;
- if (direct_ret) {
- printf(");\n");
- return 0;
+ idx++;
}
- printf("))");
- if (err) {
- if (lower_err_branch(state, err))
- return -1;
-
- if (ret) {
- printf("\n");
- indent(state);
- printf("return nullptr;\n");
- }
+out:
+ if (!returning && last && ast_flags(state->current, AST_REQ_FRAME)) {
+ /** @todo unsure if this applies to all cases but seems to work
+ * for the simple examples I've tried so far */
+ indent(&ctx_state);
+ fprintf(ctx_state.code, "fwd_stack_free(&stack, ctx);\n");
+ }
- return 0;
+ char *target = mangle2(def);
+ indent(&ctx_state);
+ if (last) {
+ fprintf(ctx_state.code, "FWD_MUSTTAIL return %s(stack, %s);\n",
+ target, q);
+ }
+ else {
+ fprintf(ctx_state.code, "stack = %s(stack, %s);\n",
+ target, q);
}
- printf("\n");
+ fprintf(ctx, "};\n\n");
+ fclose(ctx);
+ assert(ctx_buf);
- increase_indent(state);
+ add_type(state, ctx_buf);
+ free(target);
+ free(q);
+ return ret;
+}
+
+static int lower_if(struct state *state, struct ast *stmt, bool last)
+{
indent(state);
- decrease_indent(state);
+ fprintf(state->code, "if (");
+ if (lower_expr(state, if_cond(stmt)))
+ return -1;
- printf("return %s;\n", err_str);
+ fprintf(state->code, ")\n");
+ if (lower_block(state, if_body(stmt), last))
+ return -1;
- if (ret) {
- indent(state);
- printf("return nullptr;\n");
- }
+ if (!if_else(stmt))
+ return 0;
- return 0;
+ indent(state);
+ fprintf(state->code, "else\n");
+ return lower_block(state, if_else(stmt), last);
}
-static int lower_let(struct state *state, struct ast *let, bool ret)
+static int lower_stmt(struct state *state, struct ast *stmt, bool last)
{
- if (lower_var(let_var(let)))
- return -1;
-
- printf(" = ");
-
- if (lower_expr(state, let_expr(let)))
- return -1;
+ switch (stmt->k) {
+ case AST_CALL: return lower_call(state, stmt, last);
+ case AST_IF: return lower_if(state, stmt, last);
+ default:
+ internal_error("unhandled statement kind %s", ast_str(stmt->k));
+ abort();
+ break;
+ }
+ return 0;
+}
- printf(";\n");
- if (ret) {
- indent(state);
- printf("return nullptr;\n");
+static int lower_stmt_list(struct state *state, struct ast *stmt_list, bool last)
+{
+ foreach_node(stmt, stmt_list) {
+ bool req_ret = last && !stmt->n;
+ if (lower_stmt(state, stmt, req_ret))
+ return -1;
}
return 0;
}
-static int lower_if(struct state *state, struct ast *stmt, bool ret)
+static int lower_block(struct state *state, struct ast *block, bool last)
{
- printf("if (");
- if (lower_expr(state, if_cond(stmt)))
- return -1;
+ indent(state);
+ fprintf(state->code, "{\n");
- printf(") ");
+ increase_indent(state);
+ int ret = lower_stmt_list(state, block_body(block), last);
+ decrease_indent(state);
- if (lower_block(state, if_body(stmt), ret))
- return -1;
+ indent(state);
+ fprintf(state->code, "}\n");
+ return ret;
+}
- if (!if_else(stmt)) {
- printf("\n");
- return 0;
- }
+static int lower_param(struct state *state, struct ast *param)
+{
+ char *type = lower_type_str(param->t);
+ char *name = mangle2(param);
- printf(" else ");
- if (lower_block(state, if_else(stmt), ret))
- return -1;
+ fprintf(state->ctx, " %s %s;\n", type, name);
- printf("\n");
+ free(type);
+ free(name);
return 0;
}
-static int lower_error(struct ast *err)
+static int lower_params(struct state *state, struct ast *params)
{
- assert(error_str(err) || error_id(err));
- if (error_str(err)) {
- printf("return %s;\n", error_str(err));
- return 0;
+ foreach_node(p, params) {
+ if (lower_param(state, p))
+ return -1;
}
- struct ast *id = error_id(err);
- printf("return %s;\n", id_str(id));
return 0;
}
-static int lower_own(struct state *state, struct ast *stmt, bool ret)
+static size_t fwd_typeid(struct type *t)
{
- /** @todo name mangling */
- printf("if (!%s_owned) ", own_id(stmt));
- if (lower_block(state, own_body(stmt), ret))
- return -1;
+ /** @todo this should maybe be cached somewhere earlier? */
+ switch (t->k) {
+ case TYPE_I64: return FWD_I64;
+ case TYPE_PTR: return FWD_PTR;
+ default:
+ abort();
+ }
- printf("\n");
return 0;
}
-static int lower_statement(struct state *state, struct ast *stmt, bool ret)
+static const char *fwd_typeparam(struct type *t)
{
- switch (stmt->k) {
- case AST_OWN: return lower_own(state, stmt, ret);
- case AST_LET: return lower_let(state, stmt, ret);
- case AST_CALL: return lower_call(state, stmt, ret);
- case AST_IF: return lower_if(state, stmt, ret);
- case AST_EMPTY:
- if (ret)
- printf("return nullptr;\n");
- else
- printf("\n");
-
- return 0;
+ switch (t->k) {
+ case TYPE_I64: return "i64";
+ case TYPE_PTR: return "p";
default:
- internal_error("missing statement lowering");
- return -1;
+ abort();
}
return 0;
}
-static int lower_block_vars(struct state *state, struct ast *block)
+static int lower_extern_proc(struct state *state, struct ast *proc)
{
- struct scope *scope = block->scope;
+ /* only void external functions supported atm */
+ struct type *rtype = proc_rtype(proc);
+ assert(rtype->k == TYPE_VOID);
- bool populated = false;
- foreach(visible, n, &scope->symbols) {
- struct ast *def = n->data;
- if (def->k != AST_VAR_DEF)
- continue;
+ add_proc(state, proc);
+ char *name = mangle2(proc);
+ char *proto = buildstr("static fwd_stack_t %s(fwd_stack_t stack, fwd_args_t args)",
+ name);
- if (is_trivially_copyable(def->t))
- continue;
+ char *decl = buildstr("%s;\n", proto);
+ add_decl(state, decl);
- if (is_callable(def->t))
- continue;
+ char *code_buf = NULL, *ctx_buf = NULL;
+ size_t code_size = 0, ctx_size = 0;
- if (!populated) {
- indent(state);
- printf("[[maybe_unused]] bool %s_owned = true",
- var_id(def));
+ struct state new_state = create_state(state);
+ new_state.indent = 0;
+ new_state.prefix = name;
+ new_state.current = proc;
+ new_state.uniq = 0;
+ new_state.code = open_memstream(&code_buf, &code_size);
+ new_state.ctx = open_memstream(&ctx_buf, &ctx_size);
+ assert(new_state.code);
- populated = true;
- continue;
- }
+ fprintf(new_state.ctx, "struct %s_ctx {\n", name);
+ fprintf(new_state.code, "%s\n{\n", proto);
+ increase_indent(&new_state);
+
+ indent(&new_state);
+ fprintf(new_state.code, "extern long %s(fwd_extern_args_t);\n", proc_id(proc));
- printf(", %s_owned = true", var_id(def));
+ /* for now, allocate a new frame for arguments. Might want to
+ * simplify this by always using the 'external' format for argument
+ * passing, even internally */
+ indent(&new_state);
+ fprintf(new_state.code, "struct %s_ctx *ctx = args;\n", name);
+
+ indent(&new_state);
+ fprintf(new_state.code, "struct fwd_arg *extern_args = fwd_stack_alloc(&stack);\n");
+
+ size_t idx = 0;
+ foreach_node(p, proc_params(proc)) {
+ indent(&new_state);
+ /* leave place for return value */
+ fprintf(new_state.code, "extern_args[%zu] = (fwd_arg_t){%zu, "
+ "{.%s = ctx->a%zu}};\n",
+ idx + 1, fwd_typeid(p->t), fwd_typeparam(p->t), idx);
+
+
+ char *type_str = lower_type_str(p->t);
+ fprintf(new_state.ctx, " %s a%zu;\n", type_str, idx);
+ free(type_str);
+ idx++;
}
- if (populated)
- printf(";\n\n");
+ indent(&new_state);
+ fprintf(new_state.code, "%s((fwd_extern_args_t){.argc = %zu, .args = extern_args});\n",
+ proc_id(proc), idx);
- return 0;
-}
-static int lower_block(struct state *state, struct ast *block, bool ret)
-{
- printf("{\n");
- increase_indent(state);
+ indent(&new_state);
+ fprintf(new_state.code, "fwd_stack_free(&stack, extern_args);\n");
- if (lower_block_vars(state, block))
- return -1;
+ indent(&new_state);
+ fprintf(new_state.code, "return stack;\n");
- foreach_node(stmt, block_body(block)) {
- indent(state);
+ fprintf(new_state.code, "}\n\n");
+ fprintf(new_state.ctx, "};\n\n");
- bool returning = block_error(block) ? false : ret && !stmt->n;
- if (lower_statement(state, stmt, returning))
- return -1;
- }
+ fclose(new_state.code);
+ assert(code_buf);
+ add_defn(state, code_buf);
- if (block_error(block)) {
- indent(state);
- if (lower_error(block_error(block)))
- return -1;
- }
- else if (!block_body(block)) {
- indent(state);
- printf("return nullptr;\n");
- }
+ fclose(new_state.ctx);
+ assert(ctx_buf);
+ add_type(state, ctx_buf);
- decrease_indent(state);
- indent(state);
- printf("}");
+ free(proto);
+ free(name);
return 0;
}
-static int lower_var(struct ast *var)
+static int lower_param_copy(struct state *state, struct ast *param, FILE *f, size_t idx)
{
- if (lower_type(var_type(var)))
- return -1;
-
- printf(" %s", var_id(var));
+ char *type = lower_type_str(param->t);
+ fprintf(f, " %s a%zu;\n", type, idx);
+ free(type);
return 0;
}
-static int lower_vars(struct ast *vars)
+static int lower_param_copies(struct state *state, struct ast *params)
{
- if (!vars)
- return 0;
-
- if (lower_var(vars))
- return -1;
+ char *param_buf = NULL; size_t param_size = 0;
+ FILE *f = open_memstream(&param_buf, &param_size);
+ fprintf(f, "struct %s_params {\n fwd_start_t start;\n", state->prefix);
- foreach_node(var, vars->n) {
- printf(", ");
- if (lower_var(var))
+ size_t idx = 0;
+ foreach_node(p, params) {
+ if (lower_param_copy(state, p, f, idx)) {
+ fclose(f);
+ free(param_buf);
return -1;
+ }
+
+ idx++;
}
+ fprintf(f, "};\n\n");
+ fclose(f);
+ assert(param_buf);
+
+ add_type(state, param_buf);
+
+ indent(state);
+ fprintf(state->code, "*((struct %s_params *)&ctx->%s_start) ="
+ " *((struct %s_params *)args);\n",
+ state->prefix, state->prefix, state->prefix);
return 0;
}
-static int lower_closure(struct state *state, struct ast *closure)
+static int lower_proc(struct state *state, struct ast *proc)
{
- printf("[&](");
- if (lower_vars(closure_bindings(closure)))
- return -1;
+ if (proc_lowered(state, proc))
+ return 0;
+
+ if (!proc_body(proc))
+ return lower_extern_proc(state, proc);
+
+ add_proc(state, proc);
+ char *name = mangle2(proc);
+ char *proto = buildstr("static fwd_stack_t %s(fwd_stack_t stack, fwd_args_t args)", name);
+ char *decl = buildstr("%s;\n", proto);
+ add_decl(state, decl);
+
+ char *code_buf = NULL, *ctx_buf = NULL;
+ size_t code_size = 0, ctx_size = 0;
+
+ struct state new_state = create_state(state);
+ new_state.indent = 0;
+ new_state.prefix = name;
+ new_state.current = proc;
+ new_state.uniq = 0;
+ new_state.code = open_memstream(&code_buf, &code_size);
+ new_state.ctx = open_memstream(&ctx_buf, &ctx_size);
+ assert(new_state.code);
+ assert(new_state.ctx);
+
+ char *start_of = buildstr("%s_start", name);
+
+ fprintf(new_state.code, "%s\n{\n", proto);
+ fprintf(new_state.ctx, "struct %s_ctx {\n", name);
+ fprintf(new_state.ctx, " fwd_args_t global_args;\n fwd_start_t %s;\n", start_of);
+
+ increase_indent(&new_state);
+ indent(&new_state);
+ fprintf(new_state.code, "static_assert(FWD_FRAME_SIZE >= sizeof(struct %s_ctx), \"context exceeds frame size\");\n",
+ name);
+
+ if (ast_flags(proc, AST_REQ_FRAME)) {
+ indent(&new_state);
+ fprintf(new_state.code, "struct %s_ctx *ctx "
+ "= fwd_stack_alloc(&stack);\n",
+ name);
+ }
+ else {
+ indent(&new_state);
+ fprintf(new_state.code, "struct %s_ctx ctx_buf;\n", name);
+ indent(&new_state);
+ fprintf(new_state.code, "struct %s_ctx *ctx = &ctx_buf;\n", name);
+ }
- printf(")");
+ /* allocates parameter slots */
+ int ret = lower_params(&new_state, proc_params(proc));
+ assert(ret == 0);
- if (lower_block(state, closure_body(closure), true))
- return -1;
+ /* actually copies values into parameter slots */
+ ret = lower_param_copies(&new_state, proc_params(proc));
+ assert(ret == 0);
- return 0;
-}
+ indent(&new_state);
+ fprintf(new_state.code, "ctx->global_args = args;\n");
-static int lower_proto(struct ast *proc)
-{
- /* 'extern' functions should be provided to us by whatever framework the
- * user is using */
- if (!proc_body(proc))
- return 0;
+ struct ast *block = proc_body(proc);
+ ret = lower_stmt_list(&new_state, block_body(block), true);
- printf("fwd_err_t ");
- if (strcmp("main", proc_id(proc)) == 0)
- printf("fwd_main(");
- else
- printf("%s(", proc_id(proc));
+ fprintf(new_state.code, "}\n\n");
+ fprintf(new_state.ctx, "};\n\n");
+ fclose(new_state.code);
+ fclose(new_state.ctx);
+ assert(code_buf);
+ assert(ctx_buf);
- if (lower_vars(proc_params(proc)))
- return -1;
+ add_defn(state, code_buf);
+ add_type(state, ctx_buf);
- printf(");\n\n");
- return 0;
+ free(start_of);
+ free(proto);
+ free(name);
+ return ret;
}
-static int lower_proc(struct ast *proc)
+int lower(struct scope *root)
{
- if (!proc_body(proc))
- return 0;
-
- printf("fwd_err_t ");
- if (strcmp("main", proc_id(proc)) == 0)
- printf("fwd_main(");
- else
- printf("%s(", proc_id(proc));
+ struct ast *main = file_scope_find_symbol(root, "main");
+ if (!main) {
+ error("no main");
+ return -1;
+ }
- if (lower_vars(proc_params(proc)))
+ if (main->k != AST_PROC_DEF) {
+ error("main is not a procedure");
return -1;
+ }
- printf(")\n");
+ struct string_vec defns = string_vec_create(0);
+ struct string_vec decls = string_vec_create(0);
+ struct string_vec types = string_vec_create(0);
+ struct proc_set procs = proc_set_create(0);
- struct state state = {0};
- if (lower_block(&state, proc_body(proc), true))
- return -1;
+ struct state state = {
+ .indent = 0,
+ .ctx = NULL,
+ .code = NULL,
+ .defns = &defns,
+ .decls = &decls,
+ .types = &types,
+ .procs = &procs
+ };
- printf("\n\n");
- return 0;
-}
+ if (lower_proc(&state, main))
+ return -1;
-int lower(struct scope *root)
-{
- printf("#include <fwdlib.hpp>\n");
+ /* placeholder, should really be calculated to be some maximum frame
+ * size or something */
+ printf("#define FWD_FRAME_SIZE %d\n", 1024);
+ printf("#include <fwd.h>\n\n");
- foreach(visible, visible, &root->symbols) {
- struct ast *proc = visible->data;
- assert(proc->k == AST_PROC_DEF);
- if (lower_proto(proc))
- return -1;
+ foreach(string_vec, s, state.types) {
+ puts(*s);
+ free(*s);
}
- foreach(visible, visible, &root->symbols) {
- struct ast *proc = visible->data;
- if (lower_proc(proc))
- return -1;
+ foreach(string_vec, s, state.decls) {
+ puts(*s);
+ free(*s);
}
+ foreach(string_vec, s, state.defns) {
+ puts(*s);
+ free(*s);
+ }
- puts("int main()");
- puts("{");
- puts(" fwd_err_t err = fwd_main();");
- puts(" if (err) {");
- puts(" fprintf(stderr, \"%s\", err);");
- puts(" return -1;");
- puts(" }");
- puts("}");
+ char *name = mangle2(main);
+ printf("int main()\n");
+ printf("{\n");
+ printf(" fwd_stack_t stack = create_fwd_stack();\n");
+ printf(" void *args = fwd_stack_alloc(&stack);\n");
+ printf(" stack = %s(stack, args);\n", name);
+ printf(" fwd_stack_free(&stack, args);\n");
+ printf(" destroy_fwd_stack(&stack);\n\n");
+ printf("}\n");
+
+ /* modules require a register function of some kind, implement a stub */
+ printf("int fwd_register(struct fwd_state *state, const char *name, fwd_extern_t func, fwd_type_t rtype, ...) {return 0;}\n");
+
+ string_vec_destroy(&defns);
+ string_vec_destroy(&decls);
+ string_vec_destroy(&types);
+ proc_set_destroy(&procs);
+ free(name);
return 0;
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-04 20:30:04 +0000