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

refactor(ast2ir): 提取模块访问函数并优化类型大小计算

Browse Source 
- 添加 scc_ast2ir_mir_module 内联函数统一访问模块
- 替换所有直接访问 ctx->builder.cprog->module 的地方
- 移除重复的 scc_hir_type_size 函数实现
- 添加 scc_hir_module_type_size 函数到模块接口
- 更新所有类型大小计算调用使用新函数

feat(hir): 增强构建器安全性和全局变量处理

- 为 scc_hir_builder_integer 添加空指针检查断言
- 修复 scc_hir_builder_global_alloca 中全局变量类型设置
- 改进 scc_hir_builder_get_elem_ptr 处理空指针索引情况
- 重构字符串常量生成使用 get_elem_ptr 构建器函数

refactor(lir): 简化地址表达式表示并增强内置函数支持

- 移除复杂地址结构体 scc_lir_addr_t
- 简化 scc_lir_instr 结构体中的地址表示
- 移除 STORE_ADDR 操作码
- 添加 memcpy 和 memset 内置函数操作码
- 在符号元数据中使用联合体替代嵌套结构体

feat(hir2lir): 完善 HIR 到 LIR 转换中的内置函数处理

- 添加 ensure_vreg 辅助函数确保虚拟寄存器操作数
- 正确处理全局变量地址符号引用
- 优化 GET_ELEM_PTR 转换使用类型大小计算
- 完整实现所有内置函数(BUILTIN)的 LIR 转换
- 包括 memcpy、memset、va_start、va_arg、va_end、va_copy 等
This commit is contained in:
zzy
2026-05-22 15:15:18 +08:00
parent 41d060d7e7
commit d78b91894e
27 changed files with 1272 additions and 563 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
libs/ir/lir/include/scc_lir.h
View File

