feat(cbuild): 更新项目配置以支持HIR中间表示

- 统一包名格式化，添加空格对齐
- 将依赖项从ir和lir重命名为hir，移除lir注释
- 为ast2ir模块添加正确的包名称"scc_ast2ir"
- 更新依赖引用路径指向新的HIR库结构
- 移除注释掉的ir2mcode和sccf2target依赖项

refactor(ast2ir): 迁移到HIR中间表示替换IR表示

- 更新头文件包含，使用hir_builder.h替代ir_builder.h
- 修改上下文结构体，将scc_ir_builder_t替换为scc_hir_builder_t
- 更新函数签名，将参数类型从scc_ir_*转换为scc_hir_*
- 调整返回值类型，将scc_ir_value_ref_t和scc_ir_type_ref_t
  分别替换为scc_hir_value_ref_t和scc_hir_type_ref_t
- 重新排列头文件包含顺序以满足依赖关系

libs/ast2ir/cbuild.toml

@@ -1,12 +1,12 @@
 [package]
-name = ""
-version = "0.1.0"
-authors = []
+name        = "scc_ast2ir"
+version     = "0.1.0"
+authors     = []
 description = ""
 
 dependencies = [
     { name = "scc_ast", path = "../ast" },
-    { name = "scc_ir", path = "../ir" },
+    { name = "scc_hir", path = "../ir/hir" },
     { name = "scc_abi", path = "../abi" },
 ]
 # features = {}

libs/ast2ir/include/scc_ast2ir.h

@@ -1,13 +1,12 @@
 #ifndef __SCC_AST2IR_H__
 #define __SCC_AST2IR_H__
 
-#include "scc_type_abi.h"
-#include <ir_builder.h>
+#include <hir_builder.h>
 #include <scc_ast.h>
-#include <scc_ir.h>
+#include <scc_type_abi.h>
 
 typedef struct {
-    scc_ir_builder_t builder;
+    scc_hir_builder_t builder;
     scc_hashtable_t ast2ir_cache; ///< ast node to ir ref cache
     scc_hashtable_t symtab;       ///< symbol to ir_ref
     // scc_strpool_t strpool;   ///< string pool
@@ -16,17 +15,18 @@ typedef struct {
 } scc_ast2ir_ctx_t;
 
 void scc_ast2ir_ctx_init(scc_ast2ir_ctx_t *ctx, const scc_abi_type_calc_t *abi,
-                         scc_ir_cprog_t *cprog);
+                         scc_hir_cprog_t *cprog);
 void scc_ast2ir_ctx_drop(scc_ast2ir_ctx_t *ctx);
 
 void scc_ast2ir_translation_unit(scc_ast2ir_ctx_t *ctx,
                                  const scc_ast_translation_unit_t *tu);
 void scc_ast2ir_decl(scc_ast2ir_ctx_t *ctx, const scc_ast_decl_t *decl,
                      cbool is_global);
-scc_ir_value_ref_t scc_ast2ir_expr(scc_ast2ir_ctx_t *ctx,
-                                   const scc_ast_expr_t *expr, cbool is_lvalue);
+scc_hir_value_ref_t scc_ast2ir_expr(scc_ast2ir_ctx_t *ctx,
+                                    const scc_ast_expr_t *expr,
+                                    cbool is_lvalue);
 void scc_ast2ir_stmt(scc_ast2ir_ctx_t *ctx, const scc_ast_stmt_t *stmt);
-scc_ir_type_ref_t scc_ast2ir_type(scc_ast2ir_ctx_t *ctx,
-                                  const scc_ast_type_t *ast_type);
+scc_hir_type_ref_t scc_ast2ir_type(scc_ast2ir_ctx_t *ctx,
+                                   const scc_ast_type_t *ast_type);
 
 #endif /* __SCC_AST2IR_H__ */

libs/ir/cbuild.toml

@@ -1,13 +0,0 @@
-[package]
-name = "ir"
-version = "0.1.0"
-authors = []
-description = ""
-
-dependencies = [
-    { name = "scc_utils", path = "../../runtime/scc_utils" },
-    { name = "tree_dump", path = "../tree_dump" },
-]
-# dependencies = []
-# features = {}
-# default_features = []

libs/ir/cfg/cbuild.toml

@@ -0,0 +1,12 @@
+[package]
+name        = "scc_cfg"
+version     = "0.1.0"
+authors     = []
+description = ""
+
+dependencies = [
+    { name = "scc_core", path = "../../../runtime/scc_core" },
+    { name = "scc_utils", path = "../../../runtime/scc_utils" },
+]
+# features = {}
+# default_features = []

libs/ir/cfg/include/scc_cfg.h

@@ -0,0 +1,108 @@
+#ifndef __SCC_CFG_H__
+#define __SCC_CFG_H__
+
+#include <scc_core.h>
+#include <scc_hashtable.h>
+
+#define SCC_CFG_ID_nullptr (0)
+typedef usize scc_cfg_id_t;
+typedef scc_cfg_id_t scc_cfg_bblock_id_t;
+typedef scc_cfg_id_t scc_cfg_func_id_t;
+
+typedef SCC_VEC(scc_cfg_bblock_id_t) scc_cfg_bblock_id_vec_t;
+typedef SCC_VEC(void *) scc_cfg_value_vec_t;
+typedef struct scc_cfg_module scc_cfg_module_t;
+typedef struct scc_cfg_func scc_cfg_func_t;
+typedef struct scc_cfg_bblock scc_cfg_bblock_t;
+typedef struct scc_cfg_symbol scc_cfg_symbol_t;
+
+struct scc_cfg_bblock {
+    scc_cfg_bblock_id_t id;
+    const char *name;
+    scc_cfg_bblock_id_vec_t preds; // 前驱
+    scc_cfg_bblock_id_vec_t succs; // 后继
+    scc_cfg_value_vec_t values;    // using cast
+    void *attribute;
+};
+
+struct scc_cfg_func {
+    const char *name;
+
+    scc_cfg_bblock_id_t next_bblock_id;
+    scc_cfg_bblock_id_vec_t bblocks;
+    scc_hashtable_t bblock_map; // id -> index
+
+    scc_cfg_bblock_id_t entry_bblock_id; // maybe it will always 0
+    void *attribute;
+};
+
+typedef enum {
+    SCC_CFG_SYMBOL_KIND_FUNC,
+    SCC_CFG_SYMBOL_KIND_DATA,
+    SCC_CFG_SYMBOL_KIND_EXTERN,
+} scc_cfg_symbol_kind_t;
+
+struct scc_cfg_symbol {
+    const char *name;
+    scc_cfg_symbol_kind_t kind;
+    void *attribute;
+};
+
+typedef SCC_VEC(scc_cfg_bblock_t) scc_cfg_bblock_vec_t;
+typedef SCC_VEC(scc_cfg_func_t) scc_cfg_func_vec_t;
+typedef SCC_VEC(scc_cfg_symbol_t) scc_cfg_symbol_vec_t;
+struct scc_cfg_module {
+    scc_cfg_bblock_vec_t bblocks;
+    scc_cfg_func_vec_t funcs;     /* 所有函数定义（按添加顺序） */
+    scc_cfg_symbol_vec_t symbols; /* 全局符号表 */
+    scc_hashtable_t symbol_map;   /* 名称 -> 索引 */
+};
+
+void scc_cfg_module_init(scc_cfg_module_t *module);
+/**
+ * @brief
+ *
+ * @param module
+ * @warning 由于void*存在可能导致严重内存泄漏
+ */
+void scc_cfg_module_drop(scc_cfg_module_t *module);
+scc_cfg_func_id_t scc_cfg_module_add_func(scc_cfg_module_t *module,
+                                          const scc_cfg_func_t *func);
+scc_cfg_func_t *scc_cfg_module_unsafe_get_func(scc_cfg_module_t *module,
+                                               scc_cfg_func_id_t id);
+scc_cfg_bblock_id_t scc_cfg_module_add_bblock(scc_cfg_module_t *module,
+                                              const scc_cfg_bblock_t *bblock);
+scc_cfg_bblock_t *scc_cfg_module_unsafe_get_bblock(scc_cfg_module_t *module,
+                                                   scc_cfg_bblock_id_t id);
+void scc_cfg_module_add_symbol(scc_cfg_module_t *module,
+                               const scc_cfg_symbol_t *symbol);
+scc_cfg_id_t scc_cfg_module_lookup_symbol(const scc_cfg_module_t *module,
+                                          const char *name);
+
+static inline const scc_cfg_symbol_t *
+scc_cfg_module_unsafe_lookup_symbol(const scc_cfg_module_t *module,
+                                    const char *name) {
+    scc_cfg_id_t idx = scc_cfg_module_lookup_symbol(module, name);
+    if (idx == 0) {
+        Panic("Can't find symbol %s", name);
+        return nullptr;
+    }
+    return &scc_vec_at(module->symbols, idx);
+}
+
+// scc_cfg_bblock_id_t scc_cfg_func_add_bblock(scc_cfg_func_t *func,
+//                                             const scc_cfg_bblock_t *bblock);
+// scc_cfg_bblock_t *scc_cfg_func_unsafe_get_bblock(scc_cfg_func_t *func,
+//                                                  scc_cfg_bblock_id_t id);
+// scc_cfg_bblock_t *scc_cfg_func_unsafe_entry_bblock(scc_cfg_func_t *func);
+
+void scc_cfg_bblock_add_pred(scc_cfg_bblock_t *bb, scc_cfg_bblock_id_t pred_id);
+void scc_cfg_bblock_remove_pred(scc_cfg_bblock_t *bb,
+                                scc_cfg_bblock_id_t pred_id);
+void scc_cfg_bblock_clear_pred(scc_cfg_bblock_t *bb);
+void scc_cfg_bblock_add_succ(scc_cfg_bblock_t *bb, scc_cfg_bblock_id_t succ_id);
+void scc_cfg_bblock_remove_succ(scc_cfg_bblock_t *bb,
+                                scc_cfg_bblock_id_t succ_id);
+void scc_cfg_bblock_clear_succs(scc_cfg_bblock_t *bb);
+
+#endif /* __SCC_CFG_H__ */

libs/ir/cfg/src/scc_cfg.c

@@ -0,0 +1,81 @@
+#include <scc_cfg.h>
+
+void scc_cfg_module_init(scc_cfg_module_t *module) {
+    scc_vec_init(module->bblocks);
+    scc_vec_init(module->funcs);
+    scc_vec_init(module->symbols);
+    scc_hashtable_cstr_init(&module->symbol_map);
+
+    // 0 for null
+    scc_vec_push(module->bblocks, (scc_cfg_bblock_t){0});
+    scc_vec_push(module->funcs, (scc_cfg_func_t){0});
+    scc_vec_push(module->symbols, (scc_cfg_symbol_t){0});
+}
+
+void scc_cfg_module_drop(scc_cfg_module_t *module) {
+    scc_vec_free(module->bblocks);
+    scc_vec_free(module->funcs);
+    scc_vec_free(module->symbols);
+    scc_hashtable_drop(&module->symbol_map);
+}
+
+scc_cfg_func_id_t scc_cfg_module_add_func(scc_cfg_module_t *module,
+                                          const scc_cfg_func_t *func) {
+    scc_cfg_func_id_t id = scc_vec_size(module->funcs);
+    scc_vec_push(module->funcs, *func);
+    Assert(id != SCC_CFG_ID_nullptr);
+    return id;
+}
+
+scc_cfg_func_t *scc_cfg_module_unsafe_get_func(scc_cfg_module_t *module,
+                                               scc_cfg_func_id_t id) {
+    if (id == SCC_CFG_ID_nullptr) {
+        Panic("nullptr func id");
+    }
+    if (id >= scc_vec_size(module->funcs)) {
+        Panic("invalid func id");
+    }
+    return &scc_vec_at(module->funcs, id);
+}
+
+scc_cfg_bblock_id_t scc_cfg_module_add_bblock(scc_cfg_module_t *module,
+                                              const scc_cfg_bblock_t *bblock) {
+    scc_cfg_func_id_t id = scc_vec_size(module->bblocks);
+    scc_vec_push(module->bblocks, *bblock);
+    Assert(id != SCC_CFG_ID_nullptr);
+    return id;
+}
+
+scc_cfg_bblock_t *scc_cfg_module_unsafe_get_bblock(scc_cfg_module_t *module,
+                                                   scc_cfg_bblock_id_t id) {
+    if (id == SCC_CFG_ID_nullptr) {
+        Panic("nullptr bblocks id");
+    }
+    if (id >= scc_vec_size(module->bblocks)) {
+        Panic("invalid bblocks id");
+    }
+    return &scc_vec_at(module->bblocks, id);
+}
+
+void scc_cfg_module_add_symbol(scc_cfg_module_t *module,
+                               const scc_cfg_symbol_t *symbol) {}
+scc_cfg_id_t scc_cfg_module_lookup_symbol(const scc_cfg_module_t *module,
+                                          const char *name) {
+    return 0;
+}
+
+void scc_cfg_bblock_add_pred(scc_cfg_bblock_t *bb,
+                             scc_cfg_bblock_id_t pred_id) {}
+
+void scc_cfg_bblock_remove_pred(scc_cfg_bblock_t *bb,
+                                scc_cfg_bblock_id_t pred_id) {}
+
+void scc_cfg_bblock_clear_pred(scc_cfg_bblock_t *bb) {}
+
+void scc_cfg_bblock_add_succ(scc_cfg_bblock_t *bb,
+                             scc_cfg_bblock_id_t succ_id) {}
+
+void scc_cfg_bblock_remove_succ(scc_cfg_bblock_t *bb,
+                                scc_cfg_bblock_id_t succ_id) {}
+
+void scc_cfg_bblock_clear_succs(scc_cfg_bblock_t *bb) {}

libs/ir/hir/cbuild.toml

@@ -0,0 +1,14 @@
+[package]
+name        = "scc_hir"
+version     = "0.1.0"
+authors     = []
+description = ""
+
+dependencies = [
+    { name = "scc_cfg", path = "../cfg" },
+    { name = "scc_utils", path = "../../../runtime/scc_utils" },
+    { name = "tree_dump", path = "../../tree_dump" },
+]
+# dependencies = []
+# features = {}
+# default_features = []

libs/ir/hir/include/hir_builder.h

@@ -0,0 +1,281 @@
+#ifndef __SCC_HIR_BUILDER_H__
+#define __SCC_HIR_BUILDER_H__
+
+#include "hir_prog.h"
+#include "scc_hir.h"
+
+typedef struct scc_hir_builder scc_hir_builder_t;
+
+/**
+ * @brief IR 构建器上下文
+ *
+ * 负责管理 IR 构建过程中的所有状态：
+ * - 类型统一化（type uniquing）
+ * - 符号命名分配
+ * - 内存管理
+ * - 当前构建位置（函数、基本块）
+ */
+struct scc_hir_builder {
+    scc_hir_cprog_t *cprog;
+    scc_hir_func_ref_t current_func;     ///< 当前正在构建的函数
+    scc_hir_bblock_ref_t current_bblock; ///< 当前基本块
+
+    scc_hashtable_t type_uniquing; // 类型哈希表：hash -> type_ref
+    scc_hashtable_t const_pool;    // 常量哈希表：hash -> node_ref
+    scc_hashtable_t func_decl_set; // 函数声明集合：name -> func_ref
+#ifndef SCC_NO_DEBUG
+    int borrow_depth;
+    const char *dbg_file;
+    int dbg_line;
+#endif
+};
+
+#ifndef SCC_NO_DEBUG
+#define SCC_HIR_BUILDER_BEGIN_BORROW(builder, ptr_var, ptr_expr)               \
+    do {                                                                       \
+        (builder)->borrow_depth++;                                             \
+        (builder)->dbg_file = __FILE__;                                        \
+        (builder)->dbg_line = __LINE__;                                        \
+        ptr_var = (ptr_expr);                                                  \
+    } while (0)
+
+#define SCC_HIR_BUILDER_END_BORROW(builder)                                    \
+    do {                                                                       \
+        (builder)->borrow_depth--;                                             \
+    } while (0)
+
+#define SCC_HIR_BUILDER_CHECK_NO_BORROW(builder)                               \
+    do {                                                                       \
+        if ((builder)->borrow_depth != 0) {                                    \
+            Panic("IR Builder: attempt to reallocate while borrowed at %s:%d", \
+                  (builder)->dbg_file, (builder)->dbg_line);                   \
+        }                                                                      \
+    } while (0)
+#else
+#define SCC_HIR_BUILDER_BEGIN_BORROW(builder, ptr_var, ptr_expr)               \
+    ptr_var = (ptr_expr)
+#define SCC_HIR_BUILDER_END_BORROW(builder) ((void)0)
+#define SCC_HIR_BUILDER_CHECK_NO_BORROW(builder) ((void)0)
+#endif
+
+/**
+ * @brief 初始化 IR 构建器
+ */
+void scc_hir_builder_init(scc_hir_builder_t *builder, scc_hir_cprog_t *cprog);
+
+/**
+ * @brief 销毁 IR 构建器及其所有资源
+ */
+void scc_hir_builder_drop(scc_hir_builder_t *builder);
+
+scc_hir_func_ref_t scc_hir_builder_func(scc_hir_builder_t *builder,
+                                        scc_hir_type_ref_t type_ref,
+                                        const char *name);
+
+scc_hir_type_ref_t scc_hir_builder_type(scc_hir_builder_t *builder,
+                                        const scc_hir_type_t *type_desc);
+
+void scc_hir_builder_add_instr(scc_hir_builder_t *builder,
+                               scc_hir_value_ref_t instr);
+
+scc_hir_value_ref_t scc_hir_builder_global_alloca(scc_hir_builder_t *builder,
+                                                  scc_hir_type_ref_t type,
+                                                  scc_hir_value_ref_t value);
+
+/**
+ * @brief 创建alloca指令（在当前基本块中）
+ * @param type 分配的类型
+ * @param name 变量名（可为nullptr）
+ */
+scc_hir_value_ref_t scc_hir_builder_alloca(scc_hir_builder_t *builder,
+                                           scc_hir_type_ref_t type,
+                                           const char *name);
+
+#define SCC_HIR_BUILDER_TYPE_FUNC(scc_type)                                    \
+    [[maybe_unused]] static inline scc_hir_type_ref_t                          \
+    scc_hir_builder_type_##scc_type(scc_hir_builder_t *builder) {              \
+        scc_hir_type_t type_desc;                                              \
+        scc_hir_type_init(&type_desc, SCC_HIR_TYPE_##scc_type);                \
+        return scc_hir_builder_type(builder, &type_desc);                      \
+    }
+
+SCC_HIR_BUILDER_TYPE_FUNC(unknown)
+SCC_HIR_BUILDER_TYPE_FUNC(void)
+SCC_HIR_BUILDER_TYPE_FUNC(i8)
+SCC_HIR_BUILDER_TYPE_FUNC(i16)
+SCC_HIR_BUILDER_TYPE_FUNC(i32)
+SCC_HIR_BUILDER_TYPE_FUNC(i64)
+SCC_HIR_BUILDER_TYPE_FUNC(i128)
+SCC_HIR_BUILDER_TYPE_FUNC(u8)
+SCC_HIR_BUILDER_TYPE_FUNC(u16)
+SCC_HIR_BUILDER_TYPE_FUNC(u32)
+SCC_HIR_BUILDER_TYPE_FUNC(u64)
+SCC_HIR_BUILDER_TYPE_FUNC(u128)
+// SCC_HIR_BUILDER_TYPE_FUNC(f8)
+SCC_HIR_BUILDER_TYPE_FUNC(f16)
+SCC_HIR_BUILDER_TYPE_FUNC(f32)
+SCC_HIR_BUILDER_TYPE_FUNC(f64)
+SCC_HIR_BUILDER_TYPE_FUNC(f128)
+
+scc_hir_value_ref_t scc_hir_builder_builtin_memcpy(scc_hir_builder_t *builder,
+                                                   scc_hir_value_ref_t dest,
+                                                   scc_hir_value_ref_t src,
+                                                   scc_hir_value_ref_t len);
+
+// TODO
+static inline scc_hir_value_ref_t
+scc_hir_builder_integer(scc_hir_builder_t *builder, scc_hir_type_ref_t type,
+                        scc_ap_t *val) {
+    scc_hir_value_t value;
+    scc_hir_value_init(&value, nullptr, SCC_HIR_VALUE_TAG_INTEGER);
+    // FIXME assign
+    value.data.integer = *val;
+    value.type = type;
+    return scc_hir_module_add_value(&builder->cprog->module, &value);
+}
+
+scc_hir_value_ref_t scc_hir_builder_const_string(scc_hir_builder_t *builder,
+                                                 const char *str, usize len);
+
+/**
+ * @brief 开始构建函数
+ * @param func_ref 函数引用
+ * @param param_names 参数名列表（可为nullptr）
+ * @return void
+ */
+void scc_hir_builder_begin_func(scc_hir_builder_t *builder,
+                                scc_hir_func_ref_t func_ref);
+
+/**
+ * @brief 结束当前函数的构建
+ */
+void scc_hir_builder_end_func(scc_hir_builder_t *builder);
+
+/**
+ * @brief 获取当前正在构建的函数
+ */
+scc_hir_func_ref_t scc_hir_builder_current_func(scc_hir_builder_t *builder);
+
+/**
+ * @brief 创建一个新的基本块，并自动添加到当前函数中，但不改变当前块。
+ * @param builder IR构建器
+ * @param label   基本块标签（可为 nullptr，自动生成）
+ * @return 新基本块的引用
+ */
+scc_hir_bblock_ref_t scc_hir_builder_bblock(scc_hir_builder_t *builder,
+                                            const char *label);
+
+/**
+ * @brief 开始构建新的基本块
+ * @param label 基本块标签（可为nullptr，自动生成）
+ * @return 基本块引用
+ */
+scc_hir_bblock_ref_t scc_hir_builder_begin_bblock(scc_hir_builder_t *builder,
+                                                  const char *label);
+
+/**
+ * @brief 结束当前基本块的构建
+ */
+void scc_hir_builder_end_bblock(scc_hir_builder_t *builder);
+
+scc_hir_func_ref_t scc_hir_builder_current_bblock(scc_hir_builder_t *builder);
+/**
+ * @brief 设置当前基本块
+ */
+void scc_hir_builder_set_current_bblock(scc_hir_builder_t *builder,
+                                        scc_hir_bblock_ref_t bblock);
+
+scc_hir_value_ref_t scc_hir_builder_func_arg_ref(scc_hir_builder_t *builder,
+                                                 scc_hir_type_ref_t type,
+                                                 const char *name,
+                                                 usize arg_idx);
+
+/**
+ * @brief 创建load指令
+ * @param ptr 指针操作数
+ */
+scc_hir_value_ref_t scc_hir_builder_load(scc_hir_builder_t *builder,
+                                         scc_hir_value_ref_t ptr);
+
+/**
+ * @brief 创建store指令
+ * @param ptr 目标指针
+ * @param value 要存储的值
+ */
+scc_hir_value_ref_t scc_hir_builder_store(scc_hir_builder_t *builder,
+                                          scc_hir_value_ref_t ptr,
+                                          scc_hir_value_ref_t value);
+
+/**
+ * @brief 创建getptr指令（指针运算）
+ * @param ptr 基础指针
+ * @param index 索引值
+ */
+scc_hir_value_ref_t scc_hir_builder_get_elem_ptr(scc_hir_builder_t *builder,
+                                                 scc_hir_value_ref_t ptr,
+                                                 scc_hir_value_ref_t index);
+
+/**
+ * @brief 创建二元运算指令
+ * @param op 操作符
+ * @param lhs 左操作数
+ * @param rhs 右操作数
+ */
+scc_hir_value_ref_t scc_hir_builder_binop(scc_hir_builder_t *builder,
+                                          scc_hir_op_type_t op,
+                                          scc_hir_value_ref_t lhs,
+                                          scc_hir_value_ref_t rhs);
+
+/**
+ * @brief 创建比较指令
+ * @param op 比较操作符
+ * @param lhs 左操作数
+ * @param rhs 右操作数
+ */
+scc_hir_value_ref_t scc_hir_builder_cmp(scc_hir_builder_t *builder,
+                                        scc_hir_op_type_t op,
+                                        scc_hir_value_ref_t lhs,
+                                        scc_hir_value_ref_t rhs);
+
+/**
+ * @brief 创建跳转指令（无条件）
+ * @param target 目标基本块
+ */
+scc_hir_value_ref_t scc_hir_builder_jump(scc_hir_builder_t *builder,
+                                         scc_hir_bblock_ref_t target);
+
+/**
+ * @brief 创建条件分支指令
+ * @param cond 条件值
+ * @param true_target 条件为真时的目标
+ * @param false_target 条件为假时的目标
+ */
+scc_hir_value_ref_t scc_hir_builder_branch(scc_hir_builder_t *builder,
+                                           scc_hir_value_ref_t cond,
+                                           scc_hir_bblock_ref_t true_target,
+                                           scc_hir_bblock_ref_t false_target);
+
+/**
+ * @brief 创建函数调用指令
+ * @param callee 被调用函数
+ * @param args 参数列表
+ * @param arg_count 参数数量
+ */
+scc_hir_value_ref_t scc_hir_builder_call(scc_hir_builder_t *builder,
+                                         scc_hir_func_ref_t callee,
+                                         const scc_hir_value_ref_t *args,
+                                         usize arg_count);
+
+/**
+ * @brief 创建返回指令（带返回值）
+ * @param value 返回值
+ */
+scc_hir_value_ref_t scc_hir_builder_ret(scc_hir_builder_t *builder,
+                                        scc_hir_value_ref_t value);
+
+/**
+ * @brief 创建返回指令（void返回）
+ */
+scc_hir_value_ref_t scc_hir_builder_ret_void(scc_hir_builder_t *builder);
+
+#endif /* __SCC_HIR_BUILDER_H__ */

libs/ir/hir/include/hir_def.h

@@ -0,0 +1,255 @@
+#ifndef __SCC_HIR_DEF_H__
+#define __SCC_HIR_DEF_H__
+
+#include <scc_ap.h>
+#include <scc_cfg.h>
+#include <scc_core.h>
+
+#define SCC_HIR_REF_nullptr SCC_CFG_ID_nullptr
+
+typedef SCC_VEC(u8) scc_hir_buffer_t;
+
+typedef scc_cfg_bblock_t scc_hir_bblock_t;
+typedef scc_cfg_bblock_id_t scc_hir_bblock_ref_t;
+typedef SCC_VEC(scc_hir_bblock_ref_t) scc_hir_bblock_ref_vec_t;
+
+typedef scc_cfg_func_t scc_hir_func_t;
+typedef scc_cfg_func_id_t scc_hir_func_ref_t;
+typedef SCC_VEC(scc_hir_func_ref_t) scc_hir_func_ref_vec_t;
+
+typedef struct scc_hir_value scc_hir_value_t;
+typedef scc_cfg_id_t scc_hir_value_ref_t;
+typedef SCC_VEC(scc_hir_value_ref_t) scc_hir_value_ref_vec_t;
+
+typedef struct scc_hir_type scc_hir_type_t;
+typedef scc_cfg_id_t scc_hir_type_ref_t;
+typedef SCC_VEC(scc_hir_type_ref_t) scc_hir_type_ref_vec_t;
+
+typedef enum scc_hir_type_tag {
+    SCC_HIR_TYPE_unknown,
+    SCC_HIR_TYPE_void,
+    SCC_HIR_TYPE_i8,
+    SCC_HIR_TYPE_i16,
+    SCC_HIR_TYPE_i32,
+    SCC_HIR_TYPE_i64,
+    SCC_HIR_TYPE_i128,
+    SCC_HIR_TYPE_u8,
+    SCC_HIR_TYPE_u16,
+    SCC_HIR_TYPE_u32,
+    SCC_HIR_TYPE_u64,
+    SCC_HIR_TYPE_u128,
+    SCC_HIR_TYPE_f16,
+    SCC_HIR_TYPE_f32,
+    SCC_HIR_TYPE_f64,
+    SCC_HIR_TYPE_f128,
+    SCC_HIR_TYPE_PTR,
+    SCC_HIR_TYPE_ARRAY,
+    SCC_HIR_TYPE_FUNC,
+    SCC_HIR_TYPE_STRUCT,
+    SCC_HIR_TYPE_UNION,
+    SCC_HIR_TYPE_VECTOR, // TODO SIMD
+} scc_hir_type_tag_t;
+
+struct scc_hir_type {
+    scc_hir_type_tag_t tag;
+    const char *name; // For Debug
+    union {
+        struct {
+            scc_hir_type_ref_t base;
+            usize len; // TODO usize is target dependent
+        } array;
+        struct {
+            scc_hir_type_ref_t base;
+        } pointer;
+        struct {
+            scc_hir_type_ref_vec_t fields;
+        } aggregate;
+        struct {
+            scc_hir_type_ref_vec_t params;
+            scc_hir_type_ref_t ret_type;
+        } function;
+    } data;
+};
+
+typedef enum scc_hir_value_tag {
+    SCC_HIR_VALUE_TAG_NULLPTR,
+    SCC_HIR_VALUE_TAG_BUILTIN,
+    SCC_HIR_VALUE_TAG_INTEGER,
+    SCC_HIR_VALUE_TAG_DECIMAL,
+    SCC_HIR_VALUE_TAG_ARRAY,
+    SCC_HIR_VALUE_TAG_AGGREGATE,     ///< 聚合值
+    SCC_HIR_VALUE_TAG_CONV,          ///< 类型转换
+    SCC_HIR_VALUE_TAG_FUNC_ARG_REF,  ///< 函数参数引用
+    SCC_HIR_VALUE_TAG_BLOCK_ARG_REF, ///< 基本块参数引用
+    SCC_HIR_VALUE_TAG_ALLOC,         ///< 分配内存
+    SCC_HIR_VALUE_TAG_GLOBAL_ALLOC,  ///< 全局分配
+    SCC_HIR_VALUE_TAG_LOAD,          ///< 加载数据
+    SCC_HIR_VALUE_TAG_STORE,         ///< 存储数据
+    SCC_HIR_VALUE_TAG_GET_ELEM_PTR,  ///< 获取元素指针
+    SCC_HIR_VALUE_TAG_OP,            ///< 二元运算
+    SCC_HIR_VALUE_TAG_BRANCH,        ///< 有条件分支
+    SCC_HIR_VALUE_TAG_JUMP,          ///< 无条件跳转
+    SCC_HIR_VALUE_TAG_CALL,          ///< 调用函数
+    SCC_HIR_VALUE_TAG_RET,           ///< 函数返回
+} scc_hir_value_tag_t;
+
+typedef enum {
+    /// Empty op for init or nop
+    SCC_HIR_OP_EMPTY,
+    /// Not equal to.
+    SCC_HIR_OP_NEQ,
+    /// Equal to.
+    SCC_HIR_OP_EQ,
+    /// Greater than.
+    SCC_HIR_OP_GT,
+    /// Less than.
+    SCC_HIR_OP_LT,
+    /// Greater than or equal to.
+    SCC_HIR_OP_GE,
+    /// Less than or equal to.
+    SCC_HIR_OP_LE,
+    /// Addition.
+    SCC_HIR_OP_ADD,
+    /// Subtraction.
+    SCC_HIR_OP_SUB,
+    /// Multiplication.
+    SCC_HIR_OP_MUL,
+    /// Division.
+    SCC_HIR_OP_DIV,
+    /// Modulo.
+    SCC_HIR_OP_MOD,
+    /// Bitwise AND.
+    SCC_HIR_OP_AND,
+    /// Bitwise OR.
+    SCC_HIR_OP_OR,
+    /// Bitwise XOR.
+    SCC_HIR_OP_XOR,
+    /// Bitwise NOT.
+    SCC_HIR_OP_NOT,
+    /// Shift left logical.
+    SCC_HIR_OP_SHL,
+    /// Shift right logical.
+    SCC_HIR_OP_SHR,
+    /// Shift right arithmetic.
+    SCC_HIR_OP_SAR,
+} scc_hir_op_type_t;
+
+typedef enum {
+    SCC_HIR_BUILTIN_TAG_MEMCPY,
+    SCC_HIR_BUILTIN_TAG_MEMSET,
+    SCC_HIR_BUILTIN_TAG_VA_START,
+    SCC_HIR_BUILTIN_TAG_VA_ARG,
+    SCC_HIR_BUILTIN_TAG_VA_END,
+    SCC_HIR_BUILTIN_TAG_VA_COPY,
+} scc_hir_builtin_tag_t;
+
+typedef struct {
+    scc_hir_builtin_tag_t tag;
+    union {
+        struct {
+            scc_hir_value_ref_t dest;
+            scc_hir_value_ref_t src;
+            scc_hir_value_ref_t size;
+        } memcpy;
+        struct {
+            scc_hir_value_ref_t dest;
+            scc_hir_value_ref_t value;
+            scc_hir_value_ref_t size;
+        } memset;
+        struct {
+            scc_hir_value_ref_t ap;   // va_list 的地址（i8* 或 struct*）
+            scc_hir_value_ref_t last; // 最后一个固定参数的引用（用于 va_start）
+        } va_start;
+        struct {
+            scc_hir_value_ref_t ap;  // va_list 的地址
+            scc_hir_type_ref_t type; // 要提取的参数的类型
+        } va_arg;
+        struct {
+            scc_hir_value_ref_t ap; // va_list 的地址
+        } va_end;
+        struct {
+            scc_hir_value_ref_t dest; // 目标 va_list 地址
+            scc_hir_value_ref_t src;  // 源 va_list 地址
+        } va_copy;
+    } func;
+} scc_hir_builtin_t;
+
+struct scc_hir_value {
+    scc_hir_type_ref_t type;
+    const char *name;
+    scc_hir_value_ref_vec_t used_by;
+    scc_hir_value_tag_t tag;
+    union {
+        scc_hir_builtin_t builtin;
+        scc_ap_t integer;
+        void *decimal;
+        struct {
+            scc_hir_value_ref_t base_type;
+            scc_hir_buffer_t fields;
+        } const_array;
+        struct {
+            scc_hir_value_ref_vec_t fields;
+        } aggregate;
+        struct {
+            usize idx;
+        } arg_ref;
+        struct {
+            scc_hir_value_ref_t value;
+        } global_alloc;
+        struct {
+            scc_hir_value_ref_t operand;
+            scc_hir_type_ref_t target_type; // 目标类型
+            enum { CONV_SEXT, CONV_ZEXT, CONV_TRUNC } conv_type;
+        } conv;
+        struct {
+            scc_hir_value_ref_t target;
+        } load;
+        struct {
+            scc_hir_value_ref_t target;
+            scc_hir_value_ref_t value;
+        } store;
+        struct {
+            scc_hir_value_ref_t src_addr;
+            scc_hir_value_ref_t index;
+        } get_elem_ptr;
+        struct {
+            scc_hir_op_type_t op;
+            scc_hir_value_ref_t lhs;
+            scc_hir_value_ref_t rhs;
+        } op;
+        struct {
+            scc_hir_value_ref_t cond;
+            scc_hir_bblock_ref_t true_bblock;
+            scc_hir_bblock_ref_t false_bblock;
+        } branch;
+        struct {
+            scc_hir_bblock_ref_t target_bblock;
+        } jump;
+        struct {
+            scc_hir_func_ref_t callee; // TODO function pointer call
+            scc_hir_value_ref_vec_t args;
+        } call;
+        struct {
+            scc_hir_value_ref_t ret_val;
+        } ret;
+    } data;
+};
+
+typedef struct scc_hir_bblock_meta {
+    // scc_hir_value_ref_vec_t instrs;
+    // ir_arr_t used_by;
+} scc_hir_bblock_meta_t;
+
+typedef struct scc_hir_func_meta {
+    scc_hir_type_ref_t type;
+    scc_hir_value_ref_vec_t params;
+} scc_hir_func_meta_t;
+
+#define SCC_HIR_BBLOCK_VALUES(bblock)                                          \
+    (*(scc_hir_value_ref_vec_t *)&((bblock).values))
+
+#define SCC_HIR_BBLOCK_META(bblock)                                            \
+    ((scc_hir_bblock_meta_t *)((bblock).attribute))
+#define SCC_HIR_FUNC_META(func) ((scc_hir_func_meta_t *)((func).attribute))
+
+#endif /* __SCC_HIR_DEF_H__ */

