zzy/spl
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

stage1 实现部分ast2ir内容并重构stage0 引入并重构ir2vm 构建系统修改部分

Browse Source
This commit is contained in:
zzy committed 2026-08-28 13:01:19 +08:00
1 parent 3d57260f3f
commit 34df303b56
17 files changed
+636 -1800
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

nob.c
+10 -39
View File
@@ -1,52 +1,28 @@
#undef UNICODE
#define NOB_IMPLEMENTATION
// Redefine nob_cc_flags() to carry the project's debug flags. Keep in sync
// with CFLAGS_STR below.
#define SPL_CFLAGS "-Wall", "-Wextra", "-O0", "-g", "-D_CRT_SECURE_NO_WARNINGS"
#define nob_cc_flags(cmd) nob_cmd_append(cmd, SPL_CFLAGS)
#include "nob.h"
#ifdef _WIN32
#include <consoleapi2.h>
#endif
// C-side bootstrap build script. Builds the stage0 VM tools and the splc0
// compiler from their C sources. The SPL self-hosting chain (splc1, ...) is
// out of scope and is driven by a different mechanism.
//
// Usage:
// cc -o nob nob.c # bootstrap once
// ./nob # build all targets
// ./nob build <targets...> # build specific targets
// ./nob run <target> [..] # build and run
// ./nob test # build and run VM unit tests
// ./nob clean # remove build artifacts
// ./nob list # list all targets
// ./nob help # print this help
#define BUILD_FOLDER "build/"
#ifdef _WIN32
#define EXE_SUFFIX ".exe"
#else
#define EXE_SUFFIX ""
#endif
// Content of the .cflags stamp file; must match SPL_CFLAGS above.
#define CFLAGS_STR "-Wall -Wextra -O0 -g"
// Stamp file whose mtime is refreshed whenever the flags change so that all
// object files get rebuilt.
static const char *CFLAGS_STAMP = BUILD_FOLDER ".cflags";
// Target descriptions
#define VM_SRCS "stage0/spl_mcode.c", "stage0/spl_syscall.c", "stage0/spl_vm.c"
#define SPLC0_PART_SRCS \
"stage1/spl_ast.c", "stage1/spl_lexer.c", "stage1/spl_dumptree.c", "stage1/spl_type.c", \
"stage1/spl_sema.c", "stage1/spl_ir.c", "stage1/spl_ast2ir.c"
static const char *spl_cli_srcs[] = {"stage0/spl_cli.c", VM_SRCS};
static const char *splc0_srcs[] = {"stage1/splc0.c", VM_SRCS, SPLC0_PART_SRCS};
static const char *test_srcs[] = {"stage0/test_spl_vm.c", VM_SRCS};
static const char *spl_disasm_srcs[] = {"stage0/spl_disasm.c", VM_SRCS};
static const char *splc0_srcs[] = {
"stage1/splc0.c", "stage0/spl_mcode.c", "stage1/spl_ast.c", "stage1/spl_lexer.c",
"stage1/spl_dumptree.c", "stage1/spl_type.c", "stage1/spl_sema.c", "stage1/spl_ir.c",
"stage1/spl_ast2ir.c", "stage1/spl_ir2vm.c",
};
typedef struct {
const char *name;
@@ -56,9 +32,8 @@ typedef struct {
static Exe_Target exe_targets[] = {
{"spl_cli", spl_cli_srcs, NOB_ARRAY_LEN(spl_cli_srcs)},
{"splc0", splc0_srcs, NOB_ARRAY_LEN(splc0_srcs)},
{"test", test_srcs, NOB_ARRAY_LEN(test_srcs)},
{"spl_disasm", spl_disasm_srcs, NOB_ARRAY_LEN(spl_disasm_srcs)},
{"splc0", splc0_srcs, NOB_ARRAY_LEN(splc0_srcs)},
};
static const Exe_Target *find_exe_target(const char *name) {
@@ -84,10 +59,6 @@ static const char *obj_path(const char *src) {
return out;
}
static const char *exe_path(const char *name) {
return nob_temp_sprintf(BUILD_FOLDER "%s" EXE_SUFFIX, name);
}
static bool sync_cflags_stamp(void) {
Nob_String_View cflags = nob_sv_from_cstr(CFLAGS_STR);
Nob_String_Builder old = {0};
@@ -135,7 +106,7 @@ static bool build_object(const char *src) {
}
static bool link_exe(const Exe_Target *target) {
const char *exe = exe_path(target->name);
const char *exe = nob_temp_sprintf(BUILD_FOLDER "%s", target->name);
const char **objs = (const char **)nob_temp_alloc(sizeof(const char *) * target->srcs_count);
for (size_t i = 0; i < target->srcs_count; ++i) {
objs[i] = obj_path(target->srcs[i]);
@@ -246,7 +217,7 @@ int main(int argc, char **argv) {
if (!build_target(target_name))
return 1;
Nob_Cmd cmd = {0};
nob_cmd_append(&cmd, exe_path(target_name));
nob_cmd_append(&cmd, nob_temp_sprintf(BUILD_FOLDER "%s", target_name));
while (argc > 0) {
nob_cmd_append(&cmd, nob_shift(argv, argc));
}
@@ -259,7 +230,7 @@ int main(int argc, char **argv) {
if (!build_target("test"))
return 1;
Nob_Cmd cmd = {0};
nob_cmd_append(&cmd, exe_path("test"));
nob_cmd_append(&cmd, BUILD_FOLDER "test");
return nob_cmd_run(&cmd) ? 0 : 1;
}
stage0/spl_cli.c
+9
View File
@@ -29,6 +29,7 @@ typedef struct {
int debug;
int debug_cli;
int trace;
int disasm;
const char *entry;
const char *path; /* file.sir */
const char **args; /* spl 程序参数（file.sir 之后） */
@@ -39,6 +40,7 @@ static void usage(void) {
fprintf(stderr, "Usage: spl_cli [options] <file.sir> [args...]\n"
" -d, --debug stack-canary checks\n"
" -g, --debug-cli interactive debugger (REPL)\n"
" --disasm disasm dump sir\n"
" --entry <name> entry function (default: main)\n"
" --trace print every instruction\n"
" -h, --help show help\n");
@@ -63,6 +65,8 @@ static int parse_args(int argc, const char **argv, cli_opts_t *o) {
o->debug_cli = 1;
} else if (strcmp(a, "--trace") == 0) {
o->trace = 1;
} else if (strcmp(a, "--disasm") == 0) {
o->disasm = 1;
} else if (strcmp(a, "--entry") == 0) {
if (i + 1 >= argc) {
fprintf(stderr, "spl_cli: --entry needs a name\n");
@@ -624,6 +628,11 @@ int main(int argc, const char **argv) {
fprintf(stderr, "spl_cli: cannot load '%s'\n", o.path);
return 1;
}
if (o.disasm) {
spl_prog_dump(&prog);
return 0;
}
spl_syscall_register(&prog);
spl_vm_t vm;
stage0/spl_disasm.c
-76
View File
@@ -1,76 +0,0 @@
/* spl_disasm.c - SIR bytecode disassembler
*
* Usage: spl_disasm <file.sir>
*/
#include "spl_mcode.h"
#include <stdio.h>
int main(int argc, const char **argv) {
if (argc < 2) {
fprintf(stderr, "Usage: spl_disasm <file.sir>\n");
return 1;
}
spl_prog_t prog;
if (spl_prog_load_from_file(argv[1], &prog) != 0) {
fprintf(stderr, "spl_disasm: cannot load '%s'\n", argv[1]);
return 1;
}
printf(";; SPL bytecode dump: %s\n", argv[1]);
printf(";; ninsns=%zu nfuncs=%zu nnatives=%zu nstrs=%zu\n\n", vec_size(prog.insns),
vec_size(prog.funcs), vec_size(prog.natives), vec_size(prog.strtab));
if (vec_size(prog.funcs) > 0) {
printf(";; --- functions ---\n");
for (usize i = 0; i < vec_size(prog.funcs); i++) {
spl_vm_func_t *f = &vec_at(prog.funcs, i);
printf(" %s nargs=%zu ninsns=%zu addr=%zu\n", f->name ? f->name : "(anon)", f->nargs,
f->ninsns, f->address);
}
printf("\n");
}
if (vec_size(prog.natives) > 0) {
printf(";; --- natives ---\n");
for (int i = 0; i < (int)vec_size(prog.natives); i++) {
spl_vm_native_t *n = &vec_at(prog.natives, i);
printf(" %s\n", n->name ? n->name : "(anon)");
}
printf("\n");
}
if (vec_size(prog.strtab) > 0) {
printf(";; --- string table ---\n");
for (int i = 0; i < (int)vec_size(prog.strtab); i++) {
printf(" %d: \"%s\"\n", i, vec_at(prog.strtab, i));
}
printf("\n");
}
printf(";; --- instructions ---\n");
for (usize i = 0; i < vec_size(prog.insns); i++) {
spl_vm_ins_t *ins = &vec_at(prog.insns, i);
printf("%4zd: %s", i, spl_vm_opcode_name((spl_vm_opcode_t)ins->opcode));
if (ins->type != SPL_VOID)
printf(" %s", spl_vm_type_kind_name((spl_vm_kind_t)ins->type));
printf(" %zd", ins->imm);
/* annotate jumps / calls */
if (ins->opcode == SPL_JMP || ins->opcode == SPL_BZ || ins->opcode == SPL_BNZ) {
spl_vm_val_t target = i + 1 + ins->imm;
printf(" ; -> %zu", target);
} else if (ins->opcode == SPL_CALL) {
printf(" ; nargs=%zu, from stack", ins->imm);
} else if (ins->opcode == SPL_CALLI) {
printf(" ; indirect call");
} else if (ins->opcode == SPL_GADDR) {
printf(" ; gdata[%zu]", ins->imm);
}
printf("\n");
}
spl_prog_drop(&prog);
return 0;
}
stage0/spl_mcode.c
+55
View File
@@ -43,6 +43,61 @@ void spl_prog_drop(spl_prog_t *prog) {
prog->debug = NULL;
}
void spl_prog_dump(spl_prog_t *prog) {
printf(";; SPL bytecode dump: \n");
printf(";; ninsns=%zu nfuncs=%zu nnatives=%zu nstrs=%zu\n\n", vec_size(prog->insns),
vec_size(prog->funcs), vec_size(prog->natives), vec_size(prog->strtab));
if (vec_size(prog->funcs) > 0) {
printf(";; --- functions ---\n");
for (usize i = 0; i < vec_size(prog->funcs); i++) {
spl_vm_func_t *f = &vec_at(prog->funcs, i);
printf(" %s nargs=%zu ninsns=%zu addr=%zu\n", f->name ? f->name : "(anon)", f->nargs,
f->ninsns, f->address);
}
printf("\n");
}
if (vec_size(prog->natives) > 0) {
printf(";; --- natives ---\n");
for (int i = 0; i < (int)vec_size(prog->natives); i++) {
spl_vm_native_t *n = &vec_at(prog->natives, i);
printf(" %s\n", n->name ? n->name : "(anon)");
}
printf("\n");
}
if (vec_size(prog->strtab) > 0) {
printf(";; --- string table ---\n");
for (int i = 0; i < (int)vec_size(prog->strtab); i++) {
printf(" %d: \"%s\"\n", i, vec_at(prog->strtab, i));
}
printf("\n");
}
printf(";; --- instructions ---\n");
for (usize i = 0; i < vec_size(prog->insns); i++) {
spl_vm_ins_t *ins = &vec_at(prog->insns, i);
printf("%4zd: %s", i, spl_vm_opcode_name((spl_vm_opcode_t)ins->opcode));
if (ins->type != SPL_VOID)
printf(" %s", spl_vm_type_kind_name((spl_vm_kind_t)ins->type));
printf(" %zd", ins->imm);
/* annotate jumps / calls */
if (ins->opcode == SPL_JMP || ins->opcode == SPL_BZ || ins->opcode == SPL_BNZ) {
spl_vm_val_t target = i + 1 + ins->imm;
printf(" ; -> %zu", target);
} else if (ins->opcode == SPL_CALL) {
printf(" ; nargs=%zu, from stack", ins->imm);
} else if (ins->opcode == SPL_CALLI) {
printf(" ; indirect call");
} else if (ins->opcode == SPL_GADDR) {
printf(" ; gdata[%zu]", ins->imm);
}
printf("\n");
}
}
/* ---- LE read/write helpers ---- */
static inline spl_vm_val_t rd64(const unsigned char **p) {
stage0/spl_mcode.h
+1
View File
@@ -199,6 +199,7 @@ typedef struct spl_prog {
void spl_prog_init(spl_prog_t *prog);
void spl_prog_drop(spl_prog_t *prog);
void spl_prog_dump(spl_prog_t *prog);
int spl_prog_load_from_file(const char *fname, spl_prog_t *prog);
int spl_prog_store_to_file(const char *fname, spl_prog_t *prog);
stage1/spl_ast.c
+71 -67
View File
@@ -80,7 +80,7 @@ static spl_ast_node_ref_t mk_bin(parser_t *p, const spl_tok_t *loc, spl_ast_node
/* 前向声明 */
static spl_ast_node_ref_t parse_expr(parser_t *p);
static spl_ast_node_ref_vec_t parse_expr_list(parser_t *p);
static spl_ast_node_ref_vec_t parse_block(parser_t *p);
static spl_ast_node_ref_t parse_block(parser_t *p);
static spl_ast_node_ref_t parse_type_expr(parser_t *p);
static spl_ast_node_ref_t parse_type_base(parser_t *p);
static spl_ast_node_ref_t parse_statement(parser_t *p);
@@ -352,8 +352,7 @@ static spl_ast_node_ref_t parse_fn_decl(parser_t *p, spl_ast_node_ref_vec_t attr
advance(p);
spl_ast_node_ref_t type_expr = 0;
spl_ast_node_ref_vec_t block;
vec_init(block);
spl_ast_node_ref_t block = 0;
int has_body = 0;
t = peek(p);
@@ -525,20 +524,20 @@ static spl_ast_node_ref_t parse_container_declaration(parser_t *p) {
// 语句
static spl_ast_node_ref_vec_t parse_block(parser_t *p) {
static spl_ast_node_ref_t parse_block(parser_t *p) {
spl_ast_node_ref_vec_t vec;
vec_init(vec);
const spl_tok_t *t = peek(p);
if (t == NULL || t->type != TOK_L_BRACE) {
SPL_FATAL(t, "expected '{'");
return vec;
return 0;
}
advance(p);
while (!p->failed) {
t = peek(p);
if (!t || t->type == TOK_EOF) {
SPL_FATAL(t, "block missing '}'");
break;
return 0;
}
if (t->type == TOK_R_BRACE) {
advance(p);
@@ -565,7 +564,9 @@ static spl_ast_node_ref_vec_t parse_block(parser_t *p) {
SPL_FATAL(t, "unrecognized statement");
}
}
return vec;
spl_ast_node_ref_t block_expr_ref = new_node(p, SPL_AST_BLOCK_EXPR, t); // FIXME t not here
node_at(p->ast, block_expr_ref)->primary_expr.block_expr = vec;
return block_expr_ref;
}
static spl_ast_node_ref_t parse_statement(parser_t *p) {
@@ -668,15 +669,18 @@ static spl_ast_node_ref_t parse_if(parser_t *p) {
spl_ast_node_ref_t expr = parse_expr(p);
p->stop_agg--;
spl_ast_node_ref_vec_t if_block = parse_block(p);
spl_ast_node_ref_vec_t else_block;
vec_init(else_block);
spl_ast_node_ref_t if_block = parse_block(p);
spl_ast_node_ref_t else_block = 0;
t = peek(p);
if (t && t->type == KW_ELSE) {
advance(p);
t = peek(p);
if (t && t->type == KW_IF) {
vec_push(else_block, parse_if(p));
spl_ast_node_ref_vec_t elseif_block;
vec_init(elseif_block);
vec_push(elseif_block, parse_if(p));
else_block = new_node(p, SPL_AST_BLOCK_EXPR, t); // FIXME t not here
node_at(p->ast, else_block)->primary_expr.block_expr = elseif_block;
} else {
else_block = parse_block(p);
}
@@ -709,7 +713,7 @@ static spl_ast_node_ref_t parse_while(parser_t *p) {
p->stop_agg++;
spl_ast_node_ref_t expr = parse_expr(p);
p->stop_agg--;
spl_ast_node_ref_vec_t block = parse_block(p);
spl_ast_node_ref_t block = parse_block(p);
spl_ast_node_ref_t s = new_node(p, SPL_AST_WHILE_STATEMENT, kw);
node_at(p->ast, s)->while_statement.expr = expr;
node_at(p->ast, s)->while_statement.while_block = block;
@@ -720,7 +724,7 @@ static spl_ast_node_ref_t parse_loop(parser_t *p) {
const spl_tok_t *kw = peek(p);
Assert(kw && kw->type == KW_LOOP);
advance(p);
spl_ast_node_ref_vec_t block = parse_block(p);
spl_ast_node_ref_t block = parse_block(p);
spl_ast_node_ref_t s = new_node(p, SPL_AST_LOOP_STATEMENT, kw);
node_at(p->ast, s)->loop_statement.loop_block = block;
return s;
@@ -768,7 +772,7 @@ static spl_ast_node_ref_t parse_for(parser_t *p) {
advance(p);
vec_push(node_at(p->ast, s)->for_statement.ident_vec, sdupn(t->lexeme, t->len));
}
spl_ast_node_ref_vec_t fblock = parse_block(p);
spl_ast_node_ref_t fblock = parse_block(p);
node_at(p->ast, s)->for_statement.block = fblock;
return s;
}
@@ -810,7 +814,10 @@ static spl_ast_node_ref_t parse_match(parser_t *p) {
spl_ast_node_ref_t s = new_node(p, SPL_AST_MATCH_STATEMENT, kw);
node_at(p->ast, s)->match_statement.expr = expr;
node_at(p->ast, s)->match_statement.paced_exprs = paced_vec;
node_at(p->ast, s)->match_statement.match_block = stmt_vec;
spl_ast_node_ref_t stmt_block = new_node(p, SPL_AST_BLOCK_EXPR, t); // FIXME t not here
node_at(p->ast, stmt_block)->primary_expr.block_expr = stmt_vec;
node_at(p->ast, s)->match_statement.match_block = stmt_block;
return s;
}
@@ -893,9 +900,7 @@ static int parse_match_arm(parser_t *p, spl_ast_node_ref_vec_t *paced_vec,
return 0;
}
spl_ast_node_ref_vec_t bvec = parse_block(p);
spl_ast_node_ref_t body = new_node(p, SPL_AST_BLOCK_EXPR, t);
node_at(p->ast, body)->primary_expr.block_expr = bvec;
spl_ast_node_ref_t body = parse_block(p);
for (usize i = 0; i < modes.size; i++) {
vec_push(*paced_vec, modes.data[i]);
vec_push(*block_vec, body);
@@ -949,8 +954,9 @@ static spl_ast_node_ref_t parse_defer(parser_t *p) {
vec_init(vec);
const spl_tok_t *t = peek(p);
// FIXME parse maybe error
if (t && t->type == TOK_L_BRACE) {
vec = parse_block(p);
vec_push(vec, parse_block(p));
} else if (t && can_start_statement(t->type)) {
spl_ast_node_ref_t st = parse_statement(p);
if (st)
@@ -992,7 +998,7 @@ static spl_ast_node_kind_t assign_op_of(spl_tok_type_t t) {
case TOK_ASSIGN_L_SH:
return SPL_AST_ASSIGN_LSHIFT_EXPR;
case TOK_ASSIGN_R_SH:
return SPL_AST_ASSIGN_USHIFT_EXPR;
return SPL_AST_ASSIGN_RSHIFT_EXPR;
default:
return SPL_AST_COUNT;
}
@@ -1473,9 +1479,7 @@ static spl_ast_node_ref_t parse_primary(parser_t *p) {
case TOK_L_BRACKET:
return parse_array_literal(p);
case TOK_L_BRACE: {
spl_ast_node_ref_vec_t bvec = parse_block(p);
spl_ast_node_ref_t pr = new_node(p, SPL_AST_BLOCK_EXPR, t);
node_at(p->ast, pr)->primary_expr.block_expr = bvec;
spl_ast_node_ref_t pr = parse_block(p);
return pr;
}
default:
@@ -1827,7 +1831,7 @@ void spl_ast_valid(spl_ast_t *ast) {
}
typedef VEC(char) dump_stack_t;
static void dump_node(spl_ast_t *ast, spl_ast_node_ref_t node_ref, dump_stack_t *stack, int last);
static void dump_node(spl_ast_t *ast, spl_ast_node_ref_t node_ref, dump_stack_t *stack, bool last);
void spl_ast_dump(spl_ast_t *ast, spl_ast_node_ref_t node) {
if (!ast || !node || node >= ast->node_buckets.size)
@@ -1843,7 +1847,7 @@ void spl_ast_dump(spl_ast_t *ast, spl_ast_node_ref_t node) {
vec_for(_vec, _i) { dump_node(_ast, vec_at(_vec, _i), _stack, _i + 1 == vec_size(_vec)); } \
} while (0)
static void dump_node(spl_ast_t *ast, spl_ast_node_ref_t node_ref, dump_stack_t *stack, int last) {
static void dump_node(spl_ast_t *ast, spl_ast_node_ref_t node_ref, dump_stack_t *stack, bool last) {
spl_ast_node_t *node = &vec_at(ast->node_buckets, node_ref);
for (usize i = 0; i < vec_size(*stack); i++)
@@ -1869,36 +1873,36 @@ static void dump_node(spl_ast_t *ast, spl_ast_node_ref_t node_ref, dump_stack_t
dump_vec(ast, node->fn_decl.attr_list, stack);
dump_vec(ast, node->fn_decl.param_list, stack);
if (node->fn_decl.type_expr) {
last = node->kind == SPL_AST_FN_DECL ? 1 : 0;
last = node->kind == SPL_AST_FN_DECL ? true : false;
dump_node(ast, node->fn_decl.type_expr, stack, last);
}
dump_vec(ast, node->fn_decl.block, stack);
dump_node(ast, node->fn_decl.block, stack, true);
break;
case SPL_AST_TYPE_DECL:
if (node->type_decl.type_expr)
dump_node(ast, node->type_decl.type_expr, stack, 1);
dump_node(ast, node->type_decl.type_expr, stack, true);
break;
case SPL_AST_VAR_DECL:
case SPL_AST_CONST_DECL:
dump_vec(ast, node->var_const_decl.attr_list, stack);
if (node->var_const_decl.type_expr)
dump_node(ast, node->var_const_decl.type_expr, stack, 0);
dump_node(ast, node->var_const_decl.type_expr, stack, false);
if (node->var_const_decl.expr)
dump_node(ast, node->var_const_decl.expr, stack, 1);
dump_node(ast, node->var_const_decl.expr, stack, true);
break;
case SPL_AST_MEMBER_DECL:
dump_vec(ast, node->member_decl.attr_list, stack);
if (node->member_decl.type_expr)
dump_node(ast, node->member_decl.type_expr, stack, 1);
dump_node(ast, node->member_decl.type_expr, stack, true);
break;
case SPL_AST_PARAM_DECL:
dump_vec(ast, node->param_decl.attr_list, stack);
if (node->param_decl.type_expr)
dump_node(ast, node->param_decl.type_expr, stack, 1);
dump_node(ast, node->param_decl.type_expr, stack, true);
break;
case SPL_AST_ATTR_ITEM:
@@ -1907,31 +1911,31 @@ static void dump_node(spl_ast_t *ast, spl_ast_node_ref_t node_ref, dump_stack_t
case SPL_AST_ARGG_INIT_ITEM:
if (node->aggregate_init_item.expr)
dump_node(ast, node->aggregate_init_item.expr, stack, 1);
dump_node(ast, node->aggregate_init_item.expr, stack, true);
break;
case SPL_AST_IF_STATEMENT:
if (node->if_statement.expr)
dump_node(ast, node->if_statement.expr, stack, 0);
dump_vec(ast, node->if_statement.if_block, stack);
dump_vec(ast, node->if_statement.else_block, stack);
dump_node(ast, node->if_statement.expr, stack, false);
dump_node(ast, node->if_statement.if_block, stack, false);
dump_node(ast, node->if_statement.else_block, stack, true);
break;
case SPL_AST_IFVAR_STATEMENT:
if (node->ifvar_statement.packed_expr)
dump_node(ast, node->ifvar_statement.packed_expr, stack, 0);
dump_vec(ast, node->ifvar_statement.if_block, stack);
dump_vec(ast, node->ifvar_statement.else_block, stack);
dump_node(ast, node->ifvar_statement.packed_expr, stack, false);
dump_node(ast, node->ifvar_statement.if_block, stack, false);
dump_node(ast, node->ifvar_statement.else_block, stack, true);
break;
case SPL_AST_WHILE_STATEMENT:
if (node->while_statement.expr)
dump_node(ast, node->while_statement.expr, stack, 0);
dump_vec(ast, node->while_statement.while_block, stack);
dump_node(ast, node->while_statement.expr, stack, false);
dump_node(ast, node->while_statement.while_block, stack, true);
break;
case SPL_AST_LOOP_STATEMENT:
dump_vec(ast, node->loop_statement.loop_block, stack);
dump_node(ast, node->loop_statement.loop_block, stack, true);
break;
case SPL_AST_FOR_STATEMENT:
@@ -1943,19 +1947,19 @@ static void dump_node(spl_ast_t *ast, spl_ast_node_ref_t node_ref, dump_stack_t
i + 1 == vec_size(node->for_statement.ident_vec) ? "`-" : "|-",
node->for_statement.ident_vec.data[i]);
}
dump_vec(ast, node->for_statement.block, stack);
dump_node(ast, node->for_statement.block, stack, true);
break;
case SPL_AST_MATCH_STATEMENT:
if (node->match_statement.expr)
dump_node(ast, node->match_statement.expr, stack, 0);
dump_node(ast, node->match_statement.expr, stack, false);
dump_vec(ast, node->match_statement.paced_exprs, stack);
dump_vec(ast, node->match_statement.match_block, stack);
dump_node(ast, node->match_statement.match_block, stack, true);
break;
case SPL_AST_RET_STATEMENT:
if (node->ret_statement.expr)
dump_node(ast, node->ret_statement.expr, stack, 1);
dump_node(ast, node->ret_statement.expr, stack, true);
break;
case SPL_AST_DEFER_STATEMENT:
@@ -1964,7 +1968,7 @@ static void dump_node(spl_ast_t *ast, spl_ast_node_ref_t node_ref, dump_stack_t
case SPL_AST_PACKED_EXPR:
if (node->packed_expr.expr)
dump_node(ast, node->packed_expr.expr, stack, 1);
dump_node(ast, node->packed_expr.expr, stack, true);
break;
case SPL_AST_ASSIGN_EXPR:
@@ -1977,7 +1981,7 @@ static void dump_node(spl_ast_t *ast, spl_ast_node_ref_t node_ref, dump_stack_t
case SPL_AST_ASSIGN_OR_EXPR:
case SPL_AST_ASSIGN_XOR_EXPR:
case SPL_AST_ASSIGN_LSHIFT_EXPR:
case SPL_AST_ASSIGN_USHIFT_EXPR:
case SPL_AST_ASSIGN_RSHIFT_EXPR:
case SPL_AST_BOOL_OR_EXPR:
case SPL_AST_BOOL_AND_EXPR:
case SPL_AST_BIT_OR_EXPR:
@@ -1998,9 +2002,9 @@ static void dump_node(spl_ast_t *ast, spl_ast_node_ref_t node_ref, dump_stack_t
case SPL_AST_DIV_EXPR:
case SPL_AST_MOD_EXPR:
if (node->op_expr.left)
dump_node(ast, node->op_expr.left, stack, 0);
dump_node(ast, node->op_expr.left, stack, false);
if (node->op_expr.right)
dump_node(ast, node->op_expr.right, stack, 1);
dump_node(ast, node->op_expr.right, stack, true);
break;
case SPL_AST_MINUS_EXPR:
@@ -2008,42 +2012,42 @@ static void dump_node(spl_ast_t *ast, spl_ast_node_ref_t node_ref, dump_stack_t
case SPL_AST_BIT_NOT_EXPR:
case SPL_AST_ADDRESS_EXPR:
if (node->prefix_expr.postfix_expr)
dump_node(ast, node->prefix_expr.postfix_expr, stack, 1);
dump_node(ast, node->prefix_expr.postfix_expr, stack, true);
break;
case SPL_AST_CALL_EXPR:
if (node->postfix_expr.primary_expr)
dump_node(ast, node->postfix_expr.primary_expr, stack, 0);
dump_node(ast, node->postfix_expr.primary_expr, stack, false);
dump_vec(ast, node->postfix_expr.call_expr, stack);
break;
case SPL_AST_FIELD_EXPR:
case SPL_AST_DEREF_EXPR:
if (node->postfix_expr.primary_expr)
dump_node(ast, node->postfix_expr.primary_expr, stack, 1);
dump_node(ast, node->postfix_expr.primary_expr, stack, true);
break;
case SPL_AST_INDEX_EXPR:
if (node->postfix_expr.primary_expr)
dump_node(ast, node->postfix_expr.primary_expr, stack, 0);
dump_node(ast, node->postfix_expr.primary_expr, stack, false);
if (node->postfix_expr.index_expr)
dump_node(ast, node->postfix_expr.index_expr, stack, 1);
dump_node(ast, node->postfix_expr.index_expr, stack, true);
break;
case SPL_AST_SLICE_EXPR:
if (node->postfix_expr.primary_expr)
dump_node(ast, node->postfix_expr.primary_expr, stack, 0);
dump_node(ast, node->postfix_expr.primary_expr, stack, false);
if (node->postfix_expr.slice_expr.begin)
dump_node(ast, node->postfix_expr.slice_expr.begin, stack, 0);
dump_node(ast, node->postfix_expr.slice_expr.begin, stack, false);
if (node->postfix_expr.slice_expr.end)
dump_node(ast, node->postfix_expr.slice_expr.end, stack, 1);
dump_node(ast, node->postfix_expr.slice_expr.end, stack, true);
break;
case SPL_AST_AS_EXPR:
if (node->postfix_expr.primary_expr)
dump_node(ast, node->postfix_expr.primary_expr, stack, 0);
dump_node(ast, node->postfix_expr.primary_expr, stack, false);
if (node->postfix_expr.type_expr)
dump_node(ast, node->postfix_expr.type_expr, stack, 1);
dump_node(ast, node->postfix_expr.type_expr, stack, true);
break;
case SPL_AST_EXPR_INTEGER_LIT:
@@ -2063,12 +2067,12 @@ static void dump_node(spl_ast_t *ast, spl_ast_node_ref_t node_ref, dump_stack_t
case SPL_AST_EXPR_EXPR:
if (node->primary_expr.expr)
dump_node(ast, node->primary_expr.expr, stack, 1);
dump_node(ast, node->primary_expr.expr, stack, true);
break;
case SPL_AST_ARRAY_LIT:
if (node->primary_expr.array_lit_expr.type_expr)
dump_node(ast, node->primary_expr.array_lit_expr.type_expr, stack, 0);
dump_node(ast, node->primary_expr.array_lit_expr.type_expr, stack, false);
dump_vec(ast, node->primary_expr.array_lit_expr.expr_list, stack);
break;
@@ -2084,7 +2088,7 @@ static void dump_node(spl_ast_t *ast, spl_ast_node_ref_t node_ref, dump_stack_t
dump_vec(ast, node->type_expr.attr_list, stack);
dump_vec(ast, node->type_expr.fn_type.param_list, stack);
if (node->type_expr.fn_type.type_expr)
dump_node(ast, node->type_expr.fn_type.type_expr, stack, 1);
dump_node(ast, node->type_expr.fn_type.type_expr, stack, true);
break;
case SPL_AST_BASE_TYPE_PATH:
@@ -2094,21 +2098,21 @@ static void dump_node(spl_ast_t *ast, spl_ast_node_ref_t node_ref, dump_stack_t
case SPL_AST_TYPE_POINTER:
dump_vec(ast, node->type_expr.attr_list, stack);
if (node->type_expr.pointer_type.pointee)
dump_node(ast, node->type_expr.pointer_type.pointee, stack, 1);
dump_node(ast, node->type_expr.pointer_type.pointee, stack, true);
break;
case SPL_AST_TYPE_SLICE:
dump_vec(ast, node->type_expr.attr_list, stack);
if (node->type_expr.slice_type.element)
dump_node(ast, node->type_expr.slice_type.element, stack, 1);
dump_node(ast, node->type_expr.slice_type.element, stack, true);
break;
case SPL_AST_TYPE_ARRAY:
dump_vec(ast, node->type_expr.attr_list, stack);
if (node->type_expr.array_type.element)
dump_node(ast, node->type_expr.array_type.element, stack, 0);
dump_node(ast, node->type_expr.array_type.element, stack, false);
if (node->type_expr.array_type.size)
dump_node(ast, node->type_expr.array_type.size, stack, 1);
dump_node(ast, node->type_expr.array_type.size, stack, true);
break;
case SPL_AST_TYPE_STRUCT:
stage1/spl_ast.h
+15 -14
View File
@@ -46,7 +46,7 @@
X(SPL_AST_ASSIGN_OR_EXPR, V0, assign_or_expr) \
X(SPL_AST_ASSIGN_XOR_EXPR, V0, assign_xor_expr) \
X(SPL_AST_ASSIGN_LSHIFT_EXPR, V0, assign_lshift_expr) \
X(SPL_AST_ASSIGN_USHIFT_EXPR, V0, assign_ushift_expr) \
X(SPL_AST_ASSIGN_RSHIFT_EXPR, V0, assign_rshift_expr) \
X(SPL_AST_BOOL_OR_EXPR, V0, bool_or_expr) \
X(SPL_AST_BOOL_AND_EXPR, V0, bool_and_expr) \
X(SPL_AST_BIT_OR_EXPR, V0, bit_or_expr) \
@@ -152,14 +152,14 @@ struct spl_ast_node {
} attr_item;
struct {
spl_ast_node_ref_vec_t attr_list; /* attr_item */
spl_ast_node_ref_vec_t attr_list; /* attr_item */
const char *name;
spl_ast_node_ref_vec_t param_list; /* param_decl */
spl_ast_node_ref_t type_expr; /* ret type expr */
spl_ast_node_ref_vec_t block; /* 语句/尾表达式 */
spl_ast_node_ref_t type_expr; /* ret type expr */
spl_ast_node_ref_t block; /* block_expr */
} fn_decl;
struct {
spl_ast_node_ref_vec_t attr_list; /* attr_item */
spl_ast_node_ref_vec_t attr_list; /* attr_item */
const char *name;
spl_ast_node_ref_t type_expr;
} param_decl;
@@ -181,33 +181,34 @@ struct spl_ast_node {
spl_ast_node_ref_t expr;
} var_const_decl;
/* 语句数据：kind 决定解释哪个成员 */
/* statement */
struct {
spl_ast_node_ref_t expr;
spl_ast_node_ref_vec_t if_block; /* 语句 */
spl_ast_node_ref_vec_t else_block; /* 语句 */
spl_ast_node_ref_t if_block; /* block_expr */
spl_ast_node_ref_t else_block; /* block_expr */
} if_statement;
struct {
spl_ast_node_ref_t packed_expr;
spl_ast_node_ref_vec_t if_block; /* 语句 */
spl_ast_node_ref_vec_t else_block; /* 语句 */
spl_ast_node_ref_t if_block; /* block_expr */
spl_ast_node_ref_t else_block; /* block_expr */
} ifvar_statement;
struct {
spl_ast_node_ref_t expr;
spl_ast_node_ref_vec_t while_block; /* 语句 */
spl_ast_node_ref_t while_block; /* block_expr */
} while_statement;
struct {
spl_ast_node_ref_vec_t loop_block; /* 语句 */
spl_ast_node_ref_t loop_block; /* block_expr */
} loop_statement;
struct {
spl_ast_node_ref_vec_t expr_vec;
VEC(char *) ident_vec;
spl_ast_node_ref_vec_t block; /* 语句 */
spl_ast_node_ref_t block; /* block_expr */
} for_statement;
struct {
spl_ast_node_ref_t expr;
spl_ast_node_ref_vec_t paced_exprs; /* packed_expr */
spl_ast_node_ref_vec_t match_block; /* 语句 */
spl_ast_node_ref_t match_block; /* block_expr */
} match_statement;
struct {
spl_ast_node_ref_t expr;
stage1/spl_ast2ir.c
+355 -69
View File
@@ -10,8 +10,259 @@ static spl_type_id_t tid_from_def(const spl_sema_t *sema, spl_def_id_t def) {
return d ? d->type_id : 0;
}
static spl_ir_node_ref_t transit(spl_ir_builder_t *ir, const spl_sema_t *sema,
spl_ast_node_ref_t ref) {
static spl_ir_node_ref_t transit(spl_ast2ir_t *ctx, spl_ast_node_ref_t ref);
static spl_ir_node_ref_t transit_op(spl_ir_builder_t *ir, spl_ast_node_kind_t kind,
spl_type_id_t tid, spl_ir_node_ref_t lref,
spl_ir_node_ref_t rref) {
spl_ir_node_ref_t ret = 0;
switch (kind) {
case SPL_AST_CMP_EQ_EXPR: {
ret = spl_ir_builder_cmp_eq(ir, tid, lref, rref);
} break;
case SPL_AST_CMP_NE_EXPR: {
ret = spl_ir_builder_cmp_ne(ir, tid, lref, rref);
} break;
case SPL_AST_CMP_LE_EXPR: {
ret = spl_ir_builder_cmp_le(ir, tid, lref, rref);
} break;
case SPL_AST_CMP_GE_EXPR: {
ret = spl_ir_builder_cmp_ge(ir, tid, lref, rref);
} break;
case SPL_AST_CMP_LT_EXPR: {
ret = spl_ir_builder_cmp_lt(ir, tid, lref, rref);
} break;
case SPL_AST_CMP_GT_EXPR: {
ret = spl_ir_builder_cmp_gt(ir, tid, lref, rref);
} break;
case SPL_AST_ASSIGN_EXPR: {
ret = rref;
} break;
case SPL_AST_ASSIGN_LSHIFT_EXPR:
case SPL_AST_LSHIFT_EXPR: {
ret = spl_ir_builder_arith_shl(ir, tid, lref, rref);
} break;
case SPL_AST_ASSIGN_RSHIFT_EXPR:
case SPL_AST_RSHIFT_EXPR: {
ret = spl_ir_builder_arith_shr(ir, tid, lref, rref);
} break;
case SPL_AST_ASSIGN_ADD_EXPR:
case SPL_AST_ADD_EXPR: {
ret = spl_ir_builder_arith_add(ir, tid, lref, rref);
} break;
case SPL_AST_SUB_EXPR:
case SPL_AST_ASSIGN_SUB_EXPR: {
ret = spl_ir_builder_arith_sub(ir, tid, lref, rref);
} break;
case SPL_AST_ASSIGN_MUL_EXPR:
case SPL_AST_MUL_EXPR: {
ret = spl_ir_builder_arith_mul(ir, tid, lref, rref);
} break;
case SPL_AST_DIV_EXPR:
case SPL_AST_ASSIGN_DIV_EXPR: {
ret = spl_ir_builder_arith_div(ir, tid, lref, rref);
} break;
case SPL_AST_ASSIGN_MOD_EXPR:
case SPL_AST_MOD_EXPR: {
ret = spl_ir_builder_arith_rem(ir, tid, lref, rref);
} break;
case SPL_AST_ASSIGN_AND_EXPR:
case SPL_AST_BIT_AND_EXPR: {
ret = spl_ir_builder_arith_and(ir, tid, lref, rref);
} break;
case SPL_AST_ASSIGN_OR_EXPR:
case SPL_AST_BIT_OR_EXPR: {
ret = spl_ir_builder_arith_or(ir, tid, lref, rref);
} break;
case SPL_AST_ASSIGN_XOR_EXPR:
case SPL_AST_BIT_XOR_EXPR: {
ret = spl_ir_builder_arith_xor(ir, tid, lref, rref);
} break;
default:
UNREACHABLE();
break;
}
return ret;
}
static spl_ir_node_ref_t transit_expr(spl_ast2ir_t *ctx, spl_ast_node_ref_t ref, bool is_lval) {
spl_ir_builder_t *ir = ctx->ir;
const spl_sema_t *sema = ctx->sema;
if (ref == 0)
return 0;
Assert(sema != NULL);
spl_ast_node_t *n = spl_ast_node(sema->ast, ref);
spl_ir_node_ref_t ret = 0;
Assert(n != NULL);
switch (n->kind) {
case SPL_AST_PACKED_EXPR: {
TODO();
} break;
case SPL_AST_ASSIGN_EXPR: {
spl_ir_node_ref_t rval = transit_expr(ctx, n->op_expr.right, false);
spl_ir_node_ref_t lval = transit_expr(ctx, n->op_expr.left, true);
ret = spl_ir_builder_mem_store(ir, n->resolved_type_id, lval, rval);
} break;
case SPL_AST_ASSIGN_ADD_EXPR:
case SPL_AST_ASSIGN_SUB_EXPR:
case SPL_AST_ASSIGN_MUL_EXPR:
case SPL_AST_ASSIGN_DIV_EXPR:
case SPL_AST_ASSIGN_MOD_EXPR:
case SPL_AST_ASSIGN_AND_EXPR:
case SPL_AST_ASSIGN_OR_EXPR:
case SPL_AST_ASSIGN_XOR_EXPR:
case SPL_AST_ASSIGN_LSHIFT_EXPR:
case SPL_AST_ASSIGN_RSHIFT_EXPR: {
spl_ir_node_ref_t rval = transit_expr(ctx, n->op_expr.right, false);
spl_ir_node_ref_t lval = transit_expr(ctx, n->op_expr.left, false);
rval = transit_op(ir, n->kind, n->resolved_type_id, lval, rval);
lval = transit_expr(ctx, n->op_expr.left, true);
ret = spl_ir_builder_mem_store(ir, n->resolved_type_id, lval, rval);
} break;
case SPL_AST_CMP_EQ_EXPR:
case SPL_AST_CMP_NE_EXPR:
case SPL_AST_CMP_LE_EXPR:
case SPL_AST_CMP_GE_EXPR:
case SPL_AST_CMP_LT_EXPR:
case SPL_AST_CMP_GT_EXPR: {
spl_ir_node_ref_t rval = transit_expr(ctx, n->op_expr.right, false);
spl_ir_node_ref_t lval = transit_expr(ctx, n->op_expr.left, false);
ret = transit_op(ir, n->kind, n->resolved_type_id, lval, rval);
} break;
case SPL_AST_RANGE_EXPR: {
TODO();
} break;
case SPL_AST_BOOL_OR_EXPR:
case SPL_AST_BOOL_AND_EXPR: {
TODO();
} break;
case SPL_AST_BIT_OR_EXPR:
case SPL_AST_BIT_XOR_EXPR:
case SPL_AST_BIT_AND_EXPR:
case SPL_AST_LSHIFT_EXPR:
case SPL_AST_RSHIFT_EXPR:
case SPL_AST_ADD_EXPR:
case SPL_AST_SUB_EXPR:
case SPL_AST_MUL_EXPR:
case SPL_AST_DIV_EXPR:
case SPL_AST_MOD_EXPR: {
spl_ir_node_ref_t rval = transit_expr(ctx, n->op_expr.right, false);
spl_ir_node_ref_t lval = transit_expr(ctx, n->op_expr.left, false);
// TODO assert type is bool
ret = transit_op(ir, n->kind, n->resolved_type_id, lval, rval);
} break;
case SPL_AST_MINUS_EXPR: {
ret = transit_expr(ctx, n->prefix_expr.postfix_expr, false);
ret = spl_ir_builder_arith_neg(ir, n->resolved_type_id, ret);
} break;
case SPL_AST_NOT_EXPR: {
ret = transit_expr(ctx, n->prefix_expr.postfix_expr, false);
ret = spl_ir_builder_arith_not(ir, n->resolved_type_id, ret);
TODO(); // return bool type
} break;
case SPL_AST_BIT_NOT_EXPR: {
ret = transit_expr(ctx, n->prefix_expr.postfix_expr, false);
ret = spl_ir_builder_arith_not(ir, n->resolved_type_id, ret);
} break;
case SPL_AST_ADDRESS_EXPR: {
TODO();
} break;
case SPL_AST_CALL_EXPR: {
spl_ast_node_t *fn_sym = spl_ast_node(ctx->sema->ast, n->postfix_expr.primary_expr);
Assert(fn_sym != NULL);
spl_def_node_t *dn = spl_def_node(sema->type, fn_sym->resolved_def_id);
Assert(dn != NULL);
spl_ir_node_ref_t ir_ref = 0;
if (!map_get(ctx->def2ir_map, fn_sym->resolved_def_id, &ir_ref)) {
Panic("can't resolved ir map in def2ir");
}
Assert(ir_ref != 0);
VEC(spl_ir_node_ref_t) params;
vec_init(params);
vec_for(n->postfix_expr.call_expr, i) {
spl_ast_node_ref_t param_node = vec_at(n->postfix_expr.call_expr, i);
spl_ir_node_ref_t ref = transit_expr(ctx, param_node, false);
vec_push(params, ref);
}
spl_ir_node_ref_t call_ref = spl_ir_builder_control_call(ir, n->resolved_type_id, ir_ref);
vec_for(params, i) { spl_ir_builder_control_call_param(ir, call_ref, vec_at(params, i)); }
vec_free(params);
ret = call_ref;
} break;
case SPL_AST_FIELD_EXPR:
case SPL_AST_DEREF_EXPR:
case SPL_AST_INDEX_EXPR:
case SPL_AST_SLICE_EXPR:
case SPL_AST_AS_EXPR:
TODO();
break;
case SPL_AST_EXPR_INTEGER_LIT: {
ret = spl_ir_builder_type_const_int(ir, n->resolved_type_id, n->primary_expr.integer_expr);
break;
}
case SPL_AST_EXPR_FLOAT_LIT:
case SPL_AST_EXPR_CHAR_LIT:
case SPL_AST_EXPR_STRING_LIT: {
TODO();
} break;
case SPL_AST_EXPR_TRUE: {
return spl_ir_builder_type_const_bool(
ir, spl_type_builder_simple(sema->type, SPL_TYPE_BOOL), true);
} break;
case SPL_AST_EXPR_FALSE: {
return spl_ir_builder_type_const_bool(
ir, spl_type_builder_simple(sema->type, SPL_TYPE_BOOL), false);
}
case SPL_AST_EXPR_NULL: {
return spl_ir_builder_type_const_bool(ir, n->resolved_type_id, 0);
} break;
case SPL_AST_EXPR_UNDEFINED:
return 0;
case SPL_AST_EXPR_IDENT: {
spl_def_node_t *dn = spl_def_node(sema->type, n->resolved_def_id);
Assert(dn != NULL);
spl_ir_node_ref_t ir_ref = 0;
if (!map_get(ctx->def2ir_map, n->resolved_def_id, &ir_ref)) {
Panic("can't resolved ir map in def2ir");
}
Assert(ir_ref != 0);
if (is_lval) {
return ir_ref;
} else {
return spl_ir_builder_mem_load(ir, dn->type_id, ir_ref);
}
} break;
case SPL_AST_ARGGREGATE_INIT: {
vec_for(n->primary_expr.aggregate_init.expr, i) {
transit_expr(ctx, vec_at(n->primary_expr.aggregate_init.expr, i), false);
}
} break;
case SPL_AST_EXPR_EXPR: {
transit_expr(ctx, n->primary_expr.expr, is_lval);
} break;
case SPL_AST_ARRAY_LIT: {
TODO();
} break;
case SPL_AST_BUILTIN_EXPR: {
TODO();
} break;
case SPL_AST_BLOCK_EXPR: {
vec_for(n->primary_expr.block_expr, i) {
transit(ctx, vec_at(n->primary_expr.block_expr, i));
}
} break;
default:
UNREACHABLE();
break;
}
return ret;
}
static spl_ir_node_ref_t transit(spl_ast2ir_t *ctx, spl_ast_node_ref_t ref) {
spl_ir_builder_t *ir = ctx->ir;
const spl_sema_t *sema = ctx->sema;
if (ref == 0)
return 0;
Assert(sema != NULL);
@@ -24,7 +275,7 @@ static spl_ir_node_ref_t transit(spl_ir_builder_t *ir, const spl_sema_t *sema,
UNREACHABLE();
break;
case SPL_AST_CONTAINER_MEMBERS: {
vec_for(n->container_members, i) { transit(ir, sema, vec_at(n->container_members, i)); }
vec_for(n->container_members, i) { transit(ctx, vec_at(n->container_members, i)); }
} break;
case SPL_AST_FN_DECL:
TODO();
@@ -34,26 +285,43 @@ static spl_ir_node_ref_t transit(spl_ir_builder_t *ir, const spl_sema_t *sema,
spl_type_node_t *fn_type = spl_type_node(sema->type, tid);
Assert(fn_type && fn_type->kind == SPL_TYPE_FN);
// n->fn_decl.attr_list; TODO @extern(vm) using extern attribute
spl_ir_builder_fn_begin(ir, n->fn_decl.name, tid, (spl_ir_attr_t){0} /*TODO*/);
spl_ir_func_ref_t fn_ref =
spl_ir_builder_fn_begin(ir, n->fn_decl.name, tid, (spl_ir_attr_t){0} /*TODO*/);
Assert(fn_ref != 0);
spl_ir_builder_block_begin(ir);
vec_for(n->fn_decl.block, i) { transit(ir, sema, vec_at(n->fn_decl.block, i)); }
map_put(ctx->def2ir_map, n->resolved_def_id, fn_ref);
vec_for(n->fn_decl.param_list, i) {
spl_ast_node_ref_t nref = vec_at(n->fn_decl.param_list, i);
spl_ast_node_t *n = spl_ast_node(sema->ast, nref);
spl_type_id_t tid = tid_from_def(sema, n->resolved_def_id);
spl_ir_node_ref_t idx_ref = spl_ir_const_comptime_int(ir, sema, i);
spl_ir_node_ref_t var_ref = spl_ir_builder_control_param(ir, tid, idx_ref);
map_put(ctx->def2ir_map, n->resolved_def_id, var_ref);
}
transit(ctx, n->fn_decl.block);
if (!ir->terminated) {
// FIXME
spl_ir_builder_control_ret(ir, n->fn_decl.type_expr, 0);
}
spl_ir_builder_block_end(ir);
spl_ir_builder_fn_end(ir);
} break;
case SPL_AST_TYPE_DECL:
TODO();
break;
case SPL_AST_TYPE_DECL: {
transit(ctx, n->type_decl.type_expr);
} break;
case SPL_AST_VAR_DECL: {
spl_type_id_t tid = tid_from_def(sema, n->resolved_def_id);
spl_ir_node_ref_t var_ref =
spl_ir_builder_mem_alloca(ir, tid, spl_ir_const_comptime_int(ir, sema, 1));
map_put(ctx->def2ir_map, n->resolved_def_id, var_ref);
if (n->var_const_decl.expr) {
spl_ir_builder_mem_store(ir, tid, var_ref, transit(ir, sema, n->var_const_decl.expr));
spl_ir_node_ref_t expr_ref = transit_expr(ctx, n->var_const_decl.expr, false);
if (expr_ref != 0) { // 0 means undefined
spl_ir_builder_mem_store(ir, tid, var_ref, expr_ref);
}
}
} break;
case SPL_AST_CONST_DECL: {
@@ -64,31 +332,74 @@ static spl_ir_node_ref_t transit(spl_ir_builder_t *ir, const spl_sema_t *sema,
break;
case SPL_AST__COMPTIME_STMT:
case SPL_AST__DIRECTIVE_BLOCK:
case SPL_AST_PARAM_DECL:
break;
case SPL_AST_PARAM_DECL: {
UNREACHABLE();
} break;
case SPL_AST_ATTR_ITEM:
case SPL_AST_ARGG_INIT_ITEM: {
TODO();
} break;
case SPL_AST_IF_STATEMENT: {
spl_ir_node_ref_t ref = transit(ir, sema, n->if_statement.expr);
spl_ir_node_ref_t ref = transit_expr(ctx, n->if_statement.expr, false);
ref = spl_ir_builder_control_br(ir, ref);
spl_ir_builder_block_end(ir);
usize true_block = spl_ir_builder_block_begin(ir);
transit_expr(ctx, n->if_statement.if_block, false);
usize true_ref = spl_ir_builder_control_jmp(ir);
spl_ir_builder_block_end(ir);
usize false_block = spl_ir_builder_block_begin(ir);
transit_expr(ctx, n->if_statement.else_block, false);
usize false_ref = spl_ir_builder_control_jmp(ir);
spl_ir_builder_block_end(ir);
usize end_block = spl_ir_builder_block_begin(ir);
spl_ir_builder_control_jmp_fixup(ir, true_ref, end_block);
spl_ir_builder_control_jmp_fixup(ir, false_ref, end_block);
spl_ir_builder_control_br_fixup(ir, ref, true_block, false_block);
} break;
case SPL_AST_IFVAR_STATEMENT:
case SPL_AST_WHILE_STATEMENT:
case SPL_AST_LOOP_STATEMENT:
case SPL_AST_IFVAR_STATEMENT: {
TODO();
} break;
case SPL_AST_WHILE_STATEMENT: {
spl_ir_node_ref_t end_ref = spl_ir_builder_control_jmp(ir);
spl_ir_builder_block_end(ir);
usize cond_block = spl_ir_builder_block_begin(ir);
spl_ir_node_ref_t cond_expr_ref = transit_expr(ctx, n->while_statement.expr, false);
spl_ir_node_ref_t cond_ref = spl_ir_builder_control_br(ir, cond_expr_ref);
spl_ir_builder_block_end(ir);
usize true_block = spl_ir_builder_block_begin(ir);
transit_expr(ctx, n->while_statement.while_block, false);
usize true_ref = spl_ir_builder_control_jmp(ir);
spl_ir_builder_block_end(ir);
usize end_block = spl_ir_builder_block_begin(ir);
spl_ir_builder_control_jmp_fixup(ir, true_ref, cond_block);
spl_ir_builder_control_br_fixup(ir, cond_ref, true_block, end_block);
} break;
case SPL_AST_LOOP_STATEMENT: {
usize end_ref = spl_ir_builder_control_jmp(ir);
spl_ir_builder_block_end(ir);
usize loop_block = spl_ir_builder_block_begin(ir);
spl_ir_node_ref_t loop_expr_ref = transit_expr(ctx, n->loop_statement.loop_block, false);
usize loop_ref = spl_ir_builder_control_jmp(ir);
spl_ir_builder_block_end(ir);
usize end_block = spl_ir_builder_block_begin(ir);
spl_ir_builder_control_jmp_fixup(ir, end_ref, loop_block);
spl_ir_builder_control_jmp_fixup(ir, loop_ref, loop_block);
} break;
case SPL_AST_FOR_STATEMENT:
case SPL_AST_MATCH_STATEMENT:
TODO();
break;
case SPL_AST_RET_STATEMENT: {
if (n->ret_statement.expr) {
ret = transit(ir, sema, n->ret_statement.expr);
ret = transit(ctx, n->ret_statement.expr);
}
ret = spl_ir_builder_control_ret(ir, n->resolved_type_id, ret);
} break;
@@ -99,6 +410,8 @@ static spl_ir_node_ref_t transit(spl_ir_builder_t *ir, const spl_sema_t *sema,
case SPL_AST_CATCH_STATEMENT:
case SPL_AST_ERRDEFER_STATEMEMT:
case SPL_AST_EXPR_STATEMENT:
TODO();
break;
case SPL_AST_PACKED_EXPR:
case SPL_AST_ASSIGN_EXPR:
case SPL_AST_ASSIGN_ADD_EXPR:
@@ -110,7 +423,7 @@ static spl_ir_node_ref_t transit(spl_ir_builder_t *ir, const spl_sema_t *sema,
case SPL_AST_ASSIGN_OR_EXPR:
case SPL_AST_ASSIGN_XOR_EXPR:
case SPL_AST_ASSIGN_LSHIFT_EXPR:
case SPL_AST_ASSIGN_USHIFT_EXPR:
case SPL_AST_ASSIGN_RSHIFT_EXPR:
case SPL_AST_BOOL_OR_EXPR:
case SPL_AST_BOOL_AND_EXPR:
case SPL_AST_BIT_OR_EXPR:
@@ -140,55 +453,24 @@ static spl_ir_node_ref_t transit(spl_ir_builder_t *ir, const spl_sema_t *sema,
case SPL_AST_INDEX_EXPR:
case SPL_AST_SLICE_EXPR:
case SPL_AST_AS_EXPR:
TODO();
break;
case SPL_AST_EXPR_INTEGER_LIT: {
ret = spl_ir_builder_type_const_int(ir, n->resolved_type_id, n->primary_expr.integer_expr);
break;
}
case SPL_AST_EXPR_INTEGER_LIT:
case SPL_AST_EXPR_FLOAT_LIT:
case SPL_AST_EXPR_CHAR_LIT:
case SPL_AST_EXPR_STRING_LIT: {
TODO();
} break;
case SPL_AST_EXPR_TRUE: {
return spl_ir_builder_type_const_bool(
ir, spl_type_builder_simple(sema->type, SPL_TYPE_BOOL), true);
} break;
case SPL_AST_EXPR_FALSE: {
return spl_ir_builder_type_const_bool(
ir, spl_type_builder_simple(sema->type, SPL_TYPE_BOOL), false);
}
case SPL_AST_EXPR_NULL: {
return spl_ir_builder_type_const_bool(ir, n->resolved_type_id, 0);
} break;
case SPL_AST_EXPR_STRING_LIT:
case SPL_AST_EXPR_TRUE:
case SPL_AST_EXPR_FALSE:
case SPL_AST_EXPR_NULL:
case SPL_AST_EXPR_UNDEFINED:
break;
case SPL_AST_EXPR_IDENT: {
} break;
case SPL_AST_ARGGREGATE_INIT: {
vec_for(n->primary_expr.aggregate_init.expr, i) {
transit(ir, sema, vec_at(n->primary_expr.aggregate_init.expr, i));
}
} break;
case SPL_AST_EXPR_EXPR: {
transit(ir, sema, n->primary_expr.expr);
} break;
case SPL_AST_ARRAY_LIT: {
TODO();
} break;
case SPL_AST_BUILTIN_EXPR: {
TODO();
} break;
case SPL_AST_EXPR_IDENT:
case SPL_AST_ARGGREGATE_INIT:
case SPL_AST_EXPR_EXPR:
case SPL_AST_ARRAY_LIT:
case SPL_AST_BUILTIN_EXPR:
case SPL_AST_BLOCK_EXPR: {
vec_for(n->primary_expr.block_expr, i) {
transit(ir, sema, vec_at(n->primary_expr.block_expr, i));
}
} break;
return transit_expr(ctx, ref, false);
}
case SPL_AST_BASE_TYPE_FN:
case SPL_AST_BASE_TYPE_PATH:
TODO();
break;
case SPL_AST_TYPE_POINTER:
case SPL_AST_TYPE_ARRAY:
case SPL_AST_TYPE_SLICE:
@@ -213,20 +495,24 @@ static spl_ir_node_ref_t transit(spl_ir_builder_t *ir, const spl_sema_t *sema,
case SPL_AST_TYPE__F64:
case SPL_AST_TYPE_ANY:
case SPL_AST_TYPE_IDENT:
break;
case SPL_AST_COUNT:
case SPL_AST_COUNT: {
UNREACHABLE();
break;
}
}
return ret;
}
void spl_ast2ir_init(spl_ast2ir_t *ast2ir, spl_ir_builder_t *ir, const spl_sema_t *sema) {
ast2ir->sema = sema;
ast2ir->ir = ir;
ast2ir->err_count = 0;
static usize hash_int(spl_def_id_t k) { return MAP_HASH_INT(k); }
static int cmp_int(spl_def_id_t k1, spl_def_id_t k2) { return MAP_CMP_INT(k1, k2); }
void spl_ast2ir_init(spl_ast2ir_t *ctx, spl_ir_builder_t *ir, const spl_sema_t *sema) {
ctx->sema = sema;
ctx->ir = ir;
map_init(ctx->def2ir_map, hash_int, cmp_int);
ctx->err_count = 0;
}
void spl_ast2ir_drop(spl_ast2ir_t *ast2ir) {}
void spl_ast2ir_drop(spl_ast2ir_t *ctx) { map_free(ctx->def2ir_map); }
void spl_ast2ir_run(spl_ast2ir_t *ctx) { transit(ctx->ir, ctx->sema, ctx->sema->ast->root); }
void spl_ast2ir_run(spl_ast2ir_t *ctx) { transit(ctx, ctx->sema->ast->root); }
stage1/spl_ast2ir.h
+2
View File
@@ -4,9 +4,11 @@
#include "spl_ir.h"
#include "spl_sema.h"
typedef MAP(spl_def_id_t, spl_ir_node_ref_t) spl_def2ir_map_t;
typedef struct {
const spl_sema_t *sema;
spl_ir_builder_t *ir;
spl_def2ir_map_t def2ir_map;
int err_count;
} spl_ast2ir_t;
stage1/spl_ir.c
+7 -4
View File
@@ -113,12 +113,15 @@ static void ir_dump_node(const spl_type_t *ty, spl_ir_node_t *n) {
case SPL_IR_ARITH_XOR:
case SPL_IR_ARITH_SHL:
case SPL_IR_ARITH_SHR:
ir_dump_type(ty, n->arith.tid);
ir_dump_ref(n->arith.left);
ir_dump_ref(n->arith.right);
break;
case SPL_IR_ARITH_NEG:
case SPL_IR_ARITH_ABS:
case SPL_IR_ARITH_NOT:
ir_dump_type(ty, n->arith.tid);
ir_dump_ref(n->arith.left);
ir_dump_ref(n->arith.right);
break;
case SPL_IR_CMP_EQ:
case SPL_IR_CMP_NE:
@@ -272,7 +275,7 @@ void spl_ir_dump(spl_ir_t *ir, const spl_type_t *ty) {
if (i == 0)
continue;
spl_ir_func_t *func = &vec_at(ir->funcs, i);
printf("func %s", func->name ? func->name : "?");
printf("func %s %%%zu", func->name ? func->name : "?", i);
printf(" tid=");
spl_type_pure_dump((spl_type_t *)ty, func->fn_tid);
printf("\n");
@@ -739,9 +742,9 @@ spl_ir_node_ref_t spl_ir_builder_control_call(spl_ir_builder_t *b, spl_type_id_t
return ref;
}
void spl_ir_builder_control_call_param(spl_ir_builder_t *b, spl_ir_node_ref_t node,
void spl_ir_builder_control_call_param(spl_ir_builder_t *b, spl_ir_node_ref_t call_node,
spl_ir_node_ref_t arg) {
spl_ir_node_t *n = spl_ir_node(&b->ir, b->current_fn, node);
spl_ir_node_t *n = spl_ir_node(&b->ir, b->current_fn, call_node);
Assert(n != NULL);
vec_push(n->control_call.params, arg);
}
stage1/spl_ir.h
+1 -1
View File
@@ -409,7 +409,7 @@ void spl_ir_builder_control_jmp_fixup(spl_ir_builder_t *b, spl_ir_node_ref_t ref
usize target_block);
spl_ir_node_ref_t spl_ir_builder_control_call(spl_ir_builder_t *b, spl_type_id_t tid,
spl_ir_node_ref_t func);
void spl_ir_builder_control_call_param(spl_ir_builder_t *b, spl_ir_node_ref_t node,
void spl_ir_builder_control_call_param(spl_ir_builder_t *b, spl_ir_node_ref_t call_node,
spl_ir_node_ref_t arg);
spl_ir_node_ref_t spl_ir_builder_control_param(spl_ir_builder_t *b, spl_type_id_t tid,
spl_ir_node_ref_t idx);
stage1/spl_ir2vm.c
+55 -1406
View File
File diff suppressed because it is too large. Load diff
stage1/spl_ir2vm.h
+7 -78
View File
@@ -4,98 +4,27 @@
#include "spl_ir.h"
#include "spl_type.h"
/*
* ================================================================
* SPL VM ABI (ir2vm 的正式约定；布局知识唯一来源)
* ================================================================
*
* 栈值槽 spl_val_t = sizeof(usize) = 8 字节。
* SIR 指令 type 只表达标量 tag（SPL_I8..SPL_PTR），聚合无 tag——
* 聚合值在 vreg 中是字节块，整体搬运用 NCALL vm_memcpy。
*
* ── 函数栈帧（字节坐标系，基址 = (char*)&stacks[fp]）─────────────
*
* [canary] fp-8 .. 0 （VM CALL 自动插入，ir2vm 不触碰）
* [params 区] fp+0 .. fp+Na （Na = C ABI 参数区字节数）
* [locals / vreg] fp+Na .. fp+Na+L
*
* ALLOC ceil((Na+L)/8) 一条 prologue；epilogue 走 RET。
* LADDR(imm) 的 imm 是字节偏移；canary 在 fp-1 槽，编译码不可见。
*
* ── 参数区 = C ABI（聚合值按值） ─────────────────────────────────
* 标量参数：align_up(off,8) 后占 8 字节（一槽）。
* 聚合参数：按聚合 size 排布跨多槽（align8 + size）。
* 调用方：标量 ld/PUSH 一槽；聚合逐 8 字节块压栈（聚合 vreg 强制 8 对齐）。
* 被调方：标量参数映射参数槽；聚合参数在 prologue memcpy 参数区 → param vreg，
* emit_value(param) 取 vreg 地址。参数槽数 = ceil(param_bytes/8) = CALL nargs。
*
* ── locals = 虚拟寄存器区 ────────────────────────────────────────
* 每个产生值的 IR 节点 = 一个 vreg（locals 区按类型对齐的字节块）。
* 纯值节点（type.const / mem.global_alloc / mem.alloca / 折叠 sizeof 等）不落 vreg，
* 引用处重算（PUSH / GADDR / LADDR）；其余产生值节点落 vreg，引用处 LOAD。
* 聚合 vreg 引用处返回其地址（LADDR），搬运经 vm_memcpy。
* mem.alloca(tid)(cnt) 的 vreg 槽即缓冲区本体，节点值 = LADDR(vreg_off)。
* 所有运算走 load/store：ld A; ld B; op; st Dst；立即数直接 PUSH。
*
* ── 调用 ──────────────────────────────────────────────────────────
* 调用方：逐参数压栈（标量一槽；聚合按 C ABI 逐 8 字节块）→ push fn_addr(或
* native_idx) → CALL n / NCALL n。返回值落 call 节点 vreg。
* 原生函数：IR 中 nodes 为空的函数（@extern 声明）→ 注册进 prog.natives，
* 加载时由 spl_syscall_register 填 impl；调用改 PUSH nat_idx + NCALL。
* 变参 nargs = 实际参数槽数。
*
* ── enum（不展开，直接保留）─────────────────────────────────────
* IR 层保留 enum 类型（不再展开为 struct）。enum 布局 = tag(usize, offset 0)
* + payload(offset 8，最大变体）。构造：agg.construct(enum)(tag, payload)；
* match：先取 tag 判定变体，再 extract(enum, 1) 一跳取 payload，
* field_tid = 变体具体类型（由 ast2ir 传入）。
*
* ── 返回 ──────────────────────────────────────────────────────────
* 标量：ld vreg(val); RET(tag)（RET 的 type 决定 VM 是否弹出返回值）。
* 聚合返回 = sret（自展开，不改 VM）：
* 被调函数签名尾部追加隐藏 *T 参数（最后一个）；返回时把聚合 vreg
* memcpy 到 sret 地址，RET(void)。
* 调用方在 locals 预留聚合槽（= call 节点 vreg），压其地址为最后实参；
* call 完成后聚合值已在该槽。
* 返回 void：RET(SPL_VOID)。
*
* ── 全局数据 ──────────────────────────────────────────────────────
* 任何聚合类型下（含 $root 顶层）的 var/const 属全局数据区。gdata 是
* spl_ir_node_vec_t，每条 = 一个 value 节点（type.const：标量折叠值，
* 聚合/无 init 零）。ir2vm 遍历求值 → SIR gdata 条目（字节 blob）。
* mem.global_alloc(tid, const_node) 的 const_node = gdata 向量索引，
* 降级为 GADDR(idx)。符号(def) → gdata 索引的解析在 ast2ir 收集期
* （gdata_ref 表），ir2vm 按索引直接用。
*
* ── 类型布局（C ABI，唯一实现处）────────────────────────────────
* type_align / type_size / field_offset：标量按 bits/8 对齐；
* struct 顺序对齐 + 尾填充；union 取最大字段；enum = tag(8) + 最大 payload；
* slice/range = [ptr, len] 各 8 字节；array = len * elem。
*
* ── 分支 ──────────────────────────────────────────────────────────
* control.br/jmp/select 的 label 是 IR node ref（基本块首指令）。两遍发射：
* 第一遍逐节点发指令并记录 label 节点 → 指令地址；第二遍回填
* JMP/BZ/BNZ 相对偏移 imm = target_addr - (jmp_addr + 1)。
* ================================================================
*/
#include "../stage0/spl_mcode.h"
/* 调试映射：每函数 IR 节点 → 首条指令 ip（调试器显示当前 IR 节点用） */
typedef struct {
spl_ir_func_ref_t fid;
VEC(usize) node_first_ip; /* 索引 = IR 节点 ref，值 = 该节点首指令绝对 ip */
VEC(usize) node_first_ip;
} spl_ir2vm_fdbg_t;
typedef VEC(spl_ir2vm_fdbg_t) spl_ir2vm_fdbg_vec_t;
// MAP()
typedef struct {
const spl_ir_t *ir;
const spl_type_t *type;
spl_ir2vm_fdbg_vec_t fdbg; /* ir2vm_run 后填充；splc0 -g 读取生成 debug 段 */
spl_prog_t prog;
// spl_ir2vm_fdbg_vec_t fdbg; /* ir2vm_run 后填充；splc0 -g 读取生成 debug 段 */
} spl_ir2vm_t;
void spl_ir2vm_init(spl_ir2vm_t *ctx, const spl_ir_t *ir, const spl_type_t *type);
void spl_ir2vm_drop(spl_ir2vm_t *ctx);
int spl_ir2vm_run(spl_ir2vm_t *ctx, const char *outpath); /* 返回错误数 */
int spl_ir2vm_run(spl_ir2vm_t *ctx);
void spl_ir2vm_dump(spl_ir2vm_t *ctx);
#endif /* __SPL_IR2VM_H__ */
stage1/spl_sema.c
+10 -24
View File
@@ -341,7 +341,7 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
spl_type_id_t old_ret = sema->current_fn_ret_tid;
sema->current_fn_ret_tid = ret_id;
vec_for(n->fn_decl.block, i) { sema_parse(sema, vec_at(n->fn_decl.block, i)); }
sema_parse(sema, n->fn_decl.block);
sema->current_fn_ret_tid = old_ret;
sema_pop_scope(sema);
} break;
@@ -478,23 +478,15 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
SPL_ERROR(&n->dbg, "if condition must be bool");
sema->error_count++;
}
vec_for(n->if_statement.if_block, i) {
sema_parse(sema, vec_at(n->if_statement.if_block, i));
}
vec_for(n->if_statement.else_block, i) {
sema_parse(sema, vec_at(n->if_statement.else_block, i));
}
sema_parse(sema, n->if_statement.if_block);
sema_parse(sema, n->if_statement.else_block);
} break;
case SPL_AST_IFVAR_STATEMENT: {
if (n->ifvar_statement.packed_expr) {
sema_parse(sema, n->ifvar_statement.packed_expr);
}
vec_for(n->ifvar_statement.if_block, i) {
sema_parse(sema, vec_at(n->ifvar_statement.if_block, i));
}
vec_for(n->ifvar_statement.else_block, i) {
sema_parse(sema, vec_at(n->ifvar_statement.else_block, i));
}
sema_parse(sema, n->ifvar_statement.if_block);
sema_parse(sema, n->ifvar_statement.else_block);
} break;
case SPL_AST_WHILE_STATEMENT: {
if (!n->while_statement.expr) {
@@ -506,14 +498,10 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
SPL_ERROR(&n->dbg, "while condition must be bool");
sema->error_count++;
}
vec_for(n->while_statement.while_block, i) {
sema_parse(sema, vec_at(n->while_statement.while_block, i));
}
sema_parse(sema, n->while_statement.while_block);
} break;
case SPL_AST_LOOP_STATEMENT: {
vec_for(n->loop_statement.loop_block, i) {
sema_parse(sema, vec_at(n->loop_statement.loop_block, i));
}
sema_parse(sema, n->loop_statement.loop_block);
} break;
case SPL_AST_FOR_STATEMENT: {
sema_push_scope(sema);
@@ -531,7 +519,7 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
spl_scope_insert(sema->scope, sema->scope->current_scope, symbol);
}
}
vec_for(n->for_statement.block, j) { sema_parse(sema, vec_at(n->for_statement.block, j)); }
sema_parse(sema, n->for_statement.block);
sema_pop_scope(sema);
} break;
case SPL_AST_MATCH_STATEMENT: {
@@ -541,9 +529,7 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
vec_for(n->match_statement.paced_exprs, i) {
sema_parse(sema, vec_at(n->match_statement.paced_exprs, i));
}
vec_for(n->match_statement.match_block, i) {
sema_parse(sema, vec_at(n->match_statement.match_block, i));
}
sema_parse(sema, n->match_statement.match_block);
} break;
case SPL_AST_RET_STATEMENT: {
if (n->ret_statement.expr) {
@@ -596,7 +582,7 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
case SPL_AST_ASSIGN_OR_EXPR:
case SPL_AST_ASSIGN_XOR_EXPR:
case SPL_AST_ASSIGN_LSHIFT_EXPR:
case SPL_AST_ASSIGN_USHIFT_EXPR: {
case SPL_AST_ASSIGN_RSHIFT_EXPR: {
spl_type_id_t lt = sema_parse(sema, n->op_expr.left);
spl_type_id_t rt = sema_parse(sema, n->op_expr.right);
if (lt == 0) {
stage1/spl_type.c
+2 -2
View File
@@ -377,13 +377,13 @@ void spl_type_drop(spl_type_t *type) {
vec_free(type->def_table);
}
spl_type_node_t *spl_type_node(spl_type_t *type, spl_type_id_t id) {
spl_type_node_t *spl_type_node(const spl_type_t *type, spl_type_id_t id) {
if (!id || id >= vec_size(type->type_table))
return NULL;
return &vec_at(type->type_table, id);
}
spl_def_node_t *spl_def_node(spl_type_t *type, spl_def_id_t id) {
spl_def_node_t *spl_def_node(const spl_type_t *type, spl_def_id_t id) {
if (!id || id >= vec_size(type->def_table))
return NULL;
return &vec_at(type->def_table, id);
stage1/spl_type.h
+2 -2
View File
@@ -111,8 +111,8 @@ void spl_type_drop(spl_type_t *type);
void spl_type_def_dump(spl_type_t *type, spl_def_id_t id);
void spl_type_pure_dump(spl_type_t *type, spl_type_id_t id);
spl_type_node_t *spl_type_node(spl_type_t *type, spl_type_id_t id);
spl_def_node_t *spl_def_node(spl_type_t *type, spl_def_id_t id);
spl_type_node_t *spl_type_node(const spl_type_t *type, spl_type_id_t id);
spl_def_node_t *spl_def_node(const spl_type_t *type, spl_def_id_t id);
spl_type_id_t spl_def_alloc(spl_type_t *type, spl_def_node_kind_t kind, const char *name,
spl_dbg_node_t dbg, usize ast_node_ref);
stage1/splc0.c
+34 -18
View File
@@ -12,7 +12,7 @@
#include "spl_ast.h"
#include "spl_ast2ir.h"
// #include "spl_ir2vm.h"
#include "spl_ir2vm.h"
#include "spl_lexer.h"
#include "spl_sema.h"
#include "spl_tok.h"
@@ -23,6 +23,7 @@ typedef enum {
DUMP_AST,
DUMP_SEMA,
DUMP_IR,
DUMP_VM,
} dump_t;
static char *read_file(const char *path, long *out_len) {
@@ -68,6 +69,8 @@ static void dump_tokens(spl_tok_vec_t toks) {
static int compile_spl(const char *src, const char *fname, const char *outpath, int gen_debug,
dump_t dump) {
(void)gen_debug;
spl_tok_vec_t toks = spl_lex(src, fname);
if (dump == DUMP_TOKEN) {
dump_tokens(toks);
@@ -126,16 +129,25 @@ static int compile_spl(const char *src, const char *fname, const char *outpath,
return 0;
}
// spl_ir2vm_t ir2vm;
// spl_ir2vm_init(&ir2vm, &a2ir.ir, &sema.type);
// int rc = spl_ir2vm_run(&ir2vm, outpath);
// if (gen_debug && rc == 0)
// gen_debug_map(outpath, &ast, &a2ir.ir, &ir2vm);
// spl_ir2vm_drop(&ir2vm);
// spl_ast2ir_drop(&a2ir);
// spl_sema_drop(&sema);
// spl_ast_drop(&ast);
// return rc ? 1 : 0;
spl_ir2vm_t ir2vm;
spl_ir2vm_init(&ir2vm, &a2ir.ir->ir, sema.type);
int rc = spl_ir2vm_run(&ir2vm);
if (rc != 0) {
printf("ir2vm error %d", rc);
return rc;
}
if (dump == DUMP_VM) {
spl_prog_dump(&ir2vm.prog);
// memory leak
return 0;
}
spl_prog_store_to_file(outpath, &ir2vm.prog);
spl_ir2vm_drop(&ir2vm);
spl_ast2ir_drop(&a2ir);
spl_sema_drop(&sema);
spl_ast_drop(&ast);
return 0;
}
@@ -146,7 +158,7 @@ int main(int argc, char **argv) {
}
if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-h") == 0) {
LOG_INFO("splc0 <in> <out> compile (.spl -> .sir, stage B)");
LOG_INFO("splc0 --dump <flags> <file> dump: lex,ast,sema,ir");
LOG_INFO("splc0 --dump <flags> <file> dump: lex,ast,sema,ir,vm,none");
return 0;
}
int argi = 1;
@@ -165,15 +177,19 @@ int main(int argc, char **argv) {
const char *flags = argv[argi + 1];
if (strstr(flags, "lex") != NULL) {
dump = DUMP_TOKEN;
}
if (strstr(flags, "ast") != NULL) {
} else if (strstr(flags, "ast") != NULL) {
dump = DUMP_AST;
}
if (strstr(flags, "sema") != NULL) {
} else if (strstr(flags, "sema") != NULL) {
dump = DUMP_SEMA;
}
if (strstr(flags, "ir") != NULL) {
} else if (strstr(flags, "ir") != NULL) {
dump = DUMP_IR;
} else if (strstr(flags, "vm") != NULL) {
dump = DUMP_VM;
} else if (strstr(flags, "none") != NULL) {
dump = DUMP_NONE;
} else {
Panic("--dump unknown flags");
return 1;
}
argi += 2;
}