@@ -41,26 +41,14 @@ typedef enum {
SCC_LIR_INSTR_KIND_MEM, // 复杂地址表达式 (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 {
int arg;
int reg; // VREG 或 PREG 索引
scc_ap_t imm; // 整型立即数
f64 fimm; // 浮点立即数
const char *symbol; // 符号名 (生命周期由前端管理)
scc_lir_addr_t addr; // 复杂地址
int reg; // VREG 或 PREG 索引
scc_ap_t imm; // 整型立即数
f64 fimm; // 浮点立即数
const char *symbol; // 符号名 (生命周期由前端管理)
} data;
} scc_lir_val_t;
@@ -74,8 +62,6 @@ typedef struct scc_lir_instr {
((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_MEM, .data.addr = {b, i, s, o}})
#define SCC_LIR_ARG(n) \
((scc_lir_val_t){.kind = SCC_LIR_INSTR_KIND_ARG, .data.arg = (n)})
@@ -97,7 +83,6 @@ typedef enum {
SCC_LIR_LOAD,
SCC_LIR_LOAD_ADDR,
SCC_LIR_STORE,
SCC_LIR_STORE_ADDR,
/* 整数算术 */
SCC_LIR_ADD,
@@ -143,6 +128,9 @@ typedef enum {
SCC_LIR_VA_ARG,
SCC_LIR_VA_END,
SCC_LIR_VA_COPY,
/* 内置方法 */
SCC_LIR_MEMCPY,
SCC_LIR_MEMSET,
/* 栈管理 */
SCC_LIR_ALLOCA,
@@ -183,6 +171,12 @@ typedef struct scc_lir_ins {
union {
scc_lir_cond_t cond;
// base + index * scale + offset
struct scc_lir_addr {
int scale; // 比例因子 (1, 2, 4, 8)
i64 offset; // 常量偏移
} addr;
struct scc_lir_br {
scc_lir_bblock_id_t true_target;
scc_lir_bblock_id_t false_target;
@@ -240,6 +234,18 @@ typedef struct scc_lir_ins {
scc_lir_val_t dest;
scc_lir_val_t src;
} va_copy;
struct {
scc_lir_val_t dest;
scc_lir_val_t src;
scc_lir_val_t size;
} memcpy;
struct {
scc_lir_val_t dest;
scc_lir_val_t value;
scc_lir_val_t size;
} memset;
} metadata;
} scc_lir_instr_t;
@@ -259,17 +265,15 @@ typedef struct scc_lir_func_meta {
typedef scc_cfg_symbol_id_t scc_lir_symbol_id_t;
typedef scc_cfg_symbol_t scc_lir_symbol_t;
typedef struct scc_lir_symbol_meta {
union {
struct {
scc_lir_func_t *func; // 指向函数体（若为定义）
} func;
struct {
u8 *init_data; // 初始化数据（若为 NULL 则零初始化）
usize size; // 数据大小（字节）
int align; // 对齐要求
} data;
};
typedef union scc_lir_symbol_meta {
struct {
scc_lir_func_t *func; // 指向函数体（若为定义）
} func;
struct {
u8 *init_data; // 初始化数据（若为 NULL 则零初始化）
usize size; // 数据大小（字节）
int align; // 对齐要求
} data;
} scc_lir_symbol_meta_t;
#define SCC_LIR_SYMBOL_META(symbol) ((scc_lir_symbol_meta_t *)(symbol)->meta)

196
libs/ir/lir/src/scc_hir2lir.c
View File

@@ -79,6 +79,7 @@ static void ir_type_to_lir_size_ext(scc_hir_type_t *type, u8 *out_size,
*out_size = SCC_LIR_SIZE_64;
*out_ext = SCC_LIR_EXT_FLOAT;
break;
case SCC_HIR_TYPE_ARRAY:
case SCC_HIR_TYPE_PTR:
*out_size = SCC_LIR_SIZE_64;
*out_ext = SCC_LIR_EXT_NONE;
@@ -126,9 +127,7 @@ static scc_lir_val_t ir_value_to_lir_operand(ir2lir_ctx_t *ctx,
}
case SCC_HIR_VALUE_TAG_GLOBAL_ALLOC: {
// 全局变量地址作为符号
scc_hir_value_t *global_val = scc_hir_module_get_value(
ctx->hir_module, val->data.global_alloc.value);
return SCC_LIR_SYMBOL(global_val->name);
return SCC_LIR_SYMBOL(val->name);
}
case SCC_HIR_VALUE_TAG_FUNC_ARG_REF: {
// 函数参数：预先已分配 vreg
@@ -240,6 +239,24 @@ static scc_lir_op_t map_binop(scc_hir_op_type_t op, cbool is_float) {
return SCC_LIR_NOP;
}
// 确保操作数是一个虚拟寄存器，如果不是则生成 MOV 并返回新 VREG 编号
static int ensure_vreg(ir2lir_ctx_t *ctx, scc_lir_val_t *val) {
if (val->kind == SCC_LIR_INSTR_KIND_VREG) {
return val->data.reg;
}
// 分配新的虚拟寄存器
int new_vreg = ++(SCC_LIR_FUNC_META(ctx->current_func)->vregs_count);
scc_lir_instr_t mov = {.op = SCC_LIR_MOV,
.size = SCC_LIR_SIZE_64, // 地址宽度
.to = SCC_LIR_VREG(new_vreg),
.arg0 = *val};
scc_lir_builder_add_instr(ctx, &mov);
// 将原操作数替换为 VREG，避免重复转换
val->kind = SCC_LIR_INSTR_KIND_VREG;
val->data.reg = new_vreg;
return new_vreg;
}
static void translate_hir_value(ir2lir_ctx_t *ctx, scc_hir_value_t *value,
scc_hir_value_ref_t value_ref) {
// 防止重复翻译
@@ -254,8 +271,7 @@ static void translate_hir_value(ir2lir_ctx_t *ctx, scc_hir_value_t *value,
}
bool is_float = (ext == SCC_LIR_EXT_FLOAT);
// 为当前指令分配目标虚拟寄存器
unsigned int dst_vreg = get_vreg_for_value(ctx, value_ref);
int dst_vreg = get_vreg_for_value(ctx, value_ref);
switch (value->tag) {
case SCC_HIR_VALUE_TAG_OP: {
@@ -291,70 +307,60 @@ static void translate_hir_value(ir2lir_ctx_t *ctx, scc_hir_value_t *value,
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};
ty = scc_hir_module_get_type_by_value(ctx->hir_module,
value->data.store.value);
ir_type_to_lir_size_ext(ty, &size, &ext);
scc_lir_instr_t instr = {.op = SCC_LIR_STORE,
.ext = ext,
.size = size,
.arg0 = data,
.arg1 = addr};
scc_lir_builder_add_instr(ctx, &instr);
} break;
case SCC_HIR_VALUE_TAG_GET_ELEM_PTR: {
// 将指针运算转换为 LEA
// 1. 获取基址和索引的 LIR 操作数
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)
scc_lir_val_t index =
ir_value_to_lir_operand(ctx, value->data.get_elem_ptr.index);
// 计算元素大小
scc_hir_type_t *ptr_ty = scc_hir_module_get_type_by_value(
ctx->hir_module, value->data.get_elem_ptr.src_addr);
scc_hir_type_t *elem_ty = nullptr;
if (ptr_ty->tag == SCC_HIR_TYPE_PTR) {
elem_ty = scc_hir_module_get_type(ctx->hir_module,
ptr_ty->data.pointer.base);
} else if (ptr_ty->tag == SCC_HIR_TYPE_ARRAY) {
elem_ty = scc_hir_module_get_type(ctx->hir_module,
ptr_ty->data.array.base);
// 2. 获取元素类型和大小
scc_hir_type_t *ptr_type =
scc_hir_module_get_type(ctx->hir_module, value->type);
scc_hir_type_t *pointee = NULL;
if (ptr_type->tag == SCC_HIR_TYPE_PTR) {
pointee = scc_hir_module_get_type(ctx->hir_module,
ptr_type->data.pointer.base);
} else if (ptr_type->tag == SCC_HIR_TYPE_ARRAY) {
// 数组名退化为指针，元素类型为数组的元素类型
pointee = scc_hir_module_get_type(ctx->hir_module,
ptr_type->data.array.base);
} else {
Panic("GET_ELEM_PTR on non-pointer/array type");
}
Assert(elem_ty != nullptr);
int elem_size = 0;
// 简化：仅处理基本类型
if (elem_ty->tag == SCC_HIR_TYPE_i32 ||
elem_ty->tag == SCC_HIR_TYPE_u32)
elem_size = 4;
else if (elem_ty->tag == SCC_HIR_TYPE_i64 ||
elem_ty->tag == SCC_HIR_TYPE_u64)
elem_size = 8;
else if (elem_ty->tag == SCC_HIR_TYPE_i8 ||
elem_ty->tag == SCC_HIR_TYPE_u8)
elem_size = 1;
else if (elem_ty->tag == SCC_HIR_TYPE_ARRAY)
elem_size = 8; // FIXME ptr size
else
Panic("unsupported element type for getelemptr");
int elem_size = scc_hir_module_type_size(ctx->hir_module, pointee);
// 构造地址表达式：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_LOAD_ADDR,
.size = SCC_LIR_SIZE_64,
.to = SCC_LIR_VREG(dst_vreg),
.arg0 = base,
.arg1 = index};
// 实际需要将 index * elem_size 的信息编码，这里简化，假设后端处理
int dst_vreg = get_vreg_for_value(ctx, value_ref);
scc_lir_instr_t instr = {
.op = SCC_LIR_LOAD_ADDR,
.size = SCC_LIR_SIZE_64,
.to = SCC_LIR_VREG(dst_vreg),
.arg0 = base,
.arg1 = index,
.metadata.addr.scale = elem_size,
.metadata.addr.offset = 0,
};
scc_lir_builder_add_instr(ctx, &instr);
} break;
case SCC_HIR_VALUE_TAG_ALLOC: {
// alloca 指令：分配栈空间
Assert(ty != nullptr);
scc_hir_type_t *alloc_ty =
scc_hir_module_get_type(ctx->hir_module, ty->data.pointer.base);
// 计算大小和对齐（简化）
int alloc_size = 8; // 默认
if (alloc_ty->tag == SCC_HIR_TYPE_i32)
alloc_size = 4;
int alloc_size = scc_hir_module_type_size(ctx->hir_module, alloc_ty);
scc_lir_instr_t instr = {.op = SCC_LIR_ALLOCA,
.size = SCC_LIR_SIZE_64,
.size = alloc_size,
.to = SCC_LIR_VREG(dst_vreg),
.metadata.alloca = {alloc_size, alloc_size}};
.metadata.alloca = {alloc_size, 1}};
scc_lir_builder_add_instr(ctx, &instr);
} break;
case SCC_HIR_VALUE_TAG_CALL: {
@@ -426,8 +432,90 @@ static void translate_hir_value(ir2lir_ctx_t *ctx, scc_hir_value_t *value,
.arg0 = src};
scc_lir_builder_add_instr(ctx, &instr);
} break;
case SCC_HIR_VALUE_TAG_BUILTIN: {
scc_hir_builtin_t *b = &value->data.builtin;
switch (b->tag) {
case SCC_HIR_BUILTIN_TAG_MEMCPY: {
scc_lir_val_t dest =
ir_value_to_lir_operand(ctx, b->func.memcpy.dest);
scc_lir_val_t src =
ir_value_to_lir_operand(ctx, b->func.memcpy.src);
scc_lir_val_t len =
ir_value_to_lir_operand(ctx, b->func.memcpy.size);
scc_lir_instr_t instr = {.op = SCC_LIR_MEMCPY,
.metadata.memcpy = {dest, src, len}};
scc_lir_builder_add_instr(ctx, &instr);
break;
}
case SCC_HIR_BUILTIN_TAG_MEMSET: {
scc_lir_val_t dest =
ir_value_to_lir_operand(ctx, b->func.memset.dest);
scc_lir_val_t val =
ir_value_to_lir_operand(ctx, b->func.memset.value);
scc_lir_val_t len =
ir_value_to_lir_operand(ctx, b->func.memset.size);
scc_lir_instr_t instr = {.op = SCC_LIR_MEMSET,
.metadata.memset = {dest, val, len}};
scc_lir_builder_add_instr(ctx, &instr);
break;
}
case SCC_HIR_BUILTIN_TAG_VA_START: {
scc_lir_val_t ap =
ir_value_to_lir_operand(ctx, b->func.va_start.ap);
scc_lir_val_t last =
ir_value_to_lir_operand(ctx, b->func.va_start.last);
scc_lir_instr_t instr = {.op = SCC_LIR_VA_START,
.metadata.va_start = {ap, last}};
scc_lir_builder_add_instr(ctx, &instr);
break;
}
case SCC_HIR_BUILTIN_TAG_VA_ARG: {
// 需要从类型中获取大小和对齐以及是否为浮点
scc_hir_type_t *ty =
scc_hir_module_get_type(ctx->hir_module, b->func.va_arg.type);
u8 size = 0;
scc_lir_ext_t ext = SCC_LIR_EXT_NONE;
ir_type_to_lir_size_ext(ty, &size, &ext);
bool is_float = (ext == SCC_LIR_EXT_FLOAT);
scc_lir_val_t ap = ir_value_to_lir_operand(ctx, b->func.va_arg.ap);
scc_lir_instr_t instr = {
.op = SCC_LIR_VA_ARG,
.to = SCC_LIR_VREG(dst_vreg),
.metadata.va_arg = {.ap = ap,
.type_size = size,
.type_align =
size, // 简化，实际应查询 ABI 对齐
.is_float = is_float,
.to = SCC_LIR_VREG(dst_vreg)}};
scc_lir_builder_add_instr(ctx, &instr);
break;
}
case SCC_HIR_BUILTIN_TAG_VA_END: {
scc_lir_val_t ap = ir_value_to_lir_operand(ctx, b->func.va_end.ap);
scc_lir_instr_t instr = {.op = SCC_LIR_VA_END,
.metadata.va_end = {ap}};
scc_lir_builder_add_instr(ctx, &instr);
break;
}
case SCC_HIR_BUILTIN_TAG_VA_COPY: {
scc_lir_val_t dest =
ir_value_to_lir_operand(ctx, b->func.va_copy.dest);
scc_lir_val_t src =
ir_value_to_lir_operand(ctx, b->func.va_copy.src);
scc_lir_instr_t instr = {.op = SCC_LIR_VA_COPY,
.metadata.va_copy = {dest, src}};
scc_lir_builder_add_instr(ctx, &instr);
break;
}
default:
TODO();
}
} break;
case SCC_HIR_VALUE_TAG_FUNC_ARG_REF:
case SCC_HIR_VALUE_TAG_BLOCK_ARG_REF:
break;
default:
// 不生成指令的节点（如 CONST_INT, FUNC_ARG_REF）不会调用本函数
Panic("unsupported opcode %d", value->tag);
break;
}
}

101
libs/ir/lir/src/scc_lir_dump.c
View File

@@ -16,8 +16,8 @@ static const char *op_to_string(scc_lir_op_t op) {
return "load.addr";
case SCC_LIR_STORE:
return "store";
case SCC_LIR_STORE_ADDR:
return "store.addr";
// case SCC_LIR_STORE_ADDR:
// return "store.addr";
case SCC_LIR_ADD:
return "add";
case SCC_LIR_SUB:
@@ -86,6 +86,11 @@ static const char *op_to_string(scc_lir_op_t op) {
return "va_copy";
case SCC_LIR_ALLOCA:
return "alloca";
case SCC_LIR_MEMCPY:
return "memcpy";
case SCC_LIR_MEMSET:
return "memset";
case SCC_LIR_NOP:
return "nop";
default:
@@ -160,29 +165,6 @@ static void dump_operand(scc_lir_dump_ctx_t *ctx, const scc_lir_val_t *op) {
scc_tree_dump_append_fmt(td, "@%s",
op->data.symbol ? op->data.symbol : "<null>");
break;
case SCC_LIR_INSTR_KIND_MEM: {
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, "<?>");
}
@@ -199,6 +181,8 @@ static void dump_size_ext(scc_lir_dump_ctx_t *ctx, u8 size, scc_lir_ext_t ext) {
size_str = "32";
else if (size == SCC_LIR_SIZE_64)
size_str = "64";
else
size_str = "sz(?)";
const char *ext_str = "";
if (ext == SCC_LIR_EXT_SEXT)
@@ -229,31 +213,40 @@ void scc_lir_dump_ins(scc_lir_dump_ctx_t *ctx, const scc_lir_instr_t *ins) {
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_LOAD_ADDR:
// base + index * scale + offset
dump_operand(ctx, &ins->to);
scc_tree_dump_append(td, " <- (");
dump_operand(ctx, &ins->arg0); // base
scc_tree_dump_append(td, " + ");
dump_operand(ctx, &ins->arg1); // index
scc_tree_dump_append_fmt(td, " * %d + %lld)", ins->metadata.addr.scale,
ins->metadata.addr.offset);
break;
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
}
scc_tree_dump_append(td, ", ");
dump_operand(ctx, &ins->arg0);
break;
case SCC_LIR_ALLOCA:
scc_tree_dump_append_fmt(td, "(sz=%zd,al=%zd) => ",
ins->metadata.alloca.size_bytes,
ins->metadata.alloca.align_bytes);
dump_operand(ctx, &ins->to);
break;
// case SCC_LIR_STORE_ADDR:
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:
@@ -277,7 +270,6 @@ void scc_lir_dump_ins(scc_lir_dump_ctx_t *ctx, const scc_lir_instr_t *ins) {
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, ",
@@ -286,22 +278,18 @@ void scc_lir_dump_ins(scc_lir_dump_ctx_t *ctx, const scc_lir_instr_t *ins) {
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%d", 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) {
@@ -317,9 +305,7 @@ void scc_lir_dump_ins(scc_lir_dump_ctx_t *ctx, const scc_lir_instr_t *ins) {
}
scc_tree_dump_append_fmt(td, ") clobber=0x%llx",
(unsigned long long)c->clobber_mask);
break;
}
} 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) {
@@ -336,15 +322,12 @@ void scc_lir_dump_ins(scc_lir_dump_ctx_t *ctx, const scc_lir_instr_t *ins) {
}
scc_tree_dump_append_fmt(td, ") clobber=0x%llx",
(unsigned long long)c->clobber_mask);
break;
}
} 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, "[");
@@ -358,13 +341,11 @@ void scc_lir_dump_ins(scc_lir_dump_ctx_t *ctx, const scc_lir_instr_t *ins) {
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 ");
@@ -373,17 +354,28 @@ void scc_lir_dump_ins(scc_lir_dump_ctx_t *ctx, const scc_lir_instr_t *ins) {
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_MEMCPY:
dump_operand(ctx, &ins->metadata.memcpy.dest);
scc_tree_dump_append(td, ", ");
dump_operand(ctx, &ins->metadata.memcpy.src);
scc_tree_dump_append(td, ", ");
dump_operand(ctx, &ins->metadata.memcpy.size);
break;
case SCC_LIR_MEMSET:
dump_operand(ctx, &ins->metadata.memset.dest);
scc_tree_dump_append(td, ", ");
dump_operand(ctx, &ins->metadata.memset.value);
scc_tree_dump_append(td, ", ");
dump_operand(ctx, &ins->metadata.memset.size);
break;
case SCC_LIR_NOP:
break;
}
@@ -451,7 +443,12 @@ void scc_lir_dump_module(scc_lir_dump_ctx_t *ctx) {
&scc_vec_at(ctx->lir_module->cfg_module.symbols, i);
scc_tree_dump_begin_line(ctx->dump_ctx);
scc_tree_dump_node(ctx->dump_ctx, "symbol");
scc_lir_symbol_meta_t *meta = SCC_LIR_SYMBOL_META(sym);
scc_tree_dump_append_fmt(ctx->dump_ctx, " %s", sym->name);
if (sym->kind == SCC_CFG_SYMBOL_KIND_DATA) {
scc_tree_dump_append_fmt(ctx->dump_ctx, "(size=%zu)",
meta->data.size);
}
}
scc_vec_foreach(ctx->lir_module->cfg_module.funcs, i) {
if (i == 0)