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

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

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

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

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

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

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

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

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

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

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

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

libs/ast2ir/src/scc_ast2ir.c

@@ -20,12 +20,9 @@ scc_ir_type_ref_t scc_ast2ir_type(scc_ast2ir_ctx_t *ctx,
     case SCC_AST_TYPE_POINTER: {
         scc_ir_type_init(&ir_type, SCC_IR_TYPE_PTR);
 
-        // 创建指向类型并添加到程序类型列表
         scc_ir_type_ref_t pointee_type =
             scc_ast2ir_type(ctx, ast_type->pointer.pointee);
 
-        // 注意：我们需要找到一种合适的方式来存储类型信息
-        // 目前的IR设计中类型信息应该直接存储在类型结构中
         ir_type.data.pointer.base = pointee_type;
         break;
     }
@@ -33,11 +30,9 @@ scc_ir_type_ref_t scc_ast2ir_type(scc_ast2ir_ctx_t *ctx,
     case SCC_AST_TYPE_ARRAY: {
         scc_ir_type_init(&ir_type, SCC_IR_TYPE_ARRAY);
 
-        // 创建元素类型并添加到程序类型列表
         scc_ir_type_ref_t element_type =
             scc_ast2ir_type(ctx, ast_type->array.element);
 
-        // 将类型添加到程序的类型容器中
         ir_type.data.array.base = element_type;
         // TODO: 处理数组大小表达式
         ir_type.data.array.len = 0; // 暂时设为0
@@ -267,22 +262,20 @@ scc_ir_node_ref_t scc_ast2ir_expr(scc_ast2ir_ctx_t *ctx, scc_ast_expr_t *expr,
         scc_ir_node_ref_vec_t args;
         scc_vec_init(args);
 
-        // 检查参数是否为空
-        if (expr->call.args.data != null) {
-            scc_vec_foreach(expr->call.args, i) {
-                scc_ast_expr_t *arg_expr = scc_vec_at(expr->call.args, i);
-                scc_ir_node_ref_t arg_node;
-                arg_node = scc_ast2ir_expr(ctx, arg_expr, false);
-                scc_vec_push(args, arg_node);
-            }
+        scc_vec_foreach(expr->call.args, i) {
+            scc_ast_expr_t *arg_expr = scc_vec_at(expr->call.args, i);
+            scc_ir_node_ref_t arg_node;
+            arg_node = scc_ast2ir_expr(ctx, arg_expr, false);
+            scc_vec_push(args, arg_node);
         }
 
         // 创建调用节点（需要查找函数定义）
-        // TODO: 需要符号表查找函数
-        scc_ir_node_ref_t func =
-            scc_ir_builder_call(&ctx->builder, 0, args.data, args.size);
+        scc_ir_func_ref_t func = (scc_ir_node_ref_t)(usize)scc_hashtable_get(
+            &ctx->symtab, expr->call.callee->identifier._target->name);
+        scc_ir_node_ref_t node =
+            scc_ir_builder_call(&ctx->builder, func, args.data, args.size);
         scc_vec_free(args);
-        return func;
+        return node;
     }
 
         // SCC_AST_EXPR_ARRAY_SUBSCRIPT, // 数组下标
@@ -316,6 +309,7 @@ scc_ir_node_ref_t scc_ast2ir_expr(scc_ast2ir_ctx_t *ctx, scc_ast_expr_t *expr,
         // FIXME hack hashtable
         scc_ir_node_ref_t in = (scc_ir_node_ref_t)(usize)scc_hashtable_get(
             &ctx->node2ir, expr->identifier._target);
+        Assert(in != 0);
         if (is_lvalue) {
             return in;
         } else {
@@ -548,14 +542,38 @@ void scc_ast2ir_decl(scc_ast2ir_ctx_t *ctx, scc_ast_decl_t *decl) {
     }
 
     case SCC_AST_DECL_FUNC: {
-        scc_ir_type_ref_t func_type = scc_ast2ir_type(ctx, decl->func.type);
+        scc_ir_type_ref_t func_type_ref = scc_ast2ir_type(ctx, decl->func.type);
+        scc_ir_func_ref_t func_ref =
+            (usize)scc_hashtable_get(&ctx->symtab, decl->name);
+        if (func_ref == 0) {
+            func_ref =
+                scc_ir_builder_func(&ctx->builder, func_type_ref, decl->name);
+            scc_hashtable_set(&ctx->symtab, decl->name,
+                              (void *)(usize)func_ref);
+            scc_vec_push(ctx->builder.cprog.func_decls, func_ref);
+        }
+
         if (decl->func.body == null) {
             // function decl
             break;
         }
-        // TODO params name
-        scc_ir_builder_begin_func(&ctx->builder, decl->name, func_type, null);
+
+        scc_ir_builder_begin_func(&ctx->builder, func_ref, null);
+        scc_ir_func_t *func = scc_ir_ctx_get_func(&ctx->builder.ctx, func_ref);
+        Assert(func != null);
         scc_ir_builder_begin_bblock(&ctx->builder, "entry");
+        scc_vec_foreach(decl->func.type->function.params, i) {
+            scc_ast_decl_t *param =
+                scc_vec_at(decl->func.type->function.params, i);
+
+            scc_ir_node_ref_t param_node_ref = scc_vec_at(func->params, i);
+            scc_ir_node_t *param_node =
+                scc_ir_ctx_get_node(&ctx->builder.ctx, param_node_ref);
+            Assert(param_node != null);
+            param_node->name = param->name;
+            scc_hashtable_set(&ctx->node2ir, param,
+                              (void *)(usize)param_node_ref);
+        }
         scc_ast2ir_stmt(ctx, decl->func.body);
         scc_ir_builder_end_bblock(&ctx->builder);
         scc_ir_builder_end_func(&ctx->builder);
@@ -607,4 +625,6 @@ void scc_ast2ir_ctx_init(scc_ast2ir_ctx_t *ctx, const scc_type_abi_t *abi) {
     ctx->abi = abi;
     scc_ir_builder_init(&ctx->builder);
     scc_hashtable_init(&ctx->node2ir, scc_hash_node, scc_cmp_node);
+    scc_hashtable_init(&ctx->symtab, (scc_hashtable_hash_func_t)scc_strhash32,
+                       (scc_hashtable_equal_func_t)scc_strcmp);
 }