Introduce New and Delete constructs for object management, updating the parser, type checker, and IR generation accordingly. Enhance code generation for malloc and free operations in userspace.

Author: congwang-mk

examples/object_allocation.ks

@@ -0,0 +1,89 @@
+// Simple XDP packet inspector with object allocation
+// Demonstrates new/delete for connection tracking
+
+// XDP context struct (from BTF)
+struct xdp_md {
+  data: u64,
+  data_end: u64,
+  data_meta: u64,
+  ingress_ifindex: u32,
+  rx_queue_index: u32,
+  egress_ifindex: u32,
+}
+
+// XDP action enum (from BTF)
+enum xdp_action {
+  XDP_ABORTED = 0,
+  XDP_DROP = 1,
+  XDP_PASS = 2,
+  XDP_REDIRECT = 3,
+  XDP_TX = 4,
+}
+
+struct ConnStats {
+    packet_count: u64,
+    byte_count: u64,
+    first_seen: u64,
+    last_seen: u64,
+}
+
+// Map to store connection statistics
+map<u32, *ConnStats> conn_tracker : HashMap(1024)
+
+@xdp fn packet_inspector(ctx: *xdp_md) -> xdp_action {
+    // Simple source IP extraction (in real code, would parse ethernet/IP headers)
+    var src_ip: u32 = 0x08080808  // Simulated source IP
+    var packet_size: u32 = 64     // Simulated packet size
+    
+    // Look up existing connection stats
+    var stats = conn_tracker[src_ip]
+    
+    if (stats == none) {
+        // First packet from this IP - allocate new stats object
+        stats = new ConnStats()
+        if (stats == null) {
+            return XDP_DROP  // Allocation failed
+        }
+        
+        // Initialize new connection stats
+        stats->packet_count = 1
+        stats->byte_count = packet_size
+        stats->first_seen = 12345  // Fake timestamp
+        stats->last_seen = 12345
+        
+        // Store in map
+        conn_tracker[src_ip] = stats
+    } else {
+        // Update existing stats
+        stats->packet_count = stats->packet_count + 1
+        stats->byte_count = stats->byte_count + packet_size
+        stats->last_seen = 12346  // Updated timestamp
+    }
+    
+    // Simple rate limiting: drop if too many packets
+    if (stats->packet_count > 100) {
+        return XDP_DROP
+    }
+    
+    return XDP_PASS
+}
+
+fn main() -> i32 {
+    // Test userspace allocation
+    var test_stats = new ConnStats()
+    if (test_stats == null) {
+        return 1
+    }
+    
+    test_stats->packet_count = 42
+    test_stats->byte_count = 2048
+    
+    // Clean up
+    delete test_stats
+    
+    // Load and attach the XDP program
+    var prog = load(packet_inspector)
+    attach(prog, "eth0", 0)
+    
+    return 0
+} 

src/ast.ml

@@ -170,6 +170,7 @@ and expr_desc =
   | UnaryOp of unary_op * expr
   | StructLiteral of string * (string * expr) list
   | Match of expr * match_arm list  (* match (expr) { arms } *)
