Fix integer literal handling to 64bit large integers.

Signed-off-by: Cong Wang <cwang@multikernel.io>

Author: congwang-mk

src/ast.ml

@@ -55,14 +55,8 @@ type map_flag =
   | Wronly              (* BPF_F_WRONLY *)
   | Clone               (* BPF_F_CLONE *)
 
-(** Type definitions for structs, enums, and type aliases *)
-type type_def =
-  | StructDef of string * (string * bpf_type) list
-  | EnumDef of string * (string * int option) list
-  | TypeAlias of string * bpf_type
-
 (** BPF type system with extended type definitions *)
-and bpf_type =
+type bpf_type =
   (* Primitive types *)
   | U8 | U16 | U32 | U64 | I8 | I16 | I32 | I64 | Bool | Char | Void
   | Str of int  (* Fixed-size string str<N> *)
@@ -113,9 +107,82 @@ type map_declaration = {
   map_pos: position;
 }
 
+(** Integer value with proper signed/unsigned distinction *)
+type integer_value = 
+  | Signed64 of Int64.t
+  | Unsigned64 of Int64.t  (* Stored in Int64.t but interpreted as unsigned *)
+
+(** Helper module for working with integer values elegantly *)
+module IntegerValue = struct
+  let of_string s = 
+    try
+      (* Try signed parsing first *)
+      Signed64 (Int64.of_string s)
+    with Failure _ ->
+      (* Handle unsigned 64-bit integers that exceed signed range *)
+      try
+        (* Parse as unsigned using custom logic for large values *)
+        let parse_uint64 str =
+          let len = String.length str in
+          let rec aux i acc =
+            if i >= len then acc
+            else
+              let digit = Char.code str.[i] - Char.code '0' in
+              if digit < 0 || digit > 9 then
+                failwith "Invalid digit"
+              else
+                let new_acc = Int64.add (Int64.mul acc 10L) (Int64.of_int digit) in
+                aux (i + 1) new_acc
+          in
+          aux 0 0L
+        in
+        let uint64_val = parse_uint64 s in
+        Unsigned64 uint64_val
+      with _ ->
+        failwith ("Invalid integer literal: " ^ s)
+  
+  let to_string = function
+    | Signed64 i -> Int64.to_string i
+    | Unsigned64 i -> 
+        (* Handle unsigned 64-bit values correctly *)
+        if Int64.compare i 0L >= 0 then
+          Int64.to_string i
+        else
+          (* For negative Int64.t values representing large unsigned numbers *)
+          (* Use Printf to format as unsigned *)
+          Printf.sprintf "%Lu" i
+  
+  let to_c_literal = function
+    | Signed64 i -> Int64.to_string i ^ "LL"
+    | Unsigned64 i -> 
+        (* Use unsigned formatting for C literals *)
+        if Int64.compare i 0L >= 0 then
+          Int64.to_string i ^ "ULL"
+        else
+          Printf.sprintf "%LuULL" i
+  
+  let is_negative = function
+    | Signed64 i -> Int64.compare i 0L < 0
+    | Unsigned64 _ -> false  (* Unsigned values are never conceptually negative *)
+  
+  let to_int64 = function
+    | Signed64 i -> i
+    | Unsigned64 i -> i
+  
+  let compare_with_zero = function
+    | Signed64 i -> Int64.compare i 0L
+    | Unsigned64 i -> if Int64.compare i 0L < 0 then 1 else Int64.compare i 0L (* Handle unsigned wrap-around *)
+end
+
+(** Type definitions for structs, enums, and type aliases *)
+type type_def =
+  | StructDef of string * (string * bpf_type) list
+  | EnumDef of string * (string * integer_value option) list
+  | TypeAlias of string * bpf_type
+
 (** Literal values *)
 type literal =
-  | IntLit of int * string option  (* value * original_representation *)
+  | IntLit of integer_value * string option  (* value * original_representation *)
   | StringLit of string 
   | CharLit of char 
   | BoolLit of bool
@@ -649,10 +716,10 @@ let rec string_of_bpf_type = function
   | Null -> "null"
 
 let rec string_of_literal = function
-  | IntLit (i, original_opt) -> 
+  | IntLit (int_val, original_opt) -> 
       (match original_opt with
        | Some orig -> orig  (* Use original format if available *)
-       | None -> string_of_int i)
+       | None -> IntegerValue.to_string int_val)
   | StringLit s -> Printf.sprintf "\"%s\"" s
   | CharLit c -> Printf.sprintf "'%c'" c
   | BoolLit b -> string_of_bool b
@@ -848,7 +915,7 @@ let string_of_declaration = function
               (String.concat ",\n  " (List.map (fun (name, opt) ->
                 match opt with
                 | None -> name
-                | Some v -> Printf.sprintf "%s = %d" name v) values))
+                | Some v -> Printf.sprintf "%s = %s" name (IntegerValue.to_string v)) values))
         | TypeAlias (name, typ) ->
             Printf.sprintf "type %s = %s;" name (string_of_bpf_type typ)
       in

src/ebpf_c_codegen.ml

@@ -654,7 +654,7 @@ let collect_enum_definitions ?symbol_table ir_multi_prog =
         match symbol.Symbol_table.kind with
         | Symbol_table.TypeDef (Ast.EnumDef (enum_name, enum_values)) ->
             let processed_values = List.map (fun (const_name, opt_value) ->
-              (const_name, Option.value ~default:0 opt_value)
+              (const_name, Option.value ~default:(Ast.Signed64 0L) opt_value)
             ) enum_values in
             Hashtbl.replace enum_map enum_name processed_values
         | _ -> ()
@@ -669,7 +669,7 @@ let generate_enum_definition ctx enum_name enum_values =
   increase_indent ctx;
   let value_count = List.length enum_values in
   List.iteri (fun i (const_name, value) ->
-    let line = sprintf "%s = %d%s" const_name value (if i = value_count - 1 then "" else ",") in
+    let line = sprintf "%s = %s%s" const_name (Ast.IntegerValue.to_string value) (if i = value_count - 1 then "" else ",") in
     emit_line ctx line
   ) enum_values;
   decrease_indent ctx;
@@ -1491,7 +1491,7 @@ let generate_global_variables ctx global_variables =
                  (match original_opt with
                   | Some orig when String.contains orig 'x' || String.contains orig 'X' -> orig
                   | Some orig when String.contains orig 'b' || String.contains orig 'B' -> orig
-                  | _ -> string_of_int i)
+                  | _ -> Ast.IntegerValue.to_string i)
              | IRLiteral (Ast.BoolLit b) -> if b then "1" else "0"
              | IRLiteral (Ast.StringLit s) -> sprintf "\"%s\"" s
              | IRLiteral (Ast.CharLit c) -> sprintf "'%c'" c
@@ -1565,7 +1565,7 @@ let rec generate_c_value ?(auto_deref_map_access=false) ctx ir_val =
       (match original_opt with
        | Some orig when String.contains orig 'x' || String.contains orig 'X' -> orig
        | Some orig when String.contains orig 'b' || String.contains orig 'B' -> orig
-       | _ -> string_of_int i)
+       | _ -> Ast.IntegerValue.to_string i)
   | IRLiteral (BoolLit b) -> if b then "1" else "0"
   | IRLiteral (CharLit c) -> sprintf "'%c'" c
   | IRLiteral (NullLit) -> "NULL"
@@ -1593,7 +1593,7 @@ let rec generate_c_value ?(auto_deref_map_access=false) ctx ir_val =
        | ZeroArray -> "{0}"  (* Empty array initialization *)
        | FillArray fill_lit ->
            let fill_str = match fill_lit with
-             | Ast.IntLit (i, _) -> string_of_int i
+             | Ast.IntLit (i, _) -> Ast.IntegerValue.to_string i
              | Ast.BoolLit b -> if b then "1" else "0"
              | Ast.CharLit c -> sprintf "'%c'" c
              | Ast.StringLit s -> sprintf "\"%s\"" s
@@ -1605,7 +1605,7 @@ let rec generate_c_value ?(auto_deref_map_access=false) ctx ir_val =
        | ExplicitArray elements ->
            let element_strings = List.map (fun elem ->
              match elem with
-             | Ast.IntLit (i, _) -> string_of_int i
+             | Ast.IntLit (i, _) -> Ast.IntegerValue.to_string i
              | Ast.BoolLit b -> if b then "1" else "0"
              | Ast.CharLit c -> sprintf "'%c'" c
              | Ast.StringLit s -> sprintf "\"%s\"" s
@@ -2305,7 +2305,7 @@ let generate_ringbuf_operation ctx ringbuf_val op =
 (** Helper function to convert AST expressions to C code for bpf_loop callbacks *)
 let rec generate_ast_expr_to_c (expr : Ast.expr) counter_var =
   match expr.Ast.expr_desc with
-  | Ast.Literal (Ast.IntLit (i, _)) -> string_of_int i
+  | Ast.Literal (Ast.IntLit (i, _)) -> Ast.IntegerValue.to_string i
   | Ast.Literal (Ast.BoolLit b) -> if b then "true" else "false"
   | Ast.Identifier name when name = "i" -> counter_var (* Map loop variable to counter *)
   | Ast.Identifier name -> name
@@ -2880,13 +2880,13 @@ let rec generate_c_instruction ctx ir_instr =
           let ret_str = match ret_val.value_desc with
             (* Use context-specific action constant mapping *)
             | IRLiteral (IntLit (i, _)) when ret_val.val_type = IRAction Xdp_actionType ->
-                (match Kernelscript_context.Context_codegen.map_context_action_constant "xdp" i with
+                (match Kernelscript_context.Context_codegen.map_context_action_constant "xdp" (Int64.to_int (Ast.IntegerValue.to_int64 i)) with
                  | Some action -> action
-                 | None -> string_of_int i)
+                 | None -> Ast.IntegerValue.to_string i)
             | IRLiteral (IntLit (i, _)) when ret_val.val_type = IRAction TcActionType ->
-                (match Kernelscript_context.Context_codegen.map_context_action_constant "tc" i with
+                (match Kernelscript_context.Context_codegen.map_context_action_constant "tc" (Int64.to_int (Ast.IntegerValue.to_int64 i)) with
                  | Some action -> action
-                 | None -> string_of_int i)
+                 | None -> Ast.IntegerValue.to_string i)
             | IRMapAccess (_, _, _) ->
                 (* For map access in return position, auto-dereference to return the value *)
                 generate_c_value ~auto_deref_map_access:true ctx ret_val

src/evaluator.ml

@@ -32,7 +32,7 @@ type runtime_value =
   | ArrayValue of runtime_value array
   | PointerValue of int  (* Address representation *)
   | StructValue of (string * runtime_value) list
-  | EnumValue of string * int
+  | EnumValue of string * Int64.t
   | MapHandle of string  (* Map identifier *)
   | ContextValue of string * (string * runtime_value) list
   | NullValue  (* Simple null value representation *)
@@ -318,7 +318,7 @@ let rec string_of_runtime_value = function
   | StructValue fields ->
       "{" ^ String.concat "; " (List.map (fun (name, value) ->
         name ^ " = " ^ string_of_runtime_value value) fields) ^ "}"
-  | EnumValue (name, value) -> Printf.sprintf "%s(%d)" name value
+  | EnumValue (name, value) -> Printf.sprintf "%s(%Ld)" name value
   | MapHandle name -> Printf.sprintf "map<%s>" name
   | ContextValue (ctx_type, fields) ->
       Printf.sprintf "%s_context{%s}" ctx_type
@@ -330,7 +330,7 @@ let rec string_of_runtime_value = function
 
 (** Convert literal to runtime value *)
 let runtime_value_of_literal = function
-  | IntLit (i, _) -> IntValue i
+  | IntLit (i, _) -> IntValue (Int64.to_int (Ast.IntegerValue.to_int64 i))
   | StringLit s -> StringValue s
   | CharLit c -> CharValue c
   | BoolLit b -> BoolValue b
@@ -354,7 +354,7 @@ let is_truthy_value rv =
   | StringValue s -> String.length s > 0          (* empty string is falsy, non-empty is truthy *)
   | CharValue c -> c <> '\000'                    (* null character is falsy, others truthy *)
   | PointerValue addr -> addr <> 0                (* null pointer is falsy, non-null is truthy *)
-  | EnumValue (_, value) -> value <> 0            (* enum based on numeric value *)
+  | EnumValue (_, value) -> Int64.compare value 0L <> 0            (* enum based on numeric value *)
   | MapHandle _ -> true                           (* maps are always truthy *)
   | ContextValue (_, _) -> true                   (* context values are always truthy *)
   | NullValue -> false                            (* null is always falsy *)
@@ -643,7 +643,7 @@ and eval_expression ctx expr =
            (* Look up enum constants from loaded builtin AST files *)
            (match Symbol_table.lookup_symbol symbol_table name with
             | Some { kind = Symbol_table.EnumConstant (enum_name, Some value); _ } ->
-                EnumValue (enum_name, value)
+                EnumValue (enum_name, Ast.IntegerValue.to_int64 value)
             | _ ->
                 (* Not an enum constant, try variables *)
                 (try
@@ -731,8 +731,8 @@ and eval_expression ctx expr =
                        (match Symbol_table.lookup_symbol symbol_table name with
                         | Some { kind = Symbol_table.EnumConstant (_, Some value); _ } ->
                             (match matched_value with
-                             | EnumValue (_, matched_val) -> matched_val = value
-                             | IntValue matched_val -> matched_val = value
+                             | EnumValue (_, matched_val) -> matched_val = Ast.IntegerValue.to_int64 value
+                             | IntValue matched_val -> Int64.of_int matched_val = Ast.IntegerValue.to_int64 value
                              | _ -> false)
                         | _ -> false)
                    | None -> false)

src/ir.ml

@@ -135,7 +135,7 @@ and ir_type =
   | IRPointer of ir_type * bounds_info
   | IRArray of ir_type * int * bounds_info
   | IRStruct of string * (string * ir_type) list
-  | IREnum of string * (string * int) list
+  | IREnum of string * (string * Ast.integer_value) list
   | IRResult of ir_type * ir_type
   | IRContext of context_type
   | IRAction of action_type
@@ -224,7 +224,7 @@ and ir_value_desc =
   | IRRegister of int
   | IRContextField of context_type * string
   | IRMapRef of string
-  | IREnumConstant of string * string * int  (* enum_name, constant_name, value *)
+  | IREnumConstant of string * string * Ast.integer_value  (* enum_name, constant_name, value *)
   | IRFunctionRef of string  (* Function reference by name *)
   | IRMapAccess of string * ir_value * (ir_value_desc * ir_type)  (* map_name, key, (underlying_value_desc, underlying_type) *)
 
@@ -753,7 +753,7 @@ let rec ast_type_to_ir_type_with_context symbol_table ast_type =
                   IRStruct (name, ir_fields)
               | Symbol_table.TypeDef (Ast.EnumDef (_, values)) -> 
                   let ir_values = List.map (fun (enum_name, opt_value) ->
-                    (enum_name, Option.value ~default:0 opt_value)
+                    (enum_name, Option.value ~default:(Ast.Signed64 0L) opt_value)
                   ) values in
                   IREnum (name, ir_values)
               | _ -> ast_type_to_ir_type ast_type)
@@ -776,7 +776,7 @@ let rec ast_type_to_ir_type_with_context symbol_table ast_type =
                   IRStruct (name, ir_fields)
               | Symbol_table.TypeDef (Ast.EnumDef (_, values)) -> 
                   let ir_values = List.map (fun (enum_name, opt_value) ->
-                    (enum_name, Option.value ~default:0 opt_value)
+                    (enum_name, Option.value ~default:(Ast.Signed64 0L) opt_value)
                   ) values in
                   IREnum (name, ir_values)
               | _ -> ast_type_to_ir_type ast_type)
