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

- 添加 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 等

libs/ir2mcode/src/scc_ir2mcode.c

@@ -8,6 +8,20 @@
 #include <x86/scc_x86_patch.h>
 #include <x86/scc_x86_reg.h>
 
+scc_x86_reg_t mir_x86_trans_gpr(scc_x86_reg_t reg, u8 size) {
+    size *= 8;
+    if (size == 0) {
+        return reg;
+    }
+    for (scc_x86_reg_t i = 0; i < SCC_X86_REG_COUNT; i += 1) {
+        if (scc_x86_reg_table[i].max_enclosing == reg &&
+            scc_x86_reg_table[i].width == size) {
+            return i;
+        }
+    }
+    return reg;
+}
+
 void mir_x86_to_mcode(scc_mcode_t *mcode, scc_reloc_vec_t *relocs,
                       const scc_mir_x86_instr_t *_ins) {
     Assert(mcode != nullptr && _ins != nullptr);
@@ -24,15 +38,21 @@ void mir_x86_to_mcode(scc_mcode_t *mcode, scc_reloc_vec_t *relocs,
             Panic("can't convert vreg to mcode");
         if (scc_x86_op_is_slot(op_ptr))
             Panic("can't convert unresolved slot to mcode");
-        ops[i] = *op_ptr;
         if (op_ptr->kind == SCC_X86_OPR_RELOC) {
             ops[i].kind = op_ptr->reloc.kind;
             switch (op_ptr->reloc.kind) {
             case SCC_X86_OPR_RELBR:
-                ops[i].imm0 = 0;
+                ops[i].brdisp = 0;
+                break;
+            case SCC_X86_OPR_MEM:
+                ops[i].mem.base = SCC_X86_REG_RIP;
+                ops[i].mem.index = SCC_X86_REG_INVALID;
+                ops[i].mem.scale = 1;
+                ops[i].mem.disp.displacement = 0;
+                ops[i].mem.disp.displacement_bits = 32;
                 break;
             default:
-                TODO();
+                Panic("unsupported reloc type %d", op_ptr->reloc.kind);
                 break;
             }
             if (skip_reloc) {
@@ -55,8 +75,14 @@ void mir_x86_to_mcode(scc_mcode_t *mcode, scc_reloc_vec_t *relocs,
             } else {
                 TODO();
             }
+        } else if (op_ptr->kind == SCC_X86_OPR_REG) {
+            ops[i].kind = SCC_X86_OPR_REG;
+            ops[i].reg = mir_x86_trans_gpr(op_ptr->reg, op_ptr->size);
+        } else {
+            ops[i] = *op_ptr;
         }
     }
+
     scc_x86_encode_inst(mcode, ins->opcode, ops);
     if (!skip_reloc && reloc.target_kind != SCC_RELOC_TARGET_NONE) {
         reloc.offset = scc_mcode_size(mcode);

libs/ir2mcode/src/scc_ir2sccf.c

@@ -31,10 +31,18 @@ static inline void scc_ir_sym_to_sccf_sym(const scc_cfg_symbol_t *symbol,
 
 static inline void scc_ir_symbol_to_sect_data(const scc_cfg_symbol_t *symbol,
                                               sccf_sect_data_t *sect_data) {
-    // scc_vec_foreach(value->data.const_array.fields, j) {
-    //     scc_vec_push(ctx->sect_data,
-    //                  scc_vec_at(value->data.const_array.fields, j));
-    // }
+    if (symbol->kind != SCC_CFG_SYMBOL_KIND_DATA) {
+        return;
+    }
+    scc_mir_symbol_meta_t *meta = SCC_MIR_SYMBOL_META(symbol);
+    for (usize i = 0; i < meta->data.size; i += 1) {
+        scc_vec_push(*sect_data, meta->data.init_data[i]);
+    }
+    // struct {
+    //     u8 *init_data; // 初始化数据（若为 NULL 则零初始化）
+    //     usize size;    // 数据大小（字节）
+    //     int align;     // 对齐要求
+    // } data;
 }
 
 static void emit_mir_module(sccf_builder_t *builder, scc_mcode_t *mcode,
@@ -122,14 +130,16 @@ void scc_ir2sccf(sccf_builder_t *builder, scc_mir_module_t *mir_module) {
             continue;
         }
 
-        sccf_sym_t sym = (sccf_sym_t){
-            .sccf_sect_offset = scc_vec_size(sect_data),
-            .sccf_sym_size =
-                4, // FIXME on windows using rel32, on linux using ?
-        };
-
+        sccf_sym_t sym = {0};
         scc_ir_sym_to_sccf_sym(symbol, &sym);
-        scc_ir_symbol_to_sect_data(symbol, &sect_data);
+
+        // FIXME 区分只读
+        if (sym.sccf_sect_type == SCCF_SECT_DATA ||
+            sym.sccf_sect_type == SCCF_SECT_RODATA) {
+            sym.sccf_sect_offset = scc_vec_size(sect_data);
+            scc_ir_symbol_to_sect_data(symbol, &sect_data);
+            sym.sccf_sym_size = scc_vec_size(sect_data) - sym.sccf_sect_offset;
+        }
 
         usize sym_idx = sccf_builder_add_symbol(builder, symbol->name, &sym);
         Assert(sym_idx != 0);