libs/ir/hir/include/hir_dump.h

@@ -0,0 +1,21 @@
+#ifndef __SCC_HIR_DUMP_H__
+#define __SCC_HIR_DUMP_H__
+
+#include "hir_prog.h"
+#include <scc_tree_dump.h>
+
+typedef struct {
+    scc_hir_cprog_t *cprog;
+    scc_tree_dump_t *dump_ctx;
+} scc_hir_dump_t;
+
+void scc_hir_dump_ctx_init(scc_hir_dump_t *ctx, scc_tree_dump_t *tree_dump,
+                           scc_hir_cprog_t *cprog);
+void scc_hir_dump_value(scc_hir_dump_t *ctx, scc_hir_value_ref_t node_ref);
+void scc_hir_dump_type(scc_hir_dump_t *ctx, scc_hir_type_ref_t type_ref);
+void scc_hir_dump_bblock(scc_hir_dump_t *ctx, scc_hir_bblock_ref_t bblock_ref);
+void scc_hir_dump_func(scc_hir_dump_t *ctx, scc_hir_func_ref_t func_ref);
+void scc_hir_dump_cprog(scc_hir_dump_t *ctx);
+void scc_hir_dump_cprog_linear(scc_hir_dump_t *ctx);
+
+#endif /* __SCC_HIR_DUMP_H__ */

libs/ir/hir/include/hir_module.h

@@ -0,0 +1,50 @@
+#ifndef __SCC_HIR_MODULE_H__
+#define __SCC_HIR_MODULE_H__
+
+#include "hir_def.h"
+#include <scc_cfg.h>
+#include <scc_hashtable.h>
+
+typedef struct {
+    scc_cfg_module_t cfg_module;
+
+    scc_cfg_id_t value_uid;
+    scc_cfg_id_t type_uid;
+    SCC_VEC(scc_hir_value_t) values;
+    SCC_VEC(scc_hir_type_t) types;
+    // UID -> ref index
+    scc_hashtable_t uid2value;
+    scc_hashtable_t uid2type;
+
+    SCC_VEC(scc_hir_bblock_meta_t *) bblock_meta;
+    SCC_VEC(scc_hir_func_meta_t *) funcs_meta;
+} scc_hir_module_t;
+
+void scc_hir_module_init(scc_hir_module_t *ctx);
+void scc_hir_module_drop(scc_hir_module_t *ctx);
+scc_hir_type_ref_t scc_hir_module_add_type(scc_hir_module_t *ctx,
+                                           const scc_hir_type_t *type);
+scc_hir_value_ref_t scc_hir_module_add_value(scc_hir_module_t *ctx,
+                                             const scc_hir_value_t *node);
+scc_hir_bblock_ref_t scc_hir_module_add_bblock(scc_hir_module_t *ctx,
+                                               const scc_hir_bblock_t *bblock);
+scc_hir_func_ref_t scc_hir_module_add_func(scc_hir_module_t *ctx,
+                                           const scc_hir_func_t *func);
+scc_hir_type_t *scc_hir_module_get_type(scc_hir_module_t *ctx,
+                                        scc_hir_type_ref_t ref);
+scc_hir_value_t *scc_hir_module_get_value(scc_hir_module_t *ctx,
+                                          scc_hir_value_ref_t ref);
+scc_hir_bblock_t *scc_hir_module_get_bblock(scc_hir_module_t *ctx,
+                                            scc_hir_bblock_ref_t ref);
+scc_hir_func_t *scc_hir_module_get_func(scc_hir_module_t *ctx,
+                                        scc_hir_func_ref_t ref);
+
+static inline scc_hir_type_t *
+scc_hir_module_get_type_by_value(scc_hir_module_t *ctx,
+                                 scc_hir_value_ref_t ref) {
+    scc_hir_value_t *value = scc_hir_module_get_value(ctx, ref);
+    Assert(value != nullptr);
+    return scc_hir_module_get_type(ctx, value->type);
+}
+
+#endif /* __SCC_HIR_MODULE_H__ */

libs/ir/hir/include/hir_prog.h

@@ -0,0 +1,17 @@
+#ifndef __SCC_HIR_PROG_H__
+#define __SCC_HIR_PROG_H__
+
+#include "hir_def.h"
+#include "hir_module.h"
+
+typedef struct scc_hir_cprog {
+    scc_hir_module_t module;
+    scc_hir_value_ref_vec_t global_vals; /* 全局变量 */
+    scc_hir_func_ref_vec_t func_defs;    /* 所有函数定义 */
+    scc_hir_func_ref_vec_t func_decls;   /* 所有函数包括定义的声明 */
+} scc_hir_cprog_t;
+
+void scc_hir_cprog_init(scc_hir_cprog_t *in);
+void scc_hir_cprog_drop(scc_hir_cprog_t *in);
+
+#endif /* __SCC_HIR_PROG_H__ */

libs/ir/hir/include/scc_hir.h

@@ -0,0 +1,14 @@
+#ifndef __SCC_HIR_H__
+#define __SCC_HIR_H__
+
+#include "hir_def.h"
+#include "hir_prog.h"
+
+void scc_hir_type_init(scc_hir_type_t *in, scc_hir_type_tag_t tag);
+void scc_hir_bblock_init(scc_hir_bblock_t *in, const char *label);
+void scc_hir_func_init(scc_hir_func_t *in, const char *name);
+// node name can be nullptr ptr
+void scc_hir_value_init(scc_hir_value_t *in, const char *name,
+                        scc_hir_value_tag_t tag);
+
+#endif /* __SCC_HIR_H__ */

libs/ir/hir/src/hir_builder.c

@@ -0,0 +1,691 @@
+#include <hir_builder.h>
+#include <hir_def.h>
+#include <hir_prog.h>
+
+#define GET_MODULE(builder) (&(builder->cprog->module))
+
+/**
+ * @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_type(const void *_key, void *userdata) {
+    scc_hir_module_t *module = userdata;
+    const scc_hir_type_t *key =
+        _key == SCC_HIR_REF_nullptr
+            ? &scc_vec_at(module->types, 0)
+            : scc_hir_module_get_type(module, (usize)_key);
+    // 初始哈希：tag
+    u32 hash = (u32)key->tag;
+
+    switch (key->tag) {
+    case SCC_HIR_TYPE_void:
+    case SCC_HIR_TYPE_u8:
+    case SCC_HIR_TYPE_u16:
+    case SCC_HIR_TYPE_u32:
+    case SCC_HIR_TYPE_u64:
+    case SCC_HIR_TYPE_u128:
+    case SCC_HIR_TYPE_i8:
+    case SCC_HIR_TYPE_i16:
+    case SCC_HIR_TYPE_i32:
+    case SCC_HIR_TYPE_i64:
+    case SCC_HIR_TYPE_i128:
+    case SCC_HIR_TYPE_f16:
+    case SCC_HIR_TYPE_f32:
+    case SCC_HIR_TYPE_f64:
+    case SCC_HIR_TYPE_f128:
+        // 基本类型，只有tag
+        break;
+
+    case SCC_HIR_TYPE_PTR:
+        hash = scc_hash_mix(hash, (u32)key->data.array.base);
+        break;
+
+    case SCC_HIR_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_HIR_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_HIR_TYPE_STRUCT:
+    case SCC_HIR_TYPE_UNION:
+        return 0;
+    case SCC_HIR_TYPE_VECTOR:
+    default:
+        Panic("Invalid type tag %d", key->tag);
+        return 0;
+    }
+
+    return hash;
+}
+
+static int cmp_type(const void *_key1, const void *_key2, void *userdata) {
+    scc_hir_module_t *module = userdata;
+    const scc_hir_type_t *key1 = _key1 == SCC_HIR_REF_nullptr
+                                     ? &scc_vec_at(module->types, 0)
+                                     : scc_hir_module_get_type(module,
+                                                               (usize)_key1),
+                         *key2 = _key2 == SCC_HIR_REF_nullptr
+                                     ? &scc_vec_at(module->types, 0)
+                                     : scc_hir_module_get_type(module,
+                                                               (usize)_key2);
+    Assert(key1 != nullptr && key2 != nullptr);
+    if (key1->tag == SCC_HIR_TYPE_unknown ||
+        key2->tag == SCC_HIR_TYPE_unknown) {
+        return 1;
+    }
+    // tag不同
+    if (key1->tag != key2->tag) {
+        return 1;
+    }
+
+    switch (key1->tag) {
+    case SCC_HIR_TYPE_void:
+    case SCC_HIR_TYPE_u8:
+    case SCC_HIR_TYPE_u16:
+    case SCC_HIR_TYPE_u32:
+    case SCC_HIR_TYPE_u64:
+    case SCC_HIR_TYPE_u128:
+    case SCC_HIR_TYPE_i8:
+    case SCC_HIR_TYPE_i16:
+    case SCC_HIR_TYPE_i32:
+    case SCC_HIR_TYPE_i64:
+    case SCC_HIR_TYPE_i128:
+    case SCC_HIR_TYPE_f16:
+    case SCC_HIR_TYPE_f32:
+    case SCC_HIR_TYPE_f64:
+    case SCC_HIR_TYPE_f128:
+        return 0; // 基本类型，tag相同即可
+    case SCC_HIR_TYPE_PTR:
+        return key1->data.pointer.base != key2->data.pointer.base;
+    case SCC_HIR_TYPE_ARRAY:
+        return (key1->data.array.base != key2->data.array.base) ||
+               (key1->data.array.len != key2->data.array.len);
+    case SCC_HIR_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:
+        Panic("Unknown key type %d", key1->tag);
+        return 1;
+    }
+    return 1;
+}
+
+void scc_hir_builder_init(scc_hir_builder_t *builder, scc_hir_cprog_t *cprog) {
+    builder->current_bblock = SCC_HIR_REF_nullptr;
+    builder->current_func = SCC_HIR_REF_nullptr;
+    builder->cprog = cprog;
+
+    scc_hashtable_init(&builder->type_uniquing, hash_type, cmp_type,
+                       GET_MODULE(builder));
+    // scc_hashtable_init(&builder->const_pool, /* 常量哈希函数 */,
+    //                    /* 常量比较函数 */);
+    scc_hashtable_cstr_init(&builder->func_decl_set);
+#ifndef SCC_NO_DEBUG
+    builder->borrow_depth = 0;
+    builder->dbg_file = nullptr;
+    builder->dbg_line = 0;
+#endif
+}
+
+void scc_hir_builder_drop(scc_hir_builder_t *builder) {
+    scc_hashtable_drop(&builder->type_uniquing);
+    // scc_hashtable_drop(&builder->const_pool);
+    scc_hashtable_drop(&builder->func_decl_set);
+}
+
+scc_hir_func_ref_t scc_hir_builder_func(scc_hir_builder_t *builder,
+                                        scc_hir_type_ref_t type_ref,
+                                        const char *name) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    // 检查是否已声明
+    void *found = scc_hashtable_get(&builder->func_decl_set, (void *)name);
+    if (found) {
+        return (scc_hir_func_ref_t)(usize)found;
+    }
+
+    // 创建新函数
+    scc_hir_func_t func;
+    scc_hir_func_meta_t *meta = scc_malloc(sizeof(scc_hir_func_meta_t));
+    Assert(meta != nullptr);
+    func.attribute = meta;
+    scc_hir_func_init(&func, name);
+    meta->type = type_ref;
+
+    scc_hir_func_ref_t func_ref =
+        scc_hir_module_add_func(GET_MODULE(builder), &func);
+    scc_hashtable_set(&builder->func_decl_set, (void *)name,
+                      (void *)(usize)func_ref);
+
+    scc_vec_push(builder->cprog->func_decls, func_ref);
+    return func_ref;
+}
+
+scc_hir_bblock_ref_t scc_hir_builder_bblock(scc_hir_builder_t *builder,
+                                            const char *label) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    scc_hir_bblock_t bblock = {0};
+    if (label) {
+        bblock.name = label;
+    }
+    // scc_hir_bblock_meta_t bblock_meta = {0};
+    // FIXME 当前没有bblock meta
+    bblock.attribute = nullptr;
+    scc_vec_init(SCC_HIR_BBLOCK_VALUES(bblock));
+
+    scc_hir_bblock_ref_t bblock_ref =
+        scc_hir_module_add_bblock(GET_MODULE(builder), &bblock);
+
+    // 将基本块添加到当前函数
+    scc_hir_func_t *current_func = nullptr;
+    SCC_HIR_BUILDER_BEGIN_BORROW(
+        builder, current_func,
+        scc_hir_module_get_func(GET_MODULE(builder), builder->current_func));
+    if (current_func) {
+        // FIXME hack cfg
+        scc_vec_push(current_func->bblocks, bblock_ref);
+    }
+    SCC_HIR_BUILDER_END_BORROW(builder);
+    return bblock_ref;
+}
+
+scc_hir_type_ref_t scc_hir_builder_type(scc_hir_builder_t *builder,
+                                        const scc_hir_type_t *type_desc) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+
+    Assert(type_desc->tag != SCC_HIR_TYPE_unknown);
+
+    scc_vec_at(GET_MODULE(builder)->types, 0) = *type_desc;
+    // 先查哈希表
+    void *found = scc_hashtable_get(&builder->type_uniquing, (void *)(usize)0);
+    if (found) {
+        return (scc_hir_type_ref_t)(usize)found;
+    }
+
+    // 不存在，添加新类型
+    scc_hir_type_ref_t new_ref =
+        scc_hir_module_add_type(GET_MODULE(builder), type_desc);
+    scc_hashtable_set(&builder->type_uniquing, (void *)(usize)new_ref,
+                      (void *)(usize)new_ref);
+    return new_ref;
+}
+
+scc_hir_value_ref_t scc_hir_builder_const_string(scc_hir_builder_t *builder,
+                                                 const char *str, usize len) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    scc_hir_type_ref_t u8_type = scc_hir_builder_type_u8(builder);
+    scc_hir_type_t array_type = {
+        .tag = SCC_HIR_TYPE_ARRAY,
+        .data.array.base = u8_type,
+        .data.array.len = len - 1, // 包含 nullptr 结尾
+    };
+    scc_hir_type_ref_t array_type_ref =
+        scc_hir_builder_type(builder, &array_type);
+
+    // 5. 创建聚合节点
+    scc_hir_value_t const_array_value = {
+        .tag = SCC_HIR_VALUE_TAG_ARRAY,
+        .type = array_type_ref,
+        .data.const_array.base_type = u8_type,
+    };
+    char *buff = scc_malloc(len - 1);
+    Assert(buff);
+    // FIXME content to real string
+    for (usize i = 1; i < len - 1; i++) {
+        buff[i - 1] = str[i];
+    }
+    buff[len - 2] = '\0';
+    scc_vec_unsafe_from_buffer(const_array_value.data.const_array.fields,
+                               (u8 *)buff, len - 1);
+    scc_hir_value_ref_t const_array_ref =
+        scc_hir_module_add_value(GET_MODULE(builder), &const_array_value);
+    Assert(const_array_ref != SCC_HIR_REF_nullptr);
+
+    // 3. 创建全局变量节点，类型为指针，初始值指向常量数组
+    scc_hir_value_ref_t global_value_ref =
+        scc_hir_builder_global_alloca(builder, array_type_ref, const_array_ref);
+    // scc_hashtable_insert(builder);
+
+    scc_hir_value_ref_t pointer_to_global_value = scc_hir_module_add_value(
+        GET_MODULE(builder),
+        &(scc_hir_value_t){
+            .tag = SCC_HIR_VALUE_TAG_GET_ELEM_PTR,
+            .data.get_elem_ptr.src_addr = global_value_ref,
+            .data.get_elem_ptr.index = SCC_HIR_VALUE_TAG_NULLPTR,
+        });
+    scc_hir_builder_add_instr(builder, pointer_to_global_value);
+    return pointer_to_global_value;
+}
+
+void scc_hir_builder_begin_func(scc_hir_builder_t *builder,
+                                scc_hir_func_ref_t func_ref) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    builder->current_func = func_ref;
+
+    // 借用 func_ptr 和 func_type 以获取参数类型列表
+    scc_hir_func_t *func_ptr = nullptr;
+    scc_hir_type_t *func_type = nullptr;
+    SCC_HIR_BUILDER_BEGIN_BORROW(
+        builder, func_ptr,
+        scc_hir_module_get_func(GET_MODULE(builder), func_ref));
+    SCC_HIR_BUILDER_BEGIN_BORROW(
+        builder, func_type,
+        scc_hir_module_get_type(GET_MODULE(builder),
+                                SCC_HIR_FUNC_META(*func_ptr)->type));
+
+    if (func_type == nullptr || func_type->tag != SCC_HIR_TYPE_FUNC) {
+        LOG_ERROR("Invalid function type");
+        SCC_HIR_BUILDER_END_BORROW(builder); // func_type
+        SCC_HIR_BUILDER_END_BORROW(builder); // func_ptr
+        return;
+    }
+    if (func_ptr == nullptr) {
+        LOG_ERROR("Invalid function reference");
+        SCC_HIR_BUILDER_END_BORROW(builder); // func_type
+        SCC_HIR_BUILDER_END_BORROW(builder); // func_ptr
+        return;
+    }
+    if (scc_vec_size(func_ptr->bblocks) != 0 ||
+        scc_vec_size(SCC_HIR_FUNC_META(*func_ptr)->params) != 0) {
+        LOG_FATAL("Multiple function definitions");
+        SCC_HIR_BUILDER_END_BORROW(builder); // func_type
+        SCC_HIR_BUILDER_END_BORROW(builder); // func_ptr
+        return;
+    }
+
+    // 释放借用，因为下面要调用 add_value（可能 realloc）
+    SCC_HIR_BUILDER_END_BORROW(builder); // func_type
+    SCC_HIR_BUILDER_END_BORROW(builder); // func_ptr
+}
+
+void scc_hir_builder_end_func(scc_hir_builder_t *builder) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    scc_hir_func_t *func_ptr = nullptr;
+    SCC_HIR_BUILDER_BEGIN_BORROW(
+        builder, func_ptr,
+        scc_hir_module_get_func(GET_MODULE(builder), builder->current_func));
+    if (func_ptr == nullptr) {
+        LOG_FATAL("Invalid function reference");
+        SCC_HIR_BUILDER_END_BORROW(builder);
+        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);
+    }
+    SCC_HIR_BUILDER_END_BORROW(builder);
+    builder->current_func = 0;
+}
+
+scc_hir_func_ref_t scc_hir_builder_current_func(scc_hir_builder_t *builder) {
+    // 只读操作，无需检查借用
+    return builder->current_func;
+}
+
+scc_hir_bblock_ref_t scc_hir_builder_begin_bblock(scc_hir_builder_t *builder,
+                                                  const char *label) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    builder->current_bblock = scc_hir_builder_bblock(builder, label);
+    return builder->current_bblock;
+}
+
+void scc_hir_builder_end_bblock(scc_hir_builder_t *builder) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    builder->current_bblock = 0;
+}
+
+void scc_hir_builder_set_current_bblock(scc_hir_builder_t *builder,
+                                        scc_hir_bblock_ref_t bblock) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    builder->current_bblock = bblock;
+}
+
+scc_hir_func_ref_t scc_hir_builder_current_bblock(scc_hir_builder_t *builder) {
+    return builder->current_bblock;
+}
+
+void scc_hir_builder_add_instr(scc_hir_builder_t *builder,
+                               scc_hir_value_ref_t instr) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    scc_hir_bblock_t *current_bblock = nullptr;
+    SCC_HIR_BUILDER_BEGIN_BORROW(
+        builder, current_bblock,
+        scc_hir_module_get_bblock(GET_MODULE(builder),
+                                  builder->current_bblock));
+    if (current_bblock) {
+        scc_vec_push(SCC_HIR_BBLOCK_VALUES(*current_bblock), instr);
+    } else {
+        LOG_ERROR("Current basic block is not set");
+    }
+    SCC_HIR_BUILDER_END_BORROW(builder);
+}
+
+scc_hir_value_ref_t scc_hir_builder_global_alloca(scc_hir_builder_t *builder,
+                                                  scc_hir_type_ref_t type,
+                                                  scc_hir_value_ref_t value) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    char *name = scc_malloc(32);
+    scc_hir_value_ref_t global_value_ref = scc_hir_module_add_value(
+        GET_MODULE(builder), &(scc_hir_value_t){
+                                 .name = name,
+                                 .tag = SCC_HIR_VALUE_TAG_GLOBAL_ALLOC,
+                                 .type = type,
+                                 .data.global_alloc.value = value,
+                             });
+    scc_snprintf(name, 32, "$G%u", global_value_ref);
+    scc_vec_push(builder->cprog->global_vals, global_value_ref);
+    return global_value_ref;
+}
+
+scc_hir_value_ref_t scc_hir_builder_alloca(scc_hir_builder_t *builder,
+                                           scc_hir_type_ref_t type,
+                                           const char *name) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    scc_hir_value_t alloc_node = {0};
+    alloc_node.tag = SCC_HIR_VALUE_TAG_ALLOC;
+    alloc_node.type = scc_hir_module_add_type(
+        GET_MODULE(builder),
+        &(scc_hir_type_t){.tag = SCC_HIR_TYPE_PTR, .data.pointer.base = type});
+    alloc_node.name = name;
+
+    scc_hir_value_ref_t value_ref =
+        scc_hir_module_add_value(GET_MODULE(builder), &alloc_node);
+    scc_hir_builder_add_instr(builder, value_ref);
+    return value_ref;
+}
+
+scc_hir_value_ref_t scc_hir_builder_func_arg_ref(scc_hir_builder_t *builder,
+                                                 scc_hir_type_ref_t type,
+                                                 const char *name,
+                                                 usize arg_idx) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    scc_hir_value_t value = {0};
+    value.tag = SCC_HIR_VALUE_TAG_FUNC_ARG_REF;
+    value.type = type;
+    value.name = name;
+    value.data.arg_ref.idx = arg_idx;
+
+    scc_hir_value_ref_t value_ref =
+        scc_hir_module_add_value(GET_MODULE(builder), &value);
+    scc_hir_builder_add_instr(builder, value_ref);
+    return value_ref;
+}
+
+scc_hir_value_ref_t scc_hir_builder_load(scc_hir_builder_t *builder,
+                                         scc_hir_value_ref_t target) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    scc_hir_value_t load_node = {0};
+    load_node.tag = SCC_HIR_VALUE_TAG_LOAD;
+    load_node.data.load.target = target;
+
+    // 借用 ptr_node 和 ptr_type 获取类型信息
+    scc_hir_value_t *ptr_node = nullptr;
+    SCC_HIR_BUILDER_BEGIN_BORROW(
+        builder, ptr_node,
+        scc_hir_module_get_value(GET_MODULE(builder), target));
+    if (ptr_node) {
+        scc_hir_type_t *ptr_type = nullptr;
+        SCC_HIR_BUILDER_BEGIN_BORROW(
+            builder, ptr_type,
+            scc_hir_module_get_type(GET_MODULE(builder), ptr_node->type));
+        if (ptr_type && ptr_type->tag == SCC_HIR_TYPE_PTR) {
+            load_node.type = ptr_type->data.pointer.base;
+        }
+        SCC_HIR_BUILDER_END_BORROW(builder); // ptr_type
+    }
+    SCC_HIR_BUILDER_END_BORROW(builder); // ptr_node
+
+    scc_hir_value_ref_t value_ref =
+        scc_hir_module_add_value(GET_MODULE(builder), &load_node);
+    scc_hir_builder_add_instr(builder, value_ref);
+    return value_ref;
+}
+
+scc_hir_value_ref_t scc_hir_builder_store(scc_hir_builder_t *builder,
+                                          scc_hir_value_ref_t target,
+                                          scc_hir_value_ref_t value) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    Assert(target != SCC_HIR_REF_nullptr && value != SCC_HIR_REF_nullptr);
+    scc_hir_value_t store_node = {0};
+    store_node.tag = SCC_HIR_VALUE_TAG_STORE;
+    store_node.data.store.target = target;
+    store_node.data.store.value = value;
+
+    scc_hir_value_ref_t value_ref =
+        scc_hir_module_add_value(GET_MODULE(builder), &store_node);
+    scc_hir_builder_add_instr(builder, value_ref);
+    return value_ref;
+}
+
+scc_hir_value_ref_t scc_hir_builder_get_elem_ptr(scc_hir_builder_t *builder,
+                                                 scc_hir_value_ref_t target,
+                                                 scc_hir_value_ref_t index) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    scc_hir_value_t get_ptr_node = {0};
+    get_ptr_node.tag = SCC_HIR_VALUE_TAG_GET_ELEM_PTR;
+    get_ptr_node.data.get_elem_ptr.src_addr = target;
+    get_ptr_node.data.get_elem_ptr.index = index;
+
+    // 借用类型信息
+    scc_hir_type_t *type_ref = nullptr;
+    SCC_HIR_BUILDER_BEGIN_BORROW(
+        builder, type_ref,
+        scc_hir_module_get_type_by_value(GET_MODULE(builder), target));
+    Assert(type_ref != nullptr);
+    scc_hir_type_t type = *type_ref;     // 拷贝一份，避免后续借用
+    SCC_HIR_BUILDER_END_BORROW(builder); // type_ref
+
+    if (type.tag == SCC_HIR_TYPE_PTR) {
+        scc_hir_type_t *base_type = nullptr;
+        SCC_HIR_BUILDER_BEGIN_BORROW(
+            builder, base_type,
+            scc_hir_module_get_type(GET_MODULE(builder),
+                                    type_ref->data.pointer.base));
+        if (base_type->tag == SCC_HIR_TYPE_ARRAY) {
+            scc_hir_type_t type = (scc_hir_type_t){
+                .tag = SCC_HIR_TYPE_PTR,
+                .data.pointer.base = base_type->data.array.base,
+            };
+            SCC_HIR_BUILDER_END_BORROW(builder); // base_type
+            get_ptr_node.type = scc_hir_builder_type(builder, &type);
+        } else {
+            SCC_HIR_BUILDER_END_BORROW(builder); // base_type
+            get_ptr_node.type = scc_hir_builder_type(builder, &type);
+        }
+    } else {
+        get_ptr_node.type = scc_hir_builder_type(builder, &type);
+    }
+
+    scc_hir_value_ref_t value_ref =
+        scc_hir_module_add_value(GET_MODULE(builder), &get_ptr_node);
+    scc_hir_builder_add_instr(builder, value_ref);
+    return value_ref;
+}
+
+scc_hir_value_ref_t scc_hir_builder_binop(scc_hir_builder_t *builder,
+                                          scc_hir_op_type_t op,
+                                          scc_hir_value_ref_t lhs,
+                                          scc_hir_value_ref_t rhs) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    scc_hir_value_t binop_node = {0};
+    binop_node.tag = SCC_HIR_VALUE_TAG_OP;
+    binop_node.data.op.op = op;
+    binop_node.data.op.lhs = lhs;
+    binop_node.data.op.rhs = rhs;
+
+    // 借用 lhs_node 获取类型
+    scc_hir_value_t *lhs_node = nullptr;
+    SCC_HIR_BUILDER_BEGIN_BORROW(
+        builder, lhs_node, scc_hir_module_get_value(GET_MODULE(builder), lhs));
+    if (lhs_node) {
+        binop_node.type = lhs_node->type;
+    }
+    SCC_HIR_BUILDER_END_BORROW(builder); // lhs_node
+
+    scc_hir_value_ref_t value_ref =
+        scc_hir_module_add_value(GET_MODULE(builder), &binop_node);
+    scc_hir_builder_add_instr(builder, value_ref);
+    return value_ref;
+}
+
+scc_hir_value_ref_t scc_hir_builder_cmp(scc_hir_builder_t *builder,
+                                        scc_hir_op_type_t op,
+                                        scc_hir_value_ref_t lhs,
+                                        scc_hir_value_ref_t rhs) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    scc_hir_value_t cmp_node = {0};
+    cmp_node.tag = SCC_HIR_VALUE_TAG_OP;
+    cmp_node.data.op.op = op;
+    cmp_node.data.op.lhs = lhs;
+    cmp_node.data.op.rhs = rhs;
+    cmp_node.type = 0; // FIXME
+
+    scc_hir_value_ref_t value_ref =
+        scc_hir_module_add_value(GET_MODULE(builder), &cmp_node);
+    scc_hir_builder_add_instr(builder, value_ref);
+    return value_ref;
+}
+
+scc_hir_value_ref_t scc_hir_builder_jump(scc_hir_builder_t *builder,
+                                         scc_hir_bblock_ref_t target) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    scc_hir_value_t jump_node = {0};
+    jump_node.tag = SCC_HIR_VALUE_TAG_JUMP;
+    jump_node.data.jump.target_bblock = target;
+
+    scc_hir_value_ref_t value_ref =
+        scc_hir_module_add_value(GET_MODULE(builder), &jump_node);
+    scc_hir_builder_add_instr(builder, value_ref);
+    return value_ref;
+}
+
+scc_hir_value_ref_t scc_hir_builder_branch(scc_hir_builder_t *builder,
+                                           scc_hir_value_ref_t cond,
+                                           scc_hir_bblock_ref_t true_target,
+                                           scc_hir_bblock_ref_t false_target) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    scc_hir_value_t branch_node = {0};
+    branch_node.tag = SCC_HIR_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_hir_value_ref_t value_ref =
+        scc_hir_module_add_value(GET_MODULE(builder), &branch_node);
+    scc_hir_builder_add_instr(builder, value_ref);
+    return value_ref;
+}
+
+scc_hir_value_ref_t scc_hir_builder_call(scc_hir_builder_t *builder,
+                                         scc_hir_func_ref_t callee,
+                                         const scc_hir_value_ref_t *args,
+                                         usize arg_count) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    scc_hir_value_t call_node = {0};
+    call_node.tag = SCC_HIR_VALUE_TAG_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]);
+    }
+
+    // 借用 callee_func 和 func_type 获取返回类型
+    scc_hir_func_t *callee_func = nullptr;
+    SCC_HIR_BUILDER_BEGIN_BORROW(
+        builder, callee_func,
+        scc_hir_module_get_func(GET_MODULE(builder), callee));
+    if (callee_func) {
+        scc_hir_type_t *func_type = nullptr;
+        SCC_HIR_BUILDER_BEGIN_BORROW(
+            builder, func_type,
+            scc_hir_module_get_type(GET_MODULE(builder),
+                                    SCC_HIR_FUNC_META(*callee_func)->type));
+        if (func_type && func_type->tag == SCC_HIR_TYPE_FUNC) {
+            call_node.type = func_type->data.function.ret_type;
+        }
+        SCC_HIR_BUILDER_END_BORROW(builder); // func_type
+    }
+    SCC_HIR_BUILDER_END_BORROW(builder); // callee_func
+
+    scc_hir_value_ref_t value_ref =
+        scc_hir_module_add_value(GET_MODULE(builder), &call_node);
+    scc_hir_builder_add_instr(builder, value_ref);
+    return value_ref;
+}
+
+scc_hir_value_ref_t scc_hir_builder_ret(scc_hir_builder_t *builder,
+                                        scc_hir_value_ref_t value) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    scc_hir_value_t ret_node = {0};
+    ret_node.tag = SCC_HIR_VALUE_TAG_RET;
+    ret_node.data.ret.ret_val = value;
+
+    scc_hir_value_ref_t value_ref =
+        scc_hir_module_add_value(GET_MODULE(builder), &ret_node);
+    scc_hir_builder_add_instr(builder, value_ref);
+    return value_ref;
+}
+
+scc_hir_value_ref_t scc_hir_builder_ret_void(scc_hir_builder_t *builder) {
+    SCC_HIR_BUILDER_CHECK_NO_BORROW(builder);
+    scc_hir_value_t ret_node = {0};
+    ret_node.tag = SCC_HIR_VALUE_TAG_RET;
+
+    scc_hir_value_t ret_val_node;
+    scc_hir_value_init(&ret_val_node, nullptr, SCC_HIR_VALUE_TAG_NULLPTR);
+    ret_val_node.type = scc_hir_builder_type_void(builder);
+    ret_node.data.ret.ret_val =
+        scc_hir_module_add_value(GET_MODULE(builder), &ret_val_node);
+
+    scc_hir_value_ref_t value_ref =
+        scc_hir_module_add_value(GET_MODULE(builder), &ret_node);
+    scc_hir_builder_add_instr(builder, value_ref);
+    return value_ref;
+}
+
+scc_hir_value_ref_t scc_hir_builder_builtin_memcpy(scc_hir_builder_t *builder,
+                                                   scc_hir_value_ref_t dest,
+                                                   scc_hir_value_ref_t src,
+                                                   scc_hir_value_ref_t len) {
+    Assert(builder && src && dest && len);
+    scc_hir_value_t value;
+    scc_hir_value_init(&value, nullptr, SCC_HIR_VALUE_TAG_BUILTIN);
+    value.type = scc_hir_builder_type_void(builder); // memcpy 返回 void*
+    value.data.builtin.tag = SCC_HIR_BUILTIN_TAG_MEMCPY;
+    value.data.builtin.func.memcpy.dest = dest;
+    value.data.builtin.func.memcpy.src = src;
+    value.data.builtin.func.memcpy.size = len;
+    scc_hir_value_ref_t ref =
+        scc_hir_module_add_value(GET_MODULE(builder), &value);
+    scc_hir_builder_add_instr(builder, ref);
+    return ref;
+}

