feat(ast): 重构AST转储功能并创建AST到IR转换器

- 重构ast_dump.c中的宏定义，简化PRINT_VALUE、PRINT_NODE、
  PRINT_QUOTED_VALUE等宏的实现
- 移除冗余的PRINT_COLORED宏定义
- 统一使用SCC_TREE_DUMP_PRINT_PURE和SCC_TREE_DUMP_PRINT_AROUND
  宏进行转储输出
- 在dump_stmt_impl函数中优化节点转储逻辑，统一使用end_node_dump
  替代手动换行
- 添加对未知节点类型的警告日志输出
- 创建新的ast2ir模块，包含AST到IR的基本转换功能
- 实现ast_type_to_ir_type、ast_expr_to_ir、ast_stmt_to_ir、
  ast_decl_to_ir等核心转换函数
- 更新IR库依赖配置，添加scc_utils和tree_dump依赖
- 新增IR基础接口定义文件ir_base.h和IR构建器接口ir_builder.h

libs/ast/src/ast_dump.c

@@ -5,27 +5,14 @@
 
 #include <ast_dump.h>
 
-// 通用宏定义
+#define PRINT_VALUE(ctx, fmt, value)                                           \
-#define PRINT_COLORED(ctx, color_field, fmt, ...)                              \
+    SCC_TREE_DUMP_PRINT_PURE(ctx, ctx->value_color, fmt, value)
-    do {                                                                       \
-        if (ctx->use_color) {                                                  \
-            scc_printf("%s" fmt "%s", ctx->color_field, ##__VA_ARGS__,         \
-                       ctx->reset_color);                                      \
-        } else {                                                               \
-            scc_printf(fmt, ##__VA_ARGS__);                                    \
-        }                                                                      \
-    } while (0)
 
-#define PRINT_VALUE(ctx, fmt, ...)                                             \
+#define PRINT_NODE(ctx, name, value)                                           \
-    PRINT_COLORED(ctx, value_color, fmt, ##__VA_ARGS__)
+    SCC_TREE_DUMP_PRINT_PURE(ctx, ctx->node_color, "%s", name)
 
-#define PRINT_NODE_TYPE(ctx, node)                                             \
+#define PRINT_QUOTED_VALUE(ctx, str)                                           \
-    PRINT_COLORED(ctx, node_color, "%s", get_node_type_str(node->type))
+    SCC_TREE_DUMP_PRINT_AROUND(ctx, ctx->value_color, "'", "%s", str)
-
-#define PRINT_QUOTED_VALUE(ctx, value)                                         \
-    do {                                                                       \
-        PRINT_VALUE(ctx, "'%s'", value);                                       \
-    } while (0)
 
 // 获取节点类型的字符串表示
 static const char *get_node_type_str(scc_ast_node_type_t type) {
@@ -267,7 +254,8 @@ static const char *get_op_str(scc_ast_expr_op_t op) {
 static inline void start_node_dump(scc_ast_node_t *node,
                                    scc_tree_dump_ctx_t *ctx) {
     scc_tree_print_indent(ctx);
-    PRINT_NODE_TYPE(ctx, node);
+    SCC_TREE_DUMP_PRINT_PURE(ctx, ctx->node_color, "%s",
+                             get_node_type_str(node->type));
 }
 
 // 通用的结束节点打印函数
@@ -455,8 +443,7 @@ static void dump_expr_impl(scc_ast_expr_t *expr, scc_tree_dump_ctx_t *ctx) {
         dump_child_node((scc_ast_node_t *)expr->member.base, ctx, false);
         // 打印成员访问信息
         scc_tree_print_indent(ctx);
-        PRINT_COLORED(ctx, node_color, "Member [\"%s\"]",
+        PRINT_NODE(ctx, "Member [\"%s\"]", expr->member.member_name);
-                      expr->member.member_name);
         scc_printf("\n");
         break;
 
@@ -496,11 +483,10 @@ static void dump_stmt_impl(scc_ast_stmt_t *stmt, scc_tree_dump_ctx_t *ctx) {
         return;
 
     start_node_dump(&stmt->base, ctx);
-
     // 根据语句类型输出特定信息
     switch (stmt->base.type) {
     case SCC_AST_STMT_IF:
-        scc_printf("\n"); // if语句总是换行显示子节点
+        end_node_dump(ctx);
         dump_child_node((scc_ast_node_t *)stmt->if_stmt.cond, ctx, false);
         dump_child_node((scc_ast_node_t *)stmt->if_stmt.then_stmt, ctx,
                         !stmt->if_stmt.opt_else_stmt);
@@ -510,22 +496,22 @@ static void dump_stmt_impl(scc_ast_stmt_t *stmt, scc_tree_dump_ctx_t *ctx) {
         }
         return;
     case SCC_AST_STMT_WHILE:
-        scc_printf("\n"); // 循环和switch语句换行显示子节点
+        end_node_dump(ctx);
         dump_child_node((scc_ast_node_t *)stmt->while_stmt.cond, ctx, false);
         dump_child_node((scc_ast_node_t *)stmt->while_stmt.body, ctx, true);
         return;
     case SCC_AST_STMT_DO_WHILE:
-        scc_printf("\n"); // 循环和switch语句换行显示子节点
+        end_node_dump(ctx);
         dump_child_node((scc_ast_node_t *)stmt->do_while_stmt.body, ctx, false);
         dump_child_node((scc_ast_node_t *)stmt->do_while_stmt.cond, ctx, true);
         return;
     case SCC_AST_STMT_SWITCH:
-        scc_printf("\n"); // 循环和switch语句换行显示子节点
+        end_node_dump(ctx);
         dump_child_node((scc_ast_node_t *)stmt->switch_stmt.cond, ctx, false);
         dump_child_node((scc_ast_node_t *)stmt->switch_stmt.body, ctx, true);
         return;
     case SCC_AST_STMT_FOR:
-        scc_printf("\n"); // for语句换行显示子节点
+        end_node_dump(ctx);
         if (stmt->for_stmt.init) {
             dump_child_node((scc_ast_node_t *)stmt->for_stmt.init, ctx, false);
         }
@@ -539,31 +525,27 @@ static void dump_stmt_impl(scc_ast_stmt_t *stmt, scc_tree_dump_ctx_t *ctx) {
         return;
     case SCC_AST_STMT_RETURN:
         if (stmt->return_stmt.expr) {
-            scc_printf("\n");
+            end_node_dump(ctx);
             dump_child_node((scc_ast_node_t *)stmt->return_stmt.expr, ctx,
                             true);
-            return;
+        } else {
+            end_node_dump(ctx);
         }
         break;
     case SCC_AST_STMT_GOTO:
         if (stmt->goto_stmt.label) {
             PRINT_VALUE(ctx, " Label: %s", stmt->goto_stmt.label);
         }
+        end_node_dump(ctx);
         break;
     case SCC_AST_STMT_LABEL:
         if (stmt->label_stmt.label) {
             PRINT_VALUE(ctx, " %s", stmt->label_stmt.label);
         }
-        break;
-    default:
-        break;
-    }
-
         end_node_dump(ctx);
-
+        break;
-    // 递归转储其他子节点
-    switch (stmt->base.type) {
     case SCC_AST_STMT_COMPOUND:
+        end_node_dump(ctx);
         for (size_t i = 0; i < stmt->compound.block_items.size; i++) {
             scc_ast_node_t *item =
                 (scc_ast_node_t *)stmt->compound.block_items.data[i];
@@ -573,21 +555,25 @@ static void dump_stmt_impl(scc_ast_stmt_t *stmt, scc_tree_dump_ctx_t *ctx) {
         break;
 
     case SCC_AST_STMT_EXPR:
+        end_node_dump(ctx);
         if (stmt->expr.expr) {
             dump_child_node((scc_ast_node_t *)stmt->expr.expr, ctx, true);
         }
         break;
 
     case SCC_AST_STMT_CASE:
+        end_node_dump(ctx);
         dump_child_node((scc_ast_node_t *)stmt->case_stmt.expr, ctx, false);
         dump_child_node((scc_ast_node_t *)stmt->case_stmt.stmt, ctx, true);
         break;
 
     case SCC_AST_STMT_DEFAULT:
+        end_node_dump(ctx);
         dump_child_node((scc_ast_node_t *)stmt->default_stmt.stmt, ctx, true);
         break;
 
     default:
+        LOG_WARN("unknown node type %d", stmt->base.type);
         break;
     }
 }
@@ -705,8 +691,7 @@ static void dump_unit_impl(scc_ast_translation_unit_t *unit,
         return;
 
     start_node_dump(&unit->base, ctx);
-    scc_printf("\n");
+    end_node_dump(ctx);
-
     for (size_t i = 0; i < unit->declarations.size; i++) {
         dump_child_node((scc_ast_node_t *)unit->declarations.data[i], ctx,
                         i == unit->declarations.size - 1);

libs/ast2ir/cbuild.toml

@@ -0,0 +1,9 @@
+[package]
+name = ""
+version = "0.1.0"
+authors = []
+description = ""
+
+# dependencies = []
+# features = {}
+# default_features = []

libs/ast2ir/include/scc_ast2ir.h

@@ -0,0 +1,10 @@
+#ifndef __SCC_AST2IR_H__
+#define __SCC_AST2IR_H__
+
+#include <lexer_token.h>
+#include <scc_ast.h>
+#include <scc_ir.h>
+
+void scc_ast2ir(scc_ast_translation_unit_t *tu, scc_ir_builder_t *builder);
+
+#endif /* __SCC_AST2IR_H__ */

libs/ast2ir/src/ast2ir.c

@@ -0,0 +1,553 @@
+#include <ir_builtin.h>
+#include <scc_ast2ir.h>
+
+static scc_ir_node_ref_t ast_expr_to_ir(scc_ir_builder_t *ctx,
+                                        scc_ast_expr_t *expr);
+static void ast_stmt_to_ir(scc_ir_builder_t *ctx, scc_ast_stmt_t *stmt);
+static void ast_decl_to_ir(scc_ir_builder_t *ctx, scc_ast_decl_t *decl);
+static scc_ir_type_ref_t ast_type_to_ir_type(scc_ir_builder_t *ctx,
+                                             scc_ast_type_t *ast_type);
+
+// 转换AST类型为IR类型
+static scc_ir_type_ref_t ast_type_to_ir_type(scc_ir_builder_t *ctx,
+                                             scc_ast_type_t *ast_type) {
+    if (ctx == null || ast_type == null) {
+        LOG_ERROR("args is null");
+        return 0;
+    }
+    scc_ir_type_t ir_type;
+
+    switch (ast_type->base.type) {
+    case SCC_AST_TYPE_BUILTIN: {
+        // 映射内置类型
+        scc_ir_type_init(&ir_type, SCC_IR_TYPE_I32);
+        // TODO: 根据具体内置类型设置
+        break;
+    }
+
+    case SCC_AST_TYPE_POINTER: {
+        scc_ir_type_init(&ir_type, SCC_IR_TYPE_PTR);
+
+        // 创建指向类型并添加到程序类型列表
+        scc_ir_type_ref_t pointee_type =
+            ast_type_to_ir_type(ctx, ast_type->pointer.pointee);
+
+        // 注意：我们需要找到一种合适的方式来存储类型信息
+        // 目前的IR设计中类型信息应该直接存储在类型结构中
+        ir_type.data.pointer.base = pointee_type;
+        break;
+    }
+
+    case SCC_AST_TYPE_ARRAY: {
+        scc_ir_type_init(&ir_type, SCC_IR_TYPE_ARRAY);
+
+        // 创建元素类型并添加到程序类型列表
+        scc_ir_type_ref_t element_type =
+            ast_type_to_ir_type(ctx, ast_type->array.element);
+
+        // 将类型添加到程序的类型容器中
+        ir_type.data.array.base = element_type;
+        // TODO: 处理数组大小表达式
+        ir_type.data.array.len = 0; // 暂时设为0
+        break;
+    }
+
+    case SCC_AST_TYPE_FUNCTION: {
+        scc_ir_type_init(&ir_type, SCC_IR_TYPE_FUNC);
+
+        // 处理返回类型
+        scc_ir_type_ref_t ret_type =
+            ast_type_to_ir_type(ctx, ast_type->function.return_type);
+
+        // 将返回类型添加到程序的类型容器中
+        ir_type.data.function.ret_type = ret_type;
+
+        // 转换参数类型
+        scc_ir_type_ref_vec_t params;
+        scc_vec_init(params);
+        scc_vec_foreach(ast_type->function.param_types, i) {
+            scc_ast_type_t *param_type =
+                scc_vec_at(ast_type->function.param_types, i);
+            scc_ir_type_ref_t tmp_type = ast_type_to_ir_type(ctx, param_type);
+            scc_vec_push(params, tmp_type);
+        }
+        ir_type.data.function.params = params;
+        break;
+    }
+
+    default:
+        LOG_FATAL("Unsupported AST type: %d", ast_type->base.type);
+        return 0;
+    }
+    return scc_ir_ctx_new_type(&ctx->ctx, &ir_type);
+}
+
+// 转换AST表达式为IR节点
+static scc_ir_node_ref_t ast_expr_to_ir(scc_ir_builder_t *ctx,
+                                        scc_ast_expr_t *expr) {
+    if (ctx == null || expr == null) {
+        LOG_ERROR("args is null");
+        return 0;
+    }
+
+    switch (expr->base.type) {
+    case SCC_AST_EXPR_IDENTIFIER: {
+        // TODO maybe error or need symtab
+        scc_ir_node_t in;
+        scc_ir_node_init(&in, expr->identifier.name, SCC_IR_NODE_LOAD);
+        return scc_ir_ctx_new_node(&ctx->ctx, &in);
+    }
+
+    case SCC_AST_EXPR_INT_LITERAL: {
+        return scc_ir_ctx_get_i32_const(&ctx->ctx, expr->literal.value.i);
+    }
+
+    case SCC_AST_EXPR_BINARY: {
+        // 转换左右操作数
+        scc_ir_node_ref_t lhs, rhs;
+        lhs = ast_expr_to_ir(ctx, expr->binary.lhs);
+        rhs = ast_expr_to_ir(ctx, expr->binary.rhs);
+
+        // 映射操作符
+        scc_ir_op_type_t op;
+        switch (expr->binary.op) {
+            /* clang-format off */
+        case SCC_AST_OP_ADD: op = IR_OP_ADD; break;
+        case SCC_AST_OP_SUB: op = IR_OP_SUB; break;
+        case SCC_AST_OP_MUL: op = IR_OP_MUL; break;
+        case SCC_AST_OP_DIV: op = IR_OP_DIV; break;
+        case SCC_AST_OP_MOD: op = IR_OP_MOD; break;
+        case SCC_AST_OP_LOGICAL_AND: op = IR_OP_AND; break;
+        case SCC_AST_OP_LOGICAL_OR:  op = IR_OP_OR;  break;
+        case SCC_AST_OP_BITWISE_XOR: op = IR_OP_XOR; break;
+        case SCC_AST_OP_LEFT_SHIFT:  op = IR_OP_SHL; break;
+        case SCC_AST_OP_RIGHT_SHIFT: op = IR_OP_SHR; break;
+        case SCC_AST_OP_EQUAL:       op = IR_OP_EQ;  break;
+        case SCC_AST_OP_NOT_EQUAL:   op = IR_OP_NEQ; break;
+        case SCC_AST_OP_LESS:        op = IR_OP_LT;  break;
+        case SCC_AST_OP_LESS_EQUAL:  op = IR_OP_LE;  break;
+        case SCC_AST_OP_GREATER:     op = IR_OP_GT;  break;
+        case SCC_AST_OP_GREATER_EQUAL: op = IR_OP_GE;  break;
+        case SCC_AST_OP_ASSIGN: {
+            // 赋值表达式：存储右值到左值位置
+            return scc_ir_builder_store(ctx, lhs, rhs);
+            
+        }
+        case SCC_AST_OP_ASSIGN_ADD:
+            TODO();
+            /* clang-format on */
+        default:
+            LOG_WARN("Unsupported binary operator: %d", expr->binary.op);
+            op = IR_OP_ADD; // 默认
+        }
+
+        // 创建操作节点
+        return scc_ir_builder_binop(ctx, op, lhs, rhs);
+    }
+
+    case SCC_AST_EXPR_UNARY: {
+        // 转换操作数
+        scc_ir_node_ref_t operand = ast_expr_to_ir(ctx, expr->unary.operand);
+
+        // 映射一元操作符
+        switch (expr->unary.op) {
+        case SCC_TOK_SUB:
+            // 负号
+            // 实现为0 - operand
+            return scc_ir_builder_binop(ctx, IR_OP_SUB,
+                                        scc_ir_ctx_get_builtin_zero(&ctx->ctx),
+                                        operand);
+        case SCC_TOK_BIT_NOT:
+            // 按位取反
+            return scc_ir_builder_binop(ctx, IR_OP_NOT, operand, 0);
+        case SCC_TOK_NOT:
+            // 逻辑非
+            // 实现为与0比较
+            return scc_ir_builder_binop(
+                ctx, IR_OP_EQ, scc_ir_ctx_get_builtin_zero(&ctx->ctx), operand);
+        default:
+            LOG_WARN("Unsupported unary operator: %d", expr->unary.op);
+            return 0;
+        }
+    }
+
+    case SCC_AST_EXPR_COND: {
+        TODO();
+        break;
+    }
+
+    case SCC_AST_EXPR_CALL: {
+        // 转换参数
+        scc_ir_node_ref_vec_t args;
+        scc_vec_init(args);
+
+        // 检查参数是否为空
+        if (expr->call.args.data != null) {
+            scc_vec_foreach(expr->call.args, i) {
+                scc_ast_expr_t *arg_expr = scc_vec_at(expr->call.args, i);
+                scc_ir_node_ref_t arg_node;
+                arg_node = ast_expr_to_ir(ctx, arg_expr);
+                scc_vec_push(args, arg_node);
+            }
+        }
+
+        // 创建调用节点（需要查找函数定义）
+        // TODO: 需要符号表查找函数
+        scc_ir_node_ref_t func =
+            scc_ir_builder_call(ctx, 0, args.data, args.size);
+        scc_vec_free(args);
+        return func;
+    }
+
+    default:
+        LOG_WARN("Unsupported expression type: %d", expr->base.type);
+        return 0;
+    }
+}
+
+// 转换AST语句为IR
+static void ast_stmt_to_ir(scc_ir_builder_t *ctx, scc_ast_stmt_t *stmt) {
+    if (stmt == null) {
+        return;
+    }
+
+    switch (stmt->base.type) {
+    case SCC_AST_STMT_COMPOUND: {
+        // 进入新的作用域
+        scc_vec_foreach(stmt->compound.block_items, i) {
+            scc_ast_node_t *child_stmt =
+                scc_vec_at(stmt->compound.block_items, i);
+            if (SCC_AST_IS_A(scc_ast_stmt_t, child_stmt)) {
+                ast_stmt_to_ir(ctx,
+                               SCC_AST_CAST_TO(scc_ast_stmt_t, child_stmt));
+            } else if (SCC_AST_IS_A(scc_ast_decl_t, child_stmt)) {
+                ast_decl_to_ir(ctx,
+                               SCC_AST_CAST_TO(scc_ast_decl_t, child_stmt));
+            } else {
+                UNREACHABLE();
+            }
+        }
+        break;
+    }
+
+    case SCC_AST_STMT_EXPR: {
+        ast_expr_to_ir(ctx, stmt->expr.expr);
+        break;
+    }
+
+        // case SCC_AST_STMT_IF: {
+        //     // 创建基本块 - 统一使用栈上分配
+        //     scc_ir_bblock_t true_block;
+        //     scc_ir_bblock_init(&true_block, "if_true");
+
+        //     scc_ir_bblock_t false_block;
+        //     scc_ir_bblock_init(&false_block, "if_false");
+
+        //     scc_ir_bblock_t merge_block;
+        //     scc_ir_bblock_init(&merge_block, "if_merge");
+
+        //     // 转换条件
+        //     scc_ir_node_ref_t cond_node = ast_expr_to_ir(ctx,
+        //     stmt->if_stmt.cond);
+
+        //     // 创建分支指令
+        //     scc_ir_builder_branch();
+        //     scc_ir_node_t br_node;
+        //     init_branch_node(&br_node, cond, &true_block, &false_block);
+        //     emit_instruction(ctx, &br_node);
+
+        //     // 保存当前块
+        //     ast2ir_ctx_t saved = ctx->current_ctx;
+
+        //     // 生成true分支
+        //     emit_basicblock(ctx, &true_block);
+        //     ast_stmt_to_ir(ctx, stmt->if_stmt.then_stmt);
+
+        //     // 跳转到合并块
+        //     scc_ir_node_t jump_node;
+        //     init_jump_node(&jump_node, &merge_block);
+        //     emit_instruction(ctx, &jump_node);
+
+        //     // 生成false分支（如果有）
+        //     emit_basicblock(ctx, &false_block);
+        //     if (stmt->if_stmt.opt_else_stmt) {
+        //         ast_stmt_to_ir(ctx, stmt->if_stmt.opt_else_stmt);
+        //     }
+
+        //     // 跳转到合并块
+        //     init_jump_node(&jump_node, &merge_block);
+        //     emit_instruction(ctx, &jump_node);
+
+        //     // 恢复上下文并设置当前块为合并块
+        //     ctx->current_ctx = saved;
+        //     emit_basicblock(ctx, &merge_block);
+        //     break;
+        // }
+
+        // case SCC_AST_STMT_WHILE: {
+        //     // 创建基本块 - 统一使用栈上分配
+        //     scc_ir_bblock_t cond_block;
+        //     scc_ir_bblock_init(&cond_block, "while_cond");
+
+        //     scc_ir_bblock_t body_block;
+        //     scc_ir_bblock_init(&body_block, "while_body");
+
+        //     scc_ir_bblock_t exit_block;
+        //     scc_ir_bblock_init(&exit_block, "while_exit");
+
+        //     // 跳转到条件块
+        //     scc_ir_node_t jump_node;
+        //     init_jump_node(&jump_node, &cond_block);
+        //     emit_instruction(ctx, &jump_node);
+
+        //     // 保存当前块
+        //     ast2ir_ctx_t saved = ctx->current_ctx;
+
+        //     // 生成条件块
+        //     emit_basicblock(ctx, &cond_block);
+        //     scc_ir_node_t cond_node;
+        //     ast_expr_to_ir(ctx, stmt->while_stmt.cond, &cond_node);
+
+        //     // 将条件节点添加到程序节点列表
+        //     scc_vec_push(ctx->program->global_vals, cond_node);
+        //     scc_ir_node_t *cond =
+        //         &scc_vec_at(ctx->program->global_vals,
+        //                     scc_vec_size(ctx->program->global_vals) - 1);
+
+        //     // 创建分支
+        //     scc_ir_node_t br_node;
+        //     init_branch_node(&br_node, cond, &body_block, &exit_block);
+        //     emit_instruction(ctx, &br_node);
+
+        //     // 生成循环体
+        //     emit_basicblock(ctx, &body_block);
+        //     ast_stmt_to_ir(ctx, stmt->while_stmt.body);
+
+        //     // 跳转回条件块
+        //     init_jump_node(&jump_node, &cond_block);
+        //     emit_instruction(ctx, &jump_node);
+
+        //     // 恢复上下文并设置当前块为退出块
+        //     ctx->current_ctx = saved;
+        //     emit_basicblock(ctx, &exit_block);
+        //     break;
+        // }
+
+        // case SCC_AST_STMT_DO_WHILE: {
+        //     // 创建基本块 - 统一使用栈上分配
+        //     scc_ir_bblock_t cond_block;
+        //     scc_ir_bblock_init(&cond_block, "do_while_cond");
+
+        //     scc_ir_bblock_t body_block;
+        //     scc_ir_bblock_init(&body_block, "do_while_body");
+
+        //     scc_ir_bblock_t exit_block;
+        //     scc_ir_bblock_init(&exit_block, "do_while_exit");
+
+        //     // 跳转到循环体块
+        //     scc_ir_node_t jump_node;
+        //     init_jump_node(&jump_node, &body_block);
+        //     emit_instruction(ctx, &jump_node);
+
+        //     // 保存当前块
+        //     ast2ir_ctx_t saved = ctx->current_ctx;
+
+        //     // 生成循环体
+        //     emit_basicblock(ctx, &body_block);
+        //     ast_stmt_to_ir(ctx, stmt->do_while_stmt.body);
+
+        //     // 跳转到条件块
+        //     init_jump_node(&jump_node, &cond_block);
+        //     emit_instruction(ctx, &jump_node);
+
+        //     // 生成条件块
+        //     emit_basicblock(ctx, &cond_block);
+        //     scc_ir_node_t cond_node;
+        //     ast_expr_to_ir(ctx, stmt->do_while_stmt.cond, &cond_node);
+
+        //     // 将条件节点添加到程序节点列表
+        //     scc_vec_push(ctx->program->global_vals, cond_node);
+        //     scc_ir_node_t *cond =
+        //         &scc_vec_at(ctx->program->global_vals,
+        //                     scc_vec_size(ctx->program->global_vals) - 1);
+
+        //     // 创建分支
+        //     scc_ir_node_t br_node;
+        //     init_branch_node(&br_node, cond, &body_block, &exit_block);
+        //     emit_instruction(ctx, &br_node);
+
+        //     // 恢复上下文并设置当前块为退出块
+        //     ctx->current_ctx = saved;
+        //     emit_basicblock(ctx, &exit_block);
+        //     break;
+        // }
+
+        // case SCC_AST_STMT_FOR: {
+        //     // 初始化部分
+        //     if (SCC_AST_IS_A(scc_ast_expr_t, stmt->for_stmt.init)) {
+        //         scc_ir_node_t dummy_node;
+        //         ast_expr_to_ir(ctx,
+        //                        SCC_AST_CAST_TO(scc_ast_expr_t,
+        //                        stmt->for_stmt.init), &dummy_node);
+        //     } else if (SCC_AST_IS_A(scc_ast_decl_t, stmt->for_stmt.init)) {
+        //         ast_decl_to_ir(
+        //             ctx, SCC_AST_CAST_TO(scc_ast_decl_t,
+        //             stmt->for_stmt.init));
+        //     } else {
+        //         UNREACHABLE();
+        //     }
+
+        //     // 创建基本块 - 统一使用栈上分配
+        //     scc_ir_bblock_t cond_block;
+        //     scc_ir_bblock_init(&cond_block, "for_cond");
+
+        //     scc_ir_bblock_t body_block;
+        //     scc_ir_bblock_init(&body_block, "for_body");
+
+        //     scc_ir_bblock_t exit_block;
+        //     scc_ir_bblock_init(&exit_block, "for_exit");
+
+        //     // 跳转到条件块
+        //     scc_ir_node_t jump_node;
+        //     init_jump_node(&jump_node, &cond_block);
+        //     emit_instruction(ctx, &jump_node);
+
+        //     // 保存当前块
+        //     ast2ir_ctx_t saved = ctx->current_ctx;
+
+        //     // 生成条件块
+        //     emit_basicblock(ctx, &cond_block);
+
+        //     scc_ir_node_t *cond = null;
+        //     if (stmt->for_stmt.cond) {
+        //         scc_ir_node_t cond_node;
+        //         ast_expr_to_ir(ctx, stmt->for_stmt.cond, &cond_node);
+
+        //         // 将条件节点添加到程序节点列表
+        //         scc_vec_push(ctx->program->global_vals, cond_node);
+        //         cond = &scc_vec_at(ctx->program->global_vals,
+        //                            scc_vec_size(ctx->program->global_vals) -
+        //                            1);
+        //     } else {
+        //         // 无条件循环，条件为真
+        //         scc_ir_node_t true_node;
+        //         init_const_int_node(&true_node, 1, null);
+
+        //         // 将true节点添加到程序节点列表
+        //         scc_vec_push(ctx->program->global_vals, true_node);
+        //         cond = &scc_vec_at(ctx->program->global_vals,
+        //                            scc_vec_size(ctx->program->global_vals) -
+        //                            1);
+        //     }
+
+        //     // 创建分支
+        //     scc_ir_node_t br_node;
+        //     init_branch_node(&br_node, cond, &body_block, &exit_block);
+        //     emit_instruction(ctx, &br_node);
+
+        //     // 生成循环体
+        //     emit_basicblock(ctx, &body_block);
+        //     ast_stmt_to_ir(ctx, stmt->for_stmt.body);
+
+        //     // 执行迭代表达式（如果存在）
+        //     if (stmt->for_stmt.iter) {
+        //         scc_ir_node_t dummy_node;
+        //         ast_expr_to_ir(ctx, stmt->for_stmt.iter, &dummy_node);
+        //     }
+
+        //     // 跳转回条件块
+        //     init_jump_node(&jump_node, &cond_block);
+        //     emit_instruction(ctx, &jump_node);
+
+        //     // 恢复上下文并设置当前块为退出块
+        //     ctx->current_ctx = saved;
+        //     emit_basicblock(ctx, &exit_block);
+        //     break;
+        // }
+
+    case SCC_AST_STMT_RETURN: {
+        if (stmt->return_stmt.expr) {
+            scc_ir_node_ref_t ret_val_node =
+                ast_expr_to_ir(ctx, stmt->return_stmt.expr);
+
+            scc_ir_builder_ret(ctx, ret_val_node);
+        } else {
+            scc_ir_builder_ret_void(ctx);
+        }
+        break;
+    }
+
+    default:
+        LOG_WARN("Unsupported statement type: %d", stmt->base.type);
+        break;
+    }
+}
+
+// 转换AST声明为IR
+static void ast_decl_to_ir(scc_ir_builder_t *ctx, scc_ast_decl_t *decl) {
+    if (ctx == null || decl == null) {
+        LOG_ERROR("Invalid argument");
+        return;
+    }
+
+    switch (decl->base.type) {
+    case SCC_AST_DECL_VAR: {
+        // 转换类型
+        scc_ir_type_ref_t ir_type = ast_type_to_ir_type(ctx, decl->var.type);
+
+        // 创建分配节点
+        scc_ir_node_ref_t alloc_val_node =
+            scc_ir_builder_alloca(ctx, ir_type, decl->var.name);
+
+        // 如果有初始化表达式
+        if (!decl->var.init) {
+            break;
+        }
+        scc_ir_node_ref_t init_val_node = ast_expr_to_ir(ctx, decl->var.init);
+
+        // 将初始化值节点添加到程序节点列表
+        // scc_vec_push(ctx->program->global_vals, init_val_node);
+        // scc_ir_node_t *init_val =
+        //     &scc_vec_at(ctx->program->global_vals,
+        //                 scc_vec_size(ctx->program->global_vals) - 1);
+
+        scc_ir_builder_store(ctx, alloc_val_node, init_val_node);
+        break;
+    }
+
+    case SCC_AST_DECL_FUNC: {
+        // TODO params name
+        scc_ir_type_ref_t func_type = ast_type_to_ir_type(ctx, decl->func.type);
+        scc_ir_builder_begin_func(ctx, decl->func.name, func_type, null);
+        // 处理函数体（如果有）
+        if (decl->func.body) {
+            scc_ir_builder_begin_bblock(ctx, "entry");
+            ast_stmt_to_ir(ctx, decl->func.body);
+            scc_ir_builder_end_bblock(ctx);
+        }
+        scc_ir_builder_end_func(ctx);
+        break;
+    }
+
+    default:
+        LOG_WARN("Unsupported declaration type: %d", decl->base.type);
+        break;
+    }
+}
+
+// 主转换函数：将AST翻译单元转换为IR程序
+void scc_ast2ir(scc_ast_translation_unit_t *tu, scc_ir_builder_t *builder) {
+    if (tu == null || builder == null) {
+        LOG_ERROR("Invalid argument");
+        return;
+    }
+
+    // 初始化上下文
+    scc_ir_builder_init(builder);
+
+    // 转换所有声明
+    scc_vec_foreach(tu->declarations, i) {
+        scc_ast_decl_t *decl = scc_vec_at(tu->declarations, i);
+        ast_decl_to_ir(builder, decl);
+    }
+}

libs/ast2ir/tests/test_.c

@@ -0,0 +1,10 @@
+#include <stdio.h>
+
+void test_example() {
+    printf("Test passed!\n");
+}
+
+int main() {
+    test_example();
+    return 0;
+}

libs/ir/cbuild.toml

@@ -4,7 +4,10 @@ version = "0.1.0"
 authors = []
 description = ""
 
-dependencies = [{ name = "scc_core", path = "../../runtime/scc_core" }]
+dependencies = [
+    { name = "scc_utils", path = "../../runtime/scc_utils" },
+    { name = "tree_dump", path = "../tree_dump" },
+]
 # dependencies = []
 # features = {}
 # default_features = []

libs/ir/include/ir_base.h

@@ -0,0 +1,17 @@
+#ifndef __SCC_IR_BASE_H__
+#define __SCC_IR_BASE_H__
+
+#include "ir_def.h"
+
+void scc_ir_type_init(scc_ir_type_t *in, scc_ir_type_tag_t tag);
+void scc_ir_bblock_init(scc_ir_bblock_t *in, const char *label);
+void scc_ir_func_init(scc_ir_func_t *in, const char *name);
+
+// node name can be null ptr
+void scc_ir_node_init(scc_ir_node_t *in, const char *name,
+                      scc_ir_node_tag_t tag);
+
+void scc_ir_cprog_init(scc_ir_cprog_t *in);
+void scc_ir_cprog_drop(scc_ir_cprog_t *in);
+
+#endif /* __SCC_IR_BASE_H__ */

libs/ir/include/ir_builder.h

@@ -0,0 +1,174 @@
+#ifndef __SCC_IR_BUILDER_H__
+#define __SCC_IR_BUILDER_H__
+
+#include "ir_ctx.h"
+#include "ir_def.h"
+#include <scc_core.h>
+
+typedef struct scc_ir_builder scc_ir_builder_t;
+
+/**
+ * @brief IR 构建器上下文
+ *
+ * 负责管理 IR 构建过程中的所有状态：
+ * - 类型统一化（type uniquing）
+ * - 符号命名分配
+ * - 内存管理
+ * - 当前构建位置（函数、基本块）
+ */
+struct scc_ir_builder {
+    scc_ir_cprog_ctx_t ctx; /**< 核心上下文 */
+    scc_ir_cprog_t cprog;
+    // 当前构建位置
+    scc_ir_func_ref_t current_func;     /**< 当前正在构建的函数 */
+    scc_ir_bblock_ref_t current_bblock; /**< 当前基本块 */
+};
+
+/**
+ * @brief 初始化 IR 构建器
+ */
+void scc_ir_builder_init(scc_ir_builder_t *builder);
+
+/**
+ * @brief 销毁 IR 构建器及其所有资源
+ */
+void scc_ir_builder_drop(scc_ir_builder_t *builder);
+
+/**
+ * @brief 开始构建函数
+ * @param name 函数名
+ * @param type 函数类型
+ * @param param_names 参数名列表（可为NULL）
+ * @return 函数引用
+ */
+scc_ir_func_ref_t scc_ir_builder_begin_func(scc_ir_builder_t *builder,
+                                            const char *name,
+                                            scc_ir_type_ref_t type,
+                                            const char **param_names);
+
+/**
+ * @brief 结束当前函数的构建
+ */
+void scc_ir_builder_end_func(scc_ir_builder_t *builder);
+
+/**
+ * @brief 获取当前正在构建的函数
+ */
+scc_ir_func_ref_t scc_ir_builder_current_func(scc_ir_builder_t *builder);
+
+/**
+ * @brief 开始构建新的基本块
+ * @param label 基本块标签（可为NULL，自动生成）
+ * @return 基本块引用
+ */
+scc_ir_bblock_ref_t scc_ir_builder_begin_bblock(scc_ir_builder_t *builder,
+                                                const char *label);
+
+/**
+ * @brief 结束当前基本块的构建
+ */
+void scc_ir_builder_end_bblock(scc_ir_builder_t *builder);
+
+/**
+ * @brief 设置当前基本块
+ */
+void scc_ir_builder_set_current_bblock(scc_ir_builder_t *builder,
+                                       scc_ir_bblock_ref_t bblock);
+
+/**
+ * @brief 创建alloca指令（在当前基本块中）
+ * @param type 分配的类型
+ * @param name 变量名（可为NULL）
+ */
+scc_ir_node_ref_t scc_ir_builder_alloca(scc_ir_builder_t *builder,
+                                        scc_ir_type_ref_t type,
+                                        const char *name);
+
+/**
+ * @brief 创建load指令
+ * @param ptr 指针操作数
+ */
+scc_ir_node_ref_t scc_ir_builder_load(scc_ir_builder_t *builder,
+                                      scc_ir_node_ref_t ptr);
+
+/**
+ * @brief 创建store指令
+ * @param ptr 目标指针
+ * @param value 要存储的值
+ */
+scc_ir_node_ref_t scc_ir_builder_store(scc_ir_builder_t *builder,
+                                       scc_ir_node_ref_t ptr,
+                                       scc_ir_node_ref_t value);
+
+/**
+ * @brief 创建getptr指令（指针运算）
+ * @param ptr 基础指针
+ * @param index 索引值
+ */
+scc_ir_node_ref_t scc_ir_builder_get_ptr(scc_ir_builder_t *builder,
+                                         scc_ir_node_ref_t ptr,
+                                         scc_ir_node_ref_t index);
+
+/**
+ * @brief 创建二元运算指令
+ * @param op 操作符
+ * @param lhs 左操作数
+ * @param rhs 右操作数
+ */
+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);
+
+/**
+ * @brief 创建比较指令
+ * @param op 比较操作符
+ * @param lhs 左操作数
+ * @param rhs 右操作数
+ */
+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);
+
+/**
+ * @brief 创建跳转指令（无条件）
+ * @param target 目标基本块
+ */
+scc_ir_node_ref_t scc_ir_builder_jump(scc_ir_builder_t *builder,
+                                      scc_ir_bblock_ref_t target);
+
+/**
+ * @brief 创建条件分支指令
+ * @param cond 条件值
+ * @param true_target 条件为真时的目标
+ * @param false_target 条件为假时的目标
+ */
+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);
+
+/**
+ * @brief 创建函数调用指令
+ * @param callee 被调用函数
+ * @param args 参数列表
+ * @param arg_count 参数数量
+ */
+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);
+
+/**
+ * @brief 创建返回指令（带返回值）
+ * @param value 返回值
+ */
+scc_ir_node_ref_t scc_ir_builder_ret(scc_ir_builder_t *builder,
+                                     scc_ir_node_ref_t value);
+
+/**
+ * @brief 创建返回指令（void返回）
+ */
+scc_ir_node_ref_t scc_ir_builder_ret_void(scc_ir_builder_t *builder);
+
+#endif /* __SCC_IR_BUILDER_H__ */

libs/ir/include/ir_ctx.h

@@ -0,0 +1,200 @@
+#ifndef __SCC_IR_CTX_H__
+#define __SCC_IR_CTX_H__
+
+#include "ir_base.h"
+#include "ir_def.h"
+#include <scc_hashtable.h>
+
+#define SCC_IR_REF_NULL 0
+
+typedef struct {
+    unsigned int node_uid;
+    unsigned int type_uid;
+    unsigned int bblock_uid;
+    unsigned int func_uid;
+
+    SCC_VEC(scc_ir_node_t) nodes;
+    SCC_VEC(scc_ir_type_t) types;
+    SCC_VEC(scc_ir_bblock_t) bblocks;
+    SCC_VEC(scc_ir_func_t) funcs;
+
+    // UID -> 索引 映射
+    scc_hashtable_t uid2nodes;
+    scc_hashtable_t uid2types;
+    scc_hashtable_t uid2bblocks;
+    scc_hashtable_t uid2funcs;
+
+    // 类型去重表（类型键 -> 类型引用）
+    scc_hashtable_t type_uniquing;
+
+    // 常量池（常量键 -> 节点引用）
+    scc_hashtable_t const_pool;
+
+    // 内置类型缓存
+    scc_ir_type_ref_t builtin_i32;
+    scc_ir_type_ref_t builtin_i1;
+    scc_ir_type_ref_t builtin_void;
+    scc_ir_node_ref_t builtin_zero_i32;
+} scc_ir_cprog_ctx_t;
+
+/**
+ * @brief 初始化IR上下文
+ * @param ctx 上下文指针
+ */
+void scc_ir_ctx_init(scc_ir_cprog_ctx_t *ctx);
+
+/**
+ * @brief 销毁IR上下文及其所有资源
+ * @param ctx 上下文指针
+ */
+void scc_ir_ctx_drop(scc_ir_cprog_ctx_t *ctx);
+
+/**
+ * @brief 重置IR上下文（清空所有数据但保留内存）
+ * @param ctx 上下文指针
+ */
+void scc_ir_ctx_reset(scc_ir_cprog_ctx_t *ctx);
+
+/**
+ * @brief 创建新的类型
+ * @param ctx 上下文指针
+ * @param type 类型数据（会被拷贝）
+ * @return 类型引用（0表示失败）
+ */
+scc_ir_type_ref_t scc_ir_ctx_new_type(scc_ir_cprog_ctx_t *ctx,
+                                      const scc_ir_type_t *type);
+
+/**
+ * @brief 创建新的节点
+ * @param ctx 上下文指针
+ * @param node 节点数据（会被拷贝）
+ * @return 节点引用（0表示失败）
+ */
+scc_ir_node_ref_t scc_ir_ctx_new_node(scc_ir_cprog_ctx_t *ctx,
+                                      const scc_ir_node_t *node);
+
+/**
+ * @brief 创建新的基本块
+ * @param ctx 上下文指针
+ * @param bblock 基本块数据（会被拷贝）
+ * @return 基本块引用（0表示失败）
+ */
+scc_ir_bblock_ref_t scc_ir_ctx_new_bblock(scc_ir_cprog_ctx_t *ctx,
+                                          const scc_ir_bblock_t *bblock);
+
+/**
+ * @brief 创建新的函数
+ * @param ctx 上下文指针
+ * @param func 函数数据（会被拷贝）
+ * @return 函数引用（0表示失败）
+ */
+scc_ir_func_ref_t scc_ir_ctx_new_func(scc_ir_cprog_ctx_t *ctx,
+                                      const scc_ir_func_t *func);
+
+/**
+ * @brief 根据引用获取类型
+ * @param ctx 上下文指针
+ * @param ref 类型引用
+ * @return 类型指针（NULL表示无效引用）
+ */
+scc_ir_type_t *scc_ir_ctx_get_type(scc_ir_cprog_ctx_t *ctx,
+                                   scc_ir_type_ref_t ref);
+
+/**
+ * @brief 根据引用获取节点
+ * @param ctx 上下文指针
+ * @param ref 节点引用
+ * @return 节点指针（NULL表示无效引用）
+ */
+scc_ir_node_t *scc_ir_ctx_get_node(scc_ir_cprog_ctx_t *ctx,
+                                   scc_ir_node_ref_t ref);
+
+/**
+ * @brief 根据引用获取基本块
+ * @param ctx 上下文指针
+ * @param ref 基本块引用
+ * @return 基本块指针（NULL表示无效引用）
+ */
+scc_ir_bblock_t *scc_ir_ctx_get_bblock(scc_ir_cprog_ctx_t *ctx,
+                                       scc_ir_bblock_ref_t ref);
+
+/**
+ * @brief 根据引用获取函数
+ * @param ctx 上下文指针
+ * @param ref 函数引用
+ * @return 函数指针（NULL表示无效引用）
+ */
+scc_ir_func_t *scc_ir_ctx_get_func(scc_ir_cprog_ctx_t *ctx,
+                                   scc_ir_func_ref_t ref);
+
+// /**
+//  * @brief 遍历所有类型
+//  * @param ctx 上下文指针
+//  * @param callback 回调函数
+//  * @param userdata 用户数据
+//  */
+// void scc_ir_ctx_foreach_type(scc_ir_cprog_ctx_t *ctx,
+//                              void (*callback)(scc_ir_type_ref_t ref,
+//                                               scc_ir_type_t *type,
+//                                               void *userdata),
+//                              void *userdata);
+
+// /**
+//  * @brief 遍历所有节点
+//  */
+// void scc_ir_ctx_foreach_node(scc_ir_cprog_ctx_t *ctx,
+//                              void (*callback)(scc_ir_node_ref_t ref,
+//                                               scc_ir_node_t *node,
+//                                               void *userdata),
+//                              void *userdata);
+
+// /**
+//  * @brief 遍历所有基本块
+//  */
+// void scc_ir_ctx_foreach_bblock(scc_ir_cprog_ctx_t *ctx,
+//                                void (*callback)(scc_ir_bblock_ref_t ref,
+//                                                 scc_ir_bblock_t *bblock,
+//                                                 void *userdata),
+//                                void *userdata);
+
+// /**
+//  * @brief 遍历所有函数
+//  */
+// void scc_ir_ctx_foreach_func(scc_ir_cprog_ctx_t *ctx,
+//                              void (*callback)(scc_ir_func_ref_t ref,
+//                                               scc_ir_func_t *func,
+//                                               void *userdata),
+//                              void *userdata);
+
+/**
+ * @brief 获取内置i32类型
+ * @param ctx 上下文指针
+ * @return i32类型引用
+ */
+scc_ir_type_ref_t scc_ir_ctx_get_builtin_i32(scc_ir_cprog_ctx_t *ctx);
+
+/**
+ * @brief 获取内置零常量
+ * @param ctx 上下文指针
+ * @return 零常量节点引用
+ */
+scc_ir_node_ref_t scc_ir_ctx_get_builtin_zero(scc_ir_cprog_ctx_t *ctx);
+
+/**
+ * @brief 创建或获取i32常量
+ * @param ctx 上下文指针
+ * @param value 常量值
+ * @return 常量节点引用
+ */
+scc_ir_node_ref_t scc_ir_ctx_get_i32_const(scc_ir_cprog_ctx_t *ctx, i32 value);
+
+/**
+ * @brief 创建或获取null常量
+ * @param ctx 上下文指针
+ * @param ptr_type 指针类型引用
+ * @return null常量节点引用
+ */
+scc_ir_node_ref_t scc_ir_ctx_get_null_const(scc_ir_cprog_ctx_t *ctx,
+                                            scc_ir_type_ref_t ptr_type);
+
+#endif /* __SCC_IR_CTX_H__ */

libs/ir/include/ir_def.h

@@ -3,52 +3,75 @@
 
 #include <scc_core.h>
 
+typedef unsigned int ir_handle_t;
+typedef const char *scc_ir_label_t;
+
 typedef struct scc_ir_node scc_ir_node_t;
-typedef SCC_VEC(scc_ir_node_t) scc_ir_node_vec_t;
+typedef ir_handle_t scc_ir_node_ref_t;
+typedef SCC_VEC(scc_ir_node_ref_t) scc_ir_node_ref_vec_t;
+
+typedef struct scc_ir_type scc_ir_type_t;
+typedef ir_handle_t scc_ir_type_ref_t;
+typedef SCC_VEC(scc_ir_type_ref_t) scc_ir_type_ref_vec_t;
+
+typedef struct scc_ir_bblock scc_ir_bblock_t;
+typedef ir_handle_t scc_ir_bblock_ref_t;
+typedef SCC_VEC(scc_ir_bblock_ref_t) scc_ir_bblock_ref_vec_t;
+
+typedef struct scc_ir_func scc_ir_func_t;
+typedef ir_handle_t scc_ir_func_ref_t;
+typedef SCC_VEC(scc_ir_func_ref_t) scc_ir_func_ref_vec_t;
 
 typedef enum scc_ir_type_tag {
     SCC_IR_TYPE_VOID,
+    SCC_IR_TYPE_I1,
+    SCC_IR_TYPE_I8,
+    SCC_IR_TYPE_I16,
     SCC_IR_TYPE_I32,
+    SCC_IR_TYPE_I64,
+    SCC_IR_TYPE_I128,
+    SCC_IR_TYPE_F16,
+    SCC_IR_TYPE_F32,
+    SCC_IR_TYPE_F64,
+    SCC_IR_TYPE_F128,
     SCC_IR_TYPE_PTR,
     SCC_IR_TYPE_ARRAY,
     SCC_IR_TYPE_FUNC,
+    SCC_IR_TYPE_STRUCT,
+    SCC_IR_TYPE_VECTOR,
 } scc_ir_type_tag_t;
 
-typedef struct scc_ir_type scc_ir_type_t;
-typedef SCC_VEC(scc_ir_type_t) scc_ir_type_vec_t;
-
 struct scc_ir_type {
     scc_ir_type_tag_t tag;
-
+    // int size;  // 字节大小
+    // int align; // 对齐要求
     union {
         struct {
-            const scc_ir_type_t *base;
+            scc_ir_type_ref_t base;
-            usize len;
+            usize len; // TODO usize is target dependent
         } array;
         struct {
-            const scc_ir_type_t *base;
+            scc_ir_type_ref_t base;
         } pointer;
         struct {
-            scc_ir_type_vec_t params;
+            scc_ir_type_ref_vec_t params;
-            const scc_ir_type_t *ret_type;
+            scc_ir_type_ref_t ret_type;
         } function;
     } data;
 };
 
-typedef struct scc_ir_bblock {
+struct scc_ir_bblock {
-    const char *label;
+    scc_ir_label_t label;
-    scc_ir_node_vec_t instrs;
+    scc_ir_node_ref_vec_t instrs;
     // ir_arr_t used_by;
-} scc_ir_bblock_t; // basic block
+}; // basic block
-typedef SCC_VEC(scc_ir_bblock_t) scc_ir_bblock_vec_t;
 
-typedef struct {
+struct scc_ir_func {
-    const char *name;
+    scc_ir_label_t name;
-    scc_ir_type_t *type;
+    scc_ir_type_ref_t type;
-    scc_ir_node_vec_t params;
+    scc_ir_node_ref_vec_t params;
-    scc_ir_bblock_vec_t bblocks;
+    scc_ir_bblock_ref_vec_t bblocks;
-} scc_ir_func_t;
+};
-typedef SCC_VEC(scc_ir_func_t) scc_ir_func_vec_t;
 
 typedef enum scc_ir_node_tag {
     SCC_IR_NODE_NULL,
@@ -106,9 +129,9 @@ typedef enum {
 } scc_ir_op_type_t;
 
 struct scc_ir_node {
-    const scc_ir_type_t *type;
+    scc_ir_type_ref_t type;
-    const char *name;
+    scc_ir_label_t name;
-    scc_ir_node_vec_t used_by;
+    scc_ir_node_ref_vec_t used_by;
     scc_ir_node_tag_t tag;
     union {
         union {
@@ -117,7 +140,7 @@ struct scc_ir_node {
             i32 int32;
             i64 int64;
             // TODO int128
-            i8 int_any[4];
+            i8 int_any[16];
         } const_int;
         union {
             u8 uint8;
@@ -125,54 +148,54 @@ struct scc_ir_node {
             u32 uint32;
             u64 uint64;
             // TODO uint128;
-            u8 uint_any[4];
+            u8 uint_any[16];
         } const_uint;
         // aggregate;
         // func_arg_ref;
         // block_arg_ref;
         // global_alloc;
         struct {
-            scc_ir_node_t *target;
+            scc_ir_node_ref_t target;
         } load;
         struct {
-            scc_ir_node_t *target;
+            scc_ir_node_ref_t target;
-            scc_ir_node_t *value;
+            scc_ir_node_ref_t value;
         } store;
         struct {
-            scc_ir_node_t *src_addr;
+            scc_ir_node_ref_t src_addr;
-            scc_ir_node_t *index;
+            scc_ir_node_ref_t index;
         } get_ptr;
         struct {
-            scc_ir_node_t *src_addr;
+            scc_ir_node_ref_t src_addr;
-            scc_ir_node_t *index;
+            scc_ir_node_ref_t index;
         } get_elem_ptr;
         struct {
             scc_ir_op_type_t op;
-            scc_ir_node_t *lhs;
+            scc_ir_node_ref_t lhs;
-            scc_ir_node_t *rhs;
+            scc_ir_node_ref_t rhs;
         } op;
         struct {
-            scc_ir_node_t *cond;
+            scc_ir_node_ref_t cond;
-            scc_ir_bblock_t *true_bblock;
+            scc_ir_bblock_ref_t true_bblock;
-            scc_ir_bblock_t *false_bblock;
+            scc_ir_bblock_ref_t false_bblock;
         } branch;
         struct {
-            scc_ir_bblock_t *target_bblock;
+            scc_ir_bblock_ref_t target_bblock;
         } jump;
         struct {
-            scc_ir_func_t *callee;
+            scc_ir_func_ref_t callee;
-            scc_ir_node_vec_t args;
+            scc_ir_node_ref_vec_t args;
         } call;
         struct {
-            scc_ir_node_t *ret_val;
+            scc_ir_node_ref_t ret_val;
         } ret;
     } data;
 };
 
-typedef struct {
+typedef struct scc_ir_cprog {
-    scc_ir_node_vec_t global_vals;
+    scc_ir_node_ref_vec_t global_vals;
-    scc_ir_func_vec_t funcs;
+    scc_ir_func_ref_vec_t func_defs;
-    scc_ir_func_vec_t extern_funcs;
+    scc_ir_node_ref_vec_t func_decls;
-} ir_cprog_t;
+} scc_ir_cprog_t;
 
 #endif /* __SCC_IR_DEF_H__ */

libs/ir/include/ir_dump.h

@@ -1,16 +1,21 @@
 #ifndef __SCC_IR_DUMP_H__
 #define __SCC_IR_DUMP_H__
 
+#include "ir_ctx.h"
 #include "ir_def.h"
+#include <tree_dump.h>
 
 typedef struct {
-
+    scc_ir_cprog_ctx_t *ir_ctx;
+    scc_ir_cprog_t *cprog;
+    scc_tree_dump_ctx_t *dump_ctx;
 } scc_ir_dump_ctx_t;
+void scc_ir_dump_ctx_init();
 
-void scc_ir_type_dump(scc_ir_dump_ctx_t *ctx, const scc_ir_type_t *in);
+void scc_ir_dump_node(scc_ir_dump_ctx_t *ctx, scc_ir_node_ref_t node_ref);
-void scc_ir_bblock_dump(scc_ir_dump_ctx_t *ctx, const scc_ir_bblock_t *in);
+void scc_ir_dump_type(scc_ir_dump_ctx_t *ctx, scc_ir_type_ref_t type_ref);
-void scc_ir_func_dump(scc_ir_dump_ctx_t *ctx, const scc_ir_func_t *in);
+void scc_ir_dump_bblock(scc_ir_dump_ctx_t *ctx, scc_ir_bblock_ref_t bblock_ref);
-void scc_ir_node_dump(scc_ir_dump_ctx_t *ctx, scc_ir_node_t *in);
+void scc_ir_dump_func(scc_ir_dump_ctx_t *ctx, scc_ir_func_ref_t func_ref);
-void scc_ir_cprog_dump(scc_ir_dump_ctx_t *ctx, ir_cprog_t *in);
+void scc_ir_dump_cprog(scc_ir_dump_ctx_t *ctx);
 
 #endif /* __SCC_IR_DUMP_H__ */

libs/ir/include/scc_ir.h

@@ -1,27 +1,9 @@
 #ifndef __SCC_IR_H__
 #define __SCC_IR_H__
 
+#include "ir_builder.h"
+#include "ir_ctx.h"
 #include "ir_def.h"
-
+#include <scc_utils.h>
-void scc_ir_type_init(scc_ir_type_t *in, scc_ir_type_tag_t tag);
-void scc_ir_bblock_init(scc_ir_bblock_t *in, const char *label);
-void scc_ir_func_init(scc_ir_func_t *in, const char *name);
-
-// node name can be null ptr
-void scc_ir_node_init(scc_ir_node_t *in, const char *name,
-                      scc_ir_node_tag_t tag);
-
-void scc_ir_cprog_init(ir_cprog_t *in);
-
-scc_ir_type_t *scc_ir_type_alloc(scc_ir_type_tag_t tag);
-scc_ir_bblock_t *scc_ir_bblock_alloc(const char *label);
-scc_ir_func_t *scc_ir_func_alloc(const char *name);
-scc_ir_node_t *scc_ir_node_alloc(const char *name, scc_ir_node_tag_t tag);
-
-// scc_ir_type_t *scc_ir_type_alloc_with_ctx(scc_ir_type_tag_t tag);
-// scc_ir_bblock_t *scc_ir_bblock_alloc_with_ctx(const char *label);
-// scc_ir_func_t *scc_ir_func_alloc_with_ctx(const char *name);
-// scc_ir_node_t *scc_ir_node_alloc_with_ctx(const char *name,
-//                                           scc_ir_node_tag_t tag);
 
 #endif /* __SCC_IR_H__ */

libs/ir/src/ir_base.c

@@ -1,19 +1,19 @@
-#include <scc_ir.h>
+#include <ir_base.h>
 
 void scc_ir_type_init(scc_ir_type_t *in, scc_ir_type_tag_t tag) {
     Assert(in != null);
     in->tag = tag;
     switch (tag) {
     case SCC_IR_TYPE_ARRAY:
-        in->data.array.base = null;
+        in->data.array.base = 0;
         in->data.array.len = 0;
         break;
     case SCC_IR_TYPE_PTR:
-        in->data.pointer.base = null;
+        in->data.pointer.base = 0;
         break;
     case SCC_IR_TYPE_FUNC:
         scc_vec_init(in->data.function.params);
-        in->data.function.ret_type = null;
+        in->data.function.ret_type = 0;
         break;
     case SCC_IR_TYPE_VOID:
     case SCC_IR_TYPE_I32:
@@ -35,7 +35,7 @@ void scc_ir_func_init(scc_ir_func_t *in, const char *name) {
     Assert(in != null);
     Assert(name != null);
     in->name = name;
-    in->type = null;
+    in->type = 0;
     scc_vec_init(in->bblocks);
     scc_vec_init(in->params);
 }
@@ -46,7 +46,7 @@ void scc_ir_node_init(scc_ir_node_t *in, const char *name,
     in->name = name;
     in->tag = tag;
     scc_vec_init(in->used_by);
-    in->type = null;
+    in->type = 0;
 
     switch (tag) {
     case SCC_IR_NODE_NULL:
@@ -56,38 +56,38 @@ void scc_ir_node_init(scc_ir_node_t *in, const char *name,
         in->data.const_int.int32 = 0;
         break;
     case SCC_IR_NODE_ALLOC:
-        TODO();
+        // TODO();
         break;
     case SCC_IR_NODE_LOAD:
-        in->data.load.target = null;
+        in->data.load.target = 0;
         break;
     case SCC_IR_NODE_STORE:
-        in->data.store.target = null;
+        in->data.store.target = 0;
-        in->data.store.value = null;
+        in->data.store.value = 0;
         break;
     case SCC_IR_NODE_GET_PTR:
-        in->data.get_ptr.src_addr = null;
+        in->data.get_ptr.src_addr = 0;
-        in->data.get_ptr.index = null;
+        in->data.get_ptr.index = 0;
         break;
     case SCC_IR_NODE_OP:
         in->data.op.op = IR_OP_EMPTY;
-        in->data.op.lhs = null;
+        in->data.op.lhs = 0;
-        in->data.op.rhs = null;
+        in->data.op.rhs = 0;
         break;
     case SCC_IR_NODE_BRANCH:
-        in->data.branch.cond = null;
+        in->data.branch.cond = 0;
-        in->data.branch.true_bblock = null;
+        in->data.branch.true_bblock = 0;
-        in->data.branch.false_bblock = null;
+        in->data.branch.false_bblock = 0;
         break;
     case SCC_IR_NODE_JUMP:
-        in->data.jump.target_bblock = null;
+        in->data.jump.target_bblock = 0;
         break;
     case SCC_IR_NODE_CALL:
         scc_vec_init(in->data.call.args);
-        in->data.call.callee = null;
+        in->data.call.callee = 0;
         break;
     case SCC_IR_NODE_RET:
-        in->data.ret.ret_val = null;
+        in->data.ret.ret_val = 0;
         break;
     default:
         UNREACHABLE();
@@ -95,34 +95,14 @@ void scc_ir_node_init(scc_ir_node_t *in, const char *name,
     }
 }
 
-void scc_ir_cprog_init(ir_cprog_t *in) {
+void scc_ir_cprog_init(scc_ir_cprog_t *in) {
-    Assert(in != null);
+    scc_vec_init(in->func_decls);
-    scc_vec_init(in->extern_funcs);
+    scc_vec_init(in->func_defs);
-    scc_vec_init(in->funcs);
     scc_vec_init(in->global_vals);
 }
 
-scc_ir_type_t *scc_ir_type_alloc(scc_ir_type_tag_t tag) {
+void scc_ir_cprog_drop(scc_ir_cprog_t *in) {
-    scc_ir_type_t *ret = scc_malloc(sizeof(scc_ir_type_t));
+    scc_vec_free(in->func_decls);
-    Assert(ret != null);
+    scc_vec_free(in->func_defs);
-    scc_ir_type_init(ret, tag);
+    scc_vec_free(in->global_vals);
-    return ret;
-}
-scc_ir_bblock_t *scc_ir_bblock_alloc(const char *label) {
-    scc_ir_bblock_t *ret = scc_malloc(sizeof(scc_ir_bblock_t));
-    Assert(ret != null);
-    scc_ir_bblock_init(ret, label);
-    return ret;
-}
-scc_ir_func_t *scc_ir_func_alloc(const char *name) {
-    scc_ir_func_t *ret = scc_malloc(sizeof(scc_ir_func_t));
-    Assert(ret != null);
-    scc_ir_func_init(ret, name);
-    return ret;
-}
-scc_ir_node_t *scc_ir_node_alloc(const char *name, scc_ir_node_tag_t tag) {
-    scc_ir_node_t *ret = scc_malloc(sizeof(scc_ir_node_t));
-    Assert(ret != null);
-    scc_ir_node_init(ret, name, tag);
-    return ret;
 }

libs/ir/src/ir_builder.c

@@ -0,0 +1,351 @@
+#include <ir_builder.h>
+#include <ir_builtin.h>
+
+void scc_ir_builder_init(scc_ir_builder_t *builder) {
+    builder->current_bblock = SCC_IR_REF_NULL;
+    builder->current_func = SCC_IR_REF_NULL;
+
+    scc_ir_cprog_init(&builder->cprog);
+    scc_ir_ctx_init(&builder->ctx);
+}
+
+void scc_ir_builder_drop(scc_ir_builder_t *builder) {
+    scc_ir_cprog_drop(&builder->cprog);
+    scc_ir_ctx_drop(&builder->ctx);
+}
+
+scc_ir_func_ref_t scc_ir_builder_begin_func(scc_ir_builder_t *builder,
+                                            const char *name,
+                                            scc_ir_type_ref_t type,
+                                            const char **param_names) {
+    scc_ir_func_t func = {0};
+
+    // 初始化参数和基本块向量
+    func.name = name;
+    func.type = type;
+    scc_vec_init(func.params);
+    scc_vec_init(func.bblocks);
+
+    // 创建函数并设置为当前函数
+    scc_ir_func_ref_t func_ref = scc_ir_ctx_new_func(&builder->ctx, &func);
+    builder->current_func = func_ref;
+
+    // 如果提供了参数名称，则创建参数节点
+    if (param_names == null) {
+        return func_ref;
+    }
+
+    scc_ir_func_t *func_ptr = scc_ir_ctx_get_func(&builder->ctx, func_ref);
+    scc_ir_type_t *func_type = scc_ir_ctx_get_type(&builder->ctx, type);
+
+    if (func_type == null || func_type->tag != SCC_IR_TYPE_FUNC) {
+        LOG_ERROR("Invalid function type");
+        return func_ref;
+    }
+
+    scc_vec_foreach(func_type->data.function.params, i) {
+        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_NULL; // 参数节点标记
+        param_node.type = param_type;
+        param_node.name = param_names[i];
+        scc_vec_init(param_node.used_by);
+
+        scc_ir_node_ref_t param_ref =
+            scc_ir_ctx_new_node(&builder->ctx, &param_node);
+        scc_vec_push(func_ptr->params, param_ref);
+    }
+
+    return func_ref;
+}
+
+void scc_ir_builder_end_func(scc_ir_builder_t *builder) {
+    scc_ir_func_t *func_ptr =
+        scc_ir_ctx_get_func(&builder->ctx, builder->current_func);
+    if (func_ptr == null) {
+        LOG_FATAL("Invalid function reference");
+        return;
+    }
+    if (scc_vec_size(func_ptr->bblocks) == 0) {
+        scc_vec_push(builder->cprog.func_decls, builder->current_func);
+    } else {
+        scc_vec_push(builder->cprog.func_defs, builder->current_func);
+    }
+    builder->current_func = 0;
+}
+
+scc_ir_func_ref_t scc_ir_builder_current_func(scc_ir_builder_t *builder) {
+    return builder->current_func;
+}
+
+scc_ir_bblock_ref_t scc_ir_builder_begin_bblock(scc_ir_builder_t *builder,
+                                                const char *label) {
+    scc_ir_bblock_t bblock = {0};
+
+    if (label) {
+        bblock.label = label;
+    } else {
+        // TODO 自动生成标签
+        char *auto_label = scc_malloc(sizeof(char) * 64);
+        if (auto_label)
+            LOG_FATAL("allocate memory failed");
+        static int auto_counter = 0;
+        scc_snprintf(auto_label, sizeof(auto_label), ".BB%d", auto_counter++);
+        bblock.label = auto_label;
+    }
+
+    scc_vec_init(bblock.instrs);
+
+    scc_ir_bblock_ref_t bblock_ref =
+        scc_ir_ctx_new_bblock(&builder->ctx, &bblock);
+    builder->current_bblock = bblock_ref;
+
+    // 将基本块添加到当前函数
+    scc_ir_func_t *current_func =
+        scc_ir_ctx_get_func(&builder->ctx, builder->current_func);
+    if (current_func) {
+        scc_vec_push(current_func->bblocks, bblock_ref);
+    }
+
+    return bblock_ref;
+}
+
+void scc_ir_builder_end_bblock(scc_ir_builder_t *builder) {
+    builder->current_bblock = 0;
+}
+
+void scc_ir_builder_set_current_bblock(scc_ir_builder_t *builder,
+                                       scc_ir_bblock_ref_t bblock) {
+    builder->current_bblock = bblock;
+}
+
+static void scc_ir_builder_add_instr(scc_ir_builder_t *builder,
+                                     scc_ir_node_ref_t node) {
+    scc_ir_bblock_t *current_bblock =
+        scc_ir_ctx_get_bblock(&builder->ctx, builder->current_bblock);
+    if (current_bblock) {
+        scc_vec_push(current_bblock->instrs, node);
+    } 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;
+    alloc_node.type = scc_ir_ctx_new_type(
+        &builder->ctx,
+        &(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_ctx_new_node(&builder->ctx, &alloc_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 ptr) {
+    scc_ir_node_t load_node = {0};
+    load_node.tag = SCC_IR_NODE_LOAD;
+    load_node.data.load.target = ptr;
+
+    // 设置类型为指针指向的类型
+    scc_ir_node_t *ptr_node = scc_ir_ctx_get_node(&builder->ctx, ptr);
+    if (ptr_node) {
+        scc_ir_type_t *ptr_type =
+            scc_ir_ctx_get_type(&builder->ctx, ptr_node->type);
+        if (ptr_type && ptr_type->tag == SCC_IR_TYPE_PTR) {
+            load_node.type = ptr_type->data.pointer.base;
+        }
+    }
+
+    scc_ir_node_ref_t node_ref = scc_ir_ctx_new_node(&builder->ctx, &load_node);
+
+    // 添加到当前基本块
+    scc_ir_builder_add_instr(builder, node_ref);
+
+    return node_ref;
+}
+
+scc_ir_node_ref_t scc_ir_builder_store(scc_ir_builder_t *builder,
+                                       scc_ir_node_ref_t ptr,
+                                       scc_ir_node_ref_t value) {
+    scc_ir_node_t store_node = {0};
+    store_node.tag = SCC_IR_NODE_STORE;
+    store_node.data.store.target = ptr;
+    store_node.data.store.value = value;
+
+    scc_ir_node_ref_t node_ref =
+        scc_ir_ctx_new_node(&builder->ctx, &store_node);
+
+    // 添加到当前基本块
+    scc_ir_builder_add_instr(builder, node_ref);
+
+    return node_ref;
+}
+
+scc_ir_node_ref_t scc_ir_builder_get_ptr(scc_ir_builder_t *builder,
+                                         scc_ir_node_ref_t ptr,
+                                         scc_ir_node_ref_t index) {
+    scc_ir_node_t get_ptr_node = {0};
+    get_ptr_node.tag = SCC_IR_NODE_GET_PTR;
+    get_ptr_node.data.get_ptr.src_addr = ptr;
+    get_ptr_node.data.get_ptr.index = index;
+
+    // 类型应与源地址相同（都是指针）
+    scc_ir_node_t *src_node = scc_ir_ctx_get_node(&builder->ctx, ptr);
+    if (src_node) {
+        get_ptr_node.type = src_node->type;
+    }
+
+    scc_ir_node_ref_t node_ref =
+        scc_ir_ctx_new_node(&builder->ctx, &get_ptr_node);
+
+    // 添加到当前基本块
+    scc_ir_builder_add_instr(builder, node_ref);
+
+    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;
+    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_ctx_get_node(&builder->ctx, lhs);
+    if (lhs_node) {
+        binop_node.type = lhs_node->type;
+    }
+
+    scc_ir_node_ref_t node_ref =
+        scc_ir_ctx_new_node(&builder->ctx, &binop_node);
+
+    // 添加到当前基本块
+    scc_ir_builder_add_instr(builder, node_ref);
+
+    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;
+    cmp_node.data.op.op = op;
+    cmp_node.data.op.lhs = lhs;
+    cmp_node.data.op.rhs = rhs;
+
+    // 比较操作的结果通常是布尔值
+    cmp_node.type = scc_ir_ctx_get_builtin_i32(&builder->ctx);
+
+    scc_ir_node_ref_t node_ref = scc_ir_ctx_new_node(&builder->ctx, &cmp_node);
+
+    // 添加到当前基本块
+    scc_ir_builder_add_instr(builder, node_ref);
+
+    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;
+    jump_node.data.jump.target_bblock = target;
+
+    scc_ir_node_ref_t node_ref = scc_ir_ctx_new_node(&builder->ctx, &jump_node);
+
+    // 添加到当前基本块
+    scc_ir_builder_add_instr(builder, node_ref);
+
+    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;
+    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_ctx_new_node(&builder->ctx, &branch_node);
+
+    // 添加到当前基本块
+    scc_ir_builder_add_instr(builder, node_ref);
+
+    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;
+    call_node.data.call.callee = callee;
+
+    scc_vec_init(call_node.data.call.args);
+    for (usize i = 0; i < arg_count; i++) {
+        scc_vec_push(call_node.data.call.args, args[i]);
+    }
+
+    // 设置返回类型为被调用函数的返回类型
+    scc_ir_func_t *callee_func = scc_ir_ctx_get_func(&builder->ctx, callee);
+    if (callee_func) {
+        scc_ir_type_t *func_type =
+            scc_ir_ctx_get_type(&builder->ctx, callee_func->type);
+        if (func_type && func_type->tag == SCC_IR_TYPE_FUNC) {
+            call_node.type = func_type->data.function.ret_type;
+        }
+    }
+
+    scc_ir_node_ref_t node_ref = scc_ir_ctx_new_node(&builder->ctx, &call_node);
+
+    // 添加到当前基本块
+    scc_ir_builder_add_instr(builder, node_ref);
+
+    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;
+    ret_node.data.ret.ret_val = value;
+
+    scc_ir_node_ref_t node_ref = scc_ir_ctx_new_node(&builder->ctx, &ret_node);
+
+    // 添加到当前基本块
+    scc_ir_builder_add_instr(builder, node_ref);
+
+    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;
+    ret_node.data.ret.ret_val = 0; // 无返回值
+
+    scc_ir_node_ref_t node_ref = scc_ir_ctx_new_node(&builder->ctx, &ret_node);
+
+    // 添加到当前基本块
+    scc_ir_builder_add_instr(builder, node_ref);
+    return node_ref;
+}

libs/ir/src/ir_ctx.c

@@ -0,0 +1,345 @@
+#include "ir_ctx.h"
+#include "ir_builtin.h"
+
+/**
+ * @brief 哈希混合函数（类似Rust的hash combine）
+ *
+ * Rust的默认哈希实现（SipHash 1-3）使用旋转和异或，
+ * 这里使用简单的FNV-1a变体，类似于Rust的`#[derive(Hash)]`
+ */
+static inline u32 scc_hash_mix(u32 seed, u32 value) {
+    // FNV-1a风格混合
+    return (seed ^ value) * 16777619u;
+}
+
+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;
+}
+static u32 hash_type(const scc_ir_type_t *key) {
+    // 初始哈希：tag
+    u32 hash = (u32)key->tag;
+
+    switch (key->tag) {
+    case SCC_IR_TYPE_VOID:
+    case SCC_IR_TYPE_I1:
+    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_F16:
+    case SCC_IR_TYPE_F32:
+    case SCC_IR_TYPE_F64:
+    case SCC_IR_TYPE_F128:
+        // 基本类型，只有tag
+        break;
+
+    case SCC_IR_TYPE_PTR:
+        hash = scc_hash_mix(hash, (u32)key->data.array.base);
+        break;
+
+    case SCC_IR_TYPE_ARRAY:
+        hash = scc_hash_mix(hash, (u32)key->data.array.base);
+        hash = scc_hash_mix(hash, (u32)key->data.array.len);
+        break;
+
+    case SCC_IR_TYPE_FUNC:
+        // 注意：这里需要递归哈希参数类型
+        hash = scc_hash_mix(hash, (u32)key->data.function.ret_type);
+        for (usize i = 0; i < key->data.function.params.size; i++) {
+            hash = scc_hash_mix(hash, (u32)key->data.function.params.data[i]);
+        }
+        hash = scc_hash_mix(hash, (u32)key->data.function.params.size);
+        break;
+
+    case SCC_IR_TYPE_STRUCT:
+    case SCC_IR_TYPE_VECTOR:
+    default:
+        UNREACHABLE();
+        return 0;
+    }
+
+    return hash;
+}
+static int cmp_type(const scc_ir_type_t *key1, const scc_ir_type_t *key2) {
+    // tag不同
+    if (key1->tag != key2->tag) {
+        return 1;
+    }
+
+    switch (key1->tag) {
+    case SCC_IR_TYPE_VOID:
+    case SCC_IR_TYPE_I1:
+    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_F16:
+    case SCC_IR_TYPE_F32:
+    case SCC_IR_TYPE_F64:
+    case SCC_IR_TYPE_F128:
+        return 0; // 基本类型，tag相同即可
+    case SCC_IR_TYPE_PTR:
+        return key1->data.pointer.base != key2->data.pointer.base;
+
+    case SCC_IR_TYPE_ARRAY:
+        return (key1->data.array.base != key2->data.array.base) ||
+               (key1->data.array.len != key2->data.array.len);
+
+    case SCC_IR_TYPE_FUNC: {
+        if (key1->data.function.ret_type != key2->data.function.ret_type) {
+            return 1;
+        }
+
+        if (key1->data.function.params.size !=
+            key2->data.function.params.size) {
+            return 1;
+        }
+
+        for (usize i = 0; i < key1->data.function.params.size; i++) {
+            if (key1->data.function.params.data[i] !=
+                key2->data.function.params.data[i]) {
+                return 1;
+            }
+        }
+        return 0;
+    }
+    default:
+        UNREACHABLE();
+        return 1;
+    }
+    return 1;
+}
+
+void scc_ir_ctx_init(scc_ir_cprog_ctx_t *ctx) {
+    // 初始化向量
+    scc_vec_init(ctx->nodes);
+    scc_vec_init(ctx->types);
+    scc_vec_init(ctx->bblocks);
+    scc_vec_init(ctx->funcs);
+
+    // 设置哈希函数
+    ctx->uid2nodes.hash_func = hash_key;
+    ctx->uid2nodes.key_cmp = cmp_key;
+    ctx->uid2types.hash_func = hash_key;
+    ctx->uid2types.key_cmp = cmp_key;
+    ctx->uid2bblocks.hash_func = hash_key;
+    ctx->uid2bblocks.key_cmp = cmp_key;
+    ctx->uid2funcs.hash_func = hash_key;
+    ctx->uid2funcs.key_cmp = cmp_key;
+    // 初始化哈希表
+    scc_hashtable_init(&ctx->uid2nodes);
+    scc_hashtable_init(&ctx->uid2types);
+    scc_hashtable_init(&ctx->uid2bblocks);
+    scc_hashtable_init(&ctx->uid2funcs);
+
+    ctx->type_uniquing.hash_func = (void *)hash_type;
+    ctx->type_uniquing.key_cmp = (void *)cmp_type;
+    scc_hashtable_init(&ctx->type_uniquing);
+
+    // 预留UID 0 作为无效引用
+    ctx->node_uid = 1;
+    ctx->type_uid = 1;
+    ctx->bblock_uid = 1;
+    ctx->func_uid = 1;
+}
+
+void scc_ir_ctx_drop(scc_ir_cprog_ctx_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);
+}
+
+void scc_ir_ctx_reset(scc_ir_cprog_ctx_t *ctx) {
+    // 先销毁再重新初始化
+    scc_ir_ctx_drop(ctx);
+    scc_ir_ctx_init(ctx);
+}
+
+// 辅助宏：创建实体并添加到哈希表
+#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_ctx_new_type(scc_ir_cprog_ctx_t *ctx,
+                                      const scc_ir_type_t *type) {
+    // 首先检查去重表
+    void *existing = scc_hashtable_get(&ctx->type_uniquing, type);
+    if (existing) {
+        return (scc_ir_type_ref_t)(uintptr_t)existing;
+    }
+
+    // 创建新类型
+    unsigned new_uid = ctx->type_uid++;
+    scc_vec_push(ctx->types, *type);
+
+    // 添加到UID映射
+    usize idx = ctx->types.size - 1;
+    scc_hashtable_set(&ctx->uid2types, &new_uid, (void *)idx);
+
+    // 添加到去重表
+    scc_hashtable_set(&ctx->type_uniquing,
+                      &ctx->types.data[idx], // 使用向量中的地址作为键
+                      (void *)(uintptr_t)new_uid);
+
+    return new_uid;
+}
+
+scc_ir_node_ref_t scc_ir_ctx_new_node(scc_ir_cprog_ctx_t *ctx,
+                                      const scc_ir_node_t *node) {
+    CREATE_ENTITY(ctx, ctx->nodes, node_uid, node, uid2nodes);
+}
+
+scc_ir_bblock_ref_t scc_ir_ctx_new_bblock(scc_ir_cprog_ctx_t *ctx,
+                                          const scc_ir_bblock_t *bblock) {
+    CREATE_ENTITY(ctx, ctx->bblocks, bblock_uid, bblock, uid2bblocks);
+}
+
+scc_ir_func_ref_t scc_ir_ctx_new_func(scc_ir_cprog_ctx_t *ctx,
+                                      const scc_ir_func_t *func) {
+    CREATE_ENTITY(ctx, ctx->funcs, func_uid, func, uid2funcs);
+}
+
+#undef CREATE_ENTITY
+
+// 辅助宏：从哈希表获取索引
+#define GET_ENTITY_INDEX(ctx, ref, hashtable)                                  \
+    ((usize)scc_hashtable_get(&(ctx)->hashtable, (void *)(usize)ref))
+
+scc_ir_type_t *scc_ir_ctx_get_type(scc_ir_cprog_ctx_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_ctx_get_node(scc_ir_cprog_ctx_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_ctx_get_bblock(scc_ir_cprog_ctx_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_ctx_get_func(scc_ir_cprog_ctx_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];
+}
+
+#undef GET_ENTITY_INDEX
+
+// 内置类型和常量缓存
+static scc_ir_type_ref_t cached_i32_type = 0;
+static scc_ir_node_ref_t cached_zero_const = 0;
+
+scc_ir_type_ref_t scc_ir_ctx_get_builtin_i32(scc_ir_cprog_ctx_t *ctx) {
+    if (cached_i32_type == 0) {
+        scc_ir_type_t i32_type = {.tag = SCC_IR_TYPE_I32};
+        cached_i32_type = scc_ir_ctx_new_type(ctx, &i32_type);
+    }
+    return cached_i32_type;
+}
+
+scc_ir_node_ref_t scc_ir_ctx_get_builtin_zero(scc_ir_cprog_ctx_t *ctx) {
+    if (cached_zero_const == 0) {
+        scc_ir_node_t zero_node = {.tag = SCC_IR_NODE_CONST_INT,
+                                   .type = scc_ir_ctx_get_builtin_i32(ctx),
+                                   .name = "zero",
+                                   .data.const_int.int32 = 0};
+        cached_zero_const = scc_ir_ctx_new_node(ctx, &zero_node);
+    }
+    return cached_zero_const;
+}
+
+// 常量池（简化版）
+typedef struct {
+    i32 value;
+    scc_ir_node_ref_t ref;
+} i32_const_entry_t;
+
+scc_ir_node_ref_t scc_ir_ctx_get_i32_const(scc_ir_cprog_ctx_t *ctx, i32 value) {
+    // 如果是0，使用内置zero
+    if (value == 0) {
+        return scc_ir_ctx_get_builtin_zero(ctx);
+    }
+
+    // TODO: 实现常量池哈希表
+    // 这里简化实现，每次都创建新常量
+    scc_ir_node_t const_node = {.tag = SCC_IR_NODE_CONST_INT,
+                                .type = scc_ir_ctx_get_builtin_i32(ctx),
+                                .data.const_int.int32 = value};
+
+    const_node.name = "";
+
+    return scc_ir_ctx_new_node(ctx, &const_node);
+}
+
+scc_ir_node_ref_t scc_ir_ctx_get_null_const(scc_ir_cprog_ctx_t *ctx,
+                                            scc_ir_type_ref_t ptr_type) {
+    return 1;
+}

libs/ir/src/ir_dump.c

@@ -1,13 +1,522 @@
+#include <ir_ctx.h>
 #include <ir_dump.h>
 
-void scc_ir_type_dump(scc_ir_dump_ctx_t *ctx, const scc_ir_type_t *in) {
+#define PRINT_VALUE(ctx, fmt, value)                                           \
-    return;
+    SCC_TREE_DUMP_PRINT_PURE(ctx, ctx->value_color, fmt, value)
+
+#define PRINT_NODE(ctx, name)                                                  \
+    SCC_TREE_DUMP_PRINT_PURE(ctx, ctx->node_color, "%s", name)
+
+#define PRINT_QUOTED_VALUE(ctx, str)                                           \
+    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 *node_types[] = {
+        [SCC_IR_NODE_NULL] = "Null",   [SCC_IR_NODE_CONST_INT] = "ConstInt",
+        [SCC_IR_NODE_ALLOC] = "Alloc", [SCC_IR_NODE_LOAD] = "Load",
+        [SCC_IR_NODE_STORE] = "Store", [SCC_IR_NODE_GET_PTR] = "GetElementPtr",
+        [SCC_IR_NODE_OP] = "Op",       [SCC_IR_NODE_BRANCH] = "Branch",
+        [SCC_IR_NODE_JUMP] = "Jump",   [SCC_IR_NODE_CALL] = "Call",
+        [SCC_IR_NODE_RET] = "Return",
+    };
+
+    if (tag >= 0 && tag < sizeof(node_types) / sizeof(node_types[0]) &&
+        node_types[tag] != NULL) {
+        return node_types[tag];
+    }
+    return "UnknownIRNode";
 }
-void scc_ir_bblock_dump(scc_ir_dump_ctx_t *ctx, const scc_ir_bblock_t *in) {
+
-    return;
+// 获取操作符字符串
+static const char *get_op_str(scc_ir_op_type_t op) {
+    static const char *ops[] = {
+        [IR_OP_EMPTY] = "empty", [IR_OP_NEQ] = "!=", [IR_OP_EQ] = "==",
+        [IR_OP_GT] = ">",        [IR_OP_LT] = "<",   [IR_OP_GE] = ">=",
+        [IR_OP_LE] = "<=",       [IR_OP_ADD] = "+",  [IR_OP_SUB] = "-",
+        [IR_OP_MUL] = "*",       [IR_OP_DIV] = "/",  [IR_OP_MOD] = "%",
+        [IR_OP_AND] = "&",       [IR_OP_OR] = "|",   [IR_OP_XOR] = "^",
+        [IR_OP_NOT] = "~",       [IR_OP_SHL] = "<<", [IR_OP_SHR] = ">>",
+        [IR_OP_SAR] = ">>a", // Arithmetic shift right
+    };
+
+    if (op >= 0 && op < sizeof(ops) / sizeof(ops[0]) && ops[op] != NULL) {
+        return ops[op];
+    }
+    return "<unknown_op>";
 }
-void scc_ir_func_dump(scc_ir_dump_ctx_t *ctx, const scc_ir_func_t *in) {
+
-    return;
+// 获取类型标签字符串
+static const char *get_type_tag_str(scc_ir_type_tag_t tag) {
+    static const char *type_tags[] = {
+        [SCC_IR_TYPE_VOID] = "void",     [SCC_IR_TYPE_I1] = "i1",
+        [SCC_IR_TYPE_I8] = "i8",         [SCC_IR_TYPE_I16] = "i16",
+        [SCC_IR_TYPE_I32] = "i32",       [SCC_IR_TYPE_I64] = "i64",
+        [SCC_IR_TYPE_I128] = "i128",     [SCC_IR_TYPE_F16] = "f16",
+        [SCC_IR_TYPE_F32] = "f32",       [SCC_IR_TYPE_F64] = "f64",
+        [SCC_IR_TYPE_F128] = "f128",     [SCC_IR_TYPE_PTR] = "ptr",
+        [SCC_IR_TYPE_ARRAY] = "array",   [SCC_IR_TYPE_FUNC] = "func",
+        [SCC_IR_TYPE_STRUCT] = "struct", [SCC_IR_TYPE_VECTOR] = "vector",
+    };
+
+    if (tag >= 0 && tag < sizeof(type_tags) / sizeof(type_tags[0]) &&
+        type_tags[tag] != NULL) {
+        return type_tags[tag];
+    }
+    return "<unknown_type>";
+}
+
+// 递归转储辅助函数（使用引用）
+static inline void dump_child_node_ref(scc_ir_dump_ctx_t *ctx,
+                                       scc_ir_node_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_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) {
+    scc_tree_dump_push_level(ctx->dump_ctx, true);
+    scc_tree_print_indent(ctx->dump_ctx);
+    scc_printf("%d\n", node->data.const_int.int32);
+    scc_tree_dump_pop_level(ctx->dump_ctx);
+}
+
+// 转储操作节点
+static void dump_op_node(scc_ir_dump_ctx_t *ctx, const scc_ir_node_t *node) {
+    // 打印操作符
+    scc_tree_dump_push_level(ctx->dump_ctx, false);
+    scc_tree_print_indent(ctx->dump_ctx);
+    SCC_TREE_DUMP_PRINT_PURE(ctx->dump_ctx, ctx->dump_ctx->node_color,
+                             "op: %s\n", get_op_str(node->data.op.op));
+    scc_tree_dump_pop_level(ctx->dump_ctx);
+
+    // 左操作数
+    if (node->data.op.lhs) {
+        dump_child_node_ref(ctx, node->data.op.lhs,
+                            node->data.op.rhs ? false : true);
+    }
+
+    // 右操作数
+    if (node->data.op.rhs) {
+        dump_child_node_ref(ctx, node->data.op.rhs, true);
+    }
+}
+
+// 转储加载节点
+static void dump_load_node(scc_ir_dump_ctx_t *ctx, const scc_ir_node_t *node) {
+    // PRINT_NODE(ctx->dump_ctx, "load");
+    if (node->data.load.target) {
+        dump_child_node_ref(ctx, node->data.load.target, true);
+    }
+}
+
+// 转储存储节点
+static void dump_store_node(scc_ir_dump_ctx_t *ctx, const scc_ir_node_t *node) {
+    // PRINT_NODE(ctx->dump_ctx, "store");
+
+    // 输出存储位置
+    if (node->data.store.target) {
+        dump_child_node_ref(ctx, node->data.store.target, false);
+    }
+
+    // 输出存储的值
+    if (node->data.store.value) {
+        dump_child_node_ref(ctx, node->data.store.value, true);
+    }
+}
+
+// 转储获取指针节点
+static void dump_get_ptr_node(scc_ir_dump_ctx_t *ctx,
+                              const scc_ir_node_t *node) {
+    // PRINT_NODE(ctx->dump_ctx, "get_ptr");
+    // 输出源地址
+    if (node->data.get_ptr.src_addr) {
+        dump_child_node_ref(ctx, node->data.get_ptr.src_addr, false);
+    }
+
+    // 输出索引
+    if (node->data.get_ptr.index) {
+        dump_child_node_ref(ctx, node->data.get_ptr.index, true);
+    }
+}
+
+// 转储分支节点
+static void dump_branch_node(scc_ir_dump_ctx_t *ctx,
+                             const scc_ir_node_t *node) {
+    // PRINT_NODE(ctx->dump_ctx, "branch");
+
+    // 输出条件
+    if (node->data.branch.cond) {
+        dump_child_node_ref(ctx, node->data.branch.cond, false);
+    }
+
+    // 输出真分支块
+    if (node->data.branch.true_bblock) {
+        scc_ir_bblock_t *true_bblock =
+            scc_ir_ctx_get_bblock(ctx->ir_ctx, node->data.branch.true_bblock);
+        if (true_bblock) {
+            scc_tree_print_indent(ctx->dump_ctx);
+            PRINT_NODE(ctx->dump_ctx, "TrueBlock: ");
+            PRINT_QUOTED_VALUE(ctx->dump_ctx, true_bblock->label
+                                                  ? true_bblock->label
+                                                  : "<unnamed>");
+        }
+    }
+
+    // 输出假分支块
+    if (node->data.branch.false_bblock) {
+        scc_ir_bblock_t *false_bblock =
+            scc_ir_ctx_get_bblock(ctx->ir_ctx, node->data.branch.false_bblock);
+        if (false_bblock) {
+            scc_tree_print_indent(ctx->dump_ctx);
+            PRINT_NODE(ctx->dump_ctx, "FalseBlock: ");
+            PRINT_QUOTED_VALUE(ctx->dump_ctx, false_bblock->label
+                                                  ? false_bblock->label
+                                                  : "<unnamed>");
+        }
+    }
+}
+
+// 转储跳转节点
+static void dump_jump_node(scc_ir_dump_ctx_t *ctx, const scc_ir_node_t *node) {
+    // PRINT_NODE(ctx->dump_ctx, "jump");
+    if (node->data.jump.target_bblock) {
+        scc_ir_bblock_t *target_bblock =
+            scc_ir_ctx_get_bblock(ctx->ir_ctx, node->data.jump.target_bblock);
+        if (target_bblock) {
+            scc_printf("to '%s'", target_bblock->label ? target_bblock->label
+                                                       : "<unnamed>");
+        } else {
+            scc_printf("to invalid block");
+        }
+    } else {
+        scc_printf("to NULL");
+    }
+}
+
+// 转储调用节点
+static void dump_call_node(scc_ir_dump_ctx_t *ctx, const scc_ir_node_t *node) {
+    // PRINT_NODE(ctx->dump_ctx, "call");
+    if (node->data.call.callee) {
+        scc_ir_func_t *callee =
+            scc_ir_ctx_get_func(ctx->ir_ctx, node->data.call.callee);
+        if (callee) {
+            scc_printf("func='%s'", callee->name ? callee->name : "<unnamed>");
+        } else {
+            scc_printf("func=<invalid>");
+        }
+    } else {
+        scc_printf("func=NULL");
+    }
+
+    if (scc_vec_size(node->data.call.args) > 0) {
+        scc_printf("\n");
+    }
+
+    // 输出参数
+    for (usize i = 0; i < scc_vec_size(node->data.call.args); i++) {
+        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);
+        dump_child_node_ref(ctx, arg_ref, is_last);
+
+        scc_tree_dump_pop_level(ctx->dump_ctx);
+    }
+}
+
+// 转储返回节点
+static void dump_ret_node(scc_ir_dump_ctx_t *ctx, const scc_ir_node_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);
+    }
+}
+
+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_ctx_get_node(ctx->ir_ctx, node_ref);
+    if (!node) {
+        LOG_ERROR("Invalid node ref");
+        return;
+    }
+
+    scc_tree_print_indent(ctx->dump_ctx);
+    PRINT_NODE(ctx->dump_ctx, get_node_type_str(node->tag));
+
+    if (node->name && node->name[0]) {
+        PRINT_VALUE(ctx->dump_ctx, " [%s]", node->name);
+    }
+
+    if (node->type) {
+        scc_printf(" : ");
+        scc_ir_type_t *type = scc_ir_ctx_get_type(ctx->ir_ctx, node->type);
+        if (type) {
+            PRINT_VALUE(ctx->dump_ctx, "%s", get_type_tag_str(type->tag));
+        }
+    }
+
+    scc_printf("\n");
+
+    // 根据节点类型输出特定信息
+    switch (node->tag) {
+    case SCC_IR_NODE_NULL:
+        break;
+    case SCC_IR_NODE_CONST_INT:
+        dump_const_int_node(ctx, node);
+        break;
+    case SCC_IR_NODE_ALLOC:
+        break;
+    case SCC_IR_NODE_LOAD:
+        dump_load_node(ctx, node);
+        break;
+    case SCC_IR_NODE_STORE:
+        dump_store_node(ctx, node);
+        break;
+    case SCC_IR_NODE_GET_PTR:
+        dump_get_ptr_node(ctx, node);
+        break;
+    case SCC_IR_NODE_OP:
+        dump_op_node(ctx, node);
+        break;
+    case SCC_IR_NODE_BRANCH:
+        dump_branch_node(ctx, node);
+        break;
+    case SCC_IR_NODE_JUMP:
+        dump_jump_node(ctx, node);
+        break;
+    case SCC_IR_NODE_CALL:
+        dump_call_node(ctx, node);
+        break;
+    case SCC_IR_NODE_RET:
+        dump_ret_node(ctx, node);
+        break;
+    default:
+        PRINT_QUOTED_VALUE(ctx->dump_ctx, "unknown");
+        scc_printf("tag(%d)", node->tag);
+        break;
+    }
+}
+
+// 转储类型信息
+void scc_ir_dump_type(scc_ir_dump_ctx_t *ctx, scc_ir_type_ref_t type_ref) {
+    // impl fmt::Display for TypeKind {
+    //   fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    //     match self {
+    //       TypeKind::Int32 => write!(f, "i32"),
+    //       TypeKind::Unit => write!(f, "unit"),
+    //       TypeKind::Array(t, len) => write!(f, "[{}, {}]", t, len),
+    //       TypeKind::Pointer(t) => write!(f, "*{}", t),
+    //       TypeKind::Function(params, ret) => {
+    //         write!(f, "(")?;
+    //         let mut first = true;
+    //         for param in params {
+    //           if !first {
+    //             write!(f, ", ")?;
+    //           }
+    //           write!(f, "{}", param)?;
+    //           first = false;
+    //         }
+    //         if !ret.is_unit() {
+    //           write!(f, "): {}", ret)
+    //         } else {
+    //           write!(f, ")")
+    //         }
+    //       }
+    //     }
+    //   }
+    // }
+    if (!ctx || !type_ref) {
+        LOG_ERROR("invalid parameter");
+        return;
+    }
+
+    scc_ir_type_t *type = scc_ir_ctx_get_type(ctx->ir_ctx, type_ref);
+    if (!type) {
+        LOG_ERROR("invalid type ref");
+        return;
+    }
+    scc_tree_print_indent(ctx->dump_ctx);
+    PRINT_NODE(ctx->dump_ctx, "Type: ");
+    PRINT_QUOTED_VALUE(ctx->dump_ctx, get_type_tag_str(type->tag));
+    scc_printf("\n");
+
+    // 递归转储子类型
+    switch (type->tag) {
+    case SCC_IR_TYPE_PTR:
+        if (type->data.pointer.base) {
+            scc_tree_dump_push_level(ctx->dump_ctx, true);
+            scc_ir_dump_type(ctx, type->data.pointer.base);
+            scc_tree_dump_pop_level(ctx->dump_ctx);
+        }
+        break;
+    case SCC_IR_TYPE_ARRAY:
+        if (type->data.array.len > 0) {
+            scc_tree_print_indent(ctx->dump_ctx);
+            SCC_TREE_DUMP_PRINT_PURE(ctx->dump_ctx, ctx->dump_ctx->node_color,
+                                     "Array Length: %zu\n",
+                                     type->data.array.len);
+        }
+        if (type->data.array.base) {
+            scc_tree_dump_push_level(ctx->dump_ctx, true);
+            scc_ir_dump_type(ctx, type->data.array.base);
+            scc_tree_dump_pop_level(ctx->dump_ctx);
+        }
+        break;
+    case SCC_IR_TYPE_FUNC:
+        // 先输出参数类型
+        for (usize i = 0; i < scc_vec_size(type->data.function.params); i++) {
+            cbool is_last = (i + 1 == scc_vec_size(type->data.function.params));
+            scc_tree_dump_push_level(ctx->dump_ctx, is_last);
+
+            scc_ir_type_ref_t param_type_ref =
+                scc_vec_at(type->data.function.params, i);
+            scc_ir_dump_type(ctx, param_type_ref);
+
+            scc_tree_dump_pop_level(ctx->dump_ctx);
+        }
+
+        // 再输出返回类型
+        if (type->data.function.ret_type) {
+            scc_tree_dump_push_level(ctx->dump_ctx, true);
+            scc_ir_dump_type(ctx, type->data.function.ret_type);
+            scc_tree_dump_pop_level(ctx->dump_ctx);
+        }
+        break;
+    case SCC_IR_TYPE_STRUCT:
+        // 结构体处理
+        break;
+    case SCC_IR_TYPE_VECTOR:
+        // 向量处理
+        break;
+    default:
+        break;
+    }
+}
+
+// 转储基本块
+void scc_ir_dump_bblock(scc_ir_dump_ctx_t *ctx,
+                        scc_ir_bblock_ref_t bblock_ref) {
+    if (!ctx || !bblock_ref) {
+        LOG_ERROR("invalid parameter");
+        return;
+    }
+
+    scc_ir_bblock_t *bblock = scc_ir_ctx_get_bblock(ctx->ir_ctx, bblock_ref);
+    if (!bblock) {
+        LOG_ERROR("invalid bblock ref");
+        return;
+    }
+
+    scc_tree_print_indent(ctx->dump_ctx);
+    PRINT_NODE(ctx->dump_ctx, "BasicBlock: ");
+    PRINT_QUOTED_VALUE(ctx->dump_ctx,
+                       bblock->label ? bblock->label : "<unnamed>");
+    scc_printf("\n");
+
+    // 转储基本块中的指令
+    for (usize i = 0; i < scc_vec_size(bblock->instrs); i++) {
+        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_tree_dump_pop_level(ctx->dump_ctx);
+    }
+}
+
+// 转储函数
+void scc_ir_dump_func(scc_ir_dump_ctx_t *ctx, scc_ir_func_ref_t func_ref) {
+    scc_ir_func_t *func = scc_ir_ctx_get_func(ctx->ir_ctx, func_ref);
+    if (!ctx || !func) {
+        LOG_ERROR("invalid parameter");
+        return;
+    }
+
+    scc_tree_print_indent(ctx->dump_ctx);
+    PRINT_NODE(ctx->dump_ctx, "Function: ");
+    PRINT_QUOTED_VALUE(ctx->dump_ctx, func->name ? func->name : "<unnamed>");
+    scc_printf("\n");
+
+    // 输出函数类型
+    if (func->type) {
+        scc_tree_dump_push_level(ctx->dump_ctx, false);
+        scc_ir_dump_type(ctx, func->type);
+        scc_tree_dump_pop_level(ctx->dump_ctx);
+    }
+
+    // 输出函数参数
+    for (usize i = 0; i < scc_vec_size(func->params); i++) {
+        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_tree_dump_pop_level(ctx->dump_ctx);
+    }
+
+    // 输出基本块
+    for (usize i = 0; i < scc_vec_size(func->bblocks); i++) {
+        cbool is_last = (i + 1 == scc_vec_size(func->bblocks));
+        scc_tree_dump_push_level(ctx->dump_ctx, is_last);
+
+        scc_ir_bblock_ref_t bblock_ref = scc_vec_at(func->bblocks, i);
+        scc_ir_dump_bblock(ctx, bblock_ref);
+
+        scc_tree_dump_pop_level(ctx->dump_ctx);
+    }
+}
+
+// 转储整个程序
+void scc_ir_dump_cprog(scc_ir_dump_ctx_t *ctx) {
+    // 输出全局值
+
+    // if (scc_vec_size(program->global_vals) > 0) {
+    //     print_indented(ctx, "Global Values:", "");
+
+    //     for (usize i = 0; i < scc_vec_size(program->global_vals); i++) {
+    //         cbool is_last = (i + 1 ==
+    //         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
+    //         *global_node =
+    //             scc_ir_ctx_get_node(ir_ctx, global_ref);
+    //         if (global_node) {
+    //             scc_ir_dump_node(ctx, ir_ctx, global_node);
+    //         }
+
+    //         scc_tree_dump_pop_level(ctx->dump_ctx);
+    //     }
+    // }
+
+    // // 输出函数定义
+    // if (scc_vec_size(ir_ctx->funcs) > 0) {
+    //     print_indented(ctx, "Functions:", "");
+
+    //     for (usize i = 0; i < scc_vec_size(ir_ctx->funcs); i++) {
+    //         cbool is_last = (i + 1 == scc_vec_size(ir_ctx->funcs));
+    //         scc_tree_dump_push_level(ctx->dump_ctx, is_last);
+
+    //         scc_ir_func_t func_ref = scc_vec_at(ir_ctx->funcs, i);
+    //         if (func_ref.type != 0) {
+    //             // TODO hack it
+    //             dump_func_ref(ir_ctx, ctx, i + 1);
+    //         }
+
+    //         scc_tree_dump_pop_level(ctx->dump_ctx);
+    //     }
+    // }
+    PRINT_NODE(ctx->dump_ctx, "Func defs:\n");
+    scc_vec_foreach(ctx->cprog->func_defs, i) {
+        cbool is_last = (i + 1 == scc_vec_size(ctx->cprog->func_defs));
+        scc_tree_dump_push_level(ctx->dump_ctx, is_last);
+        scc_ir_dump_func(ctx, scc_vec_at(ctx->cprog->func_defs, i));
+        scc_tree_dump_pop_level(ctx->dump_ctx);
+    }
 }
-void scc_ir_node_dump(scc_ir_dump_ctx_t *ctx, scc_ir_node_t *in) { return; }
-void scc_ir_cprog_dump(scc_ir_dump_ctx_t *ctx, ir_cprog_t *in) { return; }

libs/tree_dump/include/tree_dump.h

@@ -15,6 +15,19 @@
 
 // #define ANSI_FMT
 
+#define SCC_TREE_DUMP_PRINT_COLORED(ctx, color, before_str, fmt, after_str,    \
+                                    ...)                                       \
+    scc_printf(before_str "%s" fmt "%s" after_str,                             \
+               ctx->use_color ? color : "", ##__VA_ARGS__,                     \
+               ctx->use_color ? ANSI_NONE : "");
+
+#define SCC_TREE_DUMP_PRINT_AROUND(ctx, color, around_str, fmt, ...)           \
+    SCC_TREE_DUMP_PRINT_COLORED(ctx, color, around_str, fmt, around_str,       \
+                                ##__VA_ARGS__)
+
+#define SCC_TREE_DUMP_PRINT_PURE(ctx, color, fmt, ...)                         \
+    SCC_TREE_DUMP_PRINT_COLORED(ctx, color, "", fmt, "", ##__VA_ARGS__)
+
 typedef SCC_VEC(cbool) scc_ast_dump_stack_t;
 
 typedef struct {