Merge branch 'master' into request-struct

pythonbpf/vmlinux_parser/vmlinux_exports_handler.py

@@ -1,6 +1,6 @@
 import logging
 from typing import Any
-
+import ctypes
 from llvmlite import ir
 
 from pythonbpf.local_symbol import LocalSymbol
@@ -94,12 +94,11 @@ class VmlinuxHandler:
                 f"Attempting to access field {field_name} of possible vmlinux struct {struct_var_name}"
             )
             python_type: type = var_info.metadata
-            globvar_ir, field_data = self.get_field_type(
-                python_type.__name__, field_name
-            )
+            struct_name = python_type.__name__
+            globvar_ir, field_data = self.get_field_type(struct_name, field_name)
             builder.function.args[0].type = ir.PointerType(ir.IntType(8))
             field_ptr = self.load_ctx_field(
-                builder, builder.function.args[0], globvar_ir
+                builder, builder.function.args[0], globvar_ir, field_data, struct_name
             )
             # Return pointer to field and field type
             return field_ptr, field_data
@@ -107,7 +106,7 @@ class VmlinuxHandler:
             raise RuntimeError("Variable accessed not found in symbol table")
 
     @staticmethod
-    def load_ctx_field(builder, ctx_arg, offset_global):
+    def load_ctx_field(builder, ctx_arg, offset_global, field_data, struct_name=None):
         """
         Generate LLVM IR to load a field from BPF context using offset.
 
@@ -115,9 +114,10 @@ class VmlinuxHandler:
             builder: llvmlite IRBuilder instance
             ctx_arg: The context pointer argument (ptr/i8*)
             offset_global: Global variable containing the field offset (i64)
-
+            field_data: contains data about the field
+            struct_name: Name of the struct being accessed (optional)
         Returns:
-            The loaded value (i64 register)
+            The loaded value (i64 register or appropriately sized)
         """
 
         # Load the offset value
@@ -162,13 +162,61 @@ class VmlinuxHandler:
             passthrough_fn, [ir.Constant(ir.IntType(32), 0), field_ptr], tail=True
         )
 
-        # Bitcast to i64* (assuming field is 64-bit, adjust if needed)
-        i64_ptr_type = ir.PointerType(ir.IntType(64))
-        typed_ptr = builder.bitcast(verified_ptr, i64_ptr_type)
+        # Determine the appropriate IR type based on field information
+        int_width = 64  # Default to 64-bit
+        needs_zext = False  # Track if we need zero-extension for xdp_md
+
+        if field_data is not None:
+            # Try to determine the size from field metadata
+            if field_data.type.__module__ == ctypes.__name__:
+                try:
+                    field_size_bytes = ctypes.sizeof(field_data.type)
+                    field_size_bits = field_size_bytes * 8
+
+                    if field_size_bits in [8, 16, 32, 64]:
+                        int_width = field_size_bits
+                        logger.info(f"Determined field size: {int_width} bits")
+
+                        # Special handling for struct_xdp_md i32 fields
+                        # Load as i32 but extend to i64 before storing
+                        if struct_name == "struct_xdp_md" and int_width == 32:
+                            needs_zext = True
+                            logger.info(
+                                "struct_xdp_md i32 field detected, will zero-extend to i64"
+                            )
+                    else:
+                        logger.warning(
+                            f"Unusual field size {field_size_bits} bits, using default 64"
+                        )
+                except Exception as e:
+                    logger.warning(
+                        f"Could not determine field size: {e}, using default 64"
+                    )
+
+            elif field_data.type.__module__ == "vmlinux":
+                # For pointers to structs or complex vmlinux types
+                if field_data.ctype_complex_type is not None and issubclass(
+                    field_data.ctype_complex_type, ctypes._Pointer
+                ):
+                    int_width = 64  # Pointers are always 64-bit
+                    logger.info("Field is a pointer type, using 64 bits")
+                # TODO: Add handling for other complex types (arrays, embedded structs, etc.)
+                else:
+                    logger.warning("Complex vmlinux field type, using default 64 bits")
+
+        # Bitcast to appropriate pointer type based on determined width
+        ptr_type = ir.PointerType(ir.IntType(int_width))
+
+        typed_ptr = builder.bitcast(verified_ptr, ptr_type)
 
         # Load and return the value
         value = builder.load(typed_ptr)
 
+        # Zero-extend i32 to i64 for struct_xdp_md fields
+        if needs_zext:
+            value = builder.zext(value, ir.IntType(64))
+            logger.info("Zero-extended i32 value to i64 for struct_xdp_md field")
+
         return value
 
     def has_field(self, struct_name, field_name):