libs/ir/hir/src/hir_dump.c

@@ -1,31 +1,30 @@
-#include <ir_dump.h>
-#include <ir_prog.h>
+#include <hir_dump.h>
+#include <hir_prog.h>
 #include <scc_tree_dump.h>
 
 #define GET_MODULE(ctx) (&(ctx->cprog->module))
 
-static const char *get_node_type_str(scc_ir_value_tag_t tag) {
+static const char *get_node_type_str(scc_hir_value_tag_t tag) {
     static const char *node_types[] = {
-        [SCC_IR_VALUE_TAG_NULLPTR] = "NullPtr",
-        [SCC_IR_VALUE_TAG_BUILTIN] = "Builtin",
-        [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",
-        [SCC_IR_VALUE_TAG_GLOBAL_ALLOC] = "GlobalAlloc",
-        [SCC_IR_VALUE_TAG_LOAD] = "Load",
-        [SCC_IR_VALUE_TAG_STORE] = "Store",
-        [SCC_IR_VALUE_TAG_GET_ELEM_PTR] = "GetElemPtr",
-        [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",
+        [SCC_HIR_VALUE_TAG_NULLPTR] = "NullPtr",
+        [SCC_HIR_VALUE_TAG_BUILTIN] = "Builtin",
+        [SCC_HIR_VALUE_TAG_INTEGER] = "ConstInt",
+        [SCC_HIR_VALUE_TAG_DECIMAL] = "ConstFloat",
+        [SCC_HIR_VALUE_TAG_ARRAY] = "ConstArray",
+        [SCC_HIR_VALUE_TAG_AGGREGATE] = "Aggregate",
+        [SCC_HIR_VALUE_TAG_CONV] = "Convert",
+        [SCC_HIR_VALUE_TAG_FUNC_ARG_REF] = "FuncArgRef",
+        [SCC_HIR_VALUE_TAG_BLOCK_ARG_REF] = "BlockArgRef",
+        [SCC_HIR_VALUE_TAG_ALLOC] = "Alloc",
+        [SCC_HIR_VALUE_TAG_GLOBAL_ALLOC] = "GlobalAlloc",
+        [SCC_HIR_VALUE_TAG_LOAD] = "Load",
+        [SCC_HIR_VALUE_TAG_STORE] = "Store",
+        [SCC_HIR_VALUE_TAG_GET_ELEM_PTR] = "GetElemPtr",
+        [SCC_HIR_VALUE_TAG_OP] = "Op",
+        [SCC_HIR_VALUE_TAG_BRANCH] = "Branch",
+        [SCC_HIR_VALUE_TAG_JUMP] = "Jump",
+        [SCC_HIR_VALUE_TAG_CALL] = "Call",
+        [SCC_HIR_VALUE_TAG_RET] = "Ret",
     };
     if (tag >= 0 && (usize)tag < sizeof(node_types) / sizeof(node_types[0]) &&
         node_types[tag])
@@ -33,36 +32,36 @@ static const char *get_node_type_str(scc_ir_value_tag_t tag) {
     return "UnknownIRNode";
 }
 
-static const char *get_op_str(scc_ir_op_type_t op) {
+static const char *get_op_str(scc_hir_op_type_t op) {
     static const char *ops[] = {
-        [SCC_IR_OP_EMPTY] = "empty", [SCC_IR_OP_NEQ] = "!=",
-        [SCC_IR_OP_EQ] = "==",       [SCC_IR_OP_GT] = ">",
-        [SCC_IR_OP_LT] = "<",        [SCC_IR_OP_GE] = ">=",
-        [SCC_IR_OP_LE] = "<=",       [SCC_IR_OP_ADD] = "+",
-        [SCC_IR_OP_SUB] = "-",       [SCC_IR_OP_MUL] = "*",
-        [SCC_IR_OP_DIV] = "/",       [SCC_IR_OP_MOD] = "%",
-        [SCC_IR_OP_AND] = "&",       [SCC_IR_OP_OR] = "|",
-        [SCC_IR_OP_XOR] = "^",       [SCC_IR_OP_NOT] = "~",
-        [SCC_IR_OP_SHL] = "<<",      [SCC_IR_OP_SHR] = ">>",
-        [SCC_IR_OP_SAR] = ">>a",
+        [SCC_HIR_OP_EMPTY] = "empty", [SCC_HIR_OP_NEQ] = "!=",
+        [SCC_HIR_OP_EQ] = "==",       [SCC_HIR_OP_GT] = ">",
+        [SCC_HIR_OP_LT] = "<",        [SCC_HIR_OP_GE] = ">=",
+        [SCC_HIR_OP_LE] = "<=",       [SCC_HIR_OP_ADD] = "+",
+        [SCC_HIR_OP_SUB] = "-",       [SCC_HIR_OP_MUL] = "*",
+        [SCC_HIR_OP_DIV] = "/",       [SCC_HIR_OP_MOD] = "%",
+        [SCC_HIR_OP_AND] = "&",       [SCC_HIR_OP_OR] = "|",
+        [SCC_HIR_OP_XOR] = "^",       [SCC_HIR_OP_NOT] = "~",
+        [SCC_HIR_OP_SHL] = "<<",      [SCC_HIR_OP_SHR] = ">>",
+        [SCC_HIR_OP_SAR] = ">>a",
     };
     if (op >= 0 && (usize)op < sizeof(ops) / sizeof(ops[0]) && ops[op])
         return ops[op];
     return "<unknown_op>";
 }
 
-static const char *get_type_tag_str(scc_ir_type_tag_t tag) {
+static const char *get_type_tag_str(scc_hir_type_tag_t tag) {
     static const char *type_tags[] = {
-        [SCC_IR_TYPE_void] = "void",     [SCC_IR_TYPE_u8] = "u8",
-        [SCC_IR_TYPE_u16] = "u16",       [SCC_IR_TYPE_u32] = "u32",
-        [SCC_IR_TYPE_u64] = "u64",       [SCC_IR_TYPE_u128] = "u128",
-        [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",
+        [SCC_HIR_TYPE_void] = "void",     [SCC_HIR_TYPE_u8] = "u8",
+        [SCC_HIR_TYPE_u16] = "u16",       [SCC_HIR_TYPE_u32] = "u32",
+        [SCC_HIR_TYPE_u64] = "u64",       [SCC_HIR_TYPE_u128] = "u128",
+        [SCC_HIR_TYPE_i8] = "i8",         [SCC_HIR_TYPE_i16] = "i16",
+        [SCC_HIR_TYPE_i32] = "i32",       [SCC_HIR_TYPE_i64] = "i64",
+        [SCC_HIR_TYPE_i128] = "i128",     [SCC_HIR_TYPE_f16] = "f16",
+        [SCC_HIR_TYPE_f32] = "f32",       [SCC_HIR_TYPE_f64] = "f64",
+        [SCC_HIR_TYPE_f128] = "f128",     [SCC_HIR_TYPE_PTR] = "ptr",
+        [SCC_HIR_TYPE_ARRAY] = "array",   [SCC_HIR_TYPE_FUNC] = "func",
+        [SCC_HIR_TYPE_STRUCT] = "struct", [SCC_HIR_TYPE_VECTOR] = "vector",
     };
     if (tag >= 0 && (usize)tag < sizeof(type_tags) / sizeof(type_tags[0]) &&
         type_tags[tag])
@@ -70,25 +69,26 @@ static const char *get_type_tag_str(scc_ir_type_tag_t tag) {
     return "<unknown_type>";
 }
 
-static inline void dump_child_node_ref(scc_ir_dump_ctx_t *ctx,
-                                       scc_ir_value_ref_t child,
+static inline void dump_child_node_ref(scc_hir_dump_t *ctx,
+                                       scc_hir_value_ref_t child,
                                        cbool is_last) {
     if (!child)
         return;
     scc_tree_dump_push(ctx->dump_ctx, is_last);
-    scc_ir_dump_value(ctx, child);
+    scc_hir_dump_value(ctx, child);
     scc_tree_dump_pop(ctx->dump_ctx);
 }
 
-static void dump_const_int_node(scc_ir_dump_ctx_t *ctx,
-                                const scc_ir_value_t *value) {
+static void dump_integer_node(scc_hir_dump_t *ctx,
+                              const scc_hir_value_t *value) {
     scc_tree_dump_push(ctx->dump_ctx, true);
     scc_tree_dump_begin_line(ctx->dump_ctx);
-    scc_tree_dump_value(ctx->dump_ctx, "%d", value->data.const_int.int32);
+    // FIXME hack it
+    scc_tree_dump_value(ctx->dump_ctx, "%d", value->data.integer.data.digit);
     scc_tree_dump_pop(ctx->dump_ctx);
 }
 
-static void dump_op_node(scc_ir_dump_ctx_t *ctx, const scc_ir_value_t *value) {
+static void dump_op_node(scc_hir_dump_t *ctx, const scc_hir_value_t *value) {
     scc_tree_dump_push(ctx->dump_ctx, false);
     scc_tree_dump_begin_line(ctx->dump_ctx);
     scc_tree_dump_node(ctx->dump_ctx, "op: ");
@@ -102,66 +102,63 @@ static void dump_op_node(scc_ir_dump_ctx_t *ctx, const scc_ir_value_t *value) {
         dump_child_node_ref(ctx, value->data.op.rhs, true);
 }
 
-static void dump_load_node(scc_ir_dump_ctx_t *ctx,
-                           const scc_ir_value_t *value) {
+static void dump_load_node(scc_hir_dump_t *ctx, const scc_hir_value_t *value) {
     if (value->data.load.target)
         dump_child_node_ref(ctx, value->data.load.target, true);
 }
 
-static void dump_store_node(scc_ir_dump_ctx_t *ctx,
-                            const scc_ir_value_t *value) {
+static void dump_store_node(scc_hir_dump_t *ctx, const scc_hir_value_t *value) {
     if (value->data.store.target)
         dump_child_node_ref(ctx, value->data.store.target, false);
     if (value->data.store.value)
         dump_child_node_ref(ctx, value->data.store.value, true);
 }
 
-static void dump_get_elem_ptr_node(scc_ir_dump_ctx_t *ctx,
-                                   const scc_ir_value_t *value) {
+static void dump_get_elem_ptr_node(scc_hir_dump_t *ctx,
+                                   const scc_hir_value_t *value) {
     if (value->data.get_elem_ptr.src_addr)
         dump_child_node_ref(ctx, value->data.get_elem_ptr.src_addr, false);
     if (value->data.get_elem_ptr.index)
         dump_child_node_ref(ctx, value->data.get_elem_ptr.index, true);
 }
 
-static void dump_branch_node(scc_ir_dump_ctx_t *ctx,
-                             const scc_ir_value_t *value) {
+static void dump_branch_node(scc_hir_dump_t *ctx,
+                             const scc_hir_value_t *value) {
     if (value->data.branch.cond)
         dump_child_node_ref(ctx, value->data.branch.cond, false);
 
     if (value->data.branch.true_bblock) {
-        scc_ir_bblock_t *true_bblock = scc_ir_module_get_bblock(
+        scc_hir_bblock_t *true_bblock = scc_hir_module_get_bblock(
             GET_MODULE(ctx), value->data.branch.true_bblock);
         if (true_bblock) {
             scc_tree_dump_begin_line(ctx->dump_ctx);
             scc_tree_dump_node(ctx->dump_ctx, "TrueBlock: ");
             scc_tree_dump_value(ctx->dump_ctx, "'%s'",
-                                true_bblock->label ? true_bblock->label
-                                                   : "<unnamed>");
+                                true_bblock->name ? true_bblock->name
+                                                  : "<unnamed>");
         }
     }
     if (value->data.branch.false_bblock) {
-        scc_ir_bblock_t *false_bblock = scc_ir_module_get_bblock(
+        scc_hir_bblock_t *false_bblock = scc_hir_module_get_bblock(
             GET_MODULE(ctx), value->data.branch.false_bblock);
         if (false_bblock) {
             scc_tree_dump_begin_line(ctx->dump_ctx);
             scc_tree_dump_node(ctx->dump_ctx, "FalseBlock: ");
             scc_tree_dump_value(ctx->dump_ctx, "'%s'",
-                                false_bblock->label ? false_bblock->label
-                                                    : "<unnamed>");
+                                false_bblock->name ? false_bblock->name
+                                                   : "<unnamed>");
         }
     }
 }
 
-static void dump_jump_node(scc_ir_dump_ctx_t *ctx,
-                           const scc_ir_value_t *value) {
+static void dump_jump_node(scc_hir_dump_t *ctx, const scc_hir_value_t *value) {
     scc_tree_dump_begin_line(ctx->dump_ctx);
     if (value->data.jump.target_bblock) {
-        scc_ir_bblock_t *target = scc_ir_module_get_bblock(
+        scc_hir_bblock_t *target = scc_hir_module_get_bblock(
             GET_MODULE(ctx), value->data.jump.target_bblock);
         if (target)
             scc_tree_dump_value(ctx->dump_ctx, "to '%s'",
-                                target->label ? target->label : "<unnamed>");
+                                target->name ? target->name : "<unnamed>");
         else
             scc_tree_dump_value(ctx->dump_ctx, "to invalid block");
     } else {
@@ -169,12 +166,11 @@ static void dump_jump_node(scc_ir_dump_ctx_t *ctx,
     }
 }
 
-static void dump_call_node(scc_ir_dump_ctx_t *ctx,
-                           const scc_ir_value_t *value) {
+static void dump_call_node(scc_hir_dump_t *ctx, const scc_hir_value_t *value) {
     scc_tree_dump_begin_line(ctx->dump_ctx);
     if (value->data.call.callee) {
-        scc_ir_func_t *callee =
-            scc_ir_module_get_func(GET_MODULE(ctx), value->data.call.callee);
+        scc_hir_func_t *callee =
+            scc_hir_module_get_func(GET_MODULE(ctx), value->data.call.callee);
         scc_tree_dump_value(ctx->dump_ctx, "func='%s'",
                             callee ? (callee->name ? callee->name : "<unnamed>")
                                    : "<invalid>");
@@ -185,25 +181,26 @@ static void dump_call_node(scc_ir_dump_ctx_t *ctx,
     for (usize i = 0; i < scc_vec_size(value->data.call.args); i++) {
         cbool is_last = (i + 1 == scc_vec_size(value->data.call.args));
         scc_tree_dump_push(ctx->dump_ctx, is_last);
-        scc_ir_value_ref_t arg = scc_vec_at(value->data.call.args, i);
+        scc_hir_value_ref_t arg = scc_vec_at(value->data.call.args, i);
         dump_child_node_ref(ctx, arg, is_last);
         scc_tree_dump_pop(ctx->dump_ctx);
     }
 }
 
-static void dump_ret_node(scc_ir_dump_ctx_t *ctx, const scc_ir_value_t *value) {
+static void dump_ret_node(scc_hir_dump_t *ctx, const scc_hir_value_t *value) {
     if (value->data.ret.ret_val)
         dump_child_node_ref(ctx, value->data.ret.ret_val, true);
 }
 
-void scc_ir_dump_ctx_init(scc_ir_dump_ctx_t *ctx, scc_tree_dump_t *td,
-                          scc_ir_cprog_t *cprog) {
+void scc_hir_dump_ctx_init(scc_hir_dump_t *ctx, scc_tree_dump_t *td,
+                           scc_hir_cprog_t *cprog) {
     ctx->cprog = cprog;
     ctx->dump_ctx = td;
 }
 
-void scc_ir_dump_value(scc_ir_dump_ctx_t *ctx, scc_ir_value_ref_t value_ref) {
-    scc_ir_value_t *value = scc_ir_module_get_value(GET_MODULE(ctx), value_ref);
+void scc_hir_dump_value(scc_hir_dump_t *ctx, scc_hir_value_ref_t value_ref) {
+    scc_hir_value_t *value =
+        scc_hir_module_get_value(GET_MODULE(ctx), value_ref);
     if (!value) {
         LOG_ERROR("Invalid value ref");
         return;
@@ -214,8 +211,8 @@ void scc_ir_dump_value(scc_ir_dump_ctx_t *ctx, scc_ir_value_ref_t value_ref) {
     if (value->name && value->name[0])
         scc_tree_dump_value(ctx->dump_ctx, " [%s]", value->name);
     if (value->type) {
-        scc_ir_type_t *type =
-            scc_ir_module_get_type(GET_MODULE(ctx), value->type);
+        scc_hir_type_t *type =
+            scc_hir_module_get_type(GET_MODULE(ctx), value->type);
         if (type) {
             scc_tree_dump_append(ctx->dump_ctx, " : ");
             scc_tree_dump_value(ctx->dump_ctx, "%s",
@@ -224,33 +221,33 @@ void scc_ir_dump_value(scc_ir_dump_ctx_t *ctx, scc_ir_value_ref_t value_ref) {
     }
 
     switch (value->tag) {
-    case SCC_IR_VALUE_TAG_CONST_INT:
-        dump_const_int_node(ctx, value);
+    case SCC_HIR_VALUE_TAG_INTEGER:
+        dump_integer_node(ctx, value);
         break;
-    case SCC_IR_VALUE_TAG_ALLOC:
+    case SCC_HIR_VALUE_TAG_ALLOC:
         break;
-    case SCC_IR_VALUE_TAG_LOAD:
+    case SCC_HIR_VALUE_TAG_LOAD:
         dump_load_node(ctx, value);
         break;
-    case SCC_IR_VALUE_TAG_STORE:
+    case SCC_HIR_VALUE_TAG_STORE:
         dump_store_node(ctx, value);
         break;
-    case SCC_IR_VALUE_TAG_GET_ELEM_PTR:
+    case SCC_HIR_VALUE_TAG_GET_ELEM_PTR:
         dump_get_elem_ptr_node(ctx, value);
         break;
-    case SCC_IR_VALUE_TAG_OP:
+    case SCC_HIR_VALUE_TAG_OP:
         dump_op_node(ctx, value);
         break;
-    case SCC_IR_VALUE_TAG_BRANCH:
+    case SCC_HIR_VALUE_TAG_BRANCH:
         dump_branch_node(ctx, value);
         break;
-    case SCC_IR_VALUE_TAG_JUMP:
+    case SCC_HIR_VALUE_TAG_JUMP:
         dump_jump_node(ctx, value);
         break;
-    case SCC_IR_VALUE_TAG_CALL:
+    case SCC_HIR_VALUE_TAG_CALL:
         dump_call_node(ctx, value);
         break;
-    case SCC_IR_VALUE_TAG_RET:
+    case SCC_HIR_VALUE_TAG_RET:
         dump_ret_node(ctx, value);
         break;
     default:
@@ -260,12 +257,12 @@ void scc_ir_dump_value(scc_ir_dump_ctx_t *ctx, scc_ir_value_ref_t value_ref) {
     }
 }
 
-void scc_ir_dump_type(scc_ir_dump_ctx_t *ctx, scc_ir_type_ref_t type_ref) {
+void scc_hir_dump_type(scc_hir_dump_t *ctx, scc_hir_type_ref_t type_ref) {
     if (!ctx || !type_ref) {
         LOG_ERROR("invalid parameter");
         return;
     }
-    scc_ir_type_t *type = scc_ir_module_get_type(GET_MODULE(ctx), type_ref);
+    scc_hir_type_t *type = scc_hir_module_get_type(GET_MODULE(ctx), type_ref);
     if (!type) {
         LOG_ERROR("invalid type ref");
         return;
@@ -275,14 +272,14 @@ void scc_ir_dump_type(scc_ir_dump_ctx_t *ctx, scc_ir_type_ref_t type_ref) {
     scc_tree_dump_value(ctx->dump_ctx, "%s", get_type_tag_str(type->tag));
 
     switch (type->tag) {
-    case SCC_IR_TYPE_PTR:
+    case SCC_HIR_TYPE_PTR:
         if (type->data.pointer.base) {
             scc_tree_dump_push(ctx->dump_ctx, true);
-            scc_ir_dump_type(ctx, type->data.pointer.base);
+            scc_hir_dump_type(ctx, type->data.pointer.base);
             scc_tree_dump_pop(ctx->dump_ctx);
         }
         break;
-    case SCC_IR_TYPE_ARRAY:
+    case SCC_HIR_TYPE_ARRAY:
         if (type->data.array.len > 0) {
             scc_tree_dump_begin_line(ctx->dump_ctx);
             scc_tree_dump_node(ctx->dump_ctx, "Array Length: ");
@@ -291,20 +288,20 @@ void scc_ir_dump_type(scc_ir_dump_ctx_t *ctx, scc_ir_type_ref_t type_ref) {
         }
         if (type->data.array.base) {
             scc_tree_dump_push(ctx->dump_ctx, true);
-            scc_ir_dump_type(ctx, type->data.array.base);
+            scc_hir_dump_type(ctx, type->data.array.base);
             scc_tree_dump_pop(ctx->dump_ctx);
         }
         break;
-    case SCC_IR_TYPE_FUNC:
+    case SCC_HIR_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(ctx->dump_ctx, is_last);
-            scc_ir_dump_type(ctx, scc_vec_at(type->data.function.params, i));
+            scc_hir_dump_type(ctx, scc_vec_at(type->data.function.params, i));
             scc_tree_dump_pop(ctx->dump_ctx);
         }
         if (type->data.function.ret_type) {
             scc_tree_dump_push(ctx->dump_ctx, true);
-            scc_ir_dump_type(ctx, type->data.function.ret_type);
+            scc_hir_dump_type(ctx, type->data.function.ret_type);
             scc_tree_dump_pop(ctx->dump_ctx);
         }
         break;
@@ -313,14 +310,13 @@ void scc_ir_dump_type(scc_ir_dump_ctx_t *ctx, scc_ir_type_ref_t type_ref) {
     }
 }
 
-void scc_ir_dump_bblock(scc_ir_dump_ctx_t *ctx,
-                        scc_ir_bblock_ref_t bblock_ref) {
+void scc_hir_dump_bblock(scc_hir_dump_t *ctx, scc_hir_bblock_ref_t bblock_ref) {
     if (!ctx || !bblock_ref) {
         LOG_ERROR("invalid parameter");
         return;
     }
-    scc_ir_bblock_t *bblock =
-        scc_ir_module_get_bblock(GET_MODULE(ctx), bblock_ref);
+    scc_hir_bblock_t *bblock =
+        scc_hir_module_get_bblock(GET_MODULE(ctx), bblock_ref);
     if (!bblock) {
         LOG_ERROR("invalid bblock ref");
         return;
@@ -328,19 +324,19 @@ void scc_ir_dump_bblock(scc_ir_dump_ctx_t *ctx,
     scc_tree_dump_begin_line(ctx->dump_ctx);
     scc_tree_dump_node(ctx->dump_ctx, "BasicBlock: ");
     scc_tree_dump_value(ctx->dump_ctx, "'%s'",
-                        bblock->label ? bblock->label : "<unnamed>");
+                        bblock->name ? bblock->name : "<unnamed>");
     scc_tree_dump_append(ctx->dump_ctx, "\n");
 
-    for (usize i = 0; i < scc_vec_size(bblock->instrs); i++) {
-        cbool is_last = (i + 1 == scc_vec_size(bblock->instrs));
+    for (usize i = 0; i < scc_vec_size(SCC_HIR_BBLOCK_VALUES(*bblock)); i++) {
+        cbool is_last = (i + 1 == scc_vec_size(SCC_HIR_BBLOCK_VALUES(*bblock)));
         scc_tree_dump_push(ctx->dump_ctx, is_last);
-        scc_ir_dump_value(ctx, scc_vec_at(bblock->instrs, i));
+        scc_hir_dump_value(ctx, scc_vec_at(SCC_HIR_BBLOCK_VALUES(*bblock), i));
         scc_tree_dump_pop(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_module_get_func(GET_MODULE(ctx), func_ref);
+void scc_hir_dump_func(scc_hir_dump_t *ctx, scc_hir_func_ref_t func_ref) {
+    scc_hir_func_t *func = scc_hir_module_get_func(GET_MODULE(ctx), func_ref);
     if (!ctx || !func) {
         LOG_ERROR("invalid parameter");
         return;
@@ -351,82 +347,84 @@ void scc_ir_dump_func(scc_ir_dump_ctx_t *ctx, scc_ir_func_ref_t func_ref) {
                         func->name ? func->name : "<unnamed>");
     scc_tree_dump_append(ctx->dump_ctx, "\n");
 
-    if (func->type) {
+    if (SCC_HIR_FUNC_META(*func)->type) {
         scc_tree_dump_push(ctx->dump_ctx, false);
-        scc_ir_dump_type(ctx, func->type);
+        scc_hir_dump_type(ctx, SCC_HIR_FUNC_META(*func)->type);
         scc_tree_dump_pop(ctx->dump_ctx);
     }
-    for (usize i = 0; i < scc_vec_size(func->params); i++) {
-        cbool is_last = (i + 1 == scc_vec_size(func->params));
+    for (usize i = 0; i < scc_vec_size(SCC_HIR_FUNC_META(*func)->params); i++) {
+        cbool is_last =
+            (i + 1 == scc_vec_size(SCC_HIR_FUNC_META(*func)->params));
         scc_tree_dump_push(ctx->dump_ctx, is_last);
-        scc_ir_dump_value(ctx, scc_vec_at(func->params, i));
+        scc_hir_dump_value(ctx,
+                           scc_vec_at(SCC_HIR_FUNC_META(*func)->params, i));
         scc_tree_dump_pop(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(ctx->dump_ctx, is_last);
-        scc_ir_dump_bblock(ctx, scc_vec_at(func->bblocks, i));
+        scc_hir_dump_bblock(ctx, scc_vec_at(func->bblocks, i));
         scc_tree_dump_pop(ctx->dump_ctx);
     }
 }
 
-void scc_ir_dump_cprog(scc_ir_dump_ctx_t *ctx) {
+void scc_hir_dump_cprog(scc_hir_dump_t *ctx) {
     scc_tree_dump_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(ctx->dump_ctx, is_last);
-        scc_ir_dump_func(ctx, scc_vec_at(ctx->cprog->func_defs, i));
+        scc_hir_dump_func(ctx, scc_vec_at(ctx->cprog->func_defs, i));
         scc_tree_dump_pop(ctx->dump_ctx);
     }
 }
 
 // ----- 线性输出（保留原逻辑，改用新 API）-----
-void scc_ir_dump_type_linear(scc_ir_dump_ctx_t *ctx,
-                             scc_ir_type_ref_t type_ref) {
-    scc_ir_type_t *type = scc_ir_module_get_type(GET_MODULE(ctx), type_ref);
+void scc_hir_dump_type_linear(scc_hir_dump_t *ctx,
+                              scc_hir_type_ref_t type_ref) {
+    scc_hir_type_t *type = scc_hir_module_get_type(GET_MODULE(ctx), type_ref);
     if (!ctx || !type) {
         LOG_ERROR("invalid parameter");
         return;
     }
     switch (type->tag) {
-    case SCC_IR_TYPE_unknown:
-    case SCC_IR_TYPE_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:
+    case SCC_HIR_TYPE_unknown:
+    case SCC_HIR_TYPE_void:
+    case SCC_HIR_TYPE_i8:
+    case SCC_HIR_TYPE_i16:
+    case SCC_HIR_TYPE_i32:
+    case SCC_HIR_TYPE_i64:
+    case SCC_HIR_TYPE_i128:
+    case SCC_HIR_TYPE_u8:
+    case SCC_HIR_TYPE_u16:
+    case SCC_HIR_TYPE_u32:
+    case SCC_HIR_TYPE_u64:
+    case SCC_HIR_TYPE_u128:
+    case SCC_HIR_TYPE_f16:
+    case SCC_HIR_TYPE_f32:
+    case SCC_HIR_TYPE_f64:
+    case SCC_HIR_TYPE_f128:
         scc_tree_dump_value(ctx->dump_ctx, "%s", get_type_tag_str(type->tag));
         break;
-    case SCC_IR_TYPE_ARRAY:
+    case SCC_HIR_TYPE_ARRAY:
         scc_tree_dump_append(ctx->dump_ctx, "[");
-        scc_ir_dump_type_linear(ctx, type->data.array.base);
+        scc_hir_dump_type_linear(ctx, type->data.array.base);
         scc_tree_dump_append_fmt(ctx->dump_ctx, ", %zu]", type->data.array.len);
         break;
-    case SCC_IR_TYPE_PTR:
+    case SCC_HIR_TYPE_PTR:
         scc_tree_dump_append(ctx->dump_ctx, "*");
-        scc_ir_dump_type_linear(ctx, type->data.pointer.base);
+        scc_hir_dump_type_linear(ctx, type->data.pointer.base);
         break;
-    case SCC_IR_TYPE_FUNC:
+    case SCC_HIR_TYPE_FUNC:
         scc_tree_dump_append(ctx->dump_ctx, "(");
         for (usize i = 0; i < scc_vec_size(type->data.function.params); i++) {
             if (i > 0)
                 scc_tree_dump_append(ctx->dump_ctx, ", ");
-            scc_ir_dump_type_linear(ctx,
-                                    scc_vec_at(type->data.function.params, i));
+            scc_hir_dump_type_linear(ctx,
+                                     scc_vec_at(type->data.function.params, i));
         }
         if (type->data.function.ret_type) {
             scc_tree_dump_append(ctx->dump_ctx, ") -> ");
-            scc_ir_dump_type_linear(ctx, type->data.function.ret_type);
+            scc_hir_dump_type_linear(ctx, type->data.function.ret_type);
         } else {
             scc_tree_dump_append(ctx->dump_ctx, ")");
         }
@@ -437,41 +435,44 @@ void scc_ir_dump_type_linear(scc_ir_dump_ctx_t *ctx,
     }
 }
 
-static void format_ref_or_value(scc_ir_dump_ctx_t *ctx,
-                                scc_ir_value_ref_t value_ref) {
-    scc_ir_value_t *value = scc_ir_module_get_value(GET_MODULE(ctx), value_ref);
+static void format_ref_or_value(scc_hir_dump_t *ctx,
+                                scc_hir_value_ref_t value_ref) {
+    scc_hir_value_t *value =
+        scc_hir_module_get_value(GET_MODULE(ctx), value_ref);
     if (!value) {
         scc_tree_dump_append_fmt(ctx->dump_ctx, "%%%u", value_ref);
         return;
     }
-    if (value->tag == SCC_IR_VALUE_TAG_CONST_INT) {
-        scc_tree_dump_append_fmt(ctx->dump_ctx, "%d",
-                                 value->data.const_int.int32);
-        return;
-    }
+    // FIXME
+    // if (value->tag == SCC_HIR_VALUE_TAG_INTEGER) {
+    //     scc_tree_dump_append_fmt(ctx->dump_ctx, "%d",
+    //                              value->data.const_int.int32);
+    //     return;
+    // }
     if (value->name && value->name[0] != '\0') {
         scc_tree_dump_node(ctx->dump_ctx, "%%%u[%s]", value_ref, value->name);
     } else {
         scc_tree_dump_node(ctx->dump_ctx, "%%%u", value_ref);
     }
-    if (value->type != SCC_IR_REF_nullptr) {
+    if (value->type != SCC_HIR_REF_nullptr) {
         scc_tree_dump_append(ctx->dump_ctx, ":");
-        scc_ir_dump_type_linear(ctx, value->type);
+        scc_hir_dump_type_linear(ctx, value->type);
     }
 }
 
-void scc_ir_dump_value_linear(scc_ir_dump_ctx_t *ctx,
-                              scc_ir_value_ref_t value_ref) {
-    scc_ir_value_t *value = scc_ir_module_get_value(GET_MODULE(ctx), value_ref);
+void scc_hir_dump_value_linear(scc_hir_dump_t *ctx,
+                               scc_hir_value_ref_t value_ref) {
+    scc_hir_value_t *value =
+        scc_hir_module_get_value(GET_MODULE(ctx), value_ref);
     if (!value) {
         scc_tree_dump_append(ctx->dump_ctx, "<invalid value>\n");
         return;
     }
 
-    cbool needs_equals = (value->tag != SCC_IR_VALUE_TAG_BRANCH &&
-                          value->tag != SCC_IR_VALUE_TAG_JUMP &&
-                          value->tag != SCC_IR_VALUE_TAG_RET &&
-                          value->tag != SCC_IR_VALUE_TAG_STORE);
+    cbool needs_equals = (value->tag != SCC_HIR_VALUE_TAG_BRANCH &&
+                          value->tag != SCC_HIR_VALUE_TAG_JUMP &&
+                          value->tag != SCC_HIR_VALUE_TAG_RET &&
+                          value->tag != SCC_HIR_VALUE_TAG_STORE);
 
     if (needs_equals) {
         format_ref_or_value(ctx, value_ref);
@@ -479,10 +480,10 @@ void scc_ir_dump_value_linear(scc_ir_dump_ctx_t *ctx,
     }
 
     switch (value->tag) {
-    case SCC_IR_VALUE_TAG_BUILTIN: {
+    case SCC_HIR_VALUE_TAG_BUILTIN: {
         scc_tree_dump_append(ctx->dump_ctx, "@scc::");
         switch (value->data.builtin.tag) {
-        case SCC_IR_BUILTIN_TAG_MEMCPY:
+        case SCC_HIR_BUILTIN_TAG_MEMCPY:
             scc_tree_dump_append(ctx->dump_ctx, "memcpy");
             scc_tree_dump_append(ctx->dump_ctx, "(");
             format_ref_or_value(ctx, value->data.builtin.func.memcpy.dest);
@@ -492,19 +493,19 @@ void scc_ir_dump_value_linear(scc_ir_dump_ctx_t *ctx,
             format_ref_or_value(ctx, value->data.builtin.func.memcpy.size);
             scc_tree_dump_append(ctx->dump_ctx, ")");
             break;
-        case SCC_IR_BUILTIN_TAG_MEMSET:
+        case SCC_HIR_BUILTIN_TAG_MEMSET:
             scc_tree_dump_append(ctx->dump_ctx, "memset");
             break;
-        case SCC_IR_BUILTIN_TAG_VA_ARG:
+        case SCC_HIR_BUILTIN_TAG_VA_ARG:
             scc_tree_dump_append(ctx->dump_ctx, "va_arg");
             break;
-        case SCC_IR_BUILTIN_TAG_VA_END:
+        case SCC_HIR_BUILTIN_TAG_VA_END:
             scc_tree_dump_append(ctx->dump_ctx, "va_end");
             break;
-        case SCC_IR_BUILTIN_TAG_VA_COPY:
+        case SCC_HIR_BUILTIN_TAG_VA_COPY:
             scc_tree_dump_append(ctx->dump_ctx, "va_copy");
             break;
-        case SCC_IR_BUILTIN_TAG_VA_START:
+        case SCC_HIR_BUILTIN_TAG_VA_START:
             scc_tree_dump_append(ctx->dump_ctx, "va_start");
             break;
         default:
@@ -513,60 +514,43 @@ void scc_ir_dump_value_linear(scc_ir_dump_ctx_t *ctx,
         }
         break;
     }
-    case SCC_IR_VALUE_TAG_CONST_INT:
+    case SCC_HIR_VALUE_TAG_INTEGER:
         // 值已经在 format 中输出，这里不需要再做
         break;
-    case SCC_IR_VALUE_TAG_CONST_UINT: {
-        scc_ir_type_t *type =
-            scc_ir_module_get_type(GET_MODULE(ctx), value->type);
-        Assert(type != nullptr);
-        if (type->tag == SCC_IR_TYPE_u8) {
-            scc_tree_dump_append_fmt(ctx->dump_ctx, "%c",
-                                     value->data.const_uint.uint8);
-        } else {
-            scc_tree_dump_append_fmt(ctx->dump_ctx, "%u",
-                                     value->data.const_uint.uint32);
-        }
-        break;
-    }
-    case SCC_IR_VALUE_TAG_CONST_FLOAT:
-        scc_tree_dump_append_fmt(ctx->dump_ctx, "%f",
-                                 value->data.const_float.float32);
-        break;
-    case SCC_IR_VALUE_TAG_AGGREGATE:
+    case SCC_HIR_VALUE_TAG_AGGREGATE:
         // 聚合类型：递归输出每个元素（每个占一行）
         scc_vec_foreach(value->data.aggregate.fields, i) {
-            scc_ir_dump_value_linear(
+            scc_hir_dump_value_linear(
                 ctx, scc_vec_at(value->data.aggregate.fields, i));
             scc_tree_dump_append(ctx->dump_ctx, "\n");
         }
         return;
-    case SCC_IR_VALUE_TAG_ALLOC:
+    case SCC_HIR_VALUE_TAG_ALLOC:
         scc_tree_dump_append(ctx->dump_ctx, "alloc");
         break;
-    case SCC_IR_VALUE_TAG_LOAD:
+    case SCC_HIR_VALUE_TAG_LOAD:
         scc_tree_dump_append(ctx->dump_ctx, "load ");
         format_ref_or_value(ctx, value->data.load.target);
         break;
-    case SCC_IR_VALUE_TAG_STORE:
+    case SCC_HIR_VALUE_TAG_STORE:
         scc_tree_dump_append(ctx->dump_ctx, "store ");
         format_ref_or_value(ctx, value->data.store.value);
         scc_tree_dump_append(ctx->dump_ctx, " -> ");
         format_ref_or_value(ctx, value->data.store.target);
         break;
-    case SCC_IR_VALUE_TAG_GET_ELEM_PTR:
+    case SCC_HIR_VALUE_TAG_GET_ELEM_PTR:
         scc_tree_dump_append(ctx->dump_ctx, "getelemptr ");
         format_ref_or_value(ctx, value->data.get_elem_ptr.src_addr);
         scc_tree_dump_append(ctx->dump_ctx, ", ");
         format_ref_or_value(ctx, value->data.get_elem_ptr.index);
         break;
-    case SCC_IR_VALUE_TAG_OP:
+    case SCC_HIR_VALUE_TAG_OP:
         format_ref_or_value(ctx, value->data.op.lhs);
         scc_tree_dump_append_fmt(ctx->dump_ctx, " %s ",
                                  get_op_str(value->data.op.op));
         format_ref_or_value(ctx, value->data.op.rhs);
         break;
-    case SCC_IR_VALUE_TAG_BRANCH:
+    case SCC_HIR_VALUE_TAG_BRANCH:
         if (value->data.branch.cond) {
             scc_tree_dump_append(ctx->dump_ctx, "br ");
             format_ref_or_value(ctx, value->data.branch.cond);
@@ -579,13 +563,13 @@ void scc_ir_dump_value_linear(scc_ir_dump_ctx_t *ctx,
                                      value->data.branch.true_bblock);
         }
         break;
-    case SCC_IR_VALUE_TAG_JUMP:
+    case SCC_HIR_VALUE_TAG_JUMP:
         scc_tree_dump_append_fmt(ctx->dump_ctx, "jmp label %%L%u",
                                  value->data.jump.target_bblock);
         break;
-    case SCC_IR_VALUE_TAG_CALL: {
-        scc_ir_func_t *func =
-            scc_ir_module_get_func(GET_MODULE(ctx), value->data.call.callee);
+    case SCC_HIR_VALUE_TAG_CALL: {
+        scc_hir_func_t *func =
+            scc_hir_module_get_func(GET_MODULE(ctx), value->data.call.callee);
         scc_tree_dump_append_fmt(ctx->dump_ctx, "call @%s(",
                                  func ? (func->name ? func->name : "<unnamed>")
                                       : "<invalid>");
@@ -597,7 +581,7 @@ void scc_ir_dump_value_linear(scc_ir_dump_ctx_t *ctx,
         scc_tree_dump_append(ctx->dump_ctx, ")");
         break;
     }
-    case SCC_IR_VALUE_TAG_RET:
+    case SCC_HIR_VALUE_TAG_RET:
         if (value->data.ret.ret_val != 0) {
             scc_tree_dump_append(ctx->dump_ctx, "ret ");
             format_ref_or_value(ctx, value->data.ret.ret_val);
@@ -605,18 +589,18 @@ void scc_ir_dump_value_linear(scc_ir_dump_ctx_t *ctx,
             scc_tree_dump_append(ctx->dump_ctx, "ret void");
         }
         break;
-    case SCC_IR_VALUE_TAG_FUNC_ARG_REF:
+    case SCC_HIR_VALUE_TAG_FUNC_ARG_REF:
         scc_tree_dump_append_fmt(ctx->dump_ctx, "arg[%zu]",
                                  value->data.arg_ref.idx);
         break;
-    case SCC_IR_VALUE_TAG_GLOBAL_ALLOC:
+    case SCC_HIR_VALUE_TAG_GLOBAL_ALLOC:
         scc_tree_dump_append_fmt(ctx->dump_ctx, "global %s", value->name);
         scc_tree_dump_begin_line(ctx->dump_ctx);
-        scc_ir_dump_value_linear(ctx, value->data.global_alloc.value);
+        scc_hir_dump_value_linear(ctx, value->data.global_alloc.value);
         return;
-    case SCC_IR_VALUE_TAG_CONST_ARRAY:
+    case SCC_HIR_VALUE_TAG_ARRAY:
         scc_tree_dump_append(ctx->dump_ctx, "const_array ");
-        scc_ir_dump_type_linear(ctx, value->data.const_array.base_type);
+        scc_hir_dump_type_linear(ctx, value->data.const_array.base_type);
         scc_tree_dump_append(ctx->dump_ctx, " [");
         scc_vec_foreach(value->data.const_array.fields, i) {
             u8 ch = scc_vec_at(value->data.const_array.fields, i);
@@ -631,31 +615,32 @@ void scc_ir_dump_value_linear(scc_ir_dump_ctx_t *ctx,
     }
 }
 
-void scc_ir_dump_bblock_linear(scc_ir_dump_ctx_t *ctx,
-                               scc_ir_bblock_ref_t bblock_ref) {
+void scc_hir_dump_bblock_linear(scc_hir_dump_t *ctx,
+                                scc_hir_bblock_ref_t bblock_ref) {
     scc_tree_dump_begin_line(ctx->dump_ctx);
-    scc_ir_bblock_t *bblock =
-        scc_ir_module_get_bblock(GET_MODULE(ctx), bblock_ref);
+    scc_hir_bblock_t *bblock =
+        scc_hir_module_get_bblock(GET_MODULE(ctx), bblock_ref);
     if (!bblock) {
         scc_tree_dump_append(ctx->dump_ctx, "<invalid block>");
         return;
     }
-    if (bblock->label && bblock->label[0] != '\0')
+    if (bblock->name && bblock->name[0] != '\0')
         scc_tree_dump_append_fmt(ctx->dump_ctx, "%%L%d %s:", bblock_ref,
-                                 bblock->label);
+                                 bblock->name);
     else
         scc_tree_dump_append_fmt(ctx->dump_ctx, "%%L%d <unnamed>:", bblock_ref);
 
-    for (usize i = 0; i < scc_vec_size(bblock->instrs); i++) {
+    for (usize i = 0; i < scc_vec_size(SCC_HIR_BBLOCK_VALUES(*bblock)); i++) {
         scc_tree_dump_begin_line(ctx->dump_ctx);
         scc_tree_dump_append(ctx->dump_ctx, "  ");
-        scc_ir_dump_value_linear(ctx, scc_vec_at(bblock->instrs, i));
+        scc_hir_dump_value_linear(
+            ctx, scc_vec_at(SCC_HIR_BBLOCK_VALUES(*bblock), i));
     }
 }
 
-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);
+void scc_hir_dump_func_linear(scc_hir_dump_t *ctx, scc_hir_func_ref_t func_ref,
+                              int is_decl) {
+    scc_hir_func_t *func = scc_hir_module_get_func(GET_MODULE(ctx), func_ref);
     scc_tree_dump_begin_line(ctx->dump_ctx);
     if (!func) {
         scc_tree_dump_append(ctx->dump_ctx, "<invalid function>");
@@ -665,14 +650,16 @@ void scc_ir_dump_func_linear(scc_ir_dump_ctx_t *ctx, scc_ir_func_ref_t func_ref,
                              (func->name && func->name[0]) ? func->name
                                                            : "<unnamed>");
 
-    if (scc_vec_size(func->params) > 0) {
+    if (scc_vec_size(SCC_HIR_FUNC_META(*func)->params) > 0) {
         scc_tree_dump_append(ctx->dump_ctx, "(");
-        for (usize i = 0; i < scc_vec_size(func->params); i++) {
+        for (usize i = 0; i < scc_vec_size(SCC_HIR_FUNC_META(*func)->params);
+             i++) {
             if (i > 0)
                 scc_tree_dump_append(ctx->dump_ctx, ", ");
-            scc_ir_value_ref_t param_ref = scc_vec_at(func->params, i);
-            scc_ir_value_t *param_node =
-                scc_ir_module_get_value(GET_MODULE(ctx), param_ref);
+            scc_hir_value_ref_t param_ref =
+                scc_vec_at(SCC_HIR_FUNC_META(*func)->params, i);
+            scc_hir_value_t *param_node =
+                scc_hir_module_get_value(GET_MODULE(ctx), param_ref);
             scc_tree_dump_append(ctx->dump_ctx, "%");
             if (param_node && param_node->name && param_node->name[0] != '\0')
                 scc_tree_dump_append_fmt(ctx->dump_ctx, "%u[%s]", param_ref,
@@ -686,7 +673,7 @@ void scc_ir_dump_func_linear(scc_ir_dump_ctx_t *ctx, scc_ir_func_ref_t func_ref,
     }
 
     scc_tree_dump_append(ctx->dump_ctx, ": ");
-    scc_ir_dump_type_linear(ctx, func->type);
+    scc_hir_dump_type_linear(ctx, SCC_HIR_FUNC_META(*func)->type);
 
     if (is_decl) {
         scc_tree_dump_append(ctx->dump_ctx, ";");
@@ -695,26 +682,26 @@ void scc_ir_dump_func_linear(scc_ir_dump_ctx_t *ctx, scc_ir_func_ref_t func_ref,
 
     scc_tree_dump_append(ctx->dump_ctx, " {");
     for (usize i = 0; i < scc_vec_size(func->bblocks); i++) {
-        scc_ir_dump_bblock_linear(ctx, scc_vec_at(func->bblocks, i));
+        scc_hir_dump_bblock_linear(ctx, scc_vec_at(func->bblocks, i));
         scc_tree_dump_append(ctx->dump_ctx, "");
     }
     scc_tree_dump_begin_line(ctx->dump_ctx);
     scc_tree_dump_append(ctx->dump_ctx, "}");
 }
 
-void scc_ir_dump_cprog_linear(scc_ir_dump_ctx_t *ctx) {
+void scc_hir_dump_cprog_linear(scc_hir_dump_t *ctx) {
     for (usize i = 0; i < scc_vec_size(ctx->cprog->global_vals); i++) {
         scc_tree_dump_begin_line(ctx->dump_ctx);
-        scc_ir_dump_value_linear(ctx, scc_vec_at(ctx->cprog->global_vals, i));
+        scc_hir_dump_value_linear(ctx, scc_vec_at(ctx->cprog->global_vals, i));
     }
     for (usize i = 0; i < scc_vec_size(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);
+        scc_hir_func_ref_t func_decl = scc_vec_at(ctx->cprog->func_decls, i);
+        scc_hir_func_t *func =
+            scc_hir_module_get_func(GET_MODULE(ctx), func_decl);
         if (func && scc_vec_size(func->bblocks) == 0)
-            scc_ir_dump_func_linear(ctx, func_decl, 1);
+            scc_hir_dump_func_linear(ctx, func_decl, 1);
     }
     for (usize i = 0; i < scc_vec_size(ctx->cprog->func_defs); i++) {
-        scc_ir_dump_func_linear(ctx, scc_vec_at(ctx->cprog->func_defs, i), 0);
+        scc_hir_dump_func_linear(ctx, scc_vec_at(ctx->cprog->func_defs, i), 0);
     }
 }

libs/ir/hir/src/hir_module.c

@@ -0,0 +1,128 @@
+#include <hir_module.h>
+
+void scc_hir_module_init(scc_hir_module_t *ctx) {
+    scc_cfg_module_init(&ctx->cfg_module);
+
+    scc_vec_init(ctx->values);
+    scc_vec_init(ctx->types);
+    scc_hashtable_usize_init(&ctx->uid2value);
+    scc_hashtable_usize_init(&ctx->uid2type);
+    // 预留UID 0 作为无效引用
+    scc_vec_push(ctx->values, (scc_hir_value_t){0});
+    scc_vec_push(ctx->types, (scc_hir_type_t){0});
+    ctx->value_uid = 1;
+    ctx->type_uid = 1;
+
+    scc_vec_init(ctx->funcs_meta);
+    scc_vec_init(ctx->bblock_meta);
+}
+
+void scc_hir_module_drop(scc_hir_module_t *ctx) {
+    scc_cfg_module_drop(&ctx->cfg_module);
+
+    // 释放所有实体的内部内存
+    for (usize i = 1; i < ctx->values.size; i++) {
+        scc_hir_value_t *node = &ctx->values.data[i];
+        scc_vec_free(node->used_by);
+        if (node->tag == SCC_HIR_VALUE_TAG_CALL) {
+            scc_vec_free(node->data.call.args);
+        }
+    }
+
+    for (usize i = 1; i < ctx->types.size; i++) {
+        scc_hir_type_t *type = &ctx->types.data[i];
+        if (type->tag == SCC_HIR_TYPE_FUNC) {
+            scc_vec_free(type->data.function.params);
+        }
+    }
+
+    // TODO free
+    // ctx->cfg_module.funcs;
+    // for (usize i = 1; i < ctx->bblocks.size; i++) {
+    //     scc_hir_bblock_t *bblock = &ctx->bblocks.data[i];
+    //     scc_vec_free(bblock->instrs);
+    // }
+
+    // for (usize i = 1; i < ctx->funcs.size; i++) {
+    //     scc_hir_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_hashtable_drop(&ctx->uid2value);
+    scc_hashtable_drop(&ctx->uid2type);
+}
+
+// 辅助宏：创建实体并添加到哈希表
+#define CREATE_ENTITY(ctx, vec, uid, data, hashtable)                          \
+    do {                                                                       \
+        /* 分配新UID */                                                        \
+        unsigned new_uid = (ctx)->uid++;                                       \
+        /* 添加到哈希表 */                                                     \
+        scc_hashtable_set(&(ctx)->hashtable, (const void *)(usize)new_uid,     \
+                          (void *)(usize)(scc_vec_size(vec)));                 \
+        /* 添加到向量 */                                                       \
+        scc_vec_push((vec), *(data));                                          \
+        return new_uid;                                                        \
+    } while (0)
+
+scc_hir_type_ref_t scc_hir_module_add_type(scc_hir_module_t *ctx,
+                                           const scc_hir_type_t *type) {
+    CREATE_ENTITY(ctx, ctx->types, type_uid, type, uid2type);
+}
+
+scc_hir_value_ref_t scc_hir_module_add_value(scc_hir_module_t *ctx,
+                                             const scc_hir_value_t *node) {
+    CREATE_ENTITY(ctx, ctx->values, value_uid, node, uid2value);
+}
+
+scc_hir_bblock_ref_t scc_hir_module_add_bblock(scc_hir_module_t *ctx,
+                                               const scc_hir_bblock_t *bblock) {
+    scc_hir_bblock_ref_t ref =
+        scc_cfg_module_add_bblock(&ctx->cfg_module, bblock);
+    // TODO
+    return ref;
+}
+
+scc_hir_func_ref_t scc_hir_module_add_func(scc_hir_module_t *ctx,
+                                           const scc_hir_func_t *func) {
+    scc_hir_func_ref_t ref = scc_cfg_module_add_func(&ctx->cfg_module, func);
+    scc_vec_push(ctx->funcs_meta, func->attribute);
+    return ref;
+}
+
+// 辅助宏：从哈希表获取索引
+#define GET_ENTITY_INDEX(ctx, ref, hashtable)                                  \
+    ((usize)scc_hashtable_get(&(ctx)->hashtable, (void *)(usize)ref))
+
+scc_hir_type_t *scc_hir_module_get_type(scc_hir_module_t *ctx,
+                                        scc_hir_type_ref_t ref) {
+    if (ref == 0)
+        return nullptr;
+    usize idx = GET_ENTITY_INDEX(ctx, ref, uid2type);
+    if (idx >= ctx->types.size)
+        return nullptr;
+    return &ctx->types.data[idx];
+}
+
+scc_hir_value_t *scc_hir_module_get_value(scc_hir_module_t *ctx,
+                                          scc_hir_value_ref_t ref) {
+    if (ref == 0)
+        return nullptr;
+    usize idx = GET_ENTITY_INDEX(ctx, ref, uid2value);
+    if (idx >= ctx->values.size)
+        return nullptr;
+    return &ctx->values.data[idx];
+}
+
+scc_hir_bblock_t *scc_hir_module_get_bblock(scc_hir_module_t *ctx,
+                                            scc_hir_bblock_ref_t ref) {
+    return scc_cfg_module_unsafe_get_bblock(&ctx->cfg_module, ref);
+}
+
+scc_hir_func_t *scc_hir_module_get_func(scc_hir_module_t *ctx,
+                                        scc_hir_func_ref_t ref) {
+    return scc_cfg_module_unsafe_get_func(&ctx->cfg_module, ref);
+}

libs/ir/hir/src/hir_prog.c

@@ -1,15 +1,15 @@
-#include <ir_prog.h>
+#include <hir_prog.h>
 
-void scc_ir_cprog_init(scc_ir_cprog_t *in) {
+void scc_hir_cprog_init(scc_hir_cprog_t *in) {
     scc_vec_init(in->func_decls);
     scc_vec_init(in->func_defs);
     scc_vec_init(in->global_vals);
-    scc_ir_module_init(&in->module);
+    scc_hir_module_init(&in->module);
 }
 
-void scc_ir_cprog_drop(scc_ir_cprog_t *in) {
+void scc_hir_cprog_drop(scc_hir_cprog_t *in) {
     scc_vec_free(in->func_decls);
     scc_vec_free(in->func_defs);
     scc_vec_free(in->global_vals);
-    scc_ir_module_drop(&in->module);
+    scc_hir_module_drop(&in->module);
 }

libs/ir/hir/src/scc_hir.c

@@ -0,0 +1,117 @@
+#include <scc_hir.h>
+
+void scc_hir_type_init(scc_hir_type_t *in, scc_hir_type_tag_t tag) {
+    Assert(in != nullptr);
+    in->tag = tag;
+    in->name = nullptr;
+    switch (tag) {
+    case SCC_HIR_TYPE_unknown:
+    case SCC_HIR_TYPE_void:
+    case SCC_HIR_TYPE_i8:
+    case SCC_HIR_TYPE_i16:
+    case SCC_HIR_TYPE_i32:
+    case SCC_HIR_TYPE_i64:
+    case SCC_HIR_TYPE_i128:
+    case SCC_HIR_TYPE_u8:
+    case SCC_HIR_TYPE_u16:
+    case SCC_HIR_TYPE_u32:
+    case SCC_HIR_TYPE_u64:
+    case SCC_HIR_TYPE_u128:
+    case SCC_HIR_TYPE_f16:
+    case SCC_HIR_TYPE_f32:
+    case SCC_HIR_TYPE_f64:
+    case SCC_HIR_TYPE_f128:
+        break;
+    case SCC_HIR_TYPE_ARRAY:
+        in->data.array.base = 0;
+        in->data.array.len = 0;
+        break;
+    case SCC_HIR_TYPE_PTR:
+        in->data.pointer.base = 0;
+        break;
+    case SCC_HIR_TYPE_FUNC:
+        scc_vec_init(in->data.function.params);
+        in->data.function.ret_type = 0;
+        break;
+    case SCC_HIR_TYPE_UNION:
+    case SCC_HIR_TYPE_STRUCT:
+        scc_vec_init(in->data.aggregate.fields);
+        break;
+    default:
+        UNREACHABLE();
+        break;
+    }
+}
+
+void scc_hir_bblock_init(scc_hir_bblock_t *in, const char *label) {
+    Assert(in != nullptr);
+    Assert(label != nullptr);
+    in->name = label;
+    scc_vec_init(in->values);
+}
+
+void scc_hir_func_init(scc_hir_func_t *in, const char *name) {
+    Assert(in != nullptr);
+    Assert(name != nullptr);
+    in->name = name;
+    scc_hir_func_meta_t *meta = SCC_HIR_FUNC_META(*in);
+    meta->type = SCC_HIR_REF_nullptr;
+    scc_vec_init(in->bblocks);
+    scc_vec_init(meta->params);
+}
+
+void scc_hir_value_init(scc_hir_value_t *in, const char *name,
+                        scc_hir_value_tag_t tag) {
+    Assert(in != nullptr);
+    in->name = name;
+    in->tag = tag;
+    scc_vec_init(in->used_by);
+    in->type = 0;
+
+    switch (tag) {
+    case SCC_HIR_VALUE_TAG_NULLPTR:
+        break;
+    case SCC_HIR_VALUE_TAG_BUILTIN:
+        break;
+    case SCC_HIR_VALUE_TAG_INTEGER:
+        scc_ap_init(&in->data.integer);
+        break;
+    case SCC_HIR_VALUE_TAG_ALLOC:
+        // TODO();
+        break;
+    case SCC_HIR_VALUE_TAG_LOAD:
+        in->data.load.target = 0;
+        break;
+    case SCC_HIR_VALUE_TAG_STORE:
+        in->data.store.target = 0;
+        in->data.store.value = 0;
+        break;
+    case SCC_HIR_VALUE_TAG_GET_ELEM_PTR:
+        in->data.get_elem_ptr.src_addr = 0;
+        in->data.get_elem_ptr.index = 0;
+        break;
+    case SCC_HIR_VALUE_TAG_OP:
+        in->data.op.op = SCC_HIR_OP_EMPTY;
+        in->data.op.lhs = 0;
+        in->data.op.rhs = 0;
+        break;
+    case SCC_HIR_VALUE_TAG_BRANCH:
+        in->data.branch.cond = 0;
+        in->data.branch.true_bblock = 0;
+        in->data.branch.false_bblock = 0;
+        break;
+    case SCC_HIR_VALUE_TAG_JUMP:
+        in->data.jump.target_bblock = 0;
+        break;
+    case SCC_HIR_VALUE_TAG_CALL:
+        scc_vec_init(in->data.call.args);
+        in->data.call.callee = 0;
+        break;
+    case SCC_HIR_VALUE_TAG_RET:
+        in->data.ret.ret_val = 0;
+        break;
+    default:
+        UNREACHABLE();
+        break;
+    }
+}

libs/ir/include/ir_builder.h

@@ -1,289 +0,0 @@
-#ifndef __SCC_IR_BUILDER_H__
-#define __SCC_IR_BUILDER_H__
-
-#include "ir_ctx.h"
-#include "scc_ir.h"
-
-typedef struct scc_ir_builder scc_ir_builder_t;
-
-/**
- * @brief IR 构建器上下文
- *
- * 负责管理 IR 构建过程中的所有状态：
- * - 类型统一化（type uniquing）
- * - 符号命名分配
- * - 内存管理
- * - 当前构建位置（函数、基本块）
- */
-struct scc_ir_builder {
-    scc_ir_cprog_t *cprog;
-    scc_ir_ctx_t ctx;                   ///< 核心上下文
-    scc_ir_func_ref_t current_func;     ///< 当前正在构建的函数
-    scc_ir_bblock_ref_t current_bblock; ///< 当前基本块
-#ifndef SCC_NO_DEBUG
-    int borrow_depth;
-    const char *dbg_file;
-    int dbg_line;
-#endif
-};
-
-#ifndef SCC_NO_DEBUG
-#define SCC_IR_BUILDER_BEGIN_BORROW(builder, ptr_var, ptr_expr)                \
-    do {                                                                       \
-        (builder)->borrow_depth++;                                             \
-        (builder)->dbg_file = __FILE__;                                        \
-        (builder)->dbg_line = __LINE__;                                        \
-        ptr_var = (ptr_expr);                                                  \
-    } while (0)
-
-#define SCC_IR_BUILDER_END_BORROW(builder)                                     \
-    do {                                                                       \
-        (builder)->borrow_depth--;                                             \
-    } while (0)
-
-#define SCC_IR_BUILDER_CHECK_NO_BORROW(builder)                                \
-    do {                                                                       \
-        if ((builder)->borrow_depth != 0) {                                    \
-            Panic("IR Builder: attempt to reallocate while borrowed at %s:%d", \
-                  (builder)->dbg_file, (builder)->dbg_line);                   \
-        }                                                                      \
-    } while (0)
-#else
-#define SCC_IR_BUILDER_BEGIN_BORROW(builder, ptr_var, ptr_expr)                \
-    ptr_var = (ptr_expr)
-#define SCC_IR_BUILDER_END_BORROW(builder) ((void)0)
-#define SCC_IR_BUILDER_CHECK_NO_BORROW(builder) ((void)0)
-#endif
-
-/**
- * @brief 初始化 IR 构建器
- */
-void scc_ir_builder_init(scc_ir_builder_t *builder, scc_ir_cprog_t *cprog);
-
-/**
- * @brief 销毁 IR 构建器及其所有资源
- */
-void scc_ir_builder_drop(scc_ir_builder_t *builder);
-
-scc_ir_func_ref_t scc_ir_builder_func(scc_ir_builder_t *builder,
-                                      scc_ir_type_ref_t type_ref,
-                                      const char *name);
-
-scc_ir_type_ref_t scc_ir_builder_type(scc_ir_builder_t *builder,
-                                      const scc_ir_type_t *type_desc);
-
-void scc_ir_builder_add_instr(scc_ir_builder_t *builder,
-                              scc_ir_value_ref_t instr);
-
-scc_ir_value_ref_t scc_ir_builder_global_alloca(scc_ir_builder_t *builder,
-                                                scc_ir_type_ref_t type,
-                                                scc_ir_value_ref_t value);
-
-/**
- * @brief 创建alloca指令（在当前基本块中）
- * @param type 分配的类型
- * @param name 变量名（可为nullptr）
- */
-scc_ir_value_ref_t scc_ir_builder_alloca(scc_ir_builder_t *builder,
-                                         scc_ir_type_ref_t type,
-                                         const char *name);
-
-#define SCC_IR_BUILDER_TYPE_FUNC(scc_type)                                     \
-    [[maybe_unused]] static inline scc_ir_type_ref_t                           \
-    scc_ir_builder_type_##scc_type(scc_ir_builder_t *builder) {                \
-        scc_ir_type_t type_desc;                                               \
-        scc_ir_type_init(&type_desc, SCC_IR_TYPE_##scc_type);                  \
-        return scc_ir_ctx_get_type(&builder->ctx, &type_desc);                 \
-    }
-
-SCC_IR_BUILDER_TYPE_FUNC(unknown)
-SCC_IR_BUILDER_TYPE_FUNC(void)
-SCC_IR_BUILDER_TYPE_FUNC(i8)
-SCC_IR_BUILDER_TYPE_FUNC(i16)
-SCC_IR_BUILDER_TYPE_FUNC(i32)
-SCC_IR_BUILDER_TYPE_FUNC(i64)
-SCC_IR_BUILDER_TYPE_FUNC(i128)
-SCC_IR_BUILDER_TYPE_FUNC(u8)
-SCC_IR_BUILDER_TYPE_FUNC(u16)
-SCC_IR_BUILDER_TYPE_FUNC(u32)
-SCC_IR_BUILDER_TYPE_FUNC(u64)
-SCC_IR_BUILDER_TYPE_FUNC(u128)
-// SCC_IR_BUILDER_TYPE_FUNC(f8)
-SCC_IR_BUILDER_TYPE_FUNC(f16)
-SCC_IR_BUILDER_TYPE_FUNC(f32)
-SCC_IR_BUILDER_TYPE_FUNC(f64)
-SCC_IR_BUILDER_TYPE_FUNC(f128)
-
-static inline scc_ir_value_ref_t
-scc_ir_builder_builtin_memcpy(scc_ir_builder_t *builder,
-                              scc_ir_value_ref_t dest, scc_ir_value_ref_t src,
-                              scc_ir_value_ref_t len) {
-    Assert(builder && src && dest && len);
-    scc_ir_value_t value;
-    scc_ir_value_init(&value, nullptr, SCC_IR_VALUE_TAG_BUILTIN);
-    value.type = scc_ir_builder_type_void(builder); // memcpy 返回 void*
-    value.data.builtin.tag = SCC_IR_BUILTIN_TAG_MEMCPY;
-    value.data.builtin.func.memcpy.dest = dest;
-    value.data.builtin.func.memcpy.src = src;
-    value.data.builtin.func.memcpy.size = len;
-    scc_ir_value_ref_t ref =
-        scc_ir_module_add_value(builder->ctx.module, &value);
-    scc_ir_builder_add_instr(builder, ref);
-    return ref;
-}
-
-// TODO
-static inline scc_ir_value_ref_t
-scc_ir_builder_const_int(scc_ir_builder_t *builder, scc_ir_type_ref_t type,
-                         scc_ir_const_int_t val) {
-    scc_ir_value_t value;
-    scc_ir_value_init(&value, nullptr, SCC_IR_VALUE_TAG_CONST_INT);
-    value.data.const_int = val;
-    value.type = type;
-    return scc_ir_module_add_value(&builder->cprog->module, &value);
-}
-
-scc_ir_value_ref_t scc_ir_builder_const_string(scc_ir_builder_t *builder,
-                                               const char *str, usize len);
-
-/**
- * @brief 开始构建函数
- * @param func_ref 函数引用
- * @param param_names 参数名列表（可为nullptr）
- * @return void
- */
-void scc_ir_builder_begin_func(scc_ir_builder_t *builder,
-                               scc_ir_func_ref_t func_ref);
-
-/**
- * @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 builder IR构建器
- * @param label   基本块标签（可为 nullptr，自动生成）
- * @return 新基本块的引用
- */
-scc_ir_bblock_ref_t scc_ir_builder_bblock(scc_ir_builder_t *builder,
-                                          const char *label);
-
-/**
- * @brief 开始构建新的基本块
- * @param label 基本块标签（可为nullptr，自动生成）
- * @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);
-
-scc_ir_func_ref_t scc_ir_builder_current_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);
-
-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);
-
-/**
- * @brief 创建load指令
- * @param ptr 指针操作数
- */
-scc_ir_value_ref_t scc_ir_builder_load(scc_ir_builder_t *builder,
-                                       scc_ir_value_ref_t ptr);
-
-/**
- * @brief 创建store指令
- * @param ptr 目标指针
- * @param value 要存储的值
- */
-scc_ir_value_ref_t scc_ir_builder_store(scc_ir_builder_t *builder,
-                                        scc_ir_value_ref_t ptr,
-                                        scc_ir_value_ref_t value);
-
-/**
- * @brief 创建getptr指令（指针运算）
- * @param ptr 基础指针
- * @param index 索引值
- */
-scc_ir_value_ref_t scc_ir_builder_get_elem_ptr(scc_ir_builder_t *builder,
-                                               scc_ir_value_ref_t ptr,
-                                               scc_ir_value_ref_t index);
-
-/**
- * @brief 创建二元运算指令
- * @param op 操作符
- * @param lhs 左操作数
- * @param rhs 右操作数
- */
-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);
-
-/**
- * @brief 创建比较指令
- * @param op 比较操作符
- * @param lhs 左操作数
- * @param rhs 右操作数
- */
-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);
-
-/**
- * @brief 创建跳转指令（无条件）
- * @param target 目标基本块
- */
-scc_ir_value_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_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);
-
-/**
- * @brief 创建函数调用指令
- * @param callee 被调用函数
- * @param args 参数列表
- * @param arg_count 参数数量
- */
-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);
-
-/**
- * @brief 创建返回指令（带返回值）
- * @param value 返回值
- */
-scc_ir_value_ref_t scc_ir_builder_ret(scc_ir_builder_t *builder,
-                                      scc_ir_value_ref_t value);
-
-/**
- * @brief 创建返回指令（void返回）
- */
-scc_ir_value_ref_t scc_ir_builder_ret_void(scc_ir_builder_t *builder);
-
-#endif /* __SCC_IR_BUILDER_H__ */

libs/ir/include/ir_ctx.h

@@ -1,27 +0,0 @@
-#ifndef __SCC_IR_CTX_H__
-#define __SCC_IR_CTX_H__
-
-#include "ir_def.h"
-#include "ir_prog.h"
-#include <scc_hashtable.h>
-
-typedef struct {
-    scc_ir_module_t *module;       // 关联的模块（用于实际存储）
-    scc_hashtable_t type_uniquing; // 类型哈希表：hash -> type_ref
-    scc_hashtable_t const_pool;    // 常量哈希表：hash -> node_ref
-    scc_hashtable_t func_decl_set; // 函数声明集合：name -> func_ref
-} scc_ir_ctx_t;
-
-void scc_ir_ctx_init(scc_ir_ctx_t *ctx, scc_ir_module_t *module);
-void scc_ir_ctx_drop(scc_ir_ctx_t *ctx);
-
-// 获取唯一类型，若不存在则创建并返回新引用
-scc_ir_type_ref_t scc_ir_ctx_get_type(scc_ir_ctx_t *ctx,
-                                      const scc_ir_type_t *type_desc);
-
-// 注册函数声明，若已存在则返回已有引用
-scc_ir_func_ref_t scc_ir_ctx_declare_func(scc_ir_ctx_t *ctx,
-                                          scc_ir_type_ref_t type,
-                                          const char *name);
-
-#endif /* __SCC_IR_CTX_H__ */

libs/ir/include/ir_def.h

@@ -1,287 +0,0 @@
-#ifndef __SCC_IR_DEF_H__
-#define __SCC_IR_DEF_H__
-
-#include <scc_core.h>
-
-#define SCC_IR_REF_nullptr 0
-
-typedef unsigned int ir_handle_t;
-typedef const char *scc_ir_label_t;
-
-typedef SCC_VEC(u8) scc_ir_buffer_t;
-
-typedef struct scc_ir_value scc_ir_value_t;
-typedef ir_handle_t scc_ir_value_ref_t;
-typedef SCC_VEC(scc_ir_value_ref_t) scc_ir_value_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_unknown,
-    SCC_IR_TYPE_void,
-    SCC_IR_TYPE_i8,
-    SCC_IR_TYPE_i16,
-    SCC_IR_TYPE_i32,
-    SCC_IR_TYPE_i64,
-    SCC_IR_TYPE_i128,
-    SCC_IR_TYPE_u8,
-    SCC_IR_TYPE_u16,
-    SCC_IR_TYPE_u32,
-    SCC_IR_TYPE_u64,
-    SCC_IR_TYPE_u128,
-    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_UNION,
-    SCC_IR_TYPE_VECTOR, // TODO SIMD
-} scc_ir_type_tag_t;
-
-struct scc_ir_type {
-    scc_ir_type_tag_t tag;
-    const char *name; // For Debug
-    union {
-        struct {
-            scc_ir_type_ref_t base;
-            usize len; // TODO usize is target dependent
-        } array;
-        struct {
-            scc_ir_type_ref_t base;
-        } pointer;
-        struct {
-            scc_ir_type_ref_vec_t fields;
-        } aggregate;
-        struct {
-            scc_ir_type_ref_vec_t params;
-            scc_ir_type_ref_t ret_type;
-        } function;
-    } data;
-};
-
-struct scc_ir_bblock {
-    scc_ir_label_t label;
-    scc_ir_value_ref_vec_t instrs;
-    // ir_arr_t used_by;
-}; // basic block
-
-struct scc_ir_func {
-    scc_ir_label_t name;
-    scc_ir_type_ref_t type;
-    scc_ir_value_ref_vec_t params;
-    scc_ir_bblock_ref_vec_t bblocks;
-};
-
-typedef enum scc_ir_value_tag {
-    SCC_IR_VALUE_TAG_NULLPTR,
-    SCC_IR_VALUE_TAG_BUILTIN,
-    SCC_IR_VALUE_TAG_CONST_INT,
-    SCC_IR_VALUE_TAG_CONST_UINT,
-    SCC_IR_VALUE_TAG_CONST_FLOAT,
-    SCC_IR_VALUE_TAG_CONST_ARRAY,
-    SCC_IR_VALUE_TAG_AGGREGATE,     ///< 聚合值
-    SCC_IR_VALUE_TAG_CONV,          ///< 类型转换
-    SCC_IR_VALUE_TAG_FUNC_ARG_REF,  ///< 函数参数引用
-    SCC_IR_VALUE_TAG_BLOCK_ARG_REF, ///< 基本块参数引用
-    SCC_IR_VALUE_TAG_ALLOC,         ///< 分配内存
-    SCC_IR_VALUE_TAG_GLOBAL_ALLOC,  ///< 全局分配
-    SCC_IR_VALUE_TAG_LOAD,          ///< 加载数据
-    SCC_IR_VALUE_TAG_STORE,         ///< 存储数据
-    SCC_IR_VALUE_TAG_GET_ELEM_PTR,  ///< 获取元素指针
-    SCC_IR_VALUE_TAG_OP,            ///< 二元运算
-    SCC_IR_VALUE_TAG_BRANCH,        ///< 有条件分支
-    SCC_IR_VALUE_TAG_JUMP,          ///< 无条件跳转
-    SCC_IR_VALUE_TAG_CALL,          ///< 调用函数
-    SCC_IR_VALUE_TAG_RET,           ///< 函数返回
-} scc_ir_value_tag_t;
-
-typedef enum {
-    /// Empty op for init or nop
-    SCC_IR_OP_EMPTY,
-    /// Not equal to.
-    SCC_IR_OP_NEQ,
-    /// Equal to.
-    SCC_IR_OP_EQ,
-    /// Greater than.
-    SCC_IR_OP_GT,
-    /// Less than.
-    SCC_IR_OP_LT,
-    /// Greater than or equal to.
-    SCC_IR_OP_GE,
-    /// Less than or equal to.
-    SCC_IR_OP_LE,
-    /// Addition.
-    SCC_IR_OP_ADD,
-    /// Subtraction.
-    SCC_IR_OP_SUB,
-    /// Multiplication.
-    SCC_IR_OP_MUL,
-    /// Division.
-    SCC_IR_OP_DIV,
-    /// Modulo.
-    SCC_IR_OP_MOD,
-    /// Bitwise AND.
-    SCC_IR_OP_AND,
-    /// Bitwise OR.
-    SCC_IR_OP_OR,
-    /// Bitwise XOR.
-    SCC_IR_OP_XOR,
-    /// Bitwise NOT.
-    SCC_IR_OP_NOT,
-    /// Shift left logical.
-    SCC_IR_OP_SHL,
-    /// Shift right logical.
-    SCC_IR_OP_SHR,
-    /// Shift right arithmetic.
-    SCC_IR_OP_SAR,
-} scc_ir_op_type_t;
-
-typedef union {
-    i8 int8;
-    i16 int16;
-    i32 int32;
-    i64 int64;
-    // TODO int128
-    i8 int_any[16];
-} scc_ir_const_int_t;
-
-typedef union {
-    u8 uint8;
-    u16 uint16;
-    u32 uint32;
-    u64 uint64;
-    // TODO uint128;
-    u8 uint_any[16];
-} scc_ir_const_uint_t;
-
-typedef union {
-    // f16 float16;
-    f32 float32;
-    f64 float64;
-    // TODO float128;
-    u8 float_any[16];
-} scc_ir_const_float_t;
-
-typedef enum {
-    SCC_IR_BUILTIN_TAG_MEMCPY,
-    SCC_IR_BUILTIN_TAG_MEMSET,
-    SCC_IR_BUILTIN_TAG_VA_START,
-    SCC_IR_BUILTIN_TAG_VA_ARG,
-    SCC_IR_BUILTIN_TAG_VA_END,
-    SCC_IR_BUILTIN_TAG_VA_COPY,
-} scc_ir_builtin_tag_t;
-
-typedef struct {
-    scc_ir_builtin_tag_t tag;
-    union {
-        struct {
-            scc_ir_value_ref_t dest;
-            scc_ir_value_ref_t src;
-            scc_ir_value_ref_t size;
-        } memcpy;
-        struct {
-            scc_ir_value_ref_t dest;
-            scc_ir_value_ref_t value;
-            scc_ir_value_ref_t size;
-        } memset;
-        struct {
-            scc_ir_value_ref_t ap;   // va_list 的地址（i8* 或 struct*）
-            scc_ir_value_ref_t last; // 最后一个固定参数的引用（用于 va_start）
-        } va_start;
-        struct {
-            scc_ir_value_ref_t ap;  // va_list 的地址
-            scc_ir_type_ref_t type; // 要提取的参数的类型
-        } va_arg;
-        struct {
-            scc_ir_value_ref_t ap; // va_list 的地址
-        } va_end;
-        struct {
-            scc_ir_value_ref_t dest; // 目标 va_list 地址
-            scc_ir_value_ref_t src;  // 源 va_list 地址
-        } va_copy;
-    } func;
-} scc_ir_builtin_t;
-
-typedef enum {
-    SCC_IR_LINKAGE_EXTERNAL,
-    SCC_IR_LINKAGE_INTERNAL,
-    SCC_IR_LINKAGE_PRIVATE,
-    SCC_IR_LINKAGE_WEAK,
-} scc_ir_linkage_t;
-
-struct scc_ir_value {
-    scc_ir_type_ref_t type;
-    scc_ir_label_t name;
-    scc_ir_value_ref_vec_t used_by;
-    scc_ir_value_tag_t tag;
-    union {
-        scc_ir_builtin_t builtin;
-        scc_ir_const_int_t const_int;
-        scc_ir_const_uint_t const_uint;
-        scc_ir_const_float_t const_float;
-        struct {
-            scc_ir_value_ref_t base_type;
-            scc_ir_buffer_t fields;
-        } const_array;
-        struct {
-            scc_ir_value_ref_vec_t fields;
-        } aggregate;
-        struct {
-            usize idx;
-        } arg_ref;
-        struct {
-            scc_ir_value_ref_t value;
-        } global_alloc;
-        struct {
-            scc_ir_value_ref_t operand;
-            scc_ir_type_ref_t target_type; // 目标类型
-            enum { CONV_SEXT, CONV_ZEXT, CONV_TRUNC } conv_type;
-        } conv;
-        struct {
-            scc_ir_value_ref_t target;
-        } load;
-        struct {
-            scc_ir_value_ref_t target;
-            scc_ir_value_ref_t value;
-        } store;
-        struct {
-            scc_ir_value_ref_t src_addr;
-            scc_ir_value_ref_t index;
-        } get_elem_ptr;
-        struct {
-            scc_ir_op_type_t op;
-            scc_ir_value_ref_t lhs;
-            scc_ir_value_ref_t rhs;
-        } op;
-        struct {
-            scc_ir_value_ref_t cond;
-            scc_ir_bblock_ref_t true_bblock;
-            scc_ir_bblock_ref_t false_bblock;
-        } branch;
-        struct {
-            scc_ir_bblock_ref_t target_bblock;
-        } jump;
-        struct {
-            scc_ir_func_ref_t callee; // TODO function pointer call
-            scc_ir_value_ref_vec_t args;
-        } call;
-        struct {
-            scc_ir_value_ref_t ret_val;
-        } ret;
-    } data;
-};
-
-#endif /* __SCC_IR_DEF_H__ */

libs/ir/include/ir_dump.h

@@ -1,22 +0,0 @@
-#ifndef __SCC_IR_DUMP_H__
-#define __SCC_IR_DUMP_H__
-
-#include "ir_prog.h"
-#include <scc_tree_dump.h>
-
-typedef struct {
-    scc_ir_cprog_t *cprog;
-    scc_tree_dump_t *dump_ctx;
-} scc_ir_dump_ctx_t;
-
-void scc_ir_dump_ctx_init(scc_ir_dump_ctx_t *ctx, scc_tree_dump_t *tree_dump,
-                          scc_ir_cprog_t *cprog);
-void scc_ir_dump_value(scc_ir_dump_ctx_t *ctx, scc_ir_value_ref_t node_ref);
-void scc_ir_dump_type(scc_ir_dump_ctx_t *ctx, scc_ir_type_ref_t type_ref);
-void scc_ir_dump_bblock(scc_ir_dump_ctx_t *ctx, scc_ir_bblock_ref_t bblock_ref);
-void scc_ir_dump_func(scc_ir_dump_ctx_t *ctx, scc_ir_func_ref_t func_ref);
-void scc_ir_dump_cprog(scc_ir_dump_ctx_t *ctx);
-
-void scc_ir_dump_cprog_linear(scc_ir_dump_ctx_t *ctx);
-
-#endif /* __SCC_IR_DUMP_H__ */

libs/ir/include/ir_module.h

@@ -1,49 +0,0 @@
-#ifndef __SCC_IR_MODULE_H__
-#define __SCC_IR_MODULE_H__
-
-#include "ir_def.h"
-#include <scc_hashtable.h>
-
-typedef struct {
-    unsigned int value_uid;
-    unsigned int type_uid;
-    unsigned int bblock_uid;
-    unsigned int func_uid;
-    SCC_VEC(scc_ir_value_t) values;
-    SCC_VEC(scc_ir_type_t) types;
-    SCC_VEC(scc_ir_bblock_t) bblocks;
-    SCC_VEC(scc_ir_func_t) funcs;
-    // UID -> ref index
-    scc_hashtable_t uid2value;
-    scc_hashtable_t uid2type;
-    scc_hashtable_t uid2bblock;
-    scc_hashtable_t uid2func;
-} scc_ir_module_t;
-
-void scc_ir_module_init(scc_ir_module_t *ctx);
-void scc_ir_module_drop(scc_ir_module_t *ctx);
-scc_ir_type_ref_t scc_ir_module_add_type(scc_ir_module_t *ctx,
-                                         const scc_ir_type_t *type);
-scc_ir_value_ref_t scc_ir_module_add_value(scc_ir_module_t *ctx,
-                                           const scc_ir_value_t *node);
-scc_ir_bblock_ref_t scc_ir_module_add_bblock(scc_ir_module_t *ctx,
-                                             const scc_ir_bblock_t *bblock);
-scc_ir_func_ref_t scc_ir_module_add_func(scc_ir_module_t *ctx,
-                                         const scc_ir_func_t *func);
-scc_ir_type_t *scc_ir_module_get_type(scc_ir_module_t *ctx,
-                                      scc_ir_type_ref_t ref);
-scc_ir_value_t *scc_ir_module_get_value(scc_ir_module_t *ctx,
-                                        scc_ir_value_ref_t ref);
-scc_ir_bblock_t *scc_ir_module_get_bblock(scc_ir_module_t *ctx,
-                                          scc_ir_bblock_ref_t ref);
-scc_ir_func_t *scc_ir_module_get_func(scc_ir_module_t *ctx,
-                                      scc_ir_func_ref_t ref);
-
-static inline scc_ir_type_t *
-scc_ir_module_get_type_by_value(scc_ir_module_t *ctx, scc_ir_value_ref_t ref) {
-    scc_ir_value_t *value = scc_ir_module_get_value(ctx, ref);
-    Assert(value != nullptr);
-    return scc_ir_module_get_type(ctx, value->type);
-}
-
-#endif /* __SCC_IR_MODULE_H__ */

libs/ir/include/ir_prog.h

@@ -1,17 +0,0 @@
-#ifndef __SCC_IR_PROG_H__
-#define __SCC_IR_PROG_H__
-
-#include "ir_def.h"
-#include "ir_module.h"
-
-typedef struct scc_ir_cprog {
-    scc_ir_module_t module;
-    scc_ir_value_ref_vec_t global_vals; /* 全局变量 */
-    scc_ir_func_ref_vec_t func_defs;    /* 所有函数定义 */
-    scc_ir_func_ref_vec_t func_decls;   /* 所有函数包括定义的声明 */
-} scc_ir_cprog_t;
-
-void scc_ir_cprog_init(scc_ir_cprog_t *in);
-void scc_ir_cprog_drop(scc_ir_cprog_t *in);
-
-#endif /* __SCC_IR_PROG_H__ */

libs/ir/include/scc_ir.h

@@ -1,15 +0,0 @@
-#ifndef __SCC_IR_H__
-#define __SCC_IR_H__
-
-#include "ir_def.h"
-#include "ir_prog.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 nullptr ptr
-void scc_ir_value_init(scc_ir_value_t *in, const char *name,
-                       scc_ir_value_tag_t tag);
-
-#endif /* __SCC_IR_H__ */

libs/ir/src/ir_builder.c

@@ -1,493 +0,0 @@
-#include "ir_def.h"
-#include <ir_builder.h>
-#include <ir_prog.h>
-
-#define GET_MODULE(builder) (&(builder->cprog->module))
-
-void scc_ir_builder_init(scc_ir_builder_t *builder, scc_ir_cprog_t *cprog) {
-    builder->current_bblock = SCC_IR_REF_nullptr;
-    builder->current_func = SCC_IR_REF_nullptr;
-    builder->cprog = cprog;
-
-    scc_ir_ctx_init(&builder->ctx, GET_MODULE(builder));
-#ifndef SCC_NO_DEBUG
-    builder->borrow_depth = 0;
-    builder->dbg_file = nullptr;
-    builder->dbg_line = 0;
-#endif
-}
-
-void scc_ir_builder_drop(scc_ir_builder_t *builder) {
-    scc_ir_ctx_drop(&builder->ctx);
-}
-
-scc_ir_func_ref_t scc_ir_builder_func(scc_ir_builder_t *builder,
-                                      scc_ir_type_ref_t type_ref,
-                                      const char *name) {
-    SCC_IR_BUILDER_CHECK_NO_BORROW(builder);
-    scc_ir_func_ref_t func_ref =
-        scc_ir_ctx_declare_func(&builder->ctx, type_ref, name);
-    scc_vec_push(builder->cprog->func_decls, func_ref);
-    return func_ref;
-}
-
-scc_ir_type_ref_t scc_ir_builder_type(scc_ir_builder_t *builder,
-                                      const scc_ir_type_t *type_desc) {
-    SCC_IR_BUILDER_CHECK_NO_BORROW(builder);
-    return scc_ir_ctx_get_type(&builder->ctx, type_desc);
-}
-
-scc_ir_value_ref_t scc_ir_builder_const_string(scc_ir_builder_t *builder,
-                                               const char *str, usize len) {
-    SCC_IR_BUILDER_CHECK_NO_BORROW(builder);
-    scc_ir_type_ref_t u8_type = scc_ir_builder_type_u8(builder);
-    scc_ir_type_t array_type = {
-        .tag = SCC_IR_TYPE_ARRAY,
-        .data.array.base = u8_type,
-        .data.array.len = len - 1, // 包含 nullptr 结尾
-    };
-    scc_ir_type_ref_t array_type_ref =
-        scc_ir_ctx_get_type(&builder->ctx, &array_type);
-
-    // 5. 创建聚合节点
-    scc_ir_value_t const_array_value = {
-        .tag = SCC_IR_VALUE_TAG_CONST_ARRAY,
-        .type = array_type_ref,
-        .data.const_array.base_type = u8_type,
-    };
-    char *buff = scc_malloc(len - 1);
-    Assert(buff);
-    // FIXME content to real string
-    for (usize i = 1; i < len - 1; i++) {
-        buff[i - 1] = str[i];
-    }
-    buff[len - 2] = '\0';
-    scc_vec_unsafe_from_buffer(const_array_value.data.const_array.fields,
-                               (u8 *)buff, len - 1);
-    scc_ir_value_ref_t const_array_ref =
-        scc_ir_module_add_value(builder->ctx.module, &const_array_value);
-    Assert(const_array_ref != SCC_IR_REF_nullptr);
-
-    // 3. 创建全局变量节点，类型为指针，初始值指向常量数组
-    scc_ir_value_ref_t global_value_ref =
-        scc_ir_builder_global_alloca(builder, array_type_ref, const_array_ref);
-    // scc_hashtable_insert(builder);
-
-    scc_ir_value_ref_t pointer_to_global_value = scc_ir_module_add_value(
-        builder->ctx.module,
-        &(scc_ir_value_t){
-            .tag = SCC_IR_VALUE_TAG_GET_ELEM_PTR,
-            .data.get_elem_ptr.src_addr = global_value_ref,
-            .data.get_elem_ptr.index = SCC_IR_VALUE_TAG_NULLPTR,
-        });
-    scc_ir_builder_add_instr(builder, pointer_to_global_value);
-    return pointer_to_global_value;
-}
-
-void scc_ir_builder_begin_func(scc_ir_builder_t *builder,
-                               scc_ir_func_ref_t func_ref) {
-    SCC_IR_BUILDER_CHECK_NO_BORROW(builder);
-    builder->current_func = func_ref;
-
-    // 借用 func_ptr 和 func_type 以获取参数类型列表
-    scc_ir_func_t *func_ptr = nullptr;
-    scc_ir_type_t *func_type = nullptr;
-    SCC_IR_BUILDER_BEGIN_BORROW(
-        builder, func_ptr,
-        scc_ir_module_get_func(GET_MODULE(builder), func_ref));
-    SCC_IR_BUILDER_BEGIN_BORROW(
-        builder, func_type,
-        scc_ir_module_get_type(GET_MODULE(builder), func_ptr->type));
-
-    if (func_type == nullptr || func_type->tag != SCC_IR_TYPE_FUNC) {
-        LOG_ERROR("Invalid function type");
-        SCC_IR_BUILDER_END_BORROW(builder); // func_type
-        SCC_IR_BUILDER_END_BORROW(builder); // func_ptr
-        return;
-    }
-    if (func_ptr == nullptr) {
-        LOG_ERROR("Invalid function reference");
-        SCC_IR_BUILDER_END_BORROW(builder); // func_type
-        SCC_IR_BUILDER_END_BORROW(builder); // func_ptr
-        return;
-    }
-    if (scc_vec_size(func_ptr->bblocks) != 0 ||
-        scc_vec_size(func_ptr->params) != 0) {
-        LOG_FATAL("Multiple function definitions");
-        SCC_IR_BUILDER_END_BORROW(builder); // func_type
-        SCC_IR_BUILDER_END_BORROW(builder); // func_ptr
-        return;
-    }
-
-    // 释放借用，因为下面要调用 add_value（可能 realloc）
-    SCC_IR_BUILDER_END_BORROW(builder); // func_type
-    SCC_IR_BUILDER_END_BORROW(builder); // func_ptr
-}
-
-void scc_ir_builder_end_func(scc_ir_builder_t *builder) {
-    SCC_IR_BUILDER_CHECK_NO_BORROW(builder);
-    scc_ir_func_t *func_ptr = nullptr;
-    SCC_IR_BUILDER_BEGIN_BORROW(
-        builder, func_ptr,
-        scc_ir_module_get_func(GET_MODULE(builder), builder->current_func));
-    if (func_ptr == nullptr) {
-        LOG_FATAL("Invalid function reference");
-        SCC_IR_BUILDER_END_BORROW(builder);
-        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);
-    }
-    SCC_IR_BUILDER_END_BORROW(builder);
-    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_bblock(scc_ir_builder_t *builder,
-                                          const char *label) {
-    SCC_IR_BUILDER_CHECK_NO_BORROW(builder);
-    scc_ir_bblock_t bblock = {0};
-    if (label) {
-        bblock.label = label;
-    }
-    scc_vec_init(bblock.instrs);
-    scc_ir_bblock_ref_t bblock_ref =
-        scc_ir_module_add_bblock(GET_MODULE(builder), &bblock);
-
-    // 将基本块添加到当前函数
-    scc_ir_func_t *current_func = nullptr;
-    SCC_IR_BUILDER_BEGIN_BORROW(
-        builder, current_func,
-        scc_ir_module_get_func(GET_MODULE(builder), builder->current_func));
-    if (current_func) {
-        scc_vec_push(current_func->bblocks, bblock_ref);
-    }
-    SCC_IR_BUILDER_END_BORROW(builder);
-    return bblock_ref;
-}
-
-scc_ir_bblock_ref_t scc_ir_builder_begin_bblock(scc_ir_builder_t *builder,
-                                                const char *label) {
-    SCC_IR_BUILDER_CHECK_NO_BORROW(builder);
-    builder->current_bblock = scc_ir_builder_bblock(builder, label);
-    return builder->current_bblock;
-}
-
-void scc_ir_builder_end_bblock(scc_ir_builder_t *builder) {
-    SCC_IR_BUILDER_CHECK_NO_BORROW(builder);
-    builder->current_bblock = 0;
-}
-
-void scc_ir_builder_set_current_bblock(scc_ir_builder_t *builder,
-                                       scc_ir_bblock_ref_t bblock) {
-    SCC_IR_BUILDER_CHECK_NO_BORROW(builder);
-    builder->current_bblock = bblock;
-}
-
-scc_ir_func_ref_t scc_ir_builder_current_bblock(scc_ir_builder_t *builder) {
-    return builder->current_bblock;
-}
-
-void scc_ir_builder_add_instr(scc_ir_builder_t *builder,
-                              scc_ir_value_ref_t instr) {
-    SCC_IR_BUILDER_CHECK_NO_BORROW(builder);
-    scc_ir_bblock_t *current_bblock = nullptr;
-    SCC_IR_BUILDER_BEGIN_BORROW(
-        builder, current_bblock,
-        scc_ir_module_get_bblock(GET_MODULE(builder), builder->current_bblock));
-    if (current_bblock) {
-        scc_vec_push(current_bblock->instrs, instr);
-    } else {
-        LOG_ERROR("Current basic block is not set");
-    }
-    SCC_IR_BUILDER_END_BORROW(builder);
-}
-
-scc_ir_value_ref_t scc_ir_builder_global_alloca(scc_ir_builder_t *builder,
-                                                scc_ir_type_ref_t type,
-                                                scc_ir_value_ref_t value) {
-    SCC_IR_BUILDER_CHECK_NO_BORROW(builder);
-    char *name = scc_malloc(32);
-    scc_ir_value_ref_t global_value_ref = scc_ir_module_add_value(
-        builder->ctx.module, &(scc_ir_value_t){
-                                 .name = name,
-                                 .tag = SCC_IR_VALUE_TAG_GLOBAL_ALLOC,
-                                 .type = type,
-                                 .data.global_alloc.value = value,
-                             });
-    scc_snprintf(name, 32, "$G%u", global_value_ref);
-    scc_vec_push(builder->cprog->global_vals, global_value_ref);
-    return global_value_ref;
-}
-
-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_BUILDER_CHECK_NO_BORROW(builder);
-    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_value_ref_t value_ref =
-        scc_ir_module_add_value(GET_MODULE(builder), &alloc_node);
-    scc_ir_builder_add_instr(builder, value_ref);
-    return value_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_BUILDER_CHECK_NO_BORROW(builder);
-    scc_ir_value_t value = {0};
-    value.tag = SCC_IR_VALUE_TAG_FUNC_ARG_REF;
-    value.type = type;
-    value.name = name;
-    value.data.arg_ref.idx = arg_idx;
-
-    scc_ir_value_ref_t value_ref =
-        scc_ir_module_add_value(GET_MODULE(builder), &value);
-    scc_ir_builder_add_instr(builder, value_ref);
-    return value_ref;
-}
-
-scc_ir_value_ref_t scc_ir_builder_load(scc_ir_builder_t *builder,
-                                       scc_ir_value_ref_t target) {
-    SCC_IR_BUILDER_CHECK_NO_BORROW(builder);
-    scc_ir_value_t load_node = {0};
-    load_node.tag = SCC_IR_VALUE_TAG_LOAD;
-    load_node.data.load.target = target;
-
-    // 借用 ptr_node 和 ptr_type 获取类型信息
-    scc_ir_value_t *ptr_node = nullptr;
-    SCC_IR_BUILDER_BEGIN_BORROW(
-        builder, ptr_node,
-        scc_ir_module_get_value(GET_MODULE(builder), target));
-    if (ptr_node) {
-        scc_ir_type_t *ptr_type = nullptr;
-        SCC_IR_BUILDER_BEGIN_BORROW(
-            builder, ptr_type,
-            scc_ir_module_get_type(GET_MODULE(builder), ptr_node->type));
-        if (ptr_type && ptr_type->tag == SCC_IR_TYPE_PTR) {
-            load_node.type = ptr_type->data.pointer.base;
-        }
-        SCC_IR_BUILDER_END_BORROW(builder); // ptr_type
-    }
-    SCC_IR_BUILDER_END_BORROW(builder); // ptr_node
-
-    scc_ir_value_ref_t value_ref =
-        scc_ir_module_add_value(GET_MODULE(builder), &load_node);
-    scc_ir_builder_add_instr(builder, value_ref);
-    return value_ref;
-}
-
-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_BUILDER_CHECK_NO_BORROW(builder);
-    Assert(target != SCC_IR_REF_nullptr && value != SCC_IR_REF_nullptr);
-    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_value_ref_t value_ref =
-        scc_ir_module_add_value(GET_MODULE(builder), &store_node);
-    scc_ir_builder_add_instr(builder, value_ref);
-    return value_ref;
-}
-
-scc_ir_value_ref_t scc_ir_builder_get_elem_ptr(scc_ir_builder_t *builder,
-                                               scc_ir_value_ref_t target,
-                                               scc_ir_value_ref_t index) {
-    SCC_IR_BUILDER_CHECK_NO_BORROW(builder);
-    scc_ir_value_t get_ptr_node = {0};
-    get_ptr_node.tag = SCC_IR_VALUE_TAG_GET_ELEM_PTR;
-    get_ptr_node.data.get_elem_ptr.src_addr = target;
-    get_ptr_node.data.get_elem_ptr.index = index;
-
-    // 借用类型信息
-    scc_ir_type_t *type_ref = nullptr;
-    SCC_IR_BUILDER_BEGIN_BORROW(
-        builder, type_ref,
-        scc_ir_module_get_type_by_value(GET_MODULE(builder), target));
-    Assert(type_ref != nullptr);
-    scc_ir_type_t type = *type_ref;     // 拷贝一份，避免后续借用
-    SCC_IR_BUILDER_END_BORROW(builder); // type_ref
-
-    if (type.tag == SCC_IR_TYPE_PTR) {
-        scc_ir_type_t *base_type = nullptr;
-        SCC_IR_BUILDER_BEGIN_BORROW(
-            builder, base_type,
-            scc_ir_module_get_type(GET_MODULE(builder),
-                                   type_ref->data.pointer.base));
-        if (base_type->tag == SCC_IR_TYPE_ARRAY) {
-            scc_ir_type_t type = (scc_ir_type_t){
-                .tag = SCC_IR_TYPE_PTR,
-                .data.pointer.base = base_type->data.array.base,
-            };
-            SCC_IR_BUILDER_END_BORROW(builder); // base_type
-            get_ptr_node.type = scc_ir_builder_type(builder, &type);
-        } else {
-            SCC_IR_BUILDER_END_BORROW(builder); // base_type
-            get_ptr_node.type = scc_ir_builder_type(builder, &type);
-        }
-    } else {
-        get_ptr_node.type = scc_ir_builder_type(builder, &type);
-    }
-
-    scc_ir_value_ref_t value_ref =
-        scc_ir_module_add_value(GET_MODULE(builder), &get_ptr_node);
-    scc_ir_builder_add_instr(builder, value_ref);
-    return value_ref;
-}
-
-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_BUILDER_CHECK_NO_BORROW(builder);
-    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;
-
-    // 借用 lhs_node 获取类型
-    scc_ir_value_t *lhs_node = nullptr;
-    SCC_IR_BUILDER_BEGIN_BORROW(
-        builder, lhs_node, scc_ir_module_get_value(GET_MODULE(builder), lhs));
-    if (lhs_node) {
-        binop_node.type = lhs_node->type;
-    }
-    SCC_IR_BUILDER_END_BORROW(builder); // lhs_node
-
-    scc_ir_value_ref_t value_ref =
-        scc_ir_module_add_value(GET_MODULE(builder), &binop_node);
-    scc_ir_builder_add_instr(builder, value_ref);
-    return value_ref;
-}
-
-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_BUILDER_CHECK_NO_BORROW(builder);
-    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;
-    cmp_node.type = 0; // FIXME
-
-    scc_ir_value_ref_t value_ref =
-        scc_ir_module_add_value(GET_MODULE(builder), &cmp_node);
-    scc_ir_builder_add_instr(builder, value_ref);
-    return value_ref;
-}
-
-scc_ir_value_ref_t scc_ir_builder_jump(scc_ir_builder_t *builder,
-                                       scc_ir_bblock_ref_t target) {
-    SCC_IR_BUILDER_CHECK_NO_BORROW(builder);
-    scc_ir_value_t jump_node = {0};
-    jump_node.tag = SCC_IR_VALUE_TAG_JUMP;
-    jump_node.data.jump.target_bblock = target;
-
-    scc_ir_value_ref_t value_ref =
-        scc_ir_module_add_value(GET_MODULE(builder), &jump_node);
-    scc_ir_builder_add_instr(builder, value_ref);
-    return value_ref;
-}
-
-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_BUILDER_CHECK_NO_BORROW(builder);
-    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_value_ref_t value_ref =
-        scc_ir_module_add_value(GET_MODULE(builder), &branch_node);
-    scc_ir_builder_add_instr(builder, value_ref);
-    return value_ref;
-}
-
-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_BUILDER_CHECK_NO_BORROW(builder);
-    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);
-    for (usize i = 0; i < arg_count; i++) {
-        scc_vec_push(call_node.data.call.args, args[i]);
-    }
-
-    // 借用 callee_func 和 func_type 获取返回类型
-    scc_ir_func_t *callee_func = nullptr;
-    SCC_IR_BUILDER_BEGIN_BORROW(
-        builder, callee_func,
-        scc_ir_module_get_func(GET_MODULE(builder), callee));
-    if (callee_func) {
-        scc_ir_type_t *func_type = nullptr;
-        SCC_IR_BUILDER_BEGIN_BORROW(
-            builder, func_type,
-            scc_ir_module_get_type(GET_MODULE(builder), callee_func->type));
-        if (func_type && func_type->tag == SCC_IR_TYPE_FUNC) {
-            call_node.type = func_type->data.function.ret_type;
-        }
-        SCC_IR_BUILDER_END_BORROW(builder); // func_type
-    }
-    SCC_IR_BUILDER_END_BORROW(builder); // callee_func
-
-    scc_ir_value_ref_t value_ref =
-        scc_ir_module_add_value(GET_MODULE(builder), &call_node);
-    scc_ir_builder_add_instr(builder, value_ref);
-    return value_ref;
-}
-
-scc_ir_value_ref_t scc_ir_builder_ret(scc_ir_builder_t *builder,
-                                      scc_ir_value_ref_t value) {
-    SCC_IR_BUILDER_CHECK_NO_BORROW(builder);
-    scc_ir_value_t ret_node = {0};
-    ret_node.tag = SCC_IR_VALUE_TAG_RET;
-    ret_node.data.ret.ret_val = value;
-
-    scc_ir_value_ref_t value_ref =
-        scc_ir_module_add_value(GET_MODULE(builder), &ret_node);
-    scc_ir_builder_add_instr(builder, value_ref);
-    return value_ref;
-}
-
-scc_ir_value_ref_t scc_ir_builder_ret_void(scc_ir_builder_t *builder) {
-    SCC_IR_BUILDER_CHECK_NO_BORROW(builder);
-    scc_ir_value_t ret_node = {0};
-    ret_node.tag = SCC_IR_VALUE_TAG_RET;
-
-    scc_ir_value_t ret_val_node;
-    scc_ir_value_init(&ret_val_node, nullptr, SCC_IR_VALUE_TAG_NULLPTR);
-    ret_val_node.type = scc_ir_builder_type_void(builder);
-    ret_node.data.ret.ret_val =
-        scc_ir_module_add_value(GET_MODULE(builder), &ret_val_node);
-
-    scc_ir_value_ref_t value_ref =
-        scc_ir_module_add_value(GET_MODULE(builder), &ret_node);
-    scc_ir_builder_add_instr(builder, value_ref);
-    return value_ref;
-}

libs/ir/src/ir_ctx.c

@@ -1,194 +0,0 @@
-#include <ir_ctx.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_type(const void *_key, void *userdata) {
-    scc_ir_module_t *module = userdata;
-    const scc_ir_type_t *key =
-        _key == SCC_IR_REF_nullptr
-            ? &scc_vec_at(module->types, 0)
-            : scc_ir_module_get_type(module, (usize)_key);
-    // 初始哈希：tag
-    u32 hash = (u32)key->tag;
-
-    switch (key->tag) {
-    case SCC_IR_TYPE_void:
-    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_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_UNION:
-        return 0;
-    case SCC_IR_TYPE_VECTOR:
-    default:
-        Panic("Invalid type tag %d", key->tag);
-        return 0;
-    }
-
-    return hash;
-}
-
-static int cmp_type(const void *_key1, const void *_key2, void *userdata) {
-    scc_ir_module_t *module = userdata;
-    const scc_ir_type_t *key1 =
-                            _key1 == SCC_IR_REF_nullptr
-                                ? &scc_vec_at(module->types, 0)
-                                : scc_ir_module_get_type(module, (usize)_key1),
-                        *key2 =
-                            _key2 == SCC_IR_REF_nullptr
-                                ? &scc_vec_at(module->types, 0)
-                                : scc_ir_module_get_type(module, (usize)_key2);
-    Assert(key1 != nullptr && key2 != nullptr);
-    if (key1->tag == SCC_IR_TYPE_unknown || key2->tag == SCC_IR_TYPE_unknown) {
-        return 1;
-    }
-    // tag不同
-    if (key1->tag != key2->tag) {
-        return 1;
-    }
-
-    switch (key1->tag) {
-    case SCC_IR_TYPE_void:
-    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_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:
-        Panic("Unknown key type %d", key1->tag);
-        return 1;
-    }
-    return 1;
-}
-
-void scc_ir_ctx_init(scc_ir_ctx_t *ctx, scc_ir_module_t *module) {
-    ctx->module = module;
-    scc_hashtable_init(&ctx->type_uniquing, hash_type, cmp_type, module);
-    // scc_hashtable_init(&ctx->const_pool, /* 常量哈希函数 */,
-    //                    /* 常量比较函数 */);
-    scc_hashtable_cstr_init(&ctx->func_decl_set);
-}
-
-void scc_ir_ctx_drop(scc_ir_ctx_t *ctx) {
-    scc_hashtable_drop(&ctx->type_uniquing);
-    // scc_hashtable_drop(&ctx->const_pool);
-    scc_hashtable_drop(&ctx->func_decl_set);
-}
-
-scc_ir_type_ref_t scc_ir_ctx_get_type(scc_ir_ctx_t *ctx,
-                                      const scc_ir_type_t *type_desc) {
-    Assert(type_desc->tag != SCC_IR_TYPE_unknown);
-
-    scc_vec_at(ctx->module->types, 0) = *type_desc;
-    // 先查哈希表
-    void *found = scc_hashtable_get(&ctx->type_uniquing, (void *)(usize)0);
-    if (found) {
-        return (scc_ir_type_ref_t)(usize)found;
-    }
-
-    // 不存在，添加新类型
-    scc_ir_type_ref_t new_ref = scc_ir_module_add_type(ctx->module, type_desc);
-    scc_hashtable_set(&ctx->type_uniquing, (void *)(usize)new_ref,
-                      (void *)(usize)new_ref);
-    return new_ref;
-}
-
-// 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_value_ref_t();
-// }
-
-scc_ir_func_ref_t scc_ir_ctx_declare_func(scc_ir_ctx_t *ctx,
-                                          scc_ir_type_ref_t type,
-                                          const char *name) {
-    // 检查是否已声明
-    void *found = scc_hashtable_get(&ctx->func_decl_set, (void *)name);
-    if (found) {
-        return (scc_ir_func_ref_t)(usize)found;
-    }
-
-    // 创建新函数
-    scc_ir_func_t func = {
-        .name = name,
-        .type = type,
-    };
-    scc_vec_init(func.params);
-    scc_vec_init(func.bblocks);
-    scc_ir_func_ref_t new_ref = scc_ir_module_add_func(ctx->module, &func);
-    scc_hashtable_set(&ctx->func_decl_set, (void *)name,
-                      (void *)(usize)new_ref);
-    return new_ref;
-}

libs/ir/src/ir_module.c

@@ -1,136 +0,0 @@
-#include <ir_module.h>
-
-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_usize_init(&ctx->uid2value);
-    scc_hashtable_usize_init(&ctx->uid2type);
-    scc_hashtable_usize_init(&ctx->uid2bblock);
-    scc_hashtable_usize_init(&ctx->uid2func);
-    // 预留UID 0 作为无效引用
-    scc_vec_push(ctx->values, (scc_ir_value_t){0});
-    scc_vec_push(ctx->types, (scc_ir_type_t){0});
-    scc_vec_push(ctx->bblocks, (scc_ir_bblock_t){0});
-    scc_vec_push(ctx->funcs, (scc_ir_func_t){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 = 1; 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 = 1; 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 = 1; i < ctx->bblocks.size; i++) {
-        scc_ir_bblock_t *bblock = &ctx->bblocks.data[i];
-        scc_vec_free(bblock->instrs);
-    }
-
-    for (usize i = 1; 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_hashtable_set(&(ctx)->hashtable, (const void *)(usize)new_uid,     \
-                          (void *)(usize)(scc_vec_size(vec)));                 \
-        /* 添加到向量 */                                                       \
-        scc_vec_push((vec), *(data));                                          \
-        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 nullptr;
-    usize idx = GET_ENTITY_INDEX(ctx, ref, uid2type);
-    if (idx >= ctx->types.size)
-        return nullptr;
-    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 nullptr;
-    usize idx = GET_ENTITY_INDEX(ctx, ref, uid2value);
-    if (idx >= ctx->values.size)
-        return nullptr;
-    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 nullptr;
-    usize idx = GET_ENTITY_INDEX(ctx, ref, uid2bblock);
-    if (idx >= ctx->bblocks.size)
-        return nullptr;
-    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 nullptr;
-    usize idx = GET_ENTITY_INDEX(ctx, ref, uid2func);
-    if (idx >= ctx->funcs.size)
-        return nullptr;
-    return &ctx->funcs.data[idx];
-}

libs/ir/src/scc_ir.c

@@ -1,117 +0,0 @@
-#include <scc_ir.h>
-
-void scc_ir_type_init(scc_ir_type_t *in, scc_ir_type_tag_t tag) {
-    Assert(in != nullptr);
-    in->tag = tag;
-    in->name = nullptr;
-    switch (tag) {
-    case SCC_IR_TYPE_unknown:
-    case SCC_IR_TYPE_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:
-        break;
-    case SCC_IR_TYPE_ARRAY:
-        in->data.array.base = 0;
-        in->data.array.len = 0;
-        break;
-    case SCC_IR_TYPE_PTR:
-        in->data.pointer.base = 0;
-        break;
-    case SCC_IR_TYPE_FUNC:
-        scc_vec_init(in->data.function.params);
-        in->data.function.ret_type = 0;
-        break;
-    case SCC_IR_TYPE_UNION:
-    case SCC_IR_TYPE_STRUCT:
-        scc_vec_init(in->data.aggregate.fields);
-        break;
-    default:
-        UNREACHABLE();
-        break;
-    }
-}
-
-void scc_ir_bblock_init(scc_ir_bblock_t *in, const char *label) {
-    Assert(in != nullptr);
-    Assert(label != nullptr);
-    in->label = label;
-    scc_vec_init(in->instrs);
-}
-
-void scc_ir_func_init(scc_ir_func_t *in, const char *name) {
-    Assert(in != nullptr);
-    Assert(name != nullptr);
-    in->name = name;
-    in->type = 0;
-    scc_vec_init(in->bblocks);
-    scc_vec_init(in->params);
-}
-
-void scc_ir_value_init(scc_ir_value_t *in, const char *name,
-                       scc_ir_value_tag_t tag) {
-    Assert(in != nullptr);
-    in->name = name;
-    in->tag = tag;
-    scc_vec_init(in->used_by);
-    in->type = 0;
-
-    switch (tag) {
-    case SCC_IR_VALUE_TAG_NULLPTR:
-        break;
-    case SCC_IR_VALUE_TAG_BUILTIN:
-        break;
-    case SCC_IR_VALUE_TAG_CONST_INT:
-        // TODO
-        in->data.const_int.int64 = 0;
-        break;
-    case SCC_IR_VALUE_TAG_ALLOC:
-        // TODO();
-        break;
-    case SCC_IR_VALUE_TAG_LOAD:
-        in->data.load.target = 0;
-        break;
-    case SCC_IR_VALUE_TAG_STORE:
-        in->data.store.target = 0;
-        in->data.store.value = 0;
-        break;
-    case SCC_IR_VALUE_TAG_GET_ELEM_PTR:
-        in->data.get_elem_ptr.src_addr = 0;
-        in->data.get_elem_ptr.index = 0;
-        break;
-    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_VALUE_TAG_BRANCH:
-        in->data.branch.cond = 0;
-        in->data.branch.true_bblock = 0;
-        in->data.branch.false_bblock = 0;
-        break;
-    case SCC_IR_VALUE_TAG_JUMP:
-        in->data.jump.target_bblock = 0;
-        break;
-    case SCC_IR_VALUE_TAG_CALL:
-        scc_vec_init(in->data.call.args);
-        in->data.call.callee = 0;
-        break;
-    case SCC_IR_VALUE_TAG_RET:
-        in->data.ret.ret_val = 0;
-        break;
-    default:
-        UNREACHABLE();
-        break;
-    }
-}

libs/lir/cbuild.toml

@@ -1,13 +0,0 @@
-[package]
-name = "scc_lir"
-version = "0.1.0"
-authors = []
-description = ""
-
-dependencies = [
-    { name = "scc_ir", path = "../ir" },
-    { name = "scc_utils", path = "../../runtime/scc_utils" },
-    { name = "tree_dump", path = "../tree_dump" },
-]
-# features = {}
-# default_features = []

libs/lir/include/scc_ir2lir.h

@@ -1,12 +0,0 @@
-#ifndef __SCC_IR2LIR_H__
-#define __SCC_IR2LIR_H__
-
-#include "scc_lir.h"
-#include "scc_lir_builder.h"
-#include "scc_lir_module.h"
-#include <scc_ir.h>
-
-scc_lir_module_t *scc_ir2lir(scc_lir_builder_t *builder,
-                             const scc_ir_cprog_t *cprog);
-
-#endif /* __SCC_IR2LIR_H__ */

libs/lir/include/scc_lir.h

@@ -1,263 +0,0 @@
-/**
- * @file scc_lir.h
- * @brief 低层中间表示 (Low-Level IR) - 实用精简版
- *
- * 设计原则：
- * - 依赖 scc_core.h 和 scc_utils.h (仅使用哈希表)
- * - 保留所有核心功能：复杂地址、并行复制、VA 支持、符号引用
- * - 基本块使用稳定 ID，通过哈希表快速查找
- * - 预留属性位掩码 (attr)，未来可扩展 align、packed、weak 等
- * - 无字符串池、无类型缓存，保持简单
- */
-
-#ifndef __SCC_LIR_H__
-#define __SCC_LIR_H__
-
-#include <scc_core.h>
-#include <scc_hashtable.h>
-#include <scc_pos.h>
-
-typedef enum scc_lir_attr {
-    SCC_LIR_ATTR_NONE = 0,
-    SCC_LIR_ATTR_STATIC = 1 << 0,     // 内部链接
-    SCC_LIR_ATTR_WEAK = 1 << 1,       // 弱符号
-    SCC_LIR_ATTR_VIS_HIDDEN = 1 << 2, // 符号可见性 hidden
-    SCC_LIR_ATTR_NOINLINE = 1 << 3,
-    SCC_LIR_ATTR_ALWAYSINLINE = 1 << 4,
-    // 对齐值可编码在 attr 的高位，例如：
-    // #define SCC_LIR_ATTR_ALIGN(n) (((n) << 8) | SCC_LIR_ATTR_ALIGN_FLAG)
-} scc_lir_attr_t;
-
-typedef enum {
-    SCC_LIR_INSTR_KIND_NONE,   // 无操作数
-    SCC_LIR_INSTR_KIND_VREG,   // 虚拟寄存器
-    SCC_LIR_INSTR_KIND_PREG,   // 物理寄存器 (后端定义编号)
-    SCC_LIR_INSTR_KIND_IMM,    // 整数立即数
-    SCC_LIR_INSTR_KIND_FIMM,   // 浮点立即数
-    SCC_LIR_INSTR_KIND_SYMBOL, // 全局符号 (函数名、全局变量、字符串常量)
-    SCC_LIR_INSTR_KIND_ADDR    // 复杂地址表达式 (base + index*scale + offset)
-} scc_lir_instr_kind_t;
-
-/**
- * @brief 复杂地址表达式
- * base + index * scale + offset
- */
-typedef struct scc_lir_addr {
-    int base;   // 基址寄存器，-1 表示无
-    int index;  // 索引寄存器，-1 表示无
-    int scale;  // 比例因子 (1, 2, 4, 8)
-    i64 offset; // 常量偏移
-} scc_lir_addr_t;
-
-typedef struct scc_lir_instr {
-    scc_lir_instr_kind_t kind;
-    union {
-        unsigned int reg;    // VREG 或 PREG 索引
-        i64 imm;             // 整型立即数
-        f64 fimm;            // 浮点立即数
-        const char *symbol;  // 符号名 (生命周期由前端管理)
-        scc_lir_addr_t addr; // 复杂地址
-    } data;
-} scc_lir_val_t;
-
-/* 构造宏 */
-#define SCC_LIR_NONE() ((scc_lir_val_t){.kind = SCC_LIR_INSTR_KIND_NONE})
-#define SCC_LIR_VREG(n)                                                        \
-    ((scc_lir_val_t){.kind = SCC_LIR_INSTR_KIND_VREG, .data.reg = (n)})
-#define SCC_LIR_PREG(r)                                                        \
-    ((scc_lir_val_t){.kind = SCC_LIR_INSTR_KIND_PREG, .data.reg = (r)})
-#define SCC_LIR_IMM(v)                                                         \
-    ((scc_lir_val_t){.kind = SCC_LIR_INSTR_KIND_IMM, .data.imm = (v)})
-#define SCC_LIR_FIMM(v)                                                        \
-    ((scc_lir_val_t){.kind = SCC_LIR_INSTR_KIND_FIMM, .data.fimm = (v)})
-#define SCC_LIR_SYMBOL(s)                                                      \
-    ((scc_lir_val_t){.kind = SCC_LIR_INSTR_KIND_SYMBOL, .data.symbol = (s)})
-#define SCC_LIR_ADDR(b, i, s, o)                                               \
-    ((scc_lir_val_t){.kind = SCC_LIR_INSTR_KIND_ADDR,                          \
-                     .data.addr = {b, i, s, o}})
-
-#define SCC_LIR_SIZE_8 1
-#define SCC_LIR_SIZE_16 2
-#define SCC_LIR_SIZE_32 4
-#define SCC_LIR_SIZE_64 8
-
-typedef enum {
-    SCC_LIR_EXT_NONE,
-    SCC_LIR_EXT_SEXT,
-    SCC_LIR_EXT_ZEXT,
-    SCC_LIR_EXT_FLOAT
-} scc_lir_ext_t;
-
-typedef enum {
-    /* 数据移动 */
-    SCC_LIR_MOV,
-    SCC_LIR_LOAD,
-    SCC_LIR_LOAD_ADDR,
-    SCC_LIR_STORE,
-    SCC_LIR_STORE_ADDR,
-    SCC_LIR_LEA,
-
-    /* 整数算术 */
-    SCC_LIR_ADD,
-    SCC_LIR_SUB,
-    SCC_LIR_MUL,
-    SCC_LIR_DIV_S,
-    SCC_LIR_DIV_U,
-    SCC_LIR_REM_S,
-    SCC_LIR_REM_U,
-    SCC_LIR_AND,
-    SCC_LIR_OR,
-    SCC_LIR_XOR,
-    SCC_LIR_SHL,
-    SCC_LIR_SHR,
-    SCC_LIR_SAR,
-    SCC_LIR_NEG,
-    SCC_LIR_NOT,
-
-    /* 浮点算术 */
-    SCC_LIR_FADD,
-    SCC_LIR_FSUB,
-    SCC_LIR_FMUL,
-    SCC_LIR_FDIV,
-    SCC_LIR_FNEG,
-    SCC_LIR_FCVT,
-
-    /* 比较 */
-    SCC_LIR_CMP,
-
-    /* 控制流 */
-    SCC_LIR_BR,
-    SCC_LIR_JMP,
-    SCC_LIR_JMP_INDIRECT,
-    SCC_LIR_CALL,
-    SCC_LIR_CALL_INDIRECT,
-    SCC_LIR_RET,
-
-    /* 并行复制 */
-    SCC_LIR_PARALLEL_COPY,
-
-    /* 可变参数 */
-    SCC_LIR_VA_START,
-    SCC_LIR_VA_ARG,
-    SCC_LIR_VA_END,
-    SCC_LIR_VA_COPY,
-
-    /* 栈管理 */
-    SCC_LIR_ALLOCA,
-
-    SCC_LIR_NOP
-} scc_lir_op_t;
-
-typedef enum {
-    SCC_LIR_COND_EQ,
-    SCC_LIR_COND_NE,
-    SCC_LIR_COND_SLT,
-    SCC_LIR_COND_SLE,
-    SCC_LIR_COND_SGT,
-    SCC_LIR_COND_SGE,
-    SCC_LIR_COND_ULT,
-    SCC_LIR_COND_ULE,
-    SCC_LIR_COND_UGT,
-    SCC_LIR_COND_UGE,
-    SCC_LIR_COND_FEQ,
-    SCC_LIR_COND_FNE,
-    SCC_LIR_COND_FLT,
-    SCC_LIR_COND_FLE,
-    SCC_LIR_COND_FGT,
-    SCC_LIR_COND_FGE
-} scc_lir_cond_t;
-
-typedef usize scc_lir_bblock_uid_t;
-
-typedef struct scc_lir_ins {
-    scc_lir_op_t op;
-    u8 size;
-    scc_lir_ext_t ext;
-    scc_lir_val_t to;
-    scc_lir_val_t arg0;
-    scc_lir_val_t arg1;
-    /// @brief debug 信息
-    scc_pos_t src_loc;
-
-    union {
-        scc_lir_cond_t cond;
-
-        struct scc_lir_br {
-            scc_lir_bblock_uid_t true_target;
-            scc_lir_bblock_uid_t false_target;
-        } br;
-
-        scc_lir_bblock_uid_t jmp_target;
-
-        struct scc_lir_call {
-            const char *callee;
-            scc_lir_val_t *args;
-            int arg_count;
-            scc_lir_val_t ret_vreg;
-            u64 clobber_mask;
-        } call;
-
-        struct scc_lir_call_indirect {
-            scc_lir_val_t target;
-            scc_lir_val_t *args;
-            int arg_count;
-            scc_lir_val_t ret_vreg;
-            u64 clobber_mask;
-        } call_indirect;
-
-        scc_lir_val_t ret_val;
-
-        struct scc_lir_parallel_copy {
-            scc_lir_val_t *dests;
-            scc_lir_val_t *srcs;
-            int num_copies;
-        } parallel_copy;
-
-        struct scc_lir_alloca {
-            int size_bytes;
-            int align_bytes;
-        } alloca;
-
-        struct {
-            scc_lir_val_t ap;
-            scc_lir_val_t last;
-        } va_start;
-
-        struct {
-            scc_lir_val_t ap;
-            int type_size;
-            int type_align;
-            char is_float;
-            scc_lir_val_t to;
-        } va_arg;
-
-        struct {
-            scc_lir_val_t ap;
-        } va_end;
-
-        struct {
-            scc_lir_val_t dest;
-            scc_lir_val_t src;
-        } va_copy;
-    } metadata;
-} scc_lir_instr_t;
-
-typedef SCC_VEC(scc_lir_instr_t) scc_lir_instr_vec_t;
-typedef struct scc_lir_bblock {
-    scc_lir_bblock_uid_t id; // 稳定唯一 ID
-    const char *label;       // 可读标签
-    scc_lir_instr_vec_t ins; // 指令序列
-} scc_lir_bblock_t;
-
-typedef SCC_VEC(scc_lir_bblock_t) scc_lir_bblock_vec_t;
-typedef struct scc_lir_func {
-    const char *name;
-    scc_lir_bblock_vec_t bblocks;
-    scc_hashtable_t bb_map; // ID -> 基本块索引 (usize)
-    scc_lir_bblock_uid_t next_bb_uid;
-    unsigned int vregs_count;
-    int frame_size;
-    scc_lir_attr_t attr;
-} scc_lir_func_t;
-
-#endif /* __SCC_LIR_H__ */

libs/lir/include/scc_lir_builder.h

@@ -1,26 +0,0 @@
-#ifndef __SCC_LIR_BUILDER_H__
-#define __SCC_LIR_BUILDER_H__
-
-#include "scc_lir.h"
-#include "scc_lir_module.h"
-#include <scc_hashtable.h>
-
-typedef struct scc_lir_builder {
-    scc_lir_func_t *func;
-    scc_lir_bblock_t *cur_bb;
-    scc_hashtable_t value_to_vreg; // 高层 IR 值 -> 虚拟寄存器
-    scc_lir_module_t *module;
-} scc_lir_builder_t;
-
-void scc_lir_builder_init(scc_lir_builder_t *builder, scc_lir_module_t *module);
-void scc_lir_builder_drop(scc_lir_builder_t *builder);
-void scc_lir_builder_begin_func(scc_lir_builder_t *builder, const char *name);
-void scc_lir_builder_end_func(scc_lir_builder_t *builder);
-void scc_lir_builder_begin_bblock(scc_lir_builder_t *builder,
-                                  const char *label);
-void scc_lir_builder_end_bblock(scc_lir_builder_t *builder);
-void scc_lir_builder_add_instr(scc_lir_builder_t *builder,
-                               const scc_lir_instr_t *instr);
-unsigned int scc_lir_builder_new_vreg(scc_lir_builder_t *builder);
-
-#endif /* __SCC_LIR_BUILDER_H__ */

libs/lir/include/scc_lir_dump.h

@@ -1,22 +0,0 @@
-#ifndef __SCC_LIR_DUMP_H__
-#define __SCC_LIR_DUMP_H__
-
-#include "scc_lir.h"
-#include "scc_lir_module.h"
-#include <scc_tree_dump.h>
-
-typedef struct {
-    scc_tree_dump_t *dump_ctx;
-} scc_lir_dump_ctx_t;
-
-static inline void scc_lir_dump_init(scc_lir_dump_ctx_t *ctx,
-                                     scc_tree_dump_t *dump_ctx) {
-    ctx->dump_ctx = dump_ctx;
-}
-void scc_lir_dump_ins(scc_lir_dump_ctx_t *ctx, const scc_lir_instr_t *ins);
-void scc_lir_dump_bblock(scc_lir_dump_ctx_t *ctx, const scc_lir_bblock_t *bb);
-void scc_lir_dump_func(scc_lir_dump_ctx_t *ctx, const scc_lir_func_t *func);
-void scc_lir_dump_module(scc_lir_dump_ctx_t *ctx,
-                         const scc_lir_module_t *module);
-
-#endif /* __SCC_LIR_DUMP_H__ */

libs/lir/include/scc_lir_module.h

@@ -1,98 +0,0 @@
-/**
- * @file scc_lir_module.h
- * @brief LIR 模块：管理函数定义、全局符号和声明
- */
-
-#ifndef __SCC_LIR_MODULE_H__
-#define __SCC_LIR_MODULE_H__
-
-#include "scc_lir.h"
-#include <scc_core.h>
-#include <scc_hashtable.h>
-
-typedef enum scc_lir_symbol_kind {
-    SCC_LIR_SYMBOL_FUNC,   // 函数符号
-    SCC_LIR_SYMBOL_DATA,   // 数据符号（全局变量、常量）
-    SCC_LIR_SYMBOL_EXTERN, // 外部符号（未定义，需链接器解析）
-} scc_lir_symbol_kind_t;
-
-typedef struct scc_lir_symbol {
-    const char *name;           // 符号名（驻留字符串或前端管理）
-    scc_lir_symbol_kind_t kind; // 符号类型
-    scc_lir_attr_t attr;        // 属性（static, weak 等）
-
-    union {
-        struct {
-            scc_lir_func_t *func; // 指向函数体（若为定义）
-        } func;
-        struct {
-            u8 *init_data; // 初始化数据（若为 NULL 则零初始化）
-            usize size;    // 数据大小（字节）
-            int align;     // 对齐要求
-        } data;
-    };
-} scc_lir_symbol_t;
-
-typedef struct scc_lir_module {
-    SCC_VEC(scc_lir_func_t *) funcs;   // 所有函数定义（按添加顺序）
-    SCC_VEC(scc_lir_symbol_t) symbols; // 所有全局符号（包含声明和定义）
-    scc_hashtable_t symbol_map;        // name -> 索引 (usize) 在 symbols 向量中
-} scc_lir_module_t;
-
-/**
- * @brief 初始化 LIR 模块
- */
-void scc_lir_module_init(scc_lir_module_t *module);
-
-/**
- * @brief 销毁 LIR 模块，释放所有函数和符号资源
- */
-void scc_lir_module_drop(scc_lir_module_t *module);
-
-/**
- * @brief 添加一个函数定义到模块
- * @param mod  模块
- * @param func 函数定义（所有权转移给模块）
- * @return 符号指针（内部持有，不可释放）
- */
-const scc_lir_symbol_t *scc_lir_module_add_func_def(scc_lir_module_t *module,
-                                                    scc_lir_func_t *func);
-
-/**
- * @brief 添加一个函数声明（外部或未定义）
- * @param mod  模块
- * @param name 函数名
- * @param attr 属性
- * @return 符号指针
- */
-const scc_lir_symbol_t *scc_lir_module_add_func_decl(scc_lir_module_t *module,
-                                                     const char *name,
-                                                     scc_lir_attr_t attr);
-
-/**
- * @brief 添加一个全局数据符号（定义或外部）
- * @param mod       模块
- * @param name      符号名
- * @param kind      种类（DATA 或 EXTERN）
- * @param init_data 初始化数据（若为 DATA 定义；若为 NULL 则零初始化）
- * @param size      数据大小（若为 EXTERN 可为 0）
- * @param align     对齐要求
- * @param attr      属性
- * @return 符号指针
- */
-const scc_lir_symbol_t *scc_lir_module_add_data(scc_lir_module_t *module,
-                                                const char *name,
-                                                scc_lir_symbol_kind_t kind,
-                                                const u8 *init_data, usize size,
-                                                u32 align, scc_lir_attr_t attr);
-
-/**
- * @brief 通过名称查找符号
- * @param mod  模块
- * @param name 符号名
- * @return 符号指针，未找到返回 nullptr
- */
-const scc_lir_symbol_t *
-scc_lir_module_lookup_symbol(const scc_lir_module_t *module, const char *name);
-
-#endif /* __SCC_LIR_MODULE_H__ */

libs/lir/src/scc_ir2lir.c

@@ -1,599 +0,0 @@
-/**
- * @file scc_ir2lir.c
- * @brief 将高级 IR (scc_ir) 降级为低层 LIR (scc_lir)
- */
-
-#include <scc_hashtable.h>
-#include <scc_ir2lir.h>
-
-/* ---------- 转换上下文 ---------- */
-typedef struct {
-    scc_lir_builder_t *builder;
-    scc_ir_module_t *ir_module;
-    scc_hashtable_t bb_map;        // ir_bblock_ref_t -> scc_lir_bblock_uid_t
-    scc_hashtable_t value_to_vreg; // ir_value_ref_t -> unsigned int vreg
-    scc_hashtable_t func_decl_map; // ir_func_ref_t -> const char* (用于调用)
-} ir2lir_ctx_t;
-
-static void ir2lir_ctx_init(ir2lir_ctx_t *ctx, scc_lir_builder_t *builder,
-                            scc_ir_module_t *ir_module) {
-    ctx->builder = builder;
-    ctx->ir_module = ir_module;
-    scc_hashtable_usize_init(&ctx->bb_map);
-    scc_hashtable_usize_init(&ctx->value_to_vreg);
-    scc_hashtable_usize_init(&ctx->func_decl_map);
-}
-
-static void ir2lir_ctx_drop(ir2lir_ctx_t *ctx) {
-    scc_hashtable_drop(&ctx->bb_map);
-    scc_hashtable_drop(&ctx->value_to_vreg);
-    scc_hashtable_drop(&ctx->func_decl_map);
-}
-
-/* ---------- 工具函数 ---------- */
-
-// 获取 IR 类型对应的 LIR 大小和扩展属性
-static void ir_type_to_lir_size_ext(scc_ir_type_t *type, u8 *out_size,
-                                    scc_lir_ext_t *out_ext) {
-    switch (type->tag) {
-    case SCC_IR_TYPE_i8:
-        *out_size = SCC_LIR_SIZE_8;
-        *out_ext = SCC_LIR_EXT_SEXT;
-        break;
-    case SCC_IR_TYPE_u8:
-        *out_size = SCC_LIR_SIZE_8;
-        *out_ext = SCC_LIR_EXT_ZEXT;
-        break;
-    case SCC_IR_TYPE_i16:
-        *out_size = SCC_LIR_SIZE_16;
-        *out_ext = SCC_LIR_EXT_SEXT;
-        break;
-    case SCC_IR_TYPE_u16:
-        *out_size = SCC_LIR_SIZE_16;
-        *out_ext = SCC_LIR_EXT_ZEXT;
-        break;
-    case SCC_IR_TYPE_i32:
-        *out_size = SCC_LIR_SIZE_32;
-        *out_ext = SCC_LIR_EXT_SEXT;
-        break;
-    case SCC_IR_TYPE_u32:
-        *out_size = SCC_LIR_SIZE_32;
-        *out_ext = SCC_LIR_EXT_ZEXT;
-        break;
-    case SCC_IR_TYPE_i64:
-        *out_size = SCC_LIR_SIZE_64;
-        *out_ext = SCC_LIR_EXT_SEXT;
-        break;
-    case SCC_IR_TYPE_u64:
-        *out_size = SCC_LIR_SIZE_64;
-        *out_ext = SCC_LIR_EXT_ZEXT;
-        break;
-    case SCC_IR_TYPE_f32:
-        *out_size = SCC_LIR_SIZE_32;
-        *out_ext = SCC_LIR_EXT_FLOAT;
-        break;
-    case SCC_IR_TYPE_f64:
-        *out_size = SCC_LIR_SIZE_64;
-        *out_ext = SCC_LIR_EXT_FLOAT;
-        break;
-    case SCC_IR_TYPE_PTR:
-        *out_size = SCC_LIR_SIZE_64;
-        *out_ext = SCC_LIR_EXT_NONE;
-        break;
-    case SCC_IR_TYPE_void:
-        *out_size = 0;
-        *out_ext = SCC_LIR_EXT_NONE;
-        break;
-    default:
-        Panic("unsupported IR type in lowering");
-    }
-}
-
-// 获取或创建 IR 值对应的虚拟寄存器
-static unsigned int get_vreg_for_value(ir2lir_ctx_t *ctx,
-                                       scc_ir_value_ref_t val_ref) {
-    void *found =
-        scc_hashtable_get(&ctx->value_to_vreg, (void *)(uintptr_t)val_ref);
-    if (found)
-        return (unsigned int)(uintptr_t)found;
-
-    unsigned int vreg = scc_lir_builder_new_vreg(ctx->builder);
-    scc_hashtable_set(&ctx->value_to_vreg, (void *)(uintptr_t)val_ref,
-                      (void *)(uintptr_t)vreg);
-    return vreg;
-}
-
-// 将 IR 值转换为 LIR 操作数 (可能递归触发指令生成)
-static scc_lir_val_t ir_value_to_lir_operand(ir2lir_ctx_t *ctx,
-                                             scc_ir_value_ref_t val_ref);
-
-// 前向声明
-static void translate_ir_value(ir2lir_ctx_t *ctx, scc_ir_value_t *value,
-                               scc_ir_value_ref_t value_ref);
-
-// 获取 LIR 操作数：若为常量/全局符号则直接构造，否则返回对应 vreg
-static scc_lir_val_t ir_value_to_lir_operand(ir2lir_ctx_t *ctx,
-                                             scc_ir_value_ref_t val_ref) {
-    scc_ir_value_t *val = scc_ir_module_get_value(ctx->ir_module, val_ref);
-    Assert(val != nullptr);
-
-    switch (val->tag) {
-    case SCC_IR_VALUE_TAG_CONST_INT: {
-        scc_ir_type_t *ty = scc_ir_module_get_type(ctx->ir_module, val->type);
-        i64 imm = 0;
-        if (ty->tag == SCC_IR_TYPE_i8 || ty->tag == SCC_IR_TYPE_u8)
-            imm = val->data.const_int.int8;
-        else if (ty->tag == SCC_IR_TYPE_i16 || ty->tag == SCC_IR_TYPE_u16)
-            imm = val->data.const_int.int16;
-        else if (ty->tag == SCC_IR_TYPE_i32 || ty->tag == SCC_IR_TYPE_u32)
-            imm = val->data.const_int.int32;
-        else if (ty->tag == SCC_IR_TYPE_i64 || ty->tag == SCC_IR_TYPE_u64)
-            imm = val->data.const_int.int64;
-        else
-            imm = val->data.const_int.int64;
-        return SCC_LIR_IMM(imm);
-    }
-    case SCC_IR_VALUE_TAG_CONST_FLOAT: {
-        scc_ir_type_t *ty = scc_ir_module_get_type(ctx->ir_module, val->type);
-        f64 fimm = (ty->tag == SCC_IR_TYPE_f32) ? val->data.const_float.float32
-                                                : val->data.const_float.float64;
-        return SCC_LIR_FIMM(fimm);
-    }
-    case SCC_IR_VALUE_TAG_GLOBAL_ALLOC: {
-        // 全局变量地址作为符号
-        scc_ir_value_t *global_val = scc_ir_module_get_value(
-            ctx->ir_module, val->data.global_alloc.value);
-        return SCC_LIR_SYMBOL(global_val->name);
-    }
-    case SCC_IR_VALUE_TAG_FUNC_ARG_REF: {
-        // 函数参数：预先已分配 vreg
-        unsigned int vreg = get_vreg_for_value(ctx, val_ref);
-        return SCC_LIR_VREG(vreg);
-    }
-    case SCC_IR_VALUE_TAG_NULLPTR: {
-        return SCC_LIR_IMM(0);
-    }
-    default: {
-        // 其他所有产生值的指令：确保其指令已生成，然后返回 vreg
-        // 注意：这里可能会递归调用 translate_ir_value，因此需要先检查是否已翻译
-        void *found =
-            scc_hashtable_get(&ctx->value_to_vreg, (void *)(uintptr_t)val_ref);
-        if (!found) {
-            translate_ir_value(ctx, val, val_ref);
-        }
-        unsigned int vreg = (unsigned int)(uintptr_t)scc_hashtable_get(
-            &ctx->value_to_vreg, (void *)(uintptr_t)val_ref);
-        return SCC_LIR_VREG(vreg);
-    }
-    }
-}
-
-/* ---------- 操作码映射 ---------- */
-
-static scc_lir_cond_t map_cmp_cond(scc_ir_op_type_t op, cbool is_float) {
-    if (is_float) {
-        switch (op) {
-        case SCC_IR_OP_EQ:
-            return SCC_LIR_COND_FEQ;
-        case SCC_IR_OP_NEQ:
-            return SCC_LIR_COND_FNE;
-        case SCC_IR_OP_LT:
-            return SCC_LIR_COND_FLT;
-        case SCC_IR_OP_LE:
-            return SCC_LIR_COND_FLE;
-        case SCC_IR_OP_GT:
-            return SCC_LIR_COND_FGT;
-        case SCC_IR_OP_GE:
-            return SCC_LIR_COND_FGE;
-        default:
-            Panic("invalid float cmp");
-        }
-    } else {
-        // 默认为有符号比较 (无符号需额外处理类型)
-        switch (op) {
-        case SCC_IR_OP_EQ:
-            return SCC_LIR_COND_EQ;
-        case SCC_IR_OP_NEQ:
-            return SCC_LIR_COND_NE;
-        case SCC_IR_OP_LT:
-            return SCC_LIR_COND_SLT;
-        case SCC_IR_OP_LE:
-            return SCC_LIR_COND_SLE;
-        case SCC_IR_OP_GT:
-            return SCC_LIR_COND_SGT;
-        case SCC_IR_OP_GE:
-            return SCC_LIR_COND_SGE;
-        default:
-            Panic("invalid int cmp");
-        }
-    }
-    return SCC_LIR_COND_EQ;
-}
-
-static scc_lir_op_t map_binop(scc_ir_op_type_t op, bool is_float) {
-    if (is_float) {
-        switch (op) {
-        case SCC_IR_OP_ADD:
-            return SCC_LIR_FADD;
-        case SCC_IR_OP_SUB:
-            return SCC_LIR_FSUB;
-        case SCC_IR_OP_MUL:
-            return SCC_LIR_FMUL;
-        case SCC_IR_OP_DIV:
-            return SCC_LIR_FDIV;
-        default:
-            Panic("unsupported float binop");
-        }
-    } else {
-        switch (op) {
-        case SCC_IR_OP_ADD:
-            return SCC_LIR_ADD;
-        case SCC_IR_OP_SUB:
-            return SCC_LIR_SUB;
-        case SCC_IR_OP_MUL:
-            return SCC_LIR_MUL;
-        case SCC_IR_OP_DIV:
-            return SCC_LIR_DIV_S;
-        case SCC_IR_OP_MOD:
-            return SCC_LIR_REM_S;
-        case SCC_IR_OP_AND:
-            return SCC_LIR_AND;
-        case SCC_IR_OP_OR:
-            return SCC_LIR_OR;
-        case SCC_IR_OP_XOR:
-            return SCC_LIR_XOR;
-        case SCC_IR_OP_SHL:
-            return SCC_LIR_SHL;
-        case SCC_IR_OP_SHR:
-            return SCC_LIR_SHR;
-        case SCC_IR_OP_SAR:
-            return SCC_LIR_SAR;
-        default:
-            return map_cmp_cond(op, is_float);
-        }
-    }
-    return SCC_LIR_NOP;
-}
-
-/* ---------- 单条 IR 指令翻译 ---------- */
-
-static void translate_ir_value(ir2lir_ctx_t *ctx, scc_ir_value_t *value,
-                               scc_ir_value_ref_t value_ref) {
-    // 防止重复翻译
-    if (scc_hashtable_get(&ctx->value_to_vreg, (void *)(uintptr_t)value_ref))
-        return;
-
-    scc_ir_type_t *ty = scc_ir_module_get_type(ctx->ir_module, value->type);
-    u8 size = 0;
-    scc_lir_ext_t ext = SCC_LIR_EXT_NONE;
-    if (ty != nullptr) {
-        ir_type_to_lir_size_ext(ty, &size, &ext);
-    }
-    bool is_float = (ext == SCC_LIR_EXT_FLOAT);
-
-    // 为当前指令分配目标虚拟寄存器
-    unsigned int dst_vreg = get_vreg_for_value(ctx, value_ref);
-
-    switch (value->tag) {
-    case SCC_IR_VALUE_TAG_OP: {
-        scc_lir_val_t lhs = ir_value_to_lir_operand(ctx, value->data.op.lhs);
-        scc_lir_val_t rhs = ir_value_to_lir_operand(ctx, value->data.op.rhs);
-        scc_lir_op_t op = map_binop(value->data.op.op, is_float);
-
-        scc_lir_instr_t instr = {.op = op,
-                                 .size = size,
-                                 .ext = ext,
-                                 .to = SCC_LIR_VREG(dst_vreg),
-                                 .arg0 = lhs,
-                                 .arg1 = rhs};
-        scc_lir_builder_add_instr(ctx->builder, &instr);
-        break;
-    }
-    case SCC_IR_VALUE_TAG_LOAD: {
-        scc_lir_val_t addr =
-            ir_value_to_lir_operand(ctx, value->data.load.target);
-        scc_lir_instr_t instr = {.op = SCC_LIR_LOAD,
-                                 .size = size,
-                                 .ext = ext,
-                                 .to = SCC_LIR_VREG(dst_vreg),
-                                 .arg0 = addr};
-        scc_lir_builder_add_instr(ctx->builder, &instr);
-        break;
-    }
-    case SCC_IR_VALUE_TAG_STORE: {
-        scc_lir_val_t data =
-            ir_value_to_lir_operand(ctx, value->data.store.value);
-        scc_lir_val_t addr =
-            ir_value_to_lir_operand(ctx, value->data.store.target);
-        scc_lir_instr_t instr = {
-            .op = SCC_LIR_STORE, .size = size, .arg0 = data, .arg1 = addr};
-        scc_lir_builder_add_instr(ctx->builder, &instr);
-        break;
-    }
-    case SCC_IR_VALUE_TAG_GET_ELEM_PTR: {
-        // 将指针运算转换为 LEA
-        scc_lir_val_t base =
-            ir_value_to_lir_operand(ctx, value->data.get_elem_ptr.src_addr);
-        scc_lir_val_t index = SCC_LIR_IMM(0);
-        if (value->data.get_elem_ptr.index)
-            ir_value_to_lir_operand(ctx, value->data.get_elem_ptr.index);
-
-        // 计算元素大小
-        scc_ir_type_t *ptr_ty = scc_ir_module_get_type_by_value(
-            ctx->ir_module, value->data.get_elem_ptr.src_addr);
-        scc_ir_type_t *elem_ty = nullptr;
-        if (ptr_ty->tag == SCC_IR_TYPE_PTR) {
-            elem_ty = scc_ir_module_get_type(ctx->ir_module,
-                                             ptr_ty->data.pointer.base);
-        } else if (ptr_ty->tag == SCC_IR_TYPE_ARRAY) {
-            elem_ty =
-                scc_ir_module_get_type(ctx->ir_module, ptr_ty->data.array.base);
-        }
-        Assert(elem_ty != nullptr);
-        int elem_size = 0;
-        // 简化：仅处理基本类型
-        if (elem_ty->tag == SCC_IR_TYPE_i32 || elem_ty->tag == SCC_IR_TYPE_u32)
-            elem_size = 4;
-        else if (elem_ty->tag == SCC_IR_TYPE_i64 ||
-                 elem_ty->tag == SCC_IR_TYPE_u64)
-            elem_size = 8;
-        else if (elem_ty->tag == SCC_IR_TYPE_i8 ||
-                 elem_ty->tag == SCC_IR_TYPE_u8)
-            elem_size = 1;
-        else if (elem_ty->tag == SCC_IR_TYPE_ARRAY)
-            elem_size = 8; // FIXME ptr size
-        else
-            Panic("unsupported element type for getelemptr");
-
-        // 构造地址表达式：base + index * elem_size
-        scc_lir_val_t addr =
-            SCC_LIR_ADDR(dst_vreg, -1, index.data.reg, elem_size);
-        // 更简单的做法：使用 LEA 指令，参数为 base 和 index，由后端展开
-        scc_lir_instr_t instr = {.op = SCC_LIR_LEA,
-                                 .size = SCC_LIR_SIZE_64,
-                                 .to = SCC_LIR_VREG(dst_vreg),
-                                 .arg0 = base,
-                                 .arg1 = index};
-        // 实际需要将 index * elem_size 的信息编码，这里简化，假设后端处理
-        scc_lir_builder_add_instr(ctx->builder, &instr);
-        break;
-    }
-    case SCC_IR_VALUE_TAG_ALLOC: {
-        // alloca 指令：分配栈空间
-        scc_ir_type_t *alloc_ty =
-            scc_ir_module_get_type(ctx->ir_module, ty->data.pointer.base);
-        // 计算大小和对齐（简化）
-        int alloc_size = 8; // 默认
-        if (alloc_ty->tag == SCC_IR_TYPE_i32)
-            alloc_size = 4;
-        scc_lir_instr_t instr = {.op = SCC_LIR_ALLOCA,
-                                 .size = SCC_LIR_SIZE_64,
-                                 .to = SCC_LIR_VREG(dst_vreg),
-                                 .metadata.alloca = {alloc_size, alloc_size}};
-        scc_lir_builder_add_instr(ctx->builder, &instr);
-        break;
-    }
-    case SCC_IR_VALUE_TAG_CALL: {
-        scc_ir_func_t *callee =
-            scc_ir_module_get_func(ctx->ir_module, value->data.call.callee);
-        int arg_count = scc_vec_size(value->data.call.args);
-        scc_lir_val_t *lir_args = scc_malloc(sizeof(scc_lir_val_t) * arg_count);
-        for (int i = 0; i < arg_count; i++) {
-            scc_ir_value_ref_t arg_ref = scc_vec_at(value->data.call.args, i);
-            lir_args[i] = ir_value_to_lir_operand(ctx, arg_ref);
-        }
-
-        scc_lir_instr_t instr = {
-            .op = SCC_LIR_CALL,
-            .size = size,
-            .to = SCC_LIR_VREG(dst_vreg),
-            .metadata.call = {.callee = callee->name,
-                              .args = lir_args,
-                              .arg_count = arg_count,
-                              .ret_vreg = SCC_LIR_VREG(dst_vreg),
-                              .clobber_mask = 0}};
-        scc_lir_builder_add_instr(ctx->builder, &instr);
-        // 注意：lir_args 内存将随指令结构体复制到基本块向量中，但
-        // metadata.call.args 指针仍指向 malloc 内存，
-        // 这会导致内存泄漏。实际实现中应使用 arena
-        // 分配或随函数释放。此处为示例简化。
-        break;
-    }
-    case SCC_IR_VALUE_TAG_BRANCH: {
-        scc_lir_val_t cond =
-            ir_value_to_lir_operand(ctx, value->data.branch.cond);
-        scc_lir_bblock_uid_t true_bb =
-            (scc_lir_bblock_uid_t)(uintptr_t)scc_hashtable_get(
-                &ctx->bb_map,
-                (void *)(uintptr_t)value->data.branch.true_bblock);
-        scc_lir_bblock_uid_t false_bb =
-            (scc_lir_bblock_uid_t)(uintptr_t)scc_hashtable_get(
-                &ctx->bb_map,
-                (void *)(uintptr_t)value->data.branch.false_bblock);
-        scc_lir_instr_t instr = {
-            .op = SCC_LIR_BR, .arg0 = cond, .metadata.br = {true_bb, false_bb}};
-        scc_lir_builder_add_instr(ctx->builder, &instr);
-        break;
-    }
-    case SCC_IR_VALUE_TAG_JUMP: {
-        scc_lir_bblock_uid_t target =
-            (scc_lir_bblock_uid_t)(uintptr_t)scc_hashtable_get(
-                &ctx->bb_map,
-                (void *)(uintptr_t)value->data.jump.target_bblock);
-        scc_lir_instr_t instr = {.op = SCC_LIR_JMP,
-                                 .metadata.jmp_target = target};
-        scc_lir_builder_add_instr(ctx->builder, &instr);
-        break;
-    }
-    case SCC_IR_VALUE_TAG_RET: {
-        scc_lir_val_t ret_val;
-        if (value->data.ret.ret_val != SCC_IR_REF_nullptr) {
-            ret_val = ir_value_to_lir_operand(ctx, value->data.ret.ret_val);
-        } else {
-            ret_val = SCC_LIR_NONE();
-        }
-        scc_lir_instr_t instr = {.op = SCC_LIR_RET,
-                                 .metadata.ret_val = ret_val};
-        scc_lir_builder_add_instr(ctx->builder, &instr);
-        break;
-    }
-    case SCC_IR_VALUE_TAG_CONV: {
-        // 类型转换：使用 MOV 指令配合扩展/截断
-        scc_lir_val_t src =
-            ir_value_to_lir_operand(ctx, value->data.conv.operand);
-        scc_lir_ext_t conv_ext = SCC_LIR_EXT_NONE;
-        if (value->data.conv.conv_type == CONV_SEXT)
-            conv_ext = SCC_LIR_EXT_SEXT;
-        else if (value->data.conv.conv_type == CONV_ZEXT)
-            conv_ext = SCC_LIR_EXT_ZEXT;
-        // TRUNC 用 NONE 即可（MOV 截断）
-        scc_lir_instr_t instr = {.op = SCC_LIR_MOV,
-                                 .size = size,
-                                 .ext = conv_ext,
-                                 .to = SCC_LIR_VREG(dst_vreg),
-                                 .arg0 = src};
-        scc_lir_builder_add_instr(ctx->builder, &instr);
-        break;
-    }
-    // case SCC_IR_VALUE_TAG_CMP: {
-    //     // 注意：IR 中没有单独的 CMP
-    //     // 节点，比较通常作为二元运算的一种或分支条件的一部分。
-    //     // 此处假设比较操作已由前端处理为条件分支，无需生成 LIR 指令。
-    //     break;
-    // }
-    // 常量、参数、全局变量等已在 ir_value_to_lir_operand
-    // 中直接返回，不会进入此处
-    default:
-        // 不生成指令的节点（如 CONST_INT, FUNC_ARG_REF）不会调用本函数
-        break;
-    }
-}
-
-/* ---------- 基本块翻译 ---------- */
-
-static void translate_bblock(ir2lir_ctx_t *ctx, scc_ir_bblock_t *bblock,
-                             scc_ir_bblock_ref_t bblock_ref) {
-    // 创建 LIR 基本块并记录映射
-    scc_lir_builder_begin_bblock(ctx->builder, bblock->label);
-    scc_lir_bblock_uid_t lir_bb_id = ctx->builder->cur_bb->id;
-    scc_hashtable_set(&ctx->bb_map, (void *)(uintptr_t)bblock_ref,
-                      (void *)(uintptr_t)lir_bb_id);
-
-    // 翻译每条指令
-    for (usize i = 0; i < scc_vec_size(bblock->instrs); i++) {
-        scc_ir_value_ref_t val_ref = scc_vec_at(bblock->instrs, i);
-        scc_ir_value_t *val = scc_ir_module_get_value(ctx->ir_module, val_ref);
-        translate_ir_value(ctx, val, val_ref);
-    }
-
-    scc_lir_builder_end_bblock(ctx->builder);
-}
-
-/* ---------- 函数翻译 ---------- */
-
-static void translate_func(ir2lir_ctx_t *ctx, scc_ir_func_t *ir_func) {
-    scc_lir_builder_begin_func(ctx->builder, ir_func->name);
-
-    // 预先为所有参数分配虚拟寄存器
-    for (usize i = 0; i < scc_vec_size(ir_func->params); i++) {
-        scc_ir_value_ref_t param_ref = scc_vec_at(ir_func->params, i);
-        get_vreg_for_value(ctx, param_ref);
-    }
-
-    // 第一遍：创建所有基本块（空壳），建立映射
-    for (usize i = 0; i < scc_vec_size(ir_func->bblocks); i++) {
-        scc_ir_bblock_ref_t bb_ref = scc_vec_at(ir_func->bblocks, i);
-        scc_ir_bblock_t *bb = scc_ir_module_get_bblock(ctx->ir_module, bb_ref);
-
-        scc_lir_builder_begin_bblock(ctx->builder, bb->label);
-        scc_lir_bblock_uid_t lir_bb_id = ctx->builder->cur_bb->id;
-        scc_hashtable_set(&ctx->bb_map, (void *)(uintptr_t)bb_ref,
-                          (void *)(uintptr_t)lir_bb_id);
-        scc_lir_builder_end_bblock(ctx->builder);
-    }
-
-    // 第二遍：填充每个基本块的指令
-    for (usize i = 0; i < scc_vec_size(ir_func->bblocks); i++) {
-        scc_ir_bblock_ref_t bb_ref = scc_vec_at(ir_func->bblocks, i);
-        scc_ir_bblock_t *bb = scc_ir_module_get_bblock(ctx->ir_module, bb_ref);
-        scc_lir_bblock_uid_t lir_bb_id =
-            (scc_lir_bblock_uid_t)(uintptr_t)scc_hashtable_get(
-                &ctx->bb_map, (void *)(uintptr_t)bb_ref);
-
-        // 切换到该基本块
-        scc_lir_bblock_t *lir_bb = nullptr;
-        for (usize j = 0; j < scc_vec_size(ctx->builder->func->bblocks); j++) {
-            if (scc_vec_at(ctx->builder->func->bblocks, j).id == lir_bb_id) {
-                lir_bb = &scc_vec_at(ctx->builder->func->bblocks, j);
-                break;
-            }
-        }
-        Assert(lir_bb != nullptr);
-        ctx->builder->cur_bb = lir_bb;
-
-        // 翻译指令
-        for (usize j = 0; j < scc_vec_size(bb->instrs); j++) {
-            scc_ir_value_ref_t val_ref = scc_vec_at(bb->instrs, j);
-            scc_ir_value_t *val =
-                scc_ir_module_get_value(ctx->ir_module, val_ref);
-            translate_ir_value(ctx, val, val_ref);
-        }
-    }
-
-    scc_lir_builder_end_func(ctx->builder);
-
-    // 清理本次函数翻译的临时映射
-    scc_hashtable_drop(&ctx->bb_map);
-    scc_hashtable_drop(&ctx->value_to_vreg);
-}
-
-/* ---------- 公开接口 ---------- */
-
-scc_lir_module_t *scc_ir2lir(scc_lir_builder_t *builder,
-                             const scc_ir_cprog_t *cprog) {
-    Assert(builder && builder->module && cprog);
-
-    ir2lir_ctx_t ctx;
-    ir2lir_ctx_init(&ctx, builder, &cprog->module);
-
-    // 1. 处理全局变量
-    for (usize i = 0; i < scc_vec_size(cprog->global_vals); i++) {
-        scc_ir_value_ref_t gv_ref = scc_vec_at(cprog->global_vals, i);
-        scc_ir_value_t *galloc =
-            scc_ir_module_get_value(&cprog->module, gv_ref);
-        Assert(galloc->tag == SCC_IR_VALUE_TAG_GLOBAL_ALLOC);
-        scc_ir_value_t *val = scc_ir_module_get_value(
-            &cprog->module, galloc->data.global_alloc.value);
-        scc_ir_buffer_t *data = &val->data.const_array.fields;
-        const scc_lir_symbol_t *sym = scc_lir_module_add_data(
-            builder->module, galloc->name, SCC_LIR_SYMBOL_DATA,
-            scc_vec_unsafe_get_data(*data), scc_vec_size(*data), 0, 0);
-        Assert(sym != nullptr);
-    }
-
-    // 2. 处理函数声明 (外部函数)
-    for (usize i = 0; i < scc_vec_size(cprog->func_decls); i++) {
-        scc_ir_func_ref_t func_ref = scc_vec_at(cprog->func_decls, i);
-        scc_ir_func_t *func = scc_ir_module_get_func(&cprog->module, func_ref);
-        if (!func)
-            continue;
-        const scc_lir_symbol_t *sym =
-            scc_lir_module_add_func_decl(builder->module, func->name, 0);
-        Assert(sym);
-        // 记录映射，供调用时使用
-        scc_hashtable_set(&ctx.func_decl_map, (void *)(uintptr_t)func_ref,
-                          (void *)func->name);
-    }
-
-    // 3. 处理函数定义
-    for (usize i = 0; i < scc_vec_size(cprog->func_defs); i++) {
-        scc_ir_func_ref_t func_ref = scc_vec_at(cprog->func_defs, i);
-        scc_ir_func_t *func = scc_ir_module_get_func(&cprog->module, func_ref);
-        if (!func)
-            continue;
-        translate_func(&ctx, func);
-    }
-
-    ir2lir_ctx_drop(&ctx);
-    return builder->module;
-}

libs/lir/src/scc_lir_builder.c

@@ -1,68 +0,0 @@
-#include <scc_lir_builder.h>
-#include <scc_lir_module.h>
-
-void scc_lir_builder_init(scc_lir_builder_t *builder,
-                          scc_lir_module_t *module) {
-    Assert(module != nullptr);
-    builder->cur_bb = nullptr;
-    builder->func = nullptr;
-    builder->module = module;
-    scc_hashtable_usize_init(&builder->value_to_vreg);
-}
-
-void scc_lir_builder_drop(scc_lir_builder_t *builder) {
-    scc_hashtable_drop(&builder->value_to_vreg);
-}
-
-void scc_lir_builder_begin_func(scc_lir_builder_t *builder, const char *name) {
-    Assert(builder != nullptr);
-    scc_lir_func_t *func = scc_malloc(sizeof(scc_lir_func_t));
-    builder->func = func;
-    Assert(builder->func != nullptr);
-    builder->cur_bb = nullptr;
-
-    // Init;
-    func->next_bb_uid = 1;
-    func->vregs_count = 0;
-    func->name = nullptr;
-    func->frame_size = 0;
-    func->attr = 0;
-    func->name = name;
-    scc_vec_init(func->bblocks);
-    scc_hashtable_usize_init(&func->bb_map);
-}
-
-void scc_lir_builder_end_func(scc_lir_builder_t *builder) {
-    Assert(builder != nullptr && builder->module != nullptr);
-    scc_lir_module_add_func_def(builder->module, builder->func);
-    builder->func = nullptr;
-}
-
-void scc_lir_builder_begin_bblock(scc_lir_builder_t *builder,
-                                  const char *label) {
-    Assert(builder != nullptr && builder->module != nullptr &&
-           builder->func != nullptr);
-    Assert(builder->cur_bb == nullptr);
-    scc_vec_push(builder->func->bblocks, (scc_lir_bblock_t){0});
-    builder->cur_bb = &scc_vec_at(builder->func->bblocks,
-                                  scc_vec_size(builder->func->bblocks) - 1);
-
-    builder->cur_bb->id = builder->func->next_bb_uid++;
-    scc_vec_init(builder->cur_bb->ins);
-    builder->cur_bb->label = label;
-}
-
-void scc_lir_builder_end_bblock(scc_lir_builder_t *builder) {
-    builder->cur_bb = nullptr;
-}
-
-void scc_lir_builder_add_instr(scc_lir_builder_t *builder,
-                               const scc_lir_instr_t *instr) {
-    Assert(builder != nullptr && builder->cur_bb != nullptr &&
-           instr != nullptr);
-    scc_vec_push(builder->cur_bb->ins, *instr);
-}
-
-unsigned int scc_lir_builder_new_vreg(scc_lir_builder_t *builder) {
-    return builder->func->vregs_count++;
-}

libs/lir/src/scc_lir_dump.c

@@ -1,452 +0,0 @@
-/**
- * @file scc_lir_dump.c
- * @brief LIR 文本 dump 实现
- */
-
-#include "scc_lir_dump.h"
-#include <scc_core.h>
-
-static const char *op_to_string(scc_lir_op_t op) {
-    switch (op) {
-    case SCC_LIR_MOV:
-        return "mov";
-    case SCC_LIR_LOAD:
-        return "load";
-    case SCC_LIR_LOAD_ADDR:
-        return "load.addr";
-    case SCC_LIR_STORE:
-        return "store";
-    case SCC_LIR_STORE_ADDR:
-        return "store.addr";
-    case SCC_LIR_LEA:
-        return "lea";
-    case SCC_LIR_ADD:
-        return "add";
-    case SCC_LIR_SUB:
-        return "sub";
-    case SCC_LIR_MUL:
-        return "mul";
-    case SCC_LIR_DIV_S:
-        return "div.s";
-    case SCC_LIR_DIV_U:
-        return "div.u";
-    case SCC_LIR_REM_S:
-        return "rem.s";
-    case SCC_LIR_REM_U:
-        return "rem.u";
-    case SCC_LIR_AND:
-        return "and";
-    case SCC_LIR_OR:
-        return "or";
-    case SCC_LIR_XOR:
-        return "xor";
-    case SCC_LIR_SHL:
-        return "shl";
-    case SCC_LIR_SHR:
-        return "shr";
-    case SCC_LIR_SAR:
-        return "sar";
-    case SCC_LIR_NEG:
-        return "neg";
-    case SCC_LIR_NOT:
-        return "not";
-    case SCC_LIR_FADD:
-        return "fadd";
-    case SCC_LIR_FSUB:
-        return "fsub";
-    case SCC_LIR_FMUL:
-        return "fmul";
-    case SCC_LIR_FDIV:
-        return "fdiv";
-    case SCC_LIR_FNEG:
-        return "fneg";
-    case SCC_LIR_FCVT:
-        return "fcvt";
-    case SCC_LIR_CMP:
-        return "cmp";
-    case SCC_LIR_BR:
-        return "br";
-    case SCC_LIR_JMP:
-        return "jmp";
-    case SCC_LIR_JMP_INDIRECT:
-        return "jmp.indirect";
-    case SCC_LIR_CALL:
-        return "call";
-    case SCC_LIR_CALL_INDIRECT:
-        return "call.indirect";
-    case SCC_LIR_RET:
-        return "ret";
-    case SCC_LIR_PARALLEL_COPY:
-        return "parallel_copy";
-    case SCC_LIR_VA_START:
-        return "va_start";
-    case SCC_LIR_VA_ARG:
-        return "va_arg";
-    case SCC_LIR_VA_END:
-        return "va_end";
-    case SCC_LIR_VA_COPY:
-        return "va_copy";
-    case SCC_LIR_ALLOCA:
-        return "alloca";
-    case SCC_LIR_NOP:
-        return "nop";
-    default:
-        return "???";
-    }
-}
-
-static const char *cond_to_string(scc_lir_cond_t cond) {
-    switch (cond) {
-    case SCC_LIR_COND_EQ:
-        return "eq";
-    case SCC_LIR_COND_NE:
-        return "ne";
-    case SCC_LIR_COND_SLT:
-        return "slt";
-    case SCC_LIR_COND_SLE:
-        return "sle";
-    case SCC_LIR_COND_SGT:
-        return "sgt";
-    case SCC_LIR_COND_SGE:
-        return "sge";
-    case SCC_LIR_COND_ULT:
-        return "ult";
-    case SCC_LIR_COND_ULE:
-        return "ule";
-    case SCC_LIR_COND_UGT:
-        return "ugt";
-    case SCC_LIR_COND_UGE:
-        return "uge";
-    case SCC_LIR_COND_FEQ:
-        return "feq";
-    case SCC_LIR_COND_FNE:
-        return "fne";
-    case SCC_LIR_COND_FLT:
-        return "flt";
-    case SCC_LIR_COND_FLE:
-        return "fle";
-    case SCC_LIR_COND_FGT:
-        return "fgt";
-    case SCC_LIR_COND_FGE:
-        return "fge";
-    default:
-        return "???";
-    }
-}
-
-static void dump_operand(scc_lir_dump_ctx_t *ctx, const scc_lir_val_t *op) {
-    scc_tree_dump_t *td = ctx->dump_ctx;
-
-    switch (op->kind) {
-    case SCC_LIR_INSTR_KIND_NONE:
-        scc_tree_dump_append(td, "_");
-        break;
-    case SCC_LIR_INSTR_KIND_VREG:
-        scc_tree_dump_append_fmt(td, "%%%u", op->data.reg);
-        break;
-    case SCC_LIR_INSTR_KIND_PREG:
-        scc_tree_dump_append_fmt(td, "Phy%u", op->data.reg);
-        break;
-    case SCC_LIR_INSTR_KIND_IMM:
-        scc_tree_dump_append_fmt(td, "%lld", op->data.imm);
-        break;
-    case SCC_LIR_INSTR_KIND_FIMM:
-        scc_tree_dump_append_fmt(td, "%lf", op->data.fimm);
-        break;
-    case SCC_LIR_INSTR_KIND_SYMBOL:
-        scc_tree_dump_append_fmt(td, "@%s",
-                                 op->data.symbol ? op->data.symbol : "<null>");
-        break;
-    case SCC_LIR_INSTR_KIND_ADDR: {
-        const scc_lir_addr_t *addr = &op->data.addr;
-        scc_tree_dump_append(td, "[");
-        if (addr->base != -1) {
-            scc_tree_dump_append_fmt(td, "%%%d", addr->base);
-        }
-        if (addr->index != -1) {
-            scc_tree_dump_append_fmt(td, " + %%%d * %d", addr->index,
-                                     addr->scale);
-        }
-        if (addr->offset != 0) {
-            if (addr->offset > 0)
-                scc_tree_dump_append_fmt(td, " + %lld",
-                                         (long long)addr->offset);
-            else
-                scc_tree_dump_append_fmt(td, " - %lld",
-                                         -(long long)addr->offset);
-        }
-        if (addr->base == -1 && addr->index == -1 && addr->offset == 0)
-            scc_tree_dump_append(td, "0");
-        scc_tree_dump_append(td, "]");
-        break;
-    }
-    default:
-        scc_tree_dump_append(td, "<?>");
-    }
-}
-
-static void dump_size_ext(scc_lir_dump_ctx_t *ctx, u8 size, scc_lir_ext_t ext) {
-    scc_tree_dump_t *td = ctx->dump_ctx;
-    const char *size_str = "";
-    if (size == SCC_LIR_SIZE_8)
-        size_str = "8";
-    else if (size == SCC_LIR_SIZE_16)
-        size_str = "16";
-    else if (size == SCC_LIR_SIZE_32)
-        size_str = "32";
-    else if (size == SCC_LIR_SIZE_64)
-        size_str = "64";
-
-    const char *ext_str = "";
-    if (ext == SCC_LIR_EXT_SEXT)
-        ext_str = ".s";
-    else if (ext == SCC_LIR_EXT_ZEXT)
-        ext_str = ".u";
-    else if (ext == SCC_LIR_EXT_FLOAT)
-        ext_str = ".f";
-
-    if (size_str[0] || ext_str[0]) {
-        scc_tree_dump_append_fmt(td, ".%s%s", size_str, ext_str);
-    }
-}
-
-void scc_lir_dump_ins(scc_lir_dump_ctx_t *ctx, const scc_lir_instr_t *ins) {
-    Assert(ctx != nullptr && ins != nullptr);
-    scc_tree_dump_t *td = ctx->dump_ctx;
-
-    scc_tree_dump_begin_line(td);
-    scc_tree_dump_append(td, "  ");
-    // 输出操作码（带节点颜色）
-    scc_tree_dump_node(td, "%s", op_to_string(ins->op));
-
-    // 输出宽度和扩展标志
-    dump_size_ext(ctx, ins->size, ins->ext);
-    scc_tree_dump_append(td, " ");
-
-    switch (ins->op) {
-    case SCC_LIR_MOV:
-    case SCC_LIR_LOAD:
-    case SCC_LIR_LOAD_ADDR:
-        dump_operand(ctx, &ins->to);
-        scc_tree_dump_append(td, " <- ");
-        dump_operand(ctx, &ins->arg0);
-        break;
-    case SCC_LIR_LEA:
-    case SCC_LIR_NEG:
-    case SCC_LIR_NOT:
-    case SCC_LIR_FNEG:
-    case SCC_LIR_FCVT:
-    case SCC_LIR_ALLOCA:
-        dump_operand(ctx, &ins->to);
-        if (ins->op != SCC_LIR_ALLOCA) {
-            scc_tree_dump_append(td, ", ");
-            dump_operand(ctx, &ins->arg0);
-            // alloca 额外信息在 metadata 中，但通常只关注 to
-        }
-        break;
-
-    case SCC_LIR_STORE:
-    case SCC_LIR_STORE_ADDR:
-        dump_operand(ctx, &ins->arg0);
-        scc_tree_dump_append(td, " -> ");
-        dump_operand(ctx, &ins->arg1);
-        break;
-
-    case SCC_LIR_ADD:
-    case SCC_LIR_SUB:
-    case SCC_LIR_MUL:
-    case SCC_LIR_DIV_S:
-    case SCC_LIR_DIV_U:
-    case SCC_LIR_REM_S:
-    case SCC_LIR_REM_U:
-    case SCC_LIR_AND:
-    case SCC_LIR_OR:
-    case SCC_LIR_XOR:
-    case SCC_LIR_SHL:
-    case SCC_LIR_SHR:
-    case SCC_LIR_SAR:
-    case SCC_LIR_FADD:
-    case SCC_LIR_FSUB:
-    case SCC_LIR_FMUL:
-    case SCC_LIR_FDIV:
-        dump_operand(ctx, &ins->to);
-        scc_tree_dump_append(td, ", ");
-        dump_operand(ctx, &ins->arg0);
-        scc_tree_dump_append(td, ", ");
-        dump_operand(ctx, &ins->arg1);
-        break;
-
-    case SCC_LIR_CMP:
-        dump_operand(ctx, &ins->to);
-        scc_tree_dump_append_fmt(td, ", %s, ",
-                                 cond_to_string(ins->metadata.cond));
-        dump_operand(ctx, &ins->arg0);
-        scc_tree_dump_append(td, ", ");
-        dump_operand(ctx, &ins->arg1);
-        break;
-
-    case SCC_LIR_BR:
-        dump_operand(ctx, &ins->arg0);
-        scc_tree_dump_append_fmt(td, ", BB#%zu, BB#%zu",
-                                 ins->metadata.br.true_target,
-                                 ins->metadata.br.false_target);
-        break;
-
-    case SCC_LIR_JMP:
-        scc_tree_dump_append_fmt(td, "BB#%zu", ins->metadata.jmp_target);
-        break;
-
-    case SCC_LIR_JMP_INDIRECT:
-        dump_operand(ctx, &ins->arg0);
-        break;
-
-    case SCC_LIR_CALL: {
-        const struct scc_lir_call *c = &ins->metadata.call;
-        if (c->ret_vreg.kind != SCC_LIR_INSTR_KIND_NONE) {
-            dump_operand(ctx, &c->ret_vreg);
-            scc_tree_dump_append(td, " = ");
-        }
-        scc_tree_dump_append_fmt(td, "call @%s(",
-                                 c->callee ? c->callee : "<null>");
-        for (u8 i = 0; i < c->arg_count; i++) {
-            if (i > 0)
-                scc_tree_dump_append(td, ", ");
-            dump_operand(ctx, &c->args[i]);
-        }
-        scc_tree_dump_append_fmt(td, ") clobber=0x%llx",
-                                 (unsigned long long)c->clobber_mask);
-        break;
-    }
-
-    case SCC_LIR_CALL_INDIRECT: {
-        const struct scc_lir_call_indirect *c = &ins->metadata.call_indirect;
-        if (c->ret_vreg.kind != SCC_LIR_INSTR_KIND_NONE) {
-            dump_operand(ctx, &c->ret_vreg);
-            scc_tree_dump_append(td, " = ");
-        }
-        scc_tree_dump_append(td, "call ");
-        dump_operand(ctx, &c->target);
-        scc_tree_dump_append(td, "(");
-        for (u8 i = 0; i < c->arg_count; i++) {
-            if (i > 0)
-                scc_tree_dump_append(td, ", ");
-            dump_operand(ctx, &c->args[i]);
-        }
-        scc_tree_dump_append_fmt(td, ") clobber=0x%llx",
-                                 (unsigned long long)c->clobber_mask);
-        break;
-    }
-
-    case SCC_LIR_RET:
-        if (ins->metadata.ret_val.kind != SCC_LIR_INSTR_KIND_NONE) {
-            dump_operand(ctx, &ins->metadata.ret_val);
-        }
-        break;
-
-    case SCC_LIR_PARALLEL_COPY: {
-        const struct scc_lir_parallel_copy *pc = &ins->metadata.parallel_copy;
-        scc_tree_dump_append(td, "[");
-        for (u8 i = 0; i < pc->num_copies; i++) {
-            if (i > 0)
-                scc_tree_dump_append(td, ", ");
-            dump_operand(ctx, &pc->dests[i]);
-            scc_tree_dump_append(td, " <- ");
-            dump_operand(ctx, &pc->srcs[i]);
-        }
-        scc_tree_dump_append(td, "]");
-        break;
-    }
-
-    case SCC_LIR_VA_START:
-        dump_operand(ctx, &ins->metadata.va_start.ap);
-        scc_tree_dump_append(td, ", ");
-        dump_operand(ctx, &ins->metadata.va_start.last);
-        break;
-
-    case SCC_LIR_VA_ARG:
-        dump_operand(ctx, &ins->metadata.va_arg.to);
-        scc_tree_dump_append(td, " = va_arg ");
-        dump_operand(ctx, &ins->metadata.va_arg.ap);
-        scc_tree_dump_append_fmt(
-            td, ", size=%u, align=%u, float=%d", ins->metadata.va_arg.type_size,
-            ins->metadata.va_arg.type_align, ins->metadata.va_arg.is_float);
-        break;
-
-    case SCC_LIR_VA_END:
-        dump_operand(ctx, &ins->metadata.va_end.ap);
-        break;
-
-    case SCC_LIR_VA_COPY:
-        dump_operand(ctx, &ins->metadata.va_copy.dest);
-        scc_tree_dump_append(td, ", ");
-        dump_operand(ctx, &ins->metadata.va_copy.src);
-        break;
-
-    case SCC_LIR_NOP:
-        break;
-    }
-}
-
-void scc_lir_dump_bblock(scc_lir_dump_ctx_t *ctx, const scc_lir_bblock_t *bb) {
-    Assert(ctx != nullptr && bb != nullptr);
-    scc_tree_dump_t *td = ctx->dump_ctx;
-
-    // 基本块头部
-    scc_tree_dump_begin_line(td);
-    scc_tree_dump_node(td, "BB%zu", bb->id);
-    if (bb->label) {
-        scc_tree_dump_append_fmt(td, " (%s)", bb->label);
-    }
-    scc_tree_dump_append(td, ":");
-
-    // 输出每条指令
-    for (usize i = 0; i < scc_vec_size(bb->ins); ++i) {
-        const scc_lir_instr_t *ins = &scc_vec_at(bb->ins, i);
-        scc_lir_dump_ins(ctx, ins);
-    }
-}
-
-void scc_lir_dump_func(scc_lir_dump_ctx_t *ctx, const scc_lir_func_t *func) {
-    Assert(ctx != nullptr && func != nullptr);
-    scc_tree_dump_t *td = ctx->dump_ctx;
-
-    // 函数头部
-    scc_tree_dump_begin_line(td);
-    scc_tree_dump_node(td, "func @%s", func->name ? func->name : "<anon>");
-    scc_tree_dump_append_fmt(td, " (vregs: %u, frame: %d)", func->vregs_count,
-                             func->frame_size);
-    if (func->attr != SCC_LIR_ATTR_NONE) {
-        scc_tree_dump_append(td, " [attr:");
-        if (func->attr & SCC_LIR_ATTR_STATIC)
-            scc_tree_dump_append(td, " static");
-        if (func->attr & SCC_LIR_ATTR_WEAK)
-            scc_tree_dump_append(td, " weak");
-        scc_tree_dump_append(td, " ]");
-    }
-    scc_tree_dump_append(td, " {");
-
-    // 输出所有基本块
-    for (usize i = 0; i < scc_vec_size(func->bblocks); ++i) {
-        const scc_lir_bblock_t *bb = &scc_vec_at(func->bblocks, i);
-        scc_lir_dump_bblock(ctx, bb);
-    }
-
-    scc_tree_dump_begin_line(td);
-    scc_tree_dump_append(td, "}");
-}
-
-void scc_lir_dump_module(scc_lir_dump_ctx_t *ctx,
-                         const scc_lir_module_t *module) {
-    scc_vec_foreach(module->symbols, i) {
-        // FIXME 0 is null
-        if (i == 0)
-            continue;
-        scc_lir_symbol_t *sym = &scc_vec_at(module->symbols, i);
-        scc_tree_dump_begin_line(ctx->dump_ctx);
-        scc_tree_dump_node(ctx->dump_ctx, "symbol");
-        scc_tree_dump_append_fmt(ctx->dump_ctx, " %s", sym->name);
-    }
-    scc_vec_foreach(module->funcs, i) {
-        scc_lir_dump_func(ctx, scc_vec_at(module->funcs, i));
-    }
-}

libs/lir/src/scc_lir_module.c

@@ -1,172 +0,0 @@
-#include <scc_lir_module.h>
-
-static void scc_lir_func_drop(scc_lir_func_t *func) {
-    if (!func)
-        return;
-
-    /* 释放每个基本块内的指令向量 */
-    for (usize i = 0; i < scc_vec_size(func->bblocks); ++i) {
-        scc_lir_bblock_t *bb = &func->bblocks.data[i];
-        scc_vec_free(bb->ins);
-    }
-    scc_vec_free(func->bblocks);
-    scc_hashtable_drop(&func->bb_map);
-    scc_free(func);
-}
-
-static scc_lir_symbol_t *lookup_symbol(const scc_lir_module_t *module,
-                                       const char *name) {
-    if (!module || !name)
-        return nullptr;
-    /* 注意：scc_hashtable_get 返回的是 (void*) 存储的 usize 索引 */
-    void *idx_val =
-        scc_hashtable_get((scc_hashtable_t *)&module->symbol_map, (void *)name);
-    if (!idx_val)
-        return nullptr;
-    usize idx = (usize)idx_val;
-    if (idx >= scc_vec_size(module->symbols))
-        return nullptr;
-    return &module->symbols.data[idx];
-}
-
-void scc_lir_module_init(scc_lir_module_t *module) {
-    scc_vec_init(module->funcs);
-    scc_vec_init(module->symbols);
-    scc_hashtable_cstr_init(&module->symbol_map);
-
-    // /* 预留索引 0 作为无效 func_id */
-    // scc_vec_push(module->funcs, nullptr);
-    scc_vec_push(module->symbols, (scc_lir_symbol_t){0});
-}
-
-void scc_lir_module_drop(scc_lir_module_t *module) {
-    /* 释放所有函数对象 */
-    for (usize i = 0; i < scc_vec_size(module->funcs); ++i) {
-        scc_lir_func_drop(module->funcs.data[i]);
-    }
-    scc_vec_free(module->funcs);
-
-    /* 释放数据符号中动态分配的初始化数据 */
-    for (usize i = 0; i < scc_vec_size(module->symbols); ++i) {
-        scc_lir_symbol_t *sym = &module->symbols.data[i];
-        if ((sym->kind == SCC_LIR_SYMBOL_DATA) && sym->data.init_data) {
-            scc_free(sym->data.init_data);
-        }
-    }
-    scc_vec_free(module->symbols);
-
-    scc_hashtable_drop(&module->symbol_map);
-}
-
-static const scc_lir_symbol_t *register_symbol(scc_lir_module_t *module,
-                                               scc_lir_symbol_t *sym) {
-    /* 检查是否已存在同名符号 */
-    void *existing = scc_hashtable_get(&module->symbol_map, (void *)sym->name);
-    if (existing) {
-        LOG_ERROR("symbol '%s' already defined", sym->name);
-        return nullptr;
-    }
-
-    usize idx = scc_vec_size(module->symbols);
-    scc_vec_push(module->symbols, *sym);
-    scc_hashtable_set(&module->symbol_map, (void *)sym->name, (void *)idx);
-    return &scc_vec_at(module->symbols, idx);
-}
-
-const scc_lir_symbol_t *scc_lir_module_add_func_def(scc_lir_module_t *module,
-                                                    scc_lir_func_t *func) {
-    if (!module || !func || !func->name)
-        return nullptr;
-
-    scc_vec_push(module->funcs, func);
-
-    scc_lir_symbol_t *func_decl_sym = lookup_symbol(module, (void *)func->name);
-    if (func_decl_sym) {
-        if (func_decl_sym->kind != SCC_LIR_SYMBOL_FUNC ||
-            func_decl_sym->func.func != nullptr) {
-            Panic("Symbol already exists");
-        }
-        func_decl_sym->func.func = func;
-        return func_decl_sym;
-    }
-
-    /* 构建符号 */
-    scc_lir_symbol_t sym = {.name = func->name,
-                            .kind = SCC_LIR_SYMBOL_FUNC,
-                            .attr = func->attr,
-                            .func.func = func};
-
-    const scc_lir_symbol_t *result = register_symbol(module, &sym);
-    if (!result) {
-        /* 符号冲突：回滚函数添加并释放 func */
-        module->funcs.size--;
-        scc_lir_func_drop(func);
-        return nullptr;
-    }
-    return result;
-}
-
-const scc_lir_symbol_t *scc_lir_module_add_func_decl(scc_lir_module_t *module,
-                                                     const char *name,
-                                                     scc_lir_attr_t attr) {
-    if (!module || !name)
-        return nullptr;
-
-    scc_lir_symbol_t sym = {.name = name,
-                            .kind = SCC_LIR_SYMBOL_FUNC,
-                            .attr = attr,
-                            .func.func = nullptr};
-
-    return register_symbol(module, &sym);
-}
-
-const scc_lir_symbol_t *
-scc_lir_module_add_data(scc_lir_module_t *module, const char *name,
-                        scc_lir_symbol_kind_t kind, const u8 *init_data,
-                        usize size, u32 align, scc_lir_attr_t attr) {
-    if (!module || !name)
-        return nullptr;
-    if (kind != SCC_LIR_SYMBOL_DATA && kind != SCC_LIR_SYMBOL_EXTERN)
-        return nullptr;
-
-    scc_lir_symbol_t sym = {
-        .name = name,
-        .kind = kind,
-        .attr = attr,
-        .data = {.init_data = nullptr, .size = size, .align = align}};
-
-    /* 对于数据定义，复制初始化数据（若有） */
-    if (kind == SCC_LIR_SYMBOL_DATA && init_data && size > 0) {
-        sym.data.init_data = scc_malloc(size);
-        if (!sym.data.init_data) {
-            LOG_FATAL("out of memory for data symbol '%s'", name);
-        }
-        scc_memcpy(sym.data.init_data, init_data, size);
-    } else if (kind == SCC_LIR_SYMBOL_DATA && !init_data) {
-        /* 零初始化：分配并清零 */
-        sym.data.init_data = scc_calloc(1, size);
-        if (!sym.data.init_data) {
-            LOG_FATAL("out of memory for data symbol '%s'", name);
-        }
-    }
-
-    const scc_lir_symbol_t *result = register_symbol(module, &sym);
-    if (!result) {
-        /* 冲突时释放已分配的数据 */
-        scc_free(sym.data.init_data);
-        return nullptr;
-    }
-    return result;
-}
-
-const scc_lir_symbol_t *
-scc_lir_module_lookup_symbol(const scc_lir_module_t *module, const char *name) {
-    return lookup_symbol(module, name);
-}
-
-scc_lir_func_t *scc_lir_module_get_func(const scc_lir_module_t *module,
-                                        unsigned func_id) {
-    if (!module || func_id == 0 || func_id >= scc_vec_size(module->funcs))
-        return nullptr;
-    return module->funcs.data[func_id];
-}