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

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

Browse Source 
- 统一包名格式化，添加空格对齐
- 将依赖项从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
- 重新排列头文件包含顺序以满足依赖关系
This commit is contained in:
zzy
2026-04-21 14:05:21 +08:00
parent e5bbffe170
commit 0fbfb36262
49 changed files with 2555 additions and 3989 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
libs/ir/hir/cbuild.toml Normal file
View File

@@ -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 = []

281
libs/ir/hir/include/hir_builder.h Normal file
View File

@@ -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__ */

255
libs/ir/hir/include/hir_def.h Normal file
View File

@@ -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__ */

21
libs/ir/hir/include/hir_dump.h Normal file
View File

@@ -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__ */

50
libs/ir/hir/include/hir_module.h Normal file
View File

@@ -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__ */

17
libs/ir/hir/include/hir_prog.h Normal file
View File

@@ -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__ */

14
libs/ir/hir/include/scc_hir.h Normal file
View File

@@ -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__ */

691
libs/ir/hir/src/hir_builder.c Normal file
View File

@@ -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;
}

707
libs/ir/hir/src/hir_dump.c Normal file
View File

@@ -0,0 +1,707 @@
#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_hir_value_tag_t tag) {
static const char *node_types[] = {
[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])
return node_types[tag];
return "UnknownIRNode";
}
static const char *get_op_str(scc_hir_op_type_t op) {
static const char *ops[] = {
[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_hir_type_tag_t tag) {
static const char *type_tags[] = {
[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])
return type_tags[tag];
return "<unknown_type>";
}
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_hir_dump_value(ctx, child);
scc_tree_dump_pop(ctx->dump_ctx);
}
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);
// 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_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: ");
scc_tree_dump_value(ctx->dump_ctx, "%s", get_op_str(value->data.op.op));
scc_tree_dump_pop(ctx->dump_ctx);
if (value->data.op.lhs)
dump_child_node_ref(ctx, value->data.op.lhs,
value->data.op.rhs ? false : true);
if (value->data.op.rhs)
dump_child_node_ref(ctx, value->data.op.rhs, true);
}
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_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_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_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_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->name ? true_bblock->name
: "<unnamed>");
}
}
if (value->data.branch.false_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->name ? false_bblock->name
: "<unnamed>");
}
}
}
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_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->name ? target->name : "<unnamed>");
else
scc_tree_dump_value(ctx->dump_ctx, "to invalid block");
} else {
scc_tree_dump_value(ctx->dump_ctx, "to nullptr");
}
}
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_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>");
} else {
scc_tree_dump_value(ctx->dump_ctx, "func=nullptr");
}
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_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_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_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_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;
}
scc_tree_dump_begin_line(ctx->dump_ctx);
scc_tree_dump_node(ctx->dump_ctx, "%s", get_node_type_str(value->tag));
if (value->name && value->name[0])
scc_tree_dump_value(ctx->dump_ctx, " [%s]", value->name);
if (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",
get_type_tag_str(type->tag));
}
}
switch (value->tag) {
case SCC_HIR_VALUE_TAG_INTEGER:
dump_integer_node(ctx, value);
break;
case SCC_HIR_VALUE_TAG_ALLOC:
break;
case SCC_HIR_VALUE_TAG_LOAD:
dump_load_node(ctx, value);
break;
case SCC_HIR_VALUE_TAG_STORE:
dump_store_node(ctx, value);
break;
case SCC_HIR_VALUE_TAG_GET_ELEM_PTR:
dump_get_elem_ptr_node(ctx, value);
break;
case SCC_HIR_VALUE_TAG_OP:
dump_op_node(ctx, value);
break;
case SCC_HIR_VALUE_TAG_BRANCH:
dump_branch_node(ctx, value);
break;
case SCC_HIR_VALUE_TAG_JUMP:
dump_jump_node(ctx, value);
break;
case SCC_HIR_VALUE_TAG_CALL:
dump_call_node(ctx, value);
break;
case SCC_HIR_VALUE_TAG_RET:
dump_ret_node(ctx, value);
break;
default:
scc_tree_dump_value(ctx->dump_ctx, "unknown");
scc_tree_dump_append_fmt(ctx->dump_ctx, " tag(%d)", value->tag);
break;
}
}
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_hir_type_t *type = scc_hir_module_get_type(GET_MODULE(ctx), type_ref);
if (!type) {
LOG_ERROR("invalid type ref");
return;
}
scc_tree_dump_begin_line(ctx->dump_ctx);
scc_tree_dump_node(ctx->dump_ctx, "Type: ");
scc_tree_dump_value(ctx->dump_ctx, "%s", get_type_tag_str(type->tag));
switch (type->tag) {
case SCC_HIR_TYPE_PTR:
if (type->data.pointer.base) {
scc_tree_dump_push(ctx->dump_ctx, true);
scc_hir_dump_type(ctx, type->data.pointer.base);
scc_tree_dump_pop(ctx->dump_ctx);
}
break;
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: ");
scc_tree_dump_value(ctx->dump_ctx, "%zu", type->data.array.len);
scc_tree_dump_append(ctx->dump_ctx, "\n");
}
if (type->data.array.base) {
scc_tree_dump_push(ctx->dump_ctx, true);
scc_hir_dump_type(ctx, type->data.array.base);
scc_tree_dump_pop(ctx->dump_ctx);
}
break;
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_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_hir_dump_type(ctx, type->data.function.ret_type);
scc_tree_dump_pop(ctx->dump_ctx);
}
break;
default:
break;
}
}
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_hir_bblock_t *bblock =
scc_hir_module_get_bblock(GET_MODULE(ctx), bblock_ref);
if (!bblock) {
LOG_ERROR("invalid bblock ref");
return;
}
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->name ? bblock->name : "<unnamed>");
scc_tree_dump_append(ctx->dump_ctx, "\n");
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_hir_dump_value(ctx, scc_vec_at(SCC_HIR_BBLOCK_VALUES(*bblock), i));
scc_tree_dump_pop(ctx->dump_ctx);
}
}
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;
}
scc_tree_dump_begin_line(ctx->dump_ctx);
scc_tree_dump_node(ctx->dump_ctx, "Function: ");
scc_tree_dump_value(ctx->dump_ctx, "'%s'",
func->name ? func->name : "<unnamed>");
scc_tree_dump_append(ctx->dump_ctx, "\n");
if (SCC_HIR_FUNC_META(*func)->type) {
scc_tree_dump_push(ctx->dump_ctx, false);
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(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_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_hir_dump_bblock(ctx, scc_vec_at(func->bblocks, i));
scc_tree_dump_pop(ctx->dump_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_hir_dump_func(ctx, scc_vec_at(ctx->cprog->func_defs, i));
scc_tree_dump_pop(ctx->dump_ctx);
}
}
// ----- 线性输出（保留原逻辑，改用新 API）-----
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_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_HIR_TYPE_ARRAY:
scc_tree_dump_append(ctx->dump_ctx, "[");
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_HIR_TYPE_PTR:
scc_tree_dump_append(ctx->dump_ctx, "*");
scc_hir_dump_type_linear(ctx, type->data.pointer.base);
break;
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_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_hir_dump_type_linear(ctx, type->data.function.ret_type);
} else {
scc_tree_dump_append(ctx->dump_ctx, ")");
}
break;
default:
LOG_ERROR("invalid type tag");
break;
}
}
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;
}
// 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_HIR_REF_nullptr) {
scc_tree_dump_append(ctx->dump_ctx, ":");
scc_hir_dump_type_linear(ctx, value->type);
}
}
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_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);
scc_tree_dump_append(ctx->dump_ctx, " = ");
}
switch (value->tag) {
case SCC_HIR_VALUE_TAG_BUILTIN: {
scc_tree_dump_append(ctx->dump_ctx, "@scc::");
switch (value->data.builtin.tag) {
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);
scc_tree_dump_append(ctx->dump_ctx, ", ");
format_ref_or_value(ctx, value->data.builtin.func.memcpy.src);
scc_tree_dump_append(ctx->dump_ctx, ", ");
format_ref_or_value(ctx, value->data.builtin.func.memcpy.size);
scc_tree_dump_append(ctx->dump_ctx, ")");
break;
case SCC_HIR_BUILTIN_TAG_MEMSET:
scc_tree_dump_append(ctx->dump_ctx, "memset");
break;
case SCC_HIR_BUILTIN_TAG_VA_ARG:
scc_tree_dump_append(ctx->dump_ctx, "va_arg");
break;
case SCC_HIR_BUILTIN_TAG_VA_END:
scc_tree_dump_append(ctx->dump_ctx, "va_end");
break;
case SCC_HIR_BUILTIN_TAG_VA_COPY:
scc_tree_dump_append(ctx->dump_ctx, "va_copy");
break;
case SCC_HIR_BUILTIN_TAG_VA_START:
scc_tree_dump_append(ctx->dump_ctx, "va_start");
break;
default:
Panic("Unknown builtin tag");
break;
}
break;
}
case SCC_HIR_VALUE_TAG_INTEGER:
// 值已经在 format 中输出，这里不需要再做
break;
case SCC_HIR_VALUE_TAG_AGGREGATE:
// 聚合类型：递归输出每个元素（每个占一行）
scc_vec_foreach(value->data.aggregate.fields, i) {
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_HIR_VALUE_TAG_ALLOC:
scc_tree_dump_append(ctx->dump_ctx, "alloc");
break;
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_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_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_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_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);
scc_tree_dump_append_fmt(ctx->dump_ctx,
", label %%L%u, label %%L%u",
value->data.branch.true_bblock,
value->data.branch.false_bblock);
} else {
scc_tree_dump_append_fmt(ctx->dump_ctx, "br label %%L%u",
value->data.branch.true_bblock);
}
break;
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_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>");
for (usize i = 0; i < scc_vec_size(value->data.call.args); i++) {
if (i > 0)
scc_tree_dump_append(ctx->dump_ctx, ", ");
format_ref_or_value(ctx, scc_vec_at(value->data.call.args, i));
}
scc_tree_dump_append(ctx->dump_ctx, ")");
break;
}
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);
} else {
scc_tree_dump_append(ctx->dump_ctx, "ret void");
}
break;
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_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_hir_dump_value_linear(ctx, value->data.global_alloc.value);
return;
case SCC_HIR_VALUE_TAG_ARRAY:
scc_tree_dump_append(ctx->dump_ctx, "const_array ");
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);
scc_tree_dump_append_fmt(ctx->dump_ctx, " `%c`, ", ch ? ch : ' ');
}
scc_tree_dump_append(ctx->dump_ctx, " ]");
break;
default:
scc_tree_dump_append_fmt(ctx->dump_ctx, "<%s value %u>",
get_node_type_str(value->tag), value_ref);
break;
}
}
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_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->name && bblock->name[0] != '\0')
scc_tree_dump_append_fmt(ctx->dump_ctx, "%%L%d %s:", bblock_ref,
bblock->name);
else
scc_tree_dump_append_fmt(ctx->dump_ctx, "%%L%d <unnamed>:", bblock_ref);
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_hir_dump_value_linear(
ctx, scc_vec_at(SCC_HIR_BBLOCK_VALUES(*bblock), i));
}
}
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>");
return;
}
scc_tree_dump_append_fmt(ctx->dump_ctx, "func @%s",
(func->name && func->name[0]) ? func->name
: "<unnamed>");
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(SCC_HIR_FUNC_META(*func)->params);
i++) {
if (i > 0)
scc_tree_dump_append(ctx->dump_ctx, ", ");
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,
param_node->name);
else
scc_tree_dump_append_fmt(ctx->dump_ctx, "%u", param_ref);
}
scc_tree_dump_append(ctx->dump_ctx, ")");
} else {
scc_tree_dump_append(ctx->dump_ctx, "()");
}
scc_tree_dump_append(ctx->dump_ctx, ": ");
scc_hir_dump_type_linear(ctx, SCC_HIR_FUNC_META(*func)->type);
if (is_decl) {
scc_tree_dump_append(ctx->dump_ctx, ";");
return;
}
scc_tree_dump_append(ctx->dump_ctx, " {");
for (usize i = 0; i < scc_vec_size(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_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_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_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_hir_dump_func_linear(ctx, func_decl, 1);
}
for (usize i = 0; i < scc_vec_size(ctx->cprog->func_defs); i++) {
scc_hir_dump_func_linear(ctx, scc_vec_at(ctx->cprog->func_defs, i), 0);
}
}

128
libs/ir/hir/src/hir_module.c Normal file
View File

@@ -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);
}

15
libs/ir/hir/src/hir_prog.c Normal file
View File

@@ -0,0 +1,15 @@
#include <hir_prog.h>
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_hir_module_init(&in->module);
}
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_hir_module_drop(&in->module);
}

117
libs/ir/hir/src/scc_hir.c Normal file
View File

@@ -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;
}
}

10
libs/ir/hir/tests/test_ir_unit.c Normal file
View File

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