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

refactor(ir): 将IR节点重构为值引用并添加字符串字面量支持

Browse Source 
- 将scc_ir_node_ref_t重命名为scc_ir_value_ref_t，并更新所有相关API
- 修改IR定义中的节点标签枚举为值标签枚举(scc_ir_node_tag_t -> scc_ir_value_tag_t)
- 更新AST到IR转换器中所有节点引用的类型声明
- 添加对内置类型(VOID, CHAR, INT等)的完整映射实现
- 实现字符串字面量的常量数组创建功能
- 更新项目名称从"Simple Modual C Compiler"为"Simple C Compiler"
- 在Doxyfile中排除external目录的文档生成
- 移除未使用的strpool字段并重命名decl到IR的映射表

BREAKING CHANGE: IR节点引用类型已更改，所有使用scc_ir_node_ref_t的地方需
替换为scc_ir_value_ref_t。
This commit is contained in:
zzy
2026-03-31 11:42:14 +08:00
parent 4ddad7b456
commit 78e7c800ba
22 changed files with 992 additions and 727 deletions
Download Patch File Download Diff File Expand all files Collapse all files

191
libs/ir/src/ir_builder.c
View File

@@ -60,15 +60,15 @@ void scc_ir_builder_begin_func(scc_ir_builder_t *builder,
scc_ir_type_ref_t param_type =
scc_vec_at(func_type->data.function.params, i);
scc_ir_node_t param_node = {0};
param_node.tag = SCC_IR_NODE_FUNC_ARG_REF; // 参数节点标记
scc_ir_value_t param_node = {0};
param_node.tag = SCC_IR_VALUE_TAG_FUNC_ARG_REF; // 参数节点标记
param_node.type = param_type;
param_node.name = param_names ? param_names[i] : null;
param_node.data.arg_ref.idx = i;
scc_vec_init(param_node.used_by);
scc_ir_node_ref_t param_ref =
scc_ir_module_add_node(GET_MODULE(builder), &param_node);
scc_ir_value_ref_t param_ref =
scc_ir_module_add_value(GET_MODULE(builder), &param_node);
scc_vec_push(func_ptr->params, param_ref);
}
@@ -129,29 +129,29 @@ void scc_ir_builder_set_current_bblock(scc_ir_builder_t *builder,
builder->current_bblock = bblock;
}
static void scc_ir_builder_add_instr(scc_ir_builder_t *builder,
scc_ir_node_ref_t node) {
void scc_ir_builder_add_instr(scc_ir_builder_t *builder,
scc_ir_value_ref_t instr) {
scc_ir_bblock_t *current_bblock =
scc_ir_module_get_bblock(GET_MODULE(builder), builder->current_bblock);
if (current_bblock) {
scc_vec_push(current_bblock->instrs, node);
scc_vec_push(current_bblock->instrs, instr);
} else {
LOG_ERROR("Current basic block is not set");
}
}
scc_ir_node_ref_t scc_ir_builder_alloca(scc_ir_builder_t *builder,
scc_ir_type_ref_t type,
const char *name) {
scc_ir_node_t alloc_node = {0};
alloc_node.tag = SCC_IR_NODE_ALLOC;
scc_ir_value_ref_t scc_ir_builder_alloca(scc_ir_builder_t *builder,
scc_ir_type_ref_t type,
const char *name) {
scc_ir_value_t alloc_node = {0};
alloc_node.tag = SCC_IR_VALUE_TAG_ALLOC;
alloc_node.type = scc_ir_module_add_type(
GET_MODULE(builder),
&(scc_ir_type_t){.tag = SCC_IR_TYPE_PTR, .data.pointer.base = type});
alloc_node.name = name;
scc_ir_node_ref_t node_ref =
scc_ir_module_add_node(GET_MODULE(builder), &alloc_node);
scc_ir_value_ref_t node_ref =
scc_ir_module_add_value(GET_MODULE(builder), &alloc_node);
// 添加到当前基本块
scc_ir_builder_add_instr(builder, node_ref);
@@ -159,31 +159,32 @@ scc_ir_node_ref_t scc_ir_builder_alloca(scc_ir_builder_t *builder,
return node_ref;
}
scc_ir_node_ref_t scc_ir_builder_func_arg_ref(scc_ir_builder_t *builder,
scc_ir_type_ref_t type,
const char *name, usize arg_idx) {
scc_ir_node_t node = {0};
node.tag = SCC_IR_NODE_FUNC_ARG_REF;
scc_ir_value_ref_t scc_ir_builder_func_arg_ref(scc_ir_builder_t *builder,
scc_ir_type_ref_t type,
const char *name,
usize arg_idx) {
scc_ir_value_t node = {0};
node.tag = SCC_IR_VALUE_TAG_FUNC_ARG_REF;
node.type = type;
node.name = name;
node.data.arg_ref.idx = arg_idx;
scc_ir_node_ref_t node_ref =
scc_ir_module_add_node(GET_MODULE(builder), &node);
scc_ir_value_ref_t node_ref =
scc_ir_module_add_value(GET_MODULE(builder), &node);
// 添加到当前基本块
scc_ir_builder_add_instr(builder, node_ref);
return node_ref;
}
scc_ir_node_ref_t scc_ir_builder_load(scc_ir_builder_t *builder,
scc_ir_node_ref_t target) {
scc_ir_node_t load_node = {0};
load_node.tag = SCC_IR_NODE_LOAD;
scc_ir_value_ref_t scc_ir_builder_load(scc_ir_builder_t *builder,
scc_ir_value_ref_t target) {
scc_ir_value_t load_node = {0};
load_node.tag = SCC_IR_VALUE_TAG_LOAD;
load_node.data.load.target = target;
// 设置类型为指针指向的类型
scc_ir_node_t *ptr_node =
scc_ir_module_get_node(GET_MODULE(builder), target);
scc_ir_value_t *ptr_node =
scc_ir_module_get_value(GET_MODULE(builder), target);
if (ptr_node) {
scc_ir_type_t *ptr_type =
scc_ir_module_get_type(GET_MODULE(builder), ptr_node->type);
@@ -192,8 +193,8 @@ scc_ir_node_ref_t scc_ir_builder_load(scc_ir_builder_t *builder,
}
}
scc_ir_node_ref_t node_ref =
scc_ir_module_add_node(GET_MODULE(builder), &load_node);
scc_ir_value_ref_t node_ref =
scc_ir_module_add_value(GET_MODULE(builder), &load_node);
// 添加到当前基本块
scc_ir_builder_add_instr(builder, node_ref);
@@ -201,16 +202,16 @@ scc_ir_node_ref_t scc_ir_builder_load(scc_ir_builder_t *builder,
return node_ref;
}
scc_ir_node_ref_t scc_ir_builder_store(scc_ir_builder_t *builder,
scc_ir_node_ref_t target,
scc_ir_node_ref_t value) {
scc_ir_node_t store_node = {0};
store_node.tag = SCC_IR_NODE_STORE;
scc_ir_value_ref_t scc_ir_builder_store(scc_ir_builder_t *builder,
scc_ir_value_ref_t target,
scc_ir_value_ref_t value) {
scc_ir_value_t store_node = {0};
store_node.tag = SCC_IR_VALUE_TAG_STORE;
store_node.data.store.target = target;
store_node.data.store.value = value;
scc_ir_node_ref_t node_ref =
scc_ir_module_add_node(GET_MODULE(builder), &store_node);
scc_ir_value_ref_t node_ref =
scc_ir_module_add_value(GET_MODULE(builder), &store_node);
// 添加到当前基本块
scc_ir_builder_add_instr(builder, node_ref);
@@ -218,23 +219,23 @@ scc_ir_node_ref_t scc_ir_builder_store(scc_ir_builder_t *builder,
return node_ref;
}
scc_ir_node_ref_t scc_ir_builder_get_ptr(scc_ir_builder_t *builder,
scc_ir_node_ref_t target,
scc_ir_node_ref_t index) {
scc_ir_node_t get_ptr_node = {0};
get_ptr_node.tag = SCC_IR_NODE_GET_PTR;
scc_ir_value_ref_t scc_ir_builder_get_ptr(scc_ir_builder_t *builder,
scc_ir_value_ref_t target,
scc_ir_value_ref_t index) {
scc_ir_value_t get_ptr_node = {0};
get_ptr_node.tag = SCC_IR_VALUE_TAG_GET_PTR;
get_ptr_node.data.get_ptr.src_addr = target;
get_ptr_node.data.get_ptr.index = index;
// 类型应与源地址相同（都是指针）
scc_ir_node_t *src_node =
scc_ir_module_get_node(GET_MODULE(builder), target);
scc_ir_value_t *src_node =
scc_ir_module_get_value(GET_MODULE(builder), target);
if (src_node) {
get_ptr_node.type = src_node->type;
}
scc_ir_node_ref_t node_ref =
scc_ir_module_add_node(GET_MODULE(builder), &get_ptr_node);
scc_ir_value_ref_t node_ref =
scc_ir_module_add_value(GET_MODULE(builder), &get_ptr_node);
// 添加到当前基本块
scc_ir_builder_add_instr(builder, node_ref);
@@ -242,24 +243,25 @@ scc_ir_node_ref_t scc_ir_builder_get_ptr(scc_ir_builder_t *builder,
return node_ref;
}
scc_ir_node_ref_t scc_ir_builder_binop(scc_ir_builder_t *builder,
scc_ir_op_type_t op,
scc_ir_node_ref_t lhs,
scc_ir_node_ref_t rhs) {
scc_ir_node_t binop_node = {0};
binop_node.tag = SCC_IR_NODE_OP;
scc_ir_value_ref_t scc_ir_builder_binop(scc_ir_builder_t *builder,
scc_ir_op_type_t op,
scc_ir_value_ref_t lhs,
scc_ir_value_ref_t rhs) {
scc_ir_value_t binop_node = {0};
binop_node.tag = SCC_IR_VALUE_TAG_OP;
binop_node.data.op.op = op;
binop_node.data.op.lhs = lhs;
binop_node.data.op.rhs = rhs;
// 类型通常与操作数相同（对于算术运算）
scc_ir_node_t *lhs_node = scc_ir_module_get_node(GET_MODULE(builder), lhs);
scc_ir_value_t *lhs_node =
scc_ir_module_get_value(GET_MODULE(builder), lhs);
if (lhs_node) {
binop_node.type = lhs_node->type;
}
scc_ir_node_ref_t node_ref =
scc_ir_module_add_node(GET_MODULE(builder), &binop_node);
scc_ir_value_ref_t node_ref =
scc_ir_module_add_value(GET_MODULE(builder), &binop_node);
// 添加到当前基本块
scc_ir_builder_add_instr(builder, node_ref);
@@ -267,11 +269,12 @@ scc_ir_node_ref_t scc_ir_builder_binop(scc_ir_builder_t *builder,
return node_ref;
}
scc_ir_node_ref_t scc_ir_builder_cmp(scc_ir_builder_t *builder,
scc_ir_op_type_t op, scc_ir_node_ref_t lhs,
scc_ir_node_ref_t rhs) {
scc_ir_node_t cmp_node = {0};
cmp_node.tag = SCC_IR_NODE_OP;
scc_ir_value_ref_t scc_ir_builder_cmp(scc_ir_builder_t *builder,
scc_ir_op_type_t op,
scc_ir_value_ref_t lhs,
scc_ir_value_ref_t rhs) {
scc_ir_value_t cmp_node = {0};
cmp_node.tag = SCC_IR_VALUE_TAG_OP;
cmp_node.data.op.op = op;
cmp_node.data.op.lhs = lhs;
cmp_node.data.op.rhs = rhs;
@@ -280,8 +283,8 @@ scc_ir_node_ref_t scc_ir_builder_cmp(scc_ir_builder_t *builder,
cmp_node.type =
0; // FIXME scc_ir_module_get_builtin_i32(GET_MODULE(builder));
scc_ir_node_ref_t node_ref =
scc_ir_module_add_node(GET_MODULE(builder), &cmp_node);
scc_ir_value_ref_t node_ref =
scc_ir_module_add_value(GET_MODULE(builder), &cmp_node);
// 添加到当前基本块
scc_ir_builder_add_instr(builder, node_ref);
@@ -289,14 +292,14 @@ scc_ir_node_ref_t scc_ir_builder_cmp(scc_ir_builder_t *builder,
return node_ref;
}
scc_ir_node_ref_t scc_ir_builder_jump(scc_ir_builder_t *builder,
scc_ir_bblock_ref_t target) {
scc_ir_node_t jump_node = {0};
jump_node.tag = SCC_IR_NODE_JUMP;
scc_ir_value_ref_t scc_ir_builder_jump(scc_ir_builder_t *builder,
scc_ir_bblock_ref_t target) {
scc_ir_value_t jump_node = {0};
jump_node.tag = SCC_IR_VALUE_TAG_JUMP;
jump_node.data.jump.target_bblock = target;
scc_ir_node_ref_t node_ref =
scc_ir_module_add_node(GET_MODULE(builder), &jump_node);
scc_ir_value_ref_t node_ref =
scc_ir_module_add_value(GET_MODULE(builder), &jump_node);
// 添加到当前基本块
scc_ir_builder_add_instr(builder, node_ref);
@@ -304,18 +307,18 @@ scc_ir_node_ref_t scc_ir_builder_jump(scc_ir_builder_t *builder,
return node_ref;
}
scc_ir_node_ref_t scc_ir_builder_branch(scc_ir_builder_t *builder,
scc_ir_node_ref_t cond,
scc_ir_bblock_ref_t true_target,
scc_ir_bblock_ref_t false_target) {
scc_ir_node_t branch_node = {0};
branch_node.tag = SCC_IR_NODE_BRANCH;
scc_ir_value_ref_t scc_ir_builder_branch(scc_ir_builder_t *builder,
scc_ir_value_ref_t cond,
scc_ir_bblock_ref_t true_target,
scc_ir_bblock_ref_t false_target) {
scc_ir_value_t branch_node = {0};
branch_node.tag = SCC_IR_VALUE_TAG_BRANCH;
branch_node.data.branch.cond = cond;
branch_node.data.branch.true_bblock = true_target;
branch_node.data.branch.false_bblock = false_target;
scc_ir_node_ref_t node_ref =
scc_ir_module_add_node(GET_MODULE(builder), &branch_node);
scc_ir_value_ref_t node_ref =
scc_ir_module_add_value(GET_MODULE(builder), &branch_node);
// 添加到当前基本块
scc_ir_builder_add_instr(builder, node_ref);
@@ -323,12 +326,12 @@ scc_ir_node_ref_t scc_ir_builder_branch(scc_ir_builder_t *builder,
return node_ref;
}
scc_ir_node_ref_t scc_ir_builder_call(scc_ir_builder_t *builder,
scc_ir_func_ref_t callee,
const scc_ir_node_ref_t *args,
usize arg_count) {
scc_ir_node_t call_node = {0};
call_node.tag = SCC_IR_NODE_CALL;
scc_ir_value_ref_t scc_ir_builder_call(scc_ir_builder_t *builder,
scc_ir_func_ref_t callee,
const scc_ir_value_ref_t *args,
usize arg_count) {
scc_ir_value_t call_node = {0};
call_node.tag = SCC_IR_VALUE_TAG_CALL;
call_node.data.call.callee = callee;
scc_vec_init(call_node.data.call.args);
@@ -347,8 +350,8 @@ scc_ir_node_ref_t scc_ir_builder_call(scc_ir_builder_t *builder,
}
}
scc_ir_node_ref_t node_ref =
scc_ir_module_add_node(GET_MODULE(builder), &call_node);
scc_ir_value_ref_t node_ref =
scc_ir_module_add_value(GET_MODULE(builder), &call_node);
// 添加到当前基本块
scc_ir_builder_add_instr(builder, node_ref);
@@ -356,14 +359,14 @@ scc_ir_node_ref_t scc_ir_builder_call(scc_ir_builder_t *builder,
return node_ref;
}
scc_ir_node_ref_t scc_ir_builder_ret(scc_ir_builder_t *builder,
scc_ir_node_ref_t value) {
scc_ir_node_t ret_node = {0};
ret_node.tag = SCC_IR_NODE_RET;
scc_ir_value_ref_t scc_ir_builder_ret(scc_ir_builder_t *builder,
scc_ir_value_ref_t value) {
scc_ir_value_t ret_node = {0};
ret_node.tag = SCC_IR_VALUE_TAG_RET;
ret_node.data.ret.ret_val = value;
scc_ir_node_ref_t node_ref =
scc_ir_module_add_node(GET_MODULE(builder), &ret_node);
scc_ir_value_ref_t node_ref =
scc_ir_module_add_value(GET_MODULE(builder), &ret_node);
// 添加到当前基本块
scc_ir_builder_add_instr(builder, node_ref);
@@ -371,13 +374,13 @@ scc_ir_node_ref_t scc_ir_builder_ret(scc_ir_builder_t *builder,
return node_ref;
}
scc_ir_node_ref_t scc_ir_builder_ret_void(scc_ir_builder_t *builder) {
scc_ir_node_t ret_node = {0};
ret_node.tag = SCC_IR_NODE_RET;
scc_ir_value_ref_t scc_ir_builder_ret_void(scc_ir_builder_t *builder) {
scc_ir_value_t ret_node = {0};
ret_node.tag = SCC_IR_VALUE_TAG_RET;
ret_node.data.ret.ret_val = 0; // 无返回值
scc_ir_node_ref_t node_ref =
scc_ir_module_add_node(GET_MODULE(builder), &ret_node);
scc_ir_value_ref_t node_ref =
scc_ir_module_add_value(GET_MODULE(builder), &ret_node);
// 添加到当前基本块
scc_ir_builder_add_instr(builder, node_ref);

4
libs/ir/src/ir_ctx.c
View File

@@ -149,10 +149,10 @@ scc_ir_type_ref_t scc_ir_ctx_get_type(scc_ir_ctx_t *ctx,
return new_ref;
}
// scc_ir_node_ref_t scc_ir_ctx_get_const_int(scc_ir_ctx_t *ctx,
// scc_ir_value_ref_t scc_ir_ctx_get_const_int(scc_ir_ctx_t *ctx,
// scc_ir_type_ref_t type, i64 value)
// {
// return scc_ir_node_ref_t();
// return scc_ir_value_ref_t();
// }
scc_ir_func_ref_t scc_ir_ctx_declare_func(scc_ir_ctx_t *ctx,

242
libs/ir/src/ir_dump.c
View File

@@ -13,27 +13,29 @@
SCC_TREE_DUMP_PRINT_AROUND(ctx, ctx->value_color, "'", "%s", str)
// 获取IR节点类型的字符串表示
static const char *get_node_type_str(scc_ir_node_tag_t tag) {
static const char *get_node_type_str(scc_ir_value_tag_t tag) {
static const char *node_types[] = {
[SCC_IR_NODE_NULL] = "Null",
[SCC_IR_NODE_CONST_INT] = "ConstInt",
[SCC_IR_NODE_CONST_UINT] = "ConstUint",
[SCC_IR_NODE_CONST_FLOAT] = "ConstFloat",
[SCC_IR_NODE_CONV] = "Convert", ///< 类型转换
[SCC_IR_NODE_FUNC_ARG_REF] = "FuncArgRef", ///< 函数参数引用
[SCC_IR_NODE_BLOCK_ARG_REF] = "BlockArgRef", ///< 基本块参数引用
[SCC_IR_NODE_ALLOC] = "Alloc", ///< 分配内存(stack)
[SCC_IR_NODE_GLOBAL_ALLOC] = "GlobalAlloc", ///< 全局分配(bss)
[SCC_IR_NODE_LOAD] = "Load", ///< 加载数据
[SCC_IR_NODE_STORE] = "Store", ///< 存储数据
[SCC_IR_NODE_GET_PTR] = "GetPtr", ///< 获取指针
[SCC_IR_NODE_GET_ELEM_PTR] =
"GetElemPtr", ///< 获取元素指针(used by array)
[SCC_IR_NODE_OP] = "Op", ///< 二元运算
[SCC_IR_NODE_BRANCH] = "Branch", ///< 有条件分支
[SCC_IR_NODE_JUMP] = "Jump", ///< 无条件跳转
[SCC_IR_NODE_CALL] = "Call", ///< 调用函数
[SCC_IR_NODE_RET] = "Ret", ///< 函数返回
[SCC_IR_VALUE_TAG_NULL] = "Null",
[SCC_IR_VALUE_TAG_CONST_INT] = "ConstInt",
[SCC_IR_VALUE_TAG_CONST_UINT] = "ConstUint",
[SCC_IR_VALUE_TAG_CONST_FLOAT] = "ConstFloat",
[SCC_IR_VALUE_TAG_CONST_ARRAY] = "ConstArray",
[SCC_IR_VALUE_TAG_AGGREGATE] = "Aggregate",
[SCC_IR_VALUE_TAG_CONV] = "Convert", ///< 类型转换
[SCC_IR_VALUE_TAG_FUNC_ARG_REF] = "FuncArgRef", ///< 函数参数引用
[SCC_IR_VALUE_TAG_BLOCK_ARG_REF] = "BlockArgRef", ///< 基本块参数引用
[SCC_IR_VALUE_TAG_ALLOC] = "Alloc", ///< 分配内存(stack)
[SCC_IR_VALUE_TAG_GLOBAL_ALLOC] = "GlobalAlloc", ///< 全局分配(bss)
[SCC_IR_VALUE_TAG_LOAD] = "Load", ///< 加载数据
[SCC_IR_VALUE_TAG_STORE] = "Store", ///< 存储数据
[SCC_IR_VALUE_TAG_GET_PTR] = "GetPtr", ///< 获取指针
[SCC_IR_VALUE_TAG_GET_ELEM_PTR] =
"GetElemPtr", ///< 获取元素指针(used by array)
[SCC_IR_VALUE_TAG_OP] = "Op", ///< 二元运算
[SCC_IR_VALUE_TAG_BRANCH] = "Branch", ///< 有条件分支
[SCC_IR_VALUE_TAG_JUMP] = "Jump", ///< 无条件跳转
[SCC_IR_VALUE_TAG_CALL] = "Call", ///< 调用函数
[SCC_IR_VALUE_TAG_RET] = "Ret", ///< 函数返回
};
if (tag >= 0 && (usize)tag < sizeof(node_types) / sizeof(node_types[0]) &&
@@ -89,18 +91,18 @@ static const char *get_type_tag_str(scc_ir_type_tag_t tag) {
// 递归转储辅助函数（使用引用）
static inline void dump_child_node_ref(scc_ir_dump_ctx_t *ctx,
scc_ir_node_ref_t child_ref,
scc_ir_value_ref_t child_ref,
cbool is_last) {
if (!child_ref)
return;
scc_tree_dump_push_level(ctx->dump_ctx, is_last);
scc_ir_dump_node(ctx, child_ref);
scc_ir_dump_value(ctx, child_ref);
scc_tree_dump_pop_level(ctx->dump_ctx);
}
// 转储常量整数节点
static void dump_const_int_node(scc_ir_dump_ctx_t *ctx,
const scc_ir_node_t *node) {
const scc_ir_value_t *node) {
scc_tree_dump_push_level(ctx->dump_ctx, true);
scc_tree_print_indent(ctx->dump_ctx);
scc_tree_dump_printf(ctx->dump_ctx, "%d\n", node->data.const_int.int32);
@@ -108,7 +110,7 @@ static void dump_const_int_node(scc_ir_dump_ctx_t *ctx,
}
// 转储操作节点
static void dump_op_node(scc_ir_dump_ctx_t *ctx, const scc_ir_node_t *node) {
static void dump_op_node(scc_ir_dump_ctx_t *ctx, const scc_ir_value_t *node) {
// 打印操作符
scc_tree_dump_push_level(ctx->dump_ctx, false);
scc_tree_print_indent(ctx->dump_ctx);
@@ -129,7 +131,7 @@ static void dump_op_node(scc_ir_dump_ctx_t *ctx, const scc_ir_node_t *node) {
}
// 转储加载节点
static void dump_load_node(scc_ir_dump_ctx_t *ctx, const scc_ir_node_t *node) {
static void dump_load_node(scc_ir_dump_ctx_t *ctx, const scc_ir_value_t *node) {
// PRINT_NODE(ctx->dump_ctx, "load");
if (node->data.load.target) {
dump_child_node_ref(ctx, node->data.load.target, true);
@@ -137,7 +139,8 @@ static void dump_load_node(scc_ir_dump_ctx_t *ctx, const scc_ir_node_t *node) {
}
// 转储存储节点
static void dump_store_node(scc_ir_dump_ctx_t *ctx, const scc_ir_node_t *node) {
static void dump_store_node(scc_ir_dump_ctx_t *ctx,
const scc_ir_value_t *node) {
// PRINT_NODE(ctx->dump_ctx, "store");
// 输出存储位置
@@ -153,7 +156,7 @@ static void dump_store_node(scc_ir_dump_ctx_t *ctx, const scc_ir_node_t *node) {
// 转储获取指针节点
static void dump_get_ptr_node(scc_ir_dump_ctx_t *ctx,
const scc_ir_node_t *node) {
const scc_ir_value_t *node) {
// PRINT_NODE(ctx->dump_ctx, "get_ptr");
// 输出源地址
if (node->data.get_ptr.src_addr) {
@@ -168,7 +171,7 @@ static void dump_get_ptr_node(scc_ir_dump_ctx_t *ctx,
// 转储分支节点
static void dump_branch_node(scc_ir_dump_ctx_t *ctx,
const scc_ir_node_t *node) {
const scc_ir_value_t *node) {
// PRINT_NODE(ctx->dump_ctx, "branch");
// 输出条件
@@ -204,7 +207,7 @@ static void dump_branch_node(scc_ir_dump_ctx_t *ctx,
}
// 转储跳转节点
static void dump_jump_node(scc_ir_dump_ctx_t *ctx, const scc_ir_node_t *node) {
static void dump_jump_node(scc_ir_dump_ctx_t *ctx, const scc_ir_value_t *node) {
// PRINT_NODE(ctx->dump_ctx, "jump");
if (node->data.jump.target_bblock) {
scc_ir_bblock_t *target_bblock = scc_ir_module_get_bblock(
@@ -222,7 +225,7 @@ static void dump_jump_node(scc_ir_dump_ctx_t *ctx, const scc_ir_node_t *node) {
}
// 转储调用节点
static void dump_call_node(scc_ir_dump_ctx_t *ctx, const scc_ir_node_t *node) {
static void dump_call_node(scc_ir_dump_ctx_t *ctx, const scc_ir_value_t *node) {
// PRINT_NODE(ctx->dump_ctx, "call");
if (node->data.call.callee) {
scc_ir_func_t *callee =
@@ -246,7 +249,7 @@ static void dump_call_node(scc_ir_dump_ctx_t *ctx, const scc_ir_node_t *node) {
cbool is_last = (i + 1 == scc_vec_size(node->data.call.args));
scc_tree_dump_push_level(ctx->dump_ctx, is_last);
scc_ir_node_ref_t arg_ref = scc_vec_at(node->data.call.args, i);
scc_ir_value_ref_t arg_ref = scc_vec_at(node->data.call.args, i);
dump_child_node_ref(ctx, arg_ref, is_last);
scc_tree_dump_pop_level(ctx->dump_ctx);
@@ -254,7 +257,7 @@ static void dump_call_node(scc_ir_dump_ctx_t *ctx, const scc_ir_node_t *node) {
}
// 转储返回节点
static void dump_ret_node(scc_ir_dump_ctx_t *ctx, const scc_ir_node_t *node) {
static void dump_ret_node(scc_ir_dump_ctx_t *ctx, const scc_ir_value_t *node) {
// PRINT_NODE(ctx->dump_ctx, "ret");
if (node->data.ret.ret_val) {
dump_child_node_ref(ctx, node->data.ret.ret_val, true);
@@ -268,8 +271,8 @@ void scc_ir_dump_ctx_init(scc_ir_dump_ctx_t *ctx,
ctx->dump_ctx = tree_dump;
}
void scc_ir_dump_node(scc_ir_dump_ctx_t *ctx, scc_ir_node_ref_t node_ref) {
scc_ir_node_t *node = scc_ir_module_get_node(GET_MODULE(ctx), node_ref);
void scc_ir_dump_value(scc_ir_dump_ctx_t *ctx, scc_ir_value_ref_t node_ref) {
scc_ir_value_t *node = scc_ir_module_get_value(GET_MODULE(ctx), node_ref);
if (!node) {
LOG_ERROR("Invalid node ref");
return;
@@ -295,35 +298,35 @@ void scc_ir_dump_node(scc_ir_dump_ctx_t *ctx, scc_ir_node_ref_t node_ref) {
// 根据节点类型输出特定信息
switch (node->tag) {
case SCC_IR_NODE_NULL:
case SCC_IR_VALUE_TAG_NULL:
break;
case SCC_IR_NODE_CONST_INT:
case SCC_IR_VALUE_TAG_CONST_INT:
dump_const_int_node(ctx, node);
break;
case SCC_IR_NODE_ALLOC:
case SCC_IR_VALUE_TAG_ALLOC:
break;
case SCC_IR_NODE_LOAD:
case SCC_IR_VALUE_TAG_LOAD:
dump_load_node(ctx, node);
break;
case SCC_IR_NODE_STORE:
case SCC_IR_VALUE_TAG_STORE:
dump_store_node(ctx, node);
break;
case SCC_IR_NODE_GET_PTR:
case SCC_IR_VALUE_TAG_GET_PTR:
dump_get_ptr_node(ctx, node);
break;
case SCC_IR_NODE_OP:
case SCC_IR_VALUE_TAG_OP:
dump_op_node(ctx, node);
break;
case SCC_IR_NODE_BRANCH:
case SCC_IR_VALUE_TAG_BRANCH:
dump_branch_node(ctx, node);
break;
case SCC_IR_NODE_JUMP:
case SCC_IR_VALUE_TAG_JUMP:
dump_jump_node(ctx, node);
break;
case SCC_IR_NODE_CALL:
case SCC_IR_VALUE_TAG_CALL:
dump_call_node(ctx, node);
break;
case SCC_IR_NODE_RET:
case SCC_IR_VALUE_TAG_RET:
dump_ret_node(ctx, node);
break;
default:
@@ -429,8 +432,8 @@ void scc_ir_dump_bblock(scc_ir_dump_ctx_t *ctx,
cbool is_last = (i + 1 == scc_vec_size(bblock->instrs));
scc_tree_dump_push_level(ctx->dump_ctx, is_last);
scc_ir_node_ref_t instr_ref = scc_vec_at(bblock->instrs, i);
scc_ir_dump_node(ctx, instr_ref);
scc_ir_value_ref_t instr_ref = scc_vec_at(bblock->instrs, i);
scc_ir_dump_value(ctx, instr_ref);
scc_tree_dump_pop_level(ctx->dump_ctx);
}
}
@@ -460,8 +463,8 @@ void scc_ir_dump_func(scc_ir_dump_ctx_t *ctx, scc_ir_func_ref_t func_ref) {
cbool is_last = (i + 1 == scc_vec_size(func->params));
scc_tree_dump_push_level(ctx->dump_ctx, is_last);
scc_ir_node_ref_t param_ref = scc_vec_at(func->params, i);
scc_ir_dump_node(ctx, param_ref);
scc_ir_value_ref_t param_ref = scc_vec_at(func->params, i);
scc_ir_dump_value(ctx, param_ref);
scc_tree_dump_pop_level(ctx->dump_ctx);
}
@@ -489,10 +492,10 @@ void scc_ir_dump_cprog(scc_ir_dump_ctx_t *ctx) {
// scc_vec_size(program->global_vals));
// scc_tree_dump_push_level(ctx->dump_ctx, is_last);
// scc_ir_node_ref_t global_ref =
// scc_vec_at(program->global_vals, i); scc_ir_node_t
// scc_ir_value_ref_t global_ref =
// scc_vec_at(program->global_vals, i); scc_ir_value_t
// *global_node =
// scc_ir_module_get_node(ir_ctx, global_ref);
// scc_ir_module_get_value(ir_ctx, global_ref);
// if (global_node) {
// scc_ir_dump_node(ctx, ir_ctx, global_node);
// }
@@ -536,11 +539,23 @@ void scc_ir_dump_type_linear(scc_ir_dump_ctx_t *ctx,
}
#define PRINT_TYPE(ctx, name) PRINT_VALUE(ctx, "%s", name)
switch (type->tag) {
case SCC_IR_TYPE_i32:
PRINT_TYPE(ctx->dump_ctx, "i32");
break;
case SCC_IR_TYPE_unknown:
case SCC_IR_TYPE_void:
PRINT_TYPE(ctx->dump_ctx, "void");
case SCC_IR_TYPE_i8:
case SCC_IR_TYPE_i16:
case SCC_IR_TYPE_i32:
case SCC_IR_TYPE_i64:
case SCC_IR_TYPE_i128:
case SCC_IR_TYPE_u8:
case SCC_IR_TYPE_u16:
case SCC_IR_TYPE_u32:
case SCC_IR_TYPE_u64:
case SCC_IR_TYPE_u128:
case SCC_IR_TYPE_f16:
case SCC_IR_TYPE_f32:
case SCC_IR_TYPE_f64:
case SCC_IR_TYPE_f128:
PRINT_TYPE(ctx->dump_ctx, get_type_tag_str(type->tag));
break;
case SCC_IR_TYPE_ARRAY:
PRINT_TYPE(ctx->dump_ctx, "[");
@@ -579,14 +594,14 @@ void scc_ir_dump_type_linear(scc_ir_dump_ctx_t *ctx,
// 辅助函数：输出节点引用或值到缓冲区
static usize format_node_ref_or_value(scc_ir_dump_ctx_t *ctx, char *buf,
usize size, scc_ir_node_ref_t node_ref) {
scc_ir_node_t *node = scc_ir_module_get_node(GET_MODULE(ctx), node_ref);
usize size, scc_ir_value_ref_t node_ref) {
scc_ir_value_t *node = scc_ir_module_get_value(GET_MODULE(ctx), node_ref);
if (!node) {
return scc_snprintf(buf, size, "%%%u", node_ref);
}
// 如果是常量整数，直接输出值
if (node->tag == SCC_IR_NODE_CONST_INT) {
if (node->tag == SCC_IR_VALUE_TAG_CONST_INT) {
return scc_snprintf(buf, size, "%d", node->data.const_int.int32);
}
@@ -600,8 +615,8 @@ static usize format_node_ref_or_value(scc_ir_dump_ctx_t *ctx, char *buf,
// 线性输出节点信息（SSA IR风格）
void scc_ir_dump_node_linear(scc_ir_dump_ctx_t *ctx,
scc_ir_node_ref_t node_ref) {
scc_ir_node_t *node = scc_ir_module_get_node(GET_MODULE(ctx), node_ref);
scc_ir_value_ref_t node_ref) {
scc_ir_value_t *node = scc_ir_module_get_value(GET_MODULE(ctx), node_ref);
if (node == null) {
LOG_ERROR("invalid node ref");
return;
@@ -612,9 +627,10 @@ void scc_ir_dump_node_linear(scc_ir_dump_ctx_t *ctx,
usize remaining = sizeof(buff);
// 判断是否需要输出等号
cbool needs_equals =
(node->tag != SCC_IR_NODE_BRANCH && node->tag != SCC_IR_NODE_JUMP &&
node->tag != SCC_IR_NODE_RET && node->tag != SCC_IR_NODE_STORE);
cbool needs_equals = (node->tag != SCC_IR_VALUE_TAG_BRANCH &&
node->tag != SCC_IR_VALUE_TAG_JUMP &&
node->tag != SCC_IR_VALUE_TAG_RET &&
node->tag != SCC_IR_VALUE_TAG_STORE);
if (needs_equals) {
// 输出左值和类型
@@ -641,16 +657,38 @@ void scc_ir_dump_node_linear(scc_ir_dump_ctx_t *ctx,
// 构建操作部分
switch (node->tag) {
case SCC_IR_NODE_CONST_INT:
case SCC_IR_VALUE_TAG_CONST_INT:
// 常量节点定义，直接输出值
p += scc_snprintf(p, remaining, "%d", node->data.const_int.int32);
break;
case SCC_IR_VALUE_TAG_CONST_UINT:
scc_ir_type_t *type =
scc_ir_module_get_type(GET_MODULE(ctx), node->type);
Assert(type != null);
if (type->tag == SCC_IR_TYPE_u8) {
p += scc_snprintf(p, remaining, "%c", node->data.const_uint.uint8);
} else {
p += scc_snprintf(p, remaining, "%u", node->data.const_uint.uint32);
}
break;
case SCC_IR_VALUE_TAG_CONST_FLOAT:
p += scc_snprintf(p, remaining, "%f", node->data.const_float.float32);
break;
case SCC_IR_NODE_ALLOC:
case SCC_IR_VALUE_TAG_AGGREGATE:
scc_vec_foreach(node->data.aggregate.elements, i) {
scc_ir_value_ref_t elem_node =
scc_vec_at(node->data.aggregate.elements, i);
scc_ir_dump_node_linear(ctx, elem_node);
PRINT_NODE(ctx->dump_ctx, "\n");
}
return;
case SCC_IR_VALUE_TAG_ALLOC:
p += scc_snprintf(p, remaining, "alloc");
break;
case SCC_IR_NODE_LOAD: {
case SCC_IR_VALUE_TAG_LOAD: {
char operand_buf[64];
format_node_ref_or_value(ctx, operand_buf, sizeof(operand_buf),
node->data.load.target);
@@ -658,7 +696,7 @@ void scc_ir_dump_node_linear(scc_ir_dump_ctx_t *ctx,
break;
}
case SCC_IR_NODE_STORE: {
case SCC_IR_VALUE_TAG_STORE: {
char value_buf[64], target_buf[64];
format_node_ref_or_value(ctx, value_buf, sizeof(value_buf),
node->data.store.value);
@@ -669,17 +707,21 @@ void scc_ir_dump_node_linear(scc_ir_dump_ctx_t *ctx,
break;
}
case SCC_IR_NODE_GET_PTR: {
case SCC_IR_VALUE_TAG_GET_ELEM_PTR:
case SCC_IR_VALUE_TAG_GET_PTR: {
char src_buf[64], idx_buf[64];
format_node_ref_or_value(ctx, src_buf, sizeof(src_buf),
node->data.get_ptr.src_addr);
format_node_ref_or_value(ctx, idx_buf, sizeof(idx_buf),
node->data.get_ptr.index);
p += scc_snprintf(p, remaining, "getelemptr %s, %s", src_buf, idx_buf);
p += scc_snprintf(p, remaining, "%s %s, %s",
node->tag == SCC_IR_VALUE_TAG_GET_PTR ? "getptr"
: "getelemptr",
src_buf, idx_buf);
break;
}
case SCC_IR_NODE_OP: {
case SCC_IR_VALUE_TAG_OP: {
char lhs_buf[64], rhs_buf[64];
format_node_ref_or_value(ctx, lhs_buf, sizeof(lhs_buf),
node->data.op.lhs);
@@ -690,7 +732,7 @@ void scc_ir_dump_node_linear(scc_ir_dump_ctx_t *ctx,
break;
}
case SCC_IR_NODE_BRANCH:
case SCC_IR_VALUE_TAG_BRANCH:
if (node->data.branch.cond) {
char cond_buf[64];
format_node_ref_or_value(ctx, cond_buf, sizeof(cond_buf),
@@ -704,12 +746,12 @@ void scc_ir_dump_node_linear(scc_ir_dump_ctx_t *ctx,
}
break;
case SCC_IR_NODE_JUMP:
case SCC_IR_VALUE_TAG_JUMP:
p += scc_snprintf(p, remaining, "jmp label %%%u",
node->data.jump.target_bblock);
break;
case SCC_IR_NODE_CALL: {
case SCC_IR_VALUE_TAG_CALL: {
char node_name[256] = {0};
char args_buf[256] = {0};
char *args_p = args_buf;
@@ -736,7 +778,7 @@ void scc_ir_dump_node_linear(scc_ir_dump_ctx_t *ctx,
break;
}
case SCC_IR_NODE_RET:
case SCC_IR_VALUE_TAG_RET:
if (node->data.ret.ret_val != 0) {
char ret_buf[64];
format_node_ref_or_value(ctx, ret_buf, sizeof(ret_buf),
@@ -747,13 +789,33 @@ void scc_ir_dump_node_linear(scc_ir_dump_ctx_t *ctx,
}
break;
case SCC_IR_NODE_FUNC_ARG_REF: {
case SCC_IR_VALUE_TAG_FUNC_ARG_REF: {
p += scc_snprintf(p, remaining, "arg[%zu]", node->data.arg_ref.idx);
break;
}
case SCC_IR_VALUE_TAG_GLOBAL_ALLOC: {
scc_snprintf(p, remaining, "global %s\n", node->name);
PRINT_NODE(ctx->dump_ctx, buff);
scc_ir_dump_node_linear(ctx, node->data.global_alloc.value);
return;
}
case SCC_IR_VALUE_TAG_CONST_ARRAY: {
PRINT_NODE(ctx->dump_ctx, "const_array ");
scc_ir_dump_type_linear(ctx, node->data.const_array.base_type);
PRINT_NODE(ctx->dump_ctx, " [");
scc_vec_foreach(node->data.const_array.elements, i) {
u8 ch = scc_vec_at(node->data.const_array.elements, i);
p += scc_snprintf(p, remaining, " `%c`, ", ch ? ch : ' ');
remaining = sizeof(buff) - (p - buff);
}
p += scc_snprintf(p, remaining, " ]\n");
break;
}
default:
p += scc_snprintf(p, remaining, "<%s node %u>",
p += scc_snprintf(p, remaining, "<%s node %u>\n",
get_node_type_str(node->tag), node_ref);
break;
}
@@ -786,15 +848,15 @@ void scc_ir_dump_bblock_linear(scc_ir_dump_ctx_t *ctx,
// 打印基本块中的每条指令
for (usize i = 0; i < scc_vec_size(bblock->instrs); i++) {
scc_ir_node_ref_t node_ref = scc_vec_at(bblock->instrs, i);
scc_ir_value_ref_t node_ref = scc_vec_at(bblock->instrs, i);
PRINT_NODE(ctx->dump_ctx, "\n ");
scc_ir_dump_node_linear(ctx, node_ref);
}
}
// 线性输出函数信息
void scc_ir_dump_func_linear(scc_ir_dump_ctx_t *ctx,
scc_ir_func_ref_t func_ref) {
void scc_ir_dump_func_linear(scc_ir_dump_ctx_t *ctx, scc_ir_func_ref_t func_ref,
int is_decl) {
scc_ir_func_t *func = scc_ir_module_get_func(GET_MODULE(ctx), func_ref);
if (!func) {
LOG_ERROR("invalid function reference");
@@ -817,10 +879,10 @@ void scc_ir_dump_func_linear(scc_ir_dump_ctx_t *ctx,
for (usize i = 0; i < scc_vec_size(func->params); i++) {
if (i > 0)
PRINT_NODE(ctx->dump_ctx, ", ");
scc_ir_node_ref_t param_ref = scc_vec_at(func->params, i);
scc_ir_value_ref_t param_ref = scc_vec_at(func->params, i);
PRINT_NODE(ctx->dump_ctx, "%");
scc_ir_node_t *param_node =
scc_ir_module_get_node(GET_MODULE(ctx), param_ref);
scc_ir_value_t *param_node =
scc_ir_module_get_value(GET_MODULE(ctx), param_ref);
if (param_node && param_node->name && param_node->name[0] != '\0') {
scc_snprintf(buff, sizeof(buff), "%u[%s]", param_ref,
param_node->name);
@@ -838,6 +900,11 @@ void scc_ir_dump_func_linear(scc_ir_dump_ctx_t *ctx,
PRINT_NODE(ctx->dump_ctx, ": ");
scc_ir_dump_type_linear(ctx, func->type);
if (is_decl) {
PRINT_NODE(ctx->dump_ctx, ";\n");
return;
}
PRINT_NODE(ctx->dump_ctx, " {\n");
// 打印基本块
@@ -852,15 +919,20 @@ void scc_ir_dump_func_linear(scc_ir_dump_ctx_t *ctx,
// 线性输出整个程序
void scc_ir_dump_cprog_linear(scc_ir_dump_ctx_t *ctx) {
scc_vec_foreach(ctx->cprog->global_vals, i) {
scc_ir_value_ref_t node_ref = scc_vec_at(ctx->cprog->global_vals, i);
scc_ir_dump_node_linear(ctx, node_ref);
}
scc_vec_foreach(ctx->cprog->func_decls, i) {
scc_ir_func_ref_t func_decl = scc_vec_at(ctx->cprog->func_decls, i);
scc_ir_func_t *func =
scc_ir_module_get_func(GET_MODULE(ctx), func_decl);
Assert(func != null);
if (scc_vec_size(func->bblocks) == 0)
scc_ir_dump_func_linear(ctx, func_decl);
scc_ir_dump_func_linear(ctx, func_decl, true);
}
scc_vec_foreach(ctx->cprog->func_defs, i) {
scc_ir_dump_func_linear(ctx, scc_vec_at(ctx->cprog->func_defs, i));
scc_ir_dump_func_linear(ctx, scc_vec_at(ctx->cprog->func_defs, i),
false);
}
}

137
libs/ir/src/ir_module.c Normal file
View File

@@ -0,0 +1,137 @@
#include <ir_module.h>
static u32 hash_key(const void *key) { return (u32)(usize)key; }
static int cmp_key(const void *key1, const void *key2) {
return (u32)(usize)key1 != (u32)(usize)key2;
}
void scc_ir_module_init(scc_ir_module_t *ctx) {
scc_vec_init(ctx->values);
scc_vec_init(ctx->types);
scc_vec_init(ctx->bblocks);
scc_vec_init(ctx->funcs);
scc_hashtable_init(&ctx->uid2value, hash_key, cmp_key);
scc_hashtable_init(&ctx->uid2type, hash_key, cmp_key);
scc_hashtable_init(&ctx->uid2bblock, hash_key, cmp_key);
scc_hashtable_init(&ctx->uid2func, hash_key, cmp_key);
// 预留UID 0 作为无效引用
ctx->value_uid = 1;
ctx->type_uid = 1;
ctx->bblock_uid = 1;
ctx->func_uid = 1;
}
void scc_ir_module_drop(scc_ir_module_t *ctx) {
// 释放所有实体的内部内存
for (usize i = 0; i < ctx->values.size; i++) {
scc_ir_value_t *node = &ctx->values.data[i];
scc_vec_free(node->used_by);
if (node->tag == SCC_IR_VALUE_TAG_CALL) {
scc_vec_free(node->data.call.args);
}
}
for (usize i = 0; i < ctx->types.size; i++) {
scc_ir_type_t *type = &ctx->types.data[i];
if (type->tag == SCC_IR_TYPE_FUNC) {
scc_vec_free(type->data.function.params);
}
}
for (usize i = 0; i < ctx->bblocks.size; i++) {
scc_ir_bblock_t *bblock = &ctx->bblocks.data[i];
scc_vec_free(bblock->instrs);
}
for (usize i = 0; i < ctx->funcs.size; i++) {
scc_ir_func_t *func = &ctx->funcs.data[i];
scc_vec_free(func->params);
scc_vec_free(func->bblocks);
}
scc_vec_free(ctx->values);
scc_vec_free(ctx->types);
scc_vec_free(ctx->bblocks);
scc_vec_free(ctx->funcs);
scc_hashtable_drop(&ctx->uid2value);
scc_hashtable_drop(&ctx->uid2type);
scc_hashtable_drop(&ctx->uid2bblock);
scc_hashtable_drop(&ctx->uid2func);
}
// 辅助宏：创建实体并添加到哈希表
#define CREATE_ENTITY(ctx, vec, uid, data, hashtable) \
do { \
/* 分配新UID */ \
unsigned new_uid = (ctx)->uid++; \
/* 添加到向量 */ \
scc_vec_push((vec), *(data)); \
/* 添加到哈希表 */ \
scc_hashtable_set(&(ctx)->hashtable, (const void *)(usize)new_uid, \
(void *)(usize)(scc_vec_size(vec) - 1)); \
return new_uid; \
} while (0)
scc_ir_type_ref_t scc_ir_module_add_type(scc_ir_module_t *ctx,
const scc_ir_type_t *type) {
CREATE_ENTITY(ctx, ctx->types, type_uid, type, uid2type);
}
scc_ir_value_ref_t scc_ir_module_add_value(scc_ir_module_t *ctx,
const scc_ir_value_t *node) {
CREATE_ENTITY(ctx, ctx->values, value_uid, node, uid2value);
}
scc_ir_bblock_ref_t scc_ir_module_add_bblock(scc_ir_module_t *ctx,
const scc_ir_bblock_t *bblock) {
CREATE_ENTITY(ctx, ctx->bblocks, bblock_uid, bblock, uid2bblock);
}
scc_ir_func_ref_t scc_ir_module_add_func(scc_ir_module_t *ctx,
const scc_ir_func_t *func) {
CREATE_ENTITY(ctx, ctx->funcs, func_uid, func, uid2func);
}
// 辅助宏：从哈希表获取索引
#define GET_ENTITY_INDEX(ctx, ref, hashtable) \
((usize)scc_hashtable_get(&(ctx)->hashtable, (void *)(usize)ref))
scc_ir_type_t *scc_ir_module_get_type(scc_ir_module_t *ctx,
scc_ir_type_ref_t ref) {
if (ref == 0)
return null;
usize idx = GET_ENTITY_INDEX(ctx, ref, uid2type);
if (idx >= ctx->types.size)
return null;
return &ctx->types.data[idx];
}
scc_ir_value_t *scc_ir_module_get_value(scc_ir_module_t *ctx,
scc_ir_value_ref_t ref) {
if (ref == 0)
return null;
usize idx = GET_ENTITY_INDEX(ctx, ref, uid2value);
if (idx >= ctx->values.size)
return null;
return &ctx->values.data[idx];
}
scc_ir_bblock_t *scc_ir_module_get_bblock(scc_ir_module_t *ctx,
scc_ir_bblock_ref_t ref) {
if (ref == 0)
return null;
usize idx = GET_ENTITY_INDEX(ctx, ref, uid2bblock);
if (idx >= ctx->bblocks.size)
return null;
return &ctx->bblocks.data[idx];
}
scc_ir_func_t *scc_ir_module_get_func(scc_ir_module_t *ctx,
scc_ir_func_ref_t ref) {
if (ref == 0)
return null;
usize idx = GET_ENTITY_INDEX(ctx, ref, uid2func);
if (idx >= ctx->funcs.size)
return null;
return &ctx->funcs.data[idx];
}

136
libs/ir/src/ir_prog.c
View File

@@ -13,139 +13,3 @@ void scc_ir_cprog_drop(scc_ir_cprog_t *in) {
scc_vec_free(in->global_vals);
scc_ir_module_drop(&in->module);
}
static u32 hash_key(const void *key) { return (u32)(usize)key; }
static int cmp_key(const void *key1, const void *key2) {
return (u32)(usize)key1 != (u32)(usize)key2;
}
void scc_ir_module_init(scc_ir_module_t *ctx) {
scc_vec_init(ctx->nodes);
scc_vec_init(ctx->types);
scc_vec_init(ctx->bblocks);
scc_vec_init(ctx->funcs);
scc_hashtable_init(&ctx->uid2nodes, hash_key, cmp_key);
scc_hashtable_init(&ctx->uid2types, hash_key, cmp_key);
scc_hashtable_init(&ctx->uid2bblocks, hash_key, cmp_key);
scc_hashtable_init(&ctx->uid2funcs, hash_key, cmp_key);
// 预留UID 0 作为无效引用
ctx->node_uid = 1;
ctx->type_uid = 1;
ctx->bblock_uid = 1;
ctx->func_uid = 1;
}
void scc_ir_module_drop(scc_ir_module_t *ctx) {
// 释放所有实体的内部内存
for (usize i = 0; i < ctx->nodes.size; i++) {
scc_ir_node_t *node = &ctx->nodes.data[i];
scc_vec_free(node->used_by);
if (node->tag == SCC_IR_NODE_CALL) {
scc_vec_free(node->data.call.args);
}
}
for (usize i = 0; i < ctx->types.size; i++) {
scc_ir_type_t *type = &ctx->types.data[i];
if (type->tag == SCC_IR_TYPE_FUNC) {
scc_vec_free(type->data.function.params);
}
}
for (usize i = 0; i < ctx->bblocks.size; i++) {
scc_ir_bblock_t *bblock = &ctx->bblocks.data[i];
scc_vec_free(bblock->instrs);
}
for (usize i = 0; i < ctx->funcs.size; i++) {
scc_ir_func_t *func = &ctx->funcs.data[i];
scc_vec_free(func->params);
scc_vec_free(func->bblocks);
}
scc_vec_free(ctx->nodes);
scc_vec_free(ctx->types);
scc_vec_free(ctx->bblocks);
scc_vec_free(ctx->funcs);
scc_hashtable_drop(&ctx->uid2nodes);
scc_hashtable_drop(&ctx->uid2types);
scc_hashtable_drop(&ctx->uid2bblocks);
scc_hashtable_drop(&ctx->uid2funcs);
}
// 辅助宏：创建实体并添加到哈希表
#define CREATE_ENTITY(ctx, vec, uid, data, hashtable) \
do { \
/* 分配新UID */ \
unsigned new_uid = (ctx)->uid++; \
/* 添加到向量 */ \
scc_vec_push((vec), *(data)); \
/* 添加到哈希表 */ \
scc_hashtable_set(&(ctx)->hashtable, (const void *)(usize)new_uid, \
(void *)(usize)(scc_vec_size(vec) - 1)); \
return new_uid; \
} while (0)
scc_ir_type_ref_t scc_ir_module_add_type(scc_ir_module_t *ctx,
const scc_ir_type_t *type) {
CREATE_ENTITY(ctx, ctx->types, type_uid, type, uid2types);
}
scc_ir_node_ref_t scc_ir_module_add_node(scc_ir_module_t *ctx,
const scc_ir_node_t *node) {
CREATE_ENTITY(ctx, ctx->nodes, node_uid, node, uid2nodes);
}
scc_ir_bblock_ref_t scc_ir_module_add_bblock(scc_ir_module_t *ctx,
const scc_ir_bblock_t *bblock) {
CREATE_ENTITY(ctx, ctx->bblocks, bblock_uid, bblock, uid2bblocks);
}
scc_ir_func_ref_t scc_ir_module_add_func(scc_ir_module_t *ctx,
const scc_ir_func_t *func) {
CREATE_ENTITY(ctx, ctx->funcs, func_uid, func, uid2funcs);
}
// 辅助宏：从哈希表获取索引
#define GET_ENTITY_INDEX(ctx, ref, hashtable) \
((usize)scc_hashtable_get(&(ctx)->hashtable, (void *)(usize)ref))
scc_ir_type_t *scc_ir_module_get_type(scc_ir_module_t *ctx,
scc_ir_type_ref_t ref) {
if (ref == 0)
return null;
usize idx = GET_ENTITY_INDEX(ctx, ref, uid2types);
if (idx >= ctx->types.size)
return null;
return &ctx->types.data[idx];
}
scc_ir_node_t *scc_ir_module_get_node(scc_ir_module_t *ctx,
scc_ir_node_ref_t ref) {
if (ref == 0)
return null;
usize idx = GET_ENTITY_INDEX(ctx, ref, uid2nodes);
if (idx >= ctx->nodes.size)
return null;
return &ctx->nodes.data[idx];
}
scc_ir_bblock_t *scc_ir_module_get_bblock(scc_ir_module_t *ctx,
scc_ir_bblock_ref_t ref) {
if (ref == 0)
return null;
usize idx = GET_ENTITY_INDEX(ctx, ref, uid2bblocks);
if (idx >= ctx->bblocks.size)
return null;
return &ctx->bblocks.data[idx];
}
scc_ir_func_t *scc_ir_module_get_func(scc_ir_module_t *ctx,
scc_ir_func_ref_t ref) {
if (ref == 0)
return null;
usize idx = GET_ENTITY_INDEX(ctx, ref, uid2funcs);
if (idx >= ctx->funcs.size)
return null;
return &ctx->funcs.data[idx];
}

26
libs/ir/src/scc_ir.c
View File

@@ -55,8 +55,8 @@ void scc_ir_func_init(scc_ir_func_t *in, const char *name) {
scc_vec_init(in->params);
}
void scc_ir_node_init(scc_ir_node_t *in, const char *name,
scc_ir_node_tag_t tag) {
void scc_ir_node_init(scc_ir_value_t *in, const char *name,
scc_ir_value_tag_t tag) {
Assert(in != null);
in->name = name;
in->tag = tag;
@@ -64,44 +64,44 @@ void scc_ir_node_init(scc_ir_node_t *in, const char *name,
in->type = 0;
switch (tag) {
case SCC_IR_NODE_NULL:
case SCC_IR_VALUE_TAG_NULL:
break;
case SCC_IR_NODE_CONST_INT:
case SCC_IR_VALUE_TAG_CONST_INT:
// TODO
in->data.const_int.int64 = 0;
break;
case SCC_IR_NODE_ALLOC:
case SCC_IR_VALUE_TAG_ALLOC:
// TODO();
break;
case SCC_IR_NODE_LOAD:
case SCC_IR_VALUE_TAG_LOAD:
in->data.load.target = 0;
break;
case SCC_IR_NODE_STORE:
case SCC_IR_VALUE_TAG_STORE:
in->data.store.target = 0;
in->data.store.value = 0;
break;
case SCC_IR_NODE_GET_PTR:
case SCC_IR_VALUE_TAG_GET_PTR:
in->data.get_ptr.src_addr = 0;
in->data.get_ptr.index = 0;
break;
case SCC_IR_NODE_OP:
case SCC_IR_VALUE_TAG_OP:
in->data.op.op = SCC_IR_OP_EMPTY;
in->data.op.lhs = 0;
in->data.op.rhs = 0;
break;
case SCC_IR_NODE_BRANCH:
case SCC_IR_VALUE_TAG_BRANCH:
in->data.branch.cond = 0;
in->data.branch.true_bblock = 0;
in->data.branch.false_bblock = 0;
break;
case SCC_IR_NODE_JUMP:
case SCC_IR_VALUE_TAG_JUMP:
in->data.jump.target_bblock = 0;
break;
case SCC_IR_NODE_CALL:
case SCC_IR_VALUE_TAG_CALL:
scc_vec_init(in->data.call.args);
in->data.call.callee = 0;
break;
case SCC_IR_NODE_RET:
case SCC_IR_VALUE_TAG_RET:
in->data.ret.ret_val = 0;
break;
default: