Refactor variable declaration handling in eBPF C code generation. Streamline the collection of declared registers by directly iterating over instruction blocks, improving clarity and efficiency. Enhance function call declaration processing to ensure proper instruction ordering for variable declarations and assignments.

Author: congwang-mk

src/ebpf_c_codegen.ml

@@ -2809,35 +2809,8 @@ let generate_c_basic_block ctx ir_block =
     increase_indent ctx
   );
 
-  (* Emit instructions with special handling for function call + variable declaration sequences *)
-  let rec emit_instructions_optimized = function
-    | [] -> ()
-    | call_instr :: decl_instr :: rest 
-      when (match call_instr.instr_desc, decl_instr.instr_desc with
-        | IRCall (call_target, args, Some result_val), IRDeclareVariable (dest_val, typ, None) ->
-            (* Check if the call result register matches the declaration register *)
-            (match result_val.value_desc, dest_val.value_desc with
-             | IRRegister call_reg, IRRegister decl_reg when call_reg = decl_reg ->
-                 (* Generate combined declaration with function call initialization *)
-                 let var_name = get_meaningful_var_name ctx decl_reg typ in
-                 let args_str = String.concat ", " (List.map (generate_c_value ctx) args) in
-                 let call_str = match call_target with
-                   | DirectCall name -> sprintf "%s(%s)" name args_str
-                   | FunctionPointerCall func_ptr -> sprintf "(*%s)(%s)" (generate_c_value ctx func_ptr) args_str
-                 in
-                 let decl_str = generate_ebpf_c_declaration typ var_name in
-                 emit_line ctx (sprintf "%s = %s;" decl_str call_str);
-                 true
-             | _ -> false)
-        | _ -> false) ->
-        (* Skip the next instruction since we handled it in the combined declaration *)
-        emit_instructions_optimized rest
-    | instr :: rest ->
-        (* Regular instruction processing *)
-        generate_c_instruction ctx instr;
-        emit_instructions_optimized rest
-  in
-  emit_instructions_optimized ir_block.instructions
+  (* Generate C code for each IR instruction *)
+  List.iter (generate_c_instruction ctx) ir_block.instructions
 
 (** Collect mapping from registers to variable names *)
 let collect_register_variable_mapping ir_func =

src/ir_generator.ml

@@ -1307,10 +1307,47 @@ and lower_statement ctx stmt =
 
   | Ast.Declaration (name, typ_opt, expr_opt) ->
       let reg = get_variable_register ctx name in
-      let (target_type, init_value_opt) = 
-        resolve_declaration_type_and_init ctx reg typ_opt expr_opt in
 
-      declare_variable ctx name reg target_type init_value_opt stmt.stmt_pos
+      (* Handle function call declarations elegantly by proper instruction ordering *)
+      (match expr_opt with
+       | Some expr when (match expr.Ast.expr_desc with Ast.Call _ -> true | _ -> false) ->
+           (* For function calls: emit declaration first, then call with assignment *)
+           let target_type = match typ_opt with
+             | Some ast_type -> resolve_type_alias ctx reg ast_type
+             | None ->
+                 (* Infer type from function call if no explicit type *)
+                 (match expr.expr_type with
+                  | Some ast_type -> ast_type_to_ir_type_with_context ctx.symbol_table ast_type
+                  | None -> IRU32)
+           in
+           
+           (* Emit declaration first *)
+           declare_variable ctx name reg target_type None stmt.stmt_pos;
+           
+           (* Then emit function call as assignment *)
+           (match expr.Ast.expr_desc with
+            | Ast.Call (callee_expr, args) ->
+                let arg_vals = List.map (lower_expression ctx) args in
+                let result_val = make_ir_value (IRRegister reg) target_type expr.Ast.expr_pos in
+                let call_target = match callee_expr.Ast.expr_desc with
+                  | Ast.Identifier name ->
+                      if Hashtbl.mem ctx.variables name || Hashtbl.mem ctx.function_parameters name then
+                        let callee_val = lower_expression ctx callee_expr in
+                        FunctionPointerCall callee_val
+                      else
+                        DirectCall name
+                  | _ ->
+                      let callee_val = lower_expression ctx callee_expr in
+                      FunctionPointerCall callee_val
+                in
+                let instr = make_ir_instruction (IRCall (call_target, arg_vals, Some result_val)) expr.Ast.expr_pos in
+                emit_instruction ctx instr
+            | _ -> ()) (* Shouldn't happen due to our guard *)
+       | _ ->
+           (* Non-function call declarations: use existing logic *)
+           let (target_type, init_value_opt) = 
+             resolve_declaration_type_and_init ctx reg typ_opt expr_opt in
+           declare_variable ctx name reg target_type init_value_opt stmt.stmt_pos)
 
   | Ast.ConstDeclaration (name, typ_opt, expr) ->
       let reg = get_variable_register ctx name in