@@ -798,7 +798,7 @@ let rec ast_type_to_ir_type_with_context symbol_table ast_type =
              (match symbol.kind with
               | Symbol_table.TypeDef (Ast.EnumDef (_, values)) -> 
                   let ir_values = List.map (fun (enum_name, opt_value) ->
-                    (enum_name, Option.value ~default:0 opt_value)
+                    (enum_name, Option.value ~default:(Ast.Signed64 0L) opt_value)
                   ) values in
                   IREnum (name, ir_values)
               | _ -> ast_type_to_ir_type ast_type)

src/ir_analysis.ml

@@ -205,9 +205,9 @@ module AssignmentOptimization = struct
         | IRMapStore (map_val, _key_val, _value_val, _) ->
                          let assignment = Map_assignment.{
                map_name = (match map_val.value_desc with IRMapRef name -> name | _ -> "unknown");
-               key_expr = { Ast.expr_desc = Ast.Literal (IntLit (0, None)); expr_type = None; expr_pos = instr.instr_pos; 
+               key_expr = { Ast.expr_desc = Ast.Literal (IntLit (Ast.Signed64 0L, None)); expr_type = None; expr_pos = instr.instr_pos; 
                             type_checked = false; program_context = None; map_scope = None }; (* Simplified for IR analysis *)
-                               value_expr = { Ast.expr_desc = Ast.Literal (IntLit (0, None)); expr_type = None; expr_pos = instr.instr_pos; 
+                               value_expr = { Ast.expr_desc = Ast.Literal (IntLit (Ast.Signed64 0L, None)); expr_type = None; expr_pos = instr.instr_pos; 
                                type_checked = false; program_context = None; map_scope = None }; (* Simplified for IR analysis *)
                assignment_type = DirectAssignment;
                assignment_pos = instr.instr_pos;