+  | New of bpf_type  (* new Type() - object allocation *)
 
 (** Module function call *)
 and module_call = {
@@ -218,13 +219,18 @@ and stmt_desc =
   | For of string * expr * expr * statement list
   | ForIter of string * string * expr * statement list  (* for (index, value) in expr.iter() { ... } *)
   | While of expr * statement list
-  | Delete of expr * expr  (* delete map[key] *)
+  | Delete of delete_target  (* Unified delete: map[key] or pointer *)
   | Break
   | Continue
   | Try of statement list * catch_clause list  (* try { statements } catch clauses *)
   | Throw of expr  (* throw integer_expression *)
   | Defer of expr  (* defer function_call *)
 
+(** Delete target - either map entry or object pointer *)
+and delete_target =
+  | DeleteMapEntry of expr * expr  (* delete map[key] *)
+  | DeletePointer of expr         (* delete ptr *)
+
 (** Catch clause definition *)
 and catch_clause = {
   catch_pattern: catch_pattern;
@@ -677,6 +683,7 @@ let rec string_of_expr expr =
   | Match (expr, arms) ->
       let arms_str = String.concat ",\n    " (List.map string_of_match_arm arms) in
       Printf.sprintf "match (%s) {\n    %s\n}" (string_of_expr expr) arms_str
+  | New typ -> Printf.sprintf "new %s()" (string_of_bpf_type typ)
 
 and string_of_match_pattern = function
   | ConstantPattern lit -> string_of_literal lit
@@ -746,8 +753,10 @@ and string_of_stmt stmt =
   | While (cond, body) ->
       let body_str = String.concat " " (List.map string_of_stmt body) in
       Printf.sprintf "while (%s) { %s }" (string_of_expr cond) body_str
-  | Delete (map_expr, key_expr) ->
+  | Delete (DeleteMapEntry (map_expr, key_expr)) ->
       Printf.sprintf "delete %s[%s];" (string_of_expr map_expr) (string_of_expr key_expr)
+  | Delete (DeletePointer ptr_expr) ->
+      Printf.sprintf "delete %s;" (string_of_expr ptr_expr)
   | Break -> "break;"
   | Continue -> "continue;"
   | Try (statements, catch_clauses) ->

src/ebpf_c_codegen.ml

@@ -475,6 +475,10 @@ let rec collect_string_sizes_from_instr ir_instr =
         acc @ (collect_string_sizes_from_value arg)) [] args
   | IRStructOpsRegister (instance_val, struct_ops_val) ->
       (collect_string_sizes_from_value instance_val) @ (collect_string_sizes_from_value struct_ops_val)
+  | IRObjectNew (dest_val, _) ->
+      collect_string_sizes_from_value dest_val
+  | IRObjectDelete ptr_val ->
+      collect_string_sizes_from_value ptr_val
 
 let collect_string_sizes_from_function ir_func =
   List.fold_left (fun acc block ->
@@ -1125,6 +1129,35 @@ let generate_includes ctx ?(program_types=[]) ?(include_builtin_headers=false) (
     (* For non-kprobe programs, use standard processing *)
     let all_includes = builtin_includes @ standard_includes @ unique_context_includes @ base_type_includes in
     List.iter (emit_line ctx) all_includes;
+    emit_blank_line ctx;
+        
+    (* Use proper kernel implementation: extern declarations and macros *)
+    emit_line ctx "extern void *bpf_obj_new_impl(__u64 local_type_id__k, void *meta__ign) __ksym;";
+    emit_line ctx "extern void bpf_obj_drop_impl(void *p__alloc, void *meta__ign) __ksym;";
+    emit_blank_line ctx;
+    
+    (* Use exact kernel implementation for proper typeof handling *)
+    emit_line ctx "#define ___concat(a, b) a ## b";
+    emit_line ctx "#ifdef __clang__";
+    emit_line ctx "#define ___bpf_typeof(type) ((typeof(type) *) 0)";
+    emit_line ctx "#else";
+    emit_line ctx "#define ___bpf_typeof1(type, NR) ({                                         \\";
+    emit_line ctx "        extern typeof(type) *___concat(bpf_type_tmp_, NR);                  \\";
+    emit_line ctx "        ___concat(bpf_type_tmp_, NR);                                       \\";
+    emit_line ctx "})";
+    emit_line ctx "#define ___bpf_typeof(type) ___bpf_typeof1(type, __COUNTER__)";
+    emit_line ctx "#endif";
+    emit_blank_line ctx;
+    
+    (* Add BPF_TYPE_ID_LOCAL constant *)
+    emit_line ctx "#ifndef BPF_TYPE_ID_LOCAL";
+    emit_line ctx "#define BPF_TYPE_ID_LOCAL 1";
+    emit_line ctx "#endif";
+    emit_blank_line ctx;
+    
+    emit_line ctx "#define bpf_core_type_id_kernel(type) __builtin_btf_type_id(*(type*)0, 0)";
+    emit_line ctx "#define bpf_obj_new(type) ((type *)bpf_obj_new_impl(bpf_core_type_id_kernel(type), NULL))";
+    emit_line ctx "#define bpf_obj_drop(ptr) bpf_obj_drop_impl(ptr, NULL)";
     emit_blank_line ctx
   )
 
@@ -2611,6 +2644,10 @@ let rec generate_c_instruction ctx ir_instr =
               Option.iter collect_in_value result_val_opt
           | IRTailCall (_, args, _) ->
               List.iter collect_in_value args
+          | IRObjectNew (dest_val, _) ->
+              collect_in_value dest_val
+          | IRObjectDelete ptr_val ->
+              collect_in_value ptr_val
           | IRJump _ | IRComment _ | IRBreak | IRContinue | IRThrow _ -> ()
         in
         collect_in_instr ir_instr
@@ -2813,6 +2850,18 @@ let rec generate_c_instruction ctx ir_instr =
       (* For eBPF, struct_ops registration is handled by userspace loader *)
       emit_line ctx (sprintf "/* struct_ops_register - handled by userspace */")
 
+    | IRObjectNew (dest_val, obj_type) ->
+      let dest_str = generate_c_value ctx dest_val in
+      let type_str = ebpf_type_from_ir_type obj_type in
+      (* Use proper kernel pattern: ptr = bpf_obj_new(type) *)
+      emit_line ctx (sprintf "%s = bpf_obj_new(%s);" dest_str type_str)
+      
+  | IRObjectDelete ptr_val ->
+      let ptr_str = generate_c_value ctx ptr_val in
+      (* Use the proper kernel bpf_obj_drop(ptr) macro *)
+      emit_line ctx (sprintf "bpf_obj_drop(%s);" ptr_str)
+      
+
 (** Generate C code for basic block *)
 
 let generate_c_basic_block ctx ir_block =
@@ -3016,6 +3065,10 @@ let collect_registers_in_function ir_func =
         List.iter collect_in_value args
     | IRStructOpsRegister (instance_val, struct_ops_val) ->
         collect_in_value instance_val; collect_in_value struct_ops_val
+    | IRObjectNew (dest_val, _) ->
+        collect_in_value dest_val
+    | IRObjectDelete ptr_val ->
+        collect_in_value ptr_val
   in
   List.iter (fun block ->
     List.iter collect_in_instr block.instructions

src/evaluator.ml

@@ -716,74 +716,44 @@ and eval_expression ctx expr =
       StructValue field_values
 
   | Match (matched_expr, arms) ->
-      (* Evaluate the matched expression *)
       let matched_value = eval_expression ctx matched_expr in
-      
-      (* Find the matching arm and evaluate its expression *)
-      let rec find_matching_arm = function
-        | [] -> eval_error "No matching arm found in match expression" expr.expr_pos
-        | arm :: rest_arms ->
-            (match arm.arm_pattern with
-             | ConstantPattern lit ->
-                 let pattern_value = runtime_value_of_literal lit in
-                 if runtime_values_equal matched_value pattern_value then
-                   (match arm.arm_body with
-                    | SingleExpr expr -> eval_expression ctx expr
-                    | Block stmts -> 
-                        let rec eval_stmts = function
-                          | [] -> IntValue 0 (* Default value if no return *)
-                          | stmt :: rest -> 
-                              (try
-                                 eval_statement ctx stmt;
-                                 eval_stmts rest
-                               with Return_value value -> value)
-                        in
-                        eval_stmts stmts)
-                 else
-                   find_matching_arm rest_arms
-             | IdentifierPattern name ->
-                 (* For identifier patterns, try to get the value from symbol table *)
-                 (match ctx.symbol_table with
-                  | Some symbol_table ->
-                      (match Symbol_table.lookup_symbol symbol_table name with
-                       | Some { kind = Symbol_table.EnumConstant (_, Some value); _ } ->
-                           let pattern_value = EnumValue (name, value) in
-                           if runtime_values_equal matched_value pattern_value then
-                             (match arm.arm_body with
-                              | SingleExpr expr -> eval_expression ctx expr
-                              | Block stmts -> 
-                                  let rec eval_stmts = function
-                                    | [] -> IntValue 0 (* Default value if no return *)
-                                    | stmt :: rest -> 
-                                        (try
-                                           eval_statement ctx stmt;
-                                           eval_stmts rest
-                                         with Return_value value -> value)
-                                  in
-                                  eval_stmts stmts)
-                           else
-                             find_matching_arm rest_arms
-                       | _ ->
-                           (* Pattern not found or not an enum constant, treat as wildcard *)
-                           find_matching_arm rest_arms)
-                  | None ->
-                      find_matching_arm rest_arms)
-             | DefaultPattern ->
-                 (* Default pattern always matches *)
-                 (match arm.arm_body with
-                  | SingleExpr expr -> eval_expression ctx expr
-                  | Block stmts -> 
-                      let rec eval_stmts = function
-                        | [] -> IntValue 0 (* Default value if no return *)
-                        | stmt :: rest -> 
-                            (try
-                               eval_statement ctx stmt;
-                               eval_stmts rest
-                             with Return_value value -> value)
-                      in
-                      eval_stmts stmts))
+      let rec try_arms = function
+        | [] -> eval_error "No matching pattern in match expression" expr.expr_pos
+        | arm :: remaining_arms ->
+            let pattern_matches = match arm.arm_pattern with
+              | ConstantPattern lit ->
+                  let literal_value = runtime_value_of_literal lit in
+                  runtime_values_equal matched_value literal_value
+              | IdentifierPattern name ->
+                  (* Check if this is an enum constant *)
+                  (match ctx.symbol_table with
+                   | Some symbol_table ->
+                       (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
+                             | _ -> false)
+                        | _ -> false)
+                   | None -> false)
+              | DefaultPattern -> true
+            in
+            
+            if pattern_matches then
+              match arm.arm_body with
+              | SingleExpr arm_expr -> eval_expression ctx arm_expr
+              | Block arm_stmts ->
+                  eval_statements ctx arm_stmts;
+                  UnitValue  (* Default return for block *)
+            else
+              try_arms remaining_arms
       in
-      find_matching_arm arms
+      try_arms arms
+
+  | New _ ->
+      (* For evaluator, object allocation returns a mock pointer value *)
+      (* This is just for testing - real allocation happens in generated code *)
+      PointerValue (Random.int 1000000)
 
 (** Evaluate statements *)
 and eval_statements ctx stmts =
@@ -968,24 +938,29 @@ and eval_statement ctx stmt =
       in
       loop ()
 
-  | Delete (map_expr, key_expr) ->
-      let map_name = match map_expr.expr_desc with
-        | Identifier name -> name
-        | _ -> eval_error ("Delete requires a map identifier") stmt.stmt_pos
-      in
-      let key_result = eval_expression ctx key_expr in
-      
-      (* Get the map storage *)
-      let map_store = 
-        try Hashtbl.find ctx.map_storage map_name
-        with Not_found -> eval_error ("Map not found: " ^ map_name) stmt.stmt_pos
-      in
-      
-      (* Perform the actual delete operation *)
-      let key_str = string_of_runtime_value key_result in
-      let existed = Hashtbl.mem map_store key_str in
-      if existed then
-        Hashtbl.remove map_store key_str
+  | Delete target ->
+      (match target with
+      | DeleteMapEntry (map_expr, key_expr) ->
+          let map_name = match map_expr.expr_desc with
+            | Identifier name -> name
+            | _ -> eval_error ("Delete requires a map identifier") stmt.stmt_pos
+          in
+          let key_result = eval_expression ctx key_expr in
+          
+          (* Get the map storage *)
+          let map_store = 
+            try Hashtbl.find ctx.map_storage map_name
+            with Not_found -> eval_error ("Map not found: " ^ map_name) stmt.stmt_pos
+          in
+          
+          (* Perform the actual delete operation *)
+          let key_str = string_of_runtime_value key_result in
+          let existed = Hashtbl.mem map_store key_str in
+          if existed then
+            Hashtbl.remove map_store key_str
+      | DeletePointer _ptr_expr ->
+          (* For evaluator, pointer deletion is a no-op since we don't have real memory management *)
+          ())
 
   | Break ->
       raise Break_loop