Merge origin/master (#105) into fix/packet-pointer-arith

Four keep-both conflicts: PktPtrTy and byte_size added at the same spot
in type_deducer, the allocation pass's type_deducer import, and
neighbouring entries in test_config.toml and test_signedness_ir.py.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: r41k0u

docs/getting-started/quickstart.md

@@ -188,7 +188,7 @@ def trace_open(ctx: c_void_p) -> c_int64:
 For network packet processing:
 
 ```python
-from pythonbpf.helper import XDP_PASS
+from vmlinux import XDP_PASS
 
 @section("xdp")
 def xdp_pass(ctx: c_void_p) -> c_int64:

docs/user-guide/decorators.md

@@ -108,7 +108,7 @@ def trace_open_return(ctx):
 For network packet processing at the earliest point:
 
 ```python
-from pythonbpf.helper import XDP_PASS
+from vmlinux import XDP_PASS
 from ctypes import c_void_p, c_int64
 
 @section("xdp")

docs/user-guide/structs.md

@@ -290,7 +290,8 @@ class MyStruct:
 ```python
 from pythonbpf import bpf, struct, map, section
 from pythonbpf.maps import RingBuffer
-from pythonbpf.helper import ktime, XDP_PASS
+from pythonbpf.helper import ktime
+from vmlinux import XDP_PASS
 from ctypes import c_void_p, c_int64, c_uint8, c_uint16, c_uint32, c_uint64
 
 @bpf

examples/xdp_pass.py

@@ -1,5 +1,5 @@
 from pythonbpf import bpf, map, section, bpfglobal, compile, compile_to_ir
-from pythonbpf.helper import XDP_PASS
+from vmlinux import XDP_PASS
 from pythonbpf.maps import HashMap
 from ctypes import c_int64, c_void_p
 

pyproject.toml

@@ -63,6 +63,7 @@ python_files = ["test_*.py"]
 markers = [
     "verifier: requires sudo/root for kernel verifier tests (not run by default)",
     "vmlinux: requires vmlinux.py for current kernel",
+    "verifier_match: substring a verifier-level xfail expects in the rejection",
 ]
 log_cli = false
 

pythonbpf/allocation_pass.py

@@ -6,7 +6,14 @@
 from pythonbpf.helper import HelperHandlerRegistry
 from pythonbpf.vmlinux_parser.dependency_node import Field
 from .expr import VmlinuxHandlerRegistry
-from pythonbpf.type_deducer import ctypes_to_ir, IntTy, signedness, PktPtrTy
+from pythonbpf.type_deducer import (
+    ctypes_to_ir,
+    is_ctypes,
+    IntTy,
+    signedness,
+    byte_size,
+    PktPtrTy,
+)
 from pythonbpf.expr.packet_pointer import packet_type
 from pythonbpf.expr.type_inference import infer_int_type
 from pythonbpf.maps import BPFMapType
@@ -111,10 +118,12 @@ def _allocate_for_call(builder, var_name, rval, local_sym_tab, compilation_conte
         call_type = rval.func.id
 
         # C type constructors
-        if call_type in ("c_int32", "c_int64", "c_uint32", "c_uint64", "c_void_p"):
+        if is_ctypes(call_type) and isinstance(ctypes_to_ir(call_type), ir.IntType):
+            # Any integer ctypes constructor, c_uint16 included, declares a
+            # slot of that width; the value is converted into it at the store.
             ir_type = ctypes_to_ir(call_type)
             var = builder.alloca(ir_type, name=var_name)
-            var.align = ir_type.width // 8
+            var.align = byte_size(ir_type)
             local_sym_tab[var_name] = LocalSymbol(var, ir_type)
             logger.info(f"Pre-allocated {var_name} as {call_type}")
 
@@ -207,7 +216,7 @@ def _allocate_for_map_method(
         return
 
     map_params = map_sym_tab[map_name].params
-    if map_params["type"] != BPFMapType.HASH:
+    if map_params["type"] not in (BPFMapType.HASH, BPFMapType.ARRAY):
         logger.warning(
             "Map method lookup used on non-hash map, using fallback allocation"
         )
@@ -481,7 +490,7 @@ def _allocate_for_attribute(
             tmp_name = f"{struct_var}_{field_name}_tmp"
             tmp_ir_type = ir.IntType(field_size_bits)
             tmp_var = builder.alloca(tmp_ir_type, name=tmp_name)
-            tmp_var.align = tmp_ir_type.width // 8
+            tmp_var.align = byte_size(tmp_ir_type)
             local_sym_tab[tmp_name] = LocalSymbol(tmp_var, tmp_ir_type)
             logger.info(
                 f"Pre-allocated temp {tmp_name} (i{field_size_bits}) for vmlinux field read {vmlinux_struct_name}.{field_name}"
@@ -536,8 +545,8 @@ def _allocate_with_type(builder, var_name, ir_type):
 def _get_alignment(ir_type):
     """Get appropriate alignment for IR type."""
     if isinstance(ir_type, ir.IntType):
-        return ir_type.width // 8
+        return byte_size(ir_type)
     elif isinstance(ir_type, ir.ArrayType) and isinstance(ir_type.element, ir.IntType):
-        return ir_type.element.width // 8
+        return byte_size(ir_type.element)
     else:
         return 8  # Default: pointer size

pythonbpf/assign_pass.py

@@ -5,7 +5,7 @@
 from llvmlite import ir
 from pythonbpf.expr import eval_expr, convert
 from pythonbpf.helper import emit_probe_read_kernel_str_call
-from pythonbpf.type_deducer import ctypes_to_ir
+from pythonbpf.type_deducer import field_int_type
 from pythonbpf.vmlinux_parser.dependency_node import Field
 
 logger = logging.getLogger(__name__)
@@ -40,6 +40,10 @@ def handle_struct_field_assignment(
         return
 
     val, val_type = val_result
+    if isinstance(val_type, Field):
+        field_ty = field_int_type(val_type)
+        if field_ty is not None:
+            val_type = field_ty
 
     # Special case: i8* string to [N x i8] char array
     if _is_char_array(field_type) and _is_i8_ptr(val_type):
@@ -150,6 +154,13 @@ def handle_variable_assignment(
     logger.info(
         f"Evaluated value for {var_name}: {val} of type {val_type}, expected {var_type}"
     )
+    # An integer vmlinux field is, for conversion purposes, its declared IntTy
+    # (width and sign from the ctype), so it takes the same convert() path as
+    # every other integer below instead of a special case.
+    if isinstance(val_type, Field):
+        field_ty = field_int_type(val_type)
+        if field_ty is not None:
+            val_type = field_ty
 
     if isinstance(val_type, ir.IntType) and isinstance(var_type, ir.IntType):
         # The descriptor may be narrower than the constant carrying the value
@@ -194,33 +205,13 @@ def handle_variable_assignment(
                 )
                 return False
         if isinstance(val_type, Field):
-            logger.info("Handling assignment to struct field")
-            field_ir_type = ctypes_to_ir(val_type.type.__name__)
-            # Sub-register-width context fields are zero-extended to i64 by
-            # load_ctx_field, so val is already i64 even though the field type
-            # says otherwise (c_uint for xdp_md, c_ushort for pt_regs.cs/ss).
-            if (
-                isinstance(field_ir_type, ir.IntType)
-                and field_ir_type.width < 64
-                and isinstance(var_type, ir.IntType)
-                and var_type.width == 64
-            ):
-                builder.store(val, var_ptr)
-                logger.info(
-                    f"Assigned zero-extended i{field_ir_type.width} context field "
-                    f"to {var_name} (i64)"
-                )
-                return True
-            # TODO: handling only ctype struct fields for now. Handle other stuff too later.
-            elif var_type == field_ir_type:
-                builder.store(val, var_ptr)
-                logger.info(f"Assigned ctype struct field to {var_name}")
-                return True
-            else:
-                logger.error(
-                    f"Failed to assign ctype struct field to {var_name}: {val_type} != {var_type}"
-                )
-                return False
+            # Integer fields were normalised to their IntTy above; what is
+            # left is a pointer, array or struct field, which has no path
+            # into this slot.
+            logger.error(
+                f"Failed to assign ctype struct field to {var_name}: {val_type} != {var_type}"
+            )
+            return False
         elif isinstance(val_type, ir.IntType) and isinstance(var_type, ir.PointerType):
             # NOTE: This is assignment to a PTR_TO_MAP_VALUE_OR_NULL
             logger.info(

pythonbpf/debuginfo/debug_info_generator.py

@@ -49,6 +49,27 @@ def get_basic_type(self, name: str, size: int, encoding: int) -> Any:
             )
         return self._type_cache[key]
 
+    def get_int_type(self, ty) -> Any:
+        """Debug type for an integer IR type, by width and sign (read from the
+        IntTy descriptor, signed for a plain ir.IntType). A 1-bit type is C's
+        _Bool, which occupies one byte. BTF, and so a map's key and value
+        sizes, come from this, so the width must be the real one."""
+        from pythonbpf.type_deducer import signedness
+
+        width, signed = ty.width, signedness(ty)
+        if width == 1:
+            return self.get_basic_type("_Bool", 8, dc.DW_ATE_boolean)
+        base = {8: "char", 16: "short", 32: "int", 64: "long long"}.get(width)
+        if base is None:
+            raise ValueError(f"no debug type for a {width}-bit integer")
+        if width == 8:
+            encoding = dc.DW_ATE_signed_char if signed else dc.DW_ATE_unsigned_char
+        else:
+            encoding = dc.DW_ATE_signed if signed else dc.DW_ATE_unsigned
+        return self.get_basic_type(
+            base if signed else f"unsigned {base}", width, encoding
+        )
+
     def get_uint8_type(self) -> Any:
         """Get debug info for signed 8-bit integer"""
         return self.get_basic_type("char", 8, dc.DW_ATE_unsigned)

pythonbpf/expr/expr_pass.py

@@ -263,6 +263,7 @@ def get_typed_operand(func, compilation_context, operand, builder, local_sym_tab
             vmlinux_result = VmlinuxHandlerRegistry.handle_name(operand.id)
             if vmlinux_result is not None:
                 return vmlinux_result  # (i64 constant, its C rank)
+            raise SyntaxError(f"Undefined variable {operand.id}")
     elif isinstance(operand, ast.Constant):
         if isinstance(operand.value, (int, bool)):
             v = int(operand.value)

pythonbpf/functions/functions_pass.py

@@ -30,7 +30,7 @@
     LocalSymbol,
 )
 from .function_debug_info import generate_function_debug_info
-from .return_utils import handle_none_return, handle_xdp_return, is_xdp_name
+from .return_utils import handle_none_return
 from .function_metadata import get_probe_string, is_global_function, infer_return_type
 
 
@@ -341,20 +341,6 @@ def handle_return(
     logger.info(f"Handling return statement: {ast.dump(stmt)}")
     if stmt.value is None:
         return handle_none_return(builder)
-    elif (
-        isinstance(stmt.value, ast.Name)
-        and is_xdp_name(stmt.value.id)
-        and stmt.value.id not in local_sym_tab
-        and (
-            compilation_context is None
-            or stmt.value.id not in compilation_context.bpf_globals
-        )
-    ):
-        # The XDP fast path resolves names like XDP_PASS from the helper
-        # constant table, but only as a fallback: a local or @bpfglobal of the
-        # same name shadows it, mirroring C (a local shadows an enum constant)
-        # and the resolution order everywhere else in the compiler.
-        return handle_xdp_return(stmt, builder, ret_type)
     else:
         # Fallback for now if ctx not passed, but caller should pass it
         if compilation_context is None: