feat(ir): 实现函数调用和参数处理功能

- 在AST定义中移除函数调用结构体中的冗余name字段
- 实现完整的函数声明和定义处理流程，支持符号表查找
- 添加函数参数引用节点类型，支持参数传递和访问
- 实现函数调用的IR生成，包括参数处理和符号解析
- 添加断言确保节点有效性，提升代码健壮性

fix(ast2ir): 优化类型转换处理逻辑

- 移除多余的注释说明
- 简化参数为空检查逻辑，提高代码简洁性
- 修复函数调用时的符号表查找机制

refactor(ir): 改进IR构建器接口设计

- 修改函数构建相关API，使接口更加清晰
- 添加函数声明集合管理
- 重构内置类型缓存机制

feat(ir2mcode): 完善AMD64代码生成

- 实现函数参数到寄存器的映射
- 添加函数调用约定支持（最多4个参数）
- 实现函数符号和重定位处理
- 添加栈帧管理机制
- 修正栈偏移计算

chore(ir): 清理和优化IR dump输出

- 更新节点类型描述信息
- 改进函数声明和定义的输出格式
- 修正格式化输出中的符号显示问题

style: 代码格式化和命名规范化

- 统一重定位类型枚举命名
- 优化函数参数验证和错误处理

libs/ir/src/ir_builder.c

@@ -14,33 +14,44 @@ void scc_ir_builder_drop(scc_ir_builder_t *builder) {
     scc_ir_ctx_drop(&builder->ctx);
 }
 
-scc_ir_func_ref_t scc_ir_builder_begin_func(scc_ir_builder_t *builder,
-                                            const char *name,
-                                            scc_ir_type_ref_t type,
-                                            const char **param_names) {
-    scc_ir_func_t func = {0};
-
-    // 初始化参数和基本块向量
-    func.name = name;
-    func.type = type;
+scc_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_func_t func = {
+        .name = name,
+        .type = type_ref,
+    };
     scc_vec_init(func.params);
     scc_vec_init(func.bblocks);
 
-    // 创建函数并设置为当前函数
     scc_ir_func_ref_t func_ref = scc_ir_ctx_new_func(&builder->ctx, &func);
+    return func_ref;
+}
+
+void scc_ir_builder_begin_func(scc_ir_builder_t *builder,
+                               scc_ir_func_ref_t func_ref,
+                               const char **param_names) {
+    // 创建函数并设置为当前函数
     builder->current_func = func_ref;
 
-    // 如果提供了参数名称，则创建参数节点
-    if (param_names == null) {
-        return func_ref;
-    }
-
     scc_ir_func_t *func_ptr = scc_ir_ctx_get_func(&builder->ctx, func_ref);
-    scc_ir_type_t *func_type = scc_ir_ctx_get_type(&builder->ctx, type);
+    scc_ir_type_t *func_type =
+        scc_ir_ctx_get_type(&builder->ctx, func_ptr->type);
 
     if (func_type == null || func_type->tag != SCC_IR_TYPE_FUNC) {
         LOG_ERROR("Invalid function type");
-        return func_ref;
+        return;
+    }
+
+    if (func_ptr == null) {
+        LOG_ERROR("Invalid function reference");
+        return;
+    }
+
+    if (scc_vec_size(func_ptr->bblocks) != 0 ||
+        scc_vec_size(func_ptr->params) != 0) {
+        LOG_FATAL("Multiple function definitions");
+        return;
     }
 
     scc_vec_foreach(func_type->data.function.params, i) {
@@ -48,9 +59,10 @@ scc_ir_func_ref_t scc_ir_builder_begin_func(scc_ir_builder_t *builder,
             scc_vec_at(func_type->data.function.params, i);
 
         scc_ir_node_t param_node = {0};
-        param_node.tag = SCC_IR_NODE_NULL; // 参数节点标记
+        param_node.tag = SCC_IR_NODE_FUNC_ARG_REF; // 参数节点标记
         param_node.type = param_type;
-        param_node.name = param_names[i];
+        param_node.name = param_names ? param_names[i] : null;
+        param_node.data.arg_ref.idx = i;
         scc_vec_init(param_node.used_by);
 
         scc_ir_node_ref_t param_ref =
@@ -58,7 +70,7 @@ scc_ir_func_ref_t scc_ir_builder_begin_func(scc_ir_builder_t *builder,
         scc_vec_push(func_ptr->params, param_ref);
     }
 
-    return func_ref;
+    return;
 }
 
 void scc_ir_builder_end_func(scc_ir_builder_t *builder) {
@@ -144,6 +156,21 @@ scc_ir_node_ref_t scc_ir_builder_alloca(scc_ir_builder_t *builder,
     return node_ref;
 }
 
+scc_ir_node_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_node_t node = {0};
+    node.tag = SCC_IR_NODE_FUNC_ARG_REF;
+    node.type = type;
+    node.name = name;
+    node.data.arg_ref.idx = arg_idx;
+
+    scc_ir_node_ref_t node_ref = scc_ir_ctx_new_node(&builder->ctx, &node);
+    // 添加到当前基本块
+    scc_ir_builder_add_instr(builder, node_ref);
+    return node_ref;
+}
+
 scc_ir_node_ref_t scc_ir_builder_load(scc_ir_builder_t *builder,
                                       scc_ir_node_ref_t target) {
     scc_ir_node_t load_node = {0};