Merge pull request #23 from pythonbpf/formatter

update formatter and pre-commit

.pre-commit-config.yaml

@@ -21,7 +21,7 @@ ci:
 repos:
 # Standard hooks
 - repo: https://github.com/pre-commit/pre-commit-hooks
-  rev: v4.6.0
+  rev: v6.0.0
   hooks:
   - id: check-added-large-files
   - id: check-case-conflict
@@ -36,7 +36,7 @@ repos:
   - id: trailing-whitespace
 
 - repo: https://github.com/astral-sh/ruff-pre-commit
-  rev: "v0.4.2"
+  rev: "v0.13.2"
   hooks:
     - id: ruff
       args: ["--fix", "--show-fixes"]
@@ -45,7 +45,7 @@ repos:
 
 # Checking static types
 - repo: https://github.com/pre-commit/mirrors-mypy
-  rev: "v1.10.0"
+  rev: "v1.18.2"
   hooks:
     - id: mypy
       exclude: ^(tests)|^(examples)

TODO.md

@@ -1,7 +1,6 @@
 ## Short term
 
 - Implement enough functionality to port the BCC tutorial examples in PythonBPF
-- Static Typing
 - Add all maps
 - XDP support in pylibbpf
 - ringbuf support

examples/clone-matplotlib.ipynb

@@ -12,7 +12,7 @@
     "from pythonbpf import bpf, map, section, bpfglobal, BPF\n",
     "from pythonbpf.helper import pid\n",
     "from pythonbpf.maps import HashMap\n",
-    "from pylibbpf import *\n",
+    "from pylibbpf import BpfMap\n",
     "from ctypes import c_void_p, c_int64, c_uint64, c_int32\n",
     "import matplotlib.pyplot as plt"
    ]

examples/sys_sync.py

@@ -21,17 +21,17 @@ def last() -> HashMap:
 @section("tracepoint/syscalls/sys_enter_sync")
 def do_trace(ctx: c_void_p) -> c_int64:
     key = 0
-    tsp = last().lookup(key)
+    tsp = last.lookup(key)
     if tsp:
         kt = ktime()
         delta = kt - tsp
         if delta < 1000000000:
             time_ms = delta // 1000000
             print(f"sync called within last second, last {time_ms} ms ago")
-        last().delete(key)
+        last.delete(key)
     else:
         kt = ktime()
-        last().update(key, kt)
+        last.update(key, kt)
     return c_int64(0)
 
 

pythonbpf/binary_ops.py

@@ -8,68 +8,59 @@ logger: Logger = logging.getLogger(__name__)
 
 def recursive_dereferencer(var, builder):
     """dereference until primitive type comes out"""
-    if var.type == ir.PointerType(ir.PointerType(ir.IntType(64))):
+    # TODO: Not worrying about stack overflow for now
+    if isinstance(var.type, ir.PointerType):
         a = builder.load(var)
         return recursive_dereferencer(a, builder)
-    elif var.type == ir.PointerType(ir.IntType(64)):
+    elif isinstance(var.type, ir.IntType):
-        a = builder.load(var)
-        return recursive_dereferencer(a, builder)
-    elif var.type == ir.IntType(64):
         return var
     else:
         raise TypeError(f"Unsupported type for dereferencing: {var.type}")
 
 
-def handle_binary_op(rval, module, builder, var_name, local_sym_tab, map_sym_tab, func):
+def get_operand_value(operand, module, builder, local_sym_tab):
-    logger.info(f"module {module}")
+    """Extract the value from an operand, handling variables and constants."""
-    left = rval.left
+    if isinstance(operand, ast.Name):
-    right = rval.right
+        if operand.id in local_sym_tab:
+            return recursive_dereferencer(local_sym_tab[operand.id].var, builder)
+        raise ValueError(f"Undefined variable: {operand.id}")
+    elif isinstance(operand, ast.Constant):
+        if isinstance(operand.value, int):
+            return ir.Constant(ir.IntType(64), operand.value)
+        raise TypeError(f"Unsupported constant type: {type(operand.value)}")
+    elif isinstance(operand, ast.BinOp):
+        return handle_binary_op_impl(operand, module, builder, local_sym_tab)
+    raise TypeError(f"Unsupported operand type: {type(operand)}")
+
+
+def handle_binary_op_impl(rval, module, builder, local_sym_tab):
     op = rval.op
-
+    left = get_operand_value(rval.left, module, builder, local_sym_tab)
-    # Handle left operand
+    right = get_operand_value(rval.right, module, builder, local_sym_tab)
-    if isinstance(left, ast.Name):
-        if left.id in local_sym_tab:
-            left = recursive_dereferencer(local_sym_tab[left.id].var, builder)
-        else:
-            raise SyntaxError(f"Undefined variable: {left.id}")
-    elif isinstance(left, ast.Constant):
-        left = ir.Constant(ir.IntType(64), left.value)
-    else:
-        raise SyntaxError("Unsupported left operand type")
-
-    if isinstance(right, ast.Name):
-        if right.id in local_sym_tab:
-            right = recursive_dereferencer(local_sym_tab[right.id].var, builder)
-        else:
-            raise SyntaxError(f"Undefined variable: {right.id}")
-    elif isinstance(right, ast.Constant):
-        right = ir.Constant(ir.IntType(64), right.value)
-    else:
-        raise SyntaxError("Unsupported right operand type")
-
     logger.info(f"left is {left}, right is {right}, op is {op}")
 
-    if isinstance(op, ast.Add):
+    # Map AST operation nodes to LLVM IR builder methods
-        builder.store(builder.add(left, right), local_sym_tab[var_name].var)
+    op_map = {
-    elif isinstance(op, ast.Sub):
+        ast.Add: builder.add,
-        builder.store(builder.sub(left, right), local_sym_tab[var_name].var)
+        ast.Sub: builder.sub,
-    elif isinstance(op, ast.Mult):
+        ast.Mult: builder.mul,
-        builder.store(builder.mul(left, right), local_sym_tab[var_name].var)
+        ast.Div: builder.sdiv,
-    elif isinstance(op, ast.Div):
+        ast.Mod: builder.srem,
-        builder.store(builder.sdiv(left, right), local_sym_tab[var_name].var)
+        ast.LShift: builder.shl,
-    elif isinstance(op, ast.Mod):
+        ast.RShift: builder.lshr,
-        builder.store(builder.srem(left, right), local_sym_tab[var_name].var)
+        ast.BitOr: builder.or_,
-    elif isinstance(op, ast.LShift):
+        ast.BitXor: builder.xor,
-        builder.store(builder.shl(left, right), local_sym_tab[var_name].var)
+        ast.BitAnd: builder.and_,
-    elif isinstance(op, ast.RShift):
+        ast.FloorDiv: builder.udiv,
-        builder.store(builder.lshr(left, right), local_sym_tab[var_name].var)
+    }
-    elif isinstance(op, ast.BitOr):
+
-        builder.store(builder.or_(left, right), local_sym_tab[var_name].var)
+    if type(op) in op_map:
-    elif isinstance(op, ast.BitXor):
+        result = op_map[type(op)](left, right)
-        builder.store(builder.xor(left, right), local_sym_tab[var_name].var)
+        return result
-    elif isinstance(op, ast.BitAnd):
-        builder.store(builder.and_(left, right), local_sym_tab[var_name].var)
-    elif isinstance(op, ast.FloorDiv):
-        builder.store(builder.udiv(left, right), local_sym_tab[var_name].var)
     else:
         raise SyntaxError("Unsupported binary operation")
+
+
+def handle_binary_op(rval, module, builder, var_name, local_sym_tab):
+    result = handle_binary_op_impl(rval, module, builder, local_sym_tab)
+    builder.store(result, local_sym_tab[var_name].var)

pythonbpf/codegen.py

@@ -5,7 +5,7 @@ from .functions_pass import func_proc
 from .maps import maps_proc
 from .structs import structs_proc
 from .globals_pass import globals_processing
-from .debuginfo import DW_LANG_C11, DwarfBehaviorEnum
+from .debuginfo import DW_LANG_C11, DwarfBehaviorEnum, DebugInfoGenerator
 import os
 import subprocess
 import inspect
@@ -60,33 +60,17 @@ def compile_to_ir(filename: str, output: str, loglevel=logging.WARNING):
     module.triple = "bpf"
 
     if not hasattr(module, "_debug_compile_unit"):
-        module._file_metadata = module.add_debug_info(
+        debug_generator = DebugInfoGenerator(module)
-            "DIFile",
+        debug_generator.generate_file_metadata(filename, os.path.dirname(filename))
-            {  # type: ignore
+        debug_generator.generate_debug_cu(
-                "filename": filename,
+            DW_LANG_C11,
-                "directory": os.path.dirname(filename),
+            f"PythonBPF {VERSION}",
-            },
+            True,  # TODO: This is probably not true
+            # TODO: add a global field here that keeps track of all the globals. Works without it, but I think it might
+            # be required for kprobes.
+            True,
         )
 
-        module._debug_compile_unit = module.add_debug_info(
-            "DICompileUnit",
-            {  # type: ignore
-                "language": DW_LANG_C11,
-                "file": module._file_metadata,  # type: ignore
-                "producer": f"PythonBPF {VERSION}",
-                "isOptimized": True,  # TODO: This is probably not true
-                # TODO: add a global field here that keeps track of all the globals. Works without it, but I think it might
-                # be required for kprobes.
-                "runtimeVersion": 0,
-                "emissionKind": 1,
-                "splitDebugInlining": False,
-                "nameTableKind": 0,
-            },
-            is_distinct=True,
-        )
-
-        module.add_named_metadata("llvm.dbg.cu", module._debug_compile_unit)  # type: ignore
-
     processor(source, filename, module)
 
     wchar_size = module.add_metadata(

pythonbpf/debuginfo/debug_info_generator.py

@@ -12,6 +12,34 @@ class DebugInfoGenerator:
         self.module = module
         self._type_cache = {}  # Cache for common debug types
 
+    def generate_file_metadata(self, filename, dirname):
+        self.module._file_metadata = self.module.add_debug_info(
+            "DIFile",
+            {  # type: ignore
+                "filename": filename,
+                "directory": dirname,
+            },
+        )
+
+    def generate_debug_cu(
+        self, language, producer: str, is_optimized: bool, is_distinct: bool
+    ):
+        self.module._debug_compile_unit = self.module.add_debug_info(
+            "DICompileUnit",
+            {  # type: ignore
+                "language": language,
+                "file": self.module._file_metadata,  # type: ignore
+                "producer": producer,
+                "isOptimized": is_optimized,
+                "runtimeVersion": 0,
+                "emissionKind": 1,
+                "splitDebugInlining": False,
+                "nameTableKind": 0,
+            },
+            is_distinct=is_distinct,
+        )
+        self.module.add_named_metadata("llvm.dbg.cu", self.module._debug_compile_unit)  # type: ignore
+
     def get_basic_type(self, name: str, size: int, encoding: int) -> Any:
         """Get or create a basic type with caching"""
         key = (name, size, encoding)

pythonbpf/expr_pass.py

@@ -2,10 +2,92 @@ import ast
 from llvmlite import ir
 from logging import Logger
 import logging
+from typing import Dict
 
 logger: Logger = logging.getLogger(__name__)
 
 
+def _handle_name_expr(expr: ast.Name, local_sym_tab: Dict, builder: ir.IRBuilder):
+    """Handle ast.Name expressions."""
+    if expr.id in local_sym_tab:
+        var = local_sym_tab[expr.id].var
+        val = builder.load(var)
+        return val, local_sym_tab[expr.id].ir_type
+    else:
+        logger.info(f"Undefined variable {expr.id}")
+        return None
+
+
+def _handle_constant_expr(expr: ast.Constant):
+    """Handle ast.Constant expressions."""
+    if isinstance(expr.value, int):
+        return ir.Constant(ir.IntType(64), expr.value), ir.IntType(64)
+    elif isinstance(expr.value, bool):
+        return ir.Constant(ir.IntType(1), int(expr.value)), ir.IntType(1)
+    else:
+        logger.info("Unsupported constant type")
+        return None
+
+
+def _handle_attribute_expr(
+    expr: ast.Attribute,
+    local_sym_tab: Dict,
+    structs_sym_tab: Dict,
+    builder: ir.IRBuilder,
+):
+    """Handle ast.Attribute expressions for struct field access."""
+    if isinstance(expr.value, ast.Name):
+        var_name = expr.value.id
+        attr_name = expr.attr
+        if var_name in local_sym_tab:
+            var_ptr, var_type, var_metadata = local_sym_tab[var_name]
+            logger.info(f"Loading attribute {attr_name} from variable {var_name}")
+            logger.info(f"Variable type: {var_type}, Variable ptr: {var_ptr}")
+
+            metadata = structs_sym_tab[var_metadata]
+            if attr_name in metadata.fields:
+                gep = metadata.gep(builder, var_ptr, attr_name)
+                val = builder.load(gep)
+                field_type = metadata.field_type(attr_name)
+                return val, field_type
+    return None
+
+
+def _handle_deref_call(expr: ast.Call, local_sym_tab: Dict, builder: ir.IRBuilder):
+    """Handle deref function calls."""
+    logger.info(f"Handling deref {ast.dump(expr)}")
+    if len(expr.args) != 1:
+        logger.info("deref takes exactly one argument")
+        return None
+
+    arg = expr.args[0]
+    if (
+        isinstance(arg, ast.Call)
+        and isinstance(arg.func, ast.Name)
+        and arg.func.id == "deref"
+    ):
+        logger.info("Multiple deref not supported")
+        return None
+
+    if isinstance(arg, ast.Name):
+        if arg.id in local_sym_tab:
+            arg_ptr = local_sym_tab[arg.id].var
+        else:
+            logger.info(f"Undefined variable {arg.id}")
+            return None
+    else:
+        logger.info("Unsupported argument type for deref")
+        return None
+
+    if arg_ptr is None:
+        logger.info("Failed to evaluate deref argument")
+        return None
+
+    # Load the value from pointer
+    val = builder.load(arg_ptr)
+    return val, local_sym_tab[arg.id].ir_type
+
+
 def eval_expr(
     func,
     module,
@@ -17,64 +99,28 @@ def eval_expr(
 ):
     logger.info(f"Evaluating expression: {ast.dump(expr)}")
     if isinstance(expr, ast.Name):
-        if expr.id in local_sym_tab:
+        return _handle_name_expr(expr, local_sym_tab, builder)
-            var = local_sym_tab[expr.id].var
-            val = builder.load(var)
-            return val, local_sym_tab[expr.id].ir_type  # return value and type
-        else:
-            logger.info(f"Undefined variable {expr.id}")
-            return None
     elif isinstance(expr, ast.Constant):
-        if isinstance(expr.value, int):
+        return _handle_constant_expr(expr)
-            return ir.Constant(ir.IntType(64), expr.value), ir.IntType(64)
-        elif isinstance(expr.value, bool):
-            return ir.Constant(ir.IntType(1), int(expr.value)), ir.IntType(1)
-        else:
-            logger.info("Unsupported constant type")
-            return None
     elif isinstance(expr, ast.Call):
+        if isinstance(expr.func, ast.Name) and expr.func.id == "deref":
+            return _handle_deref_call(expr, local_sym_tab, builder)
+
         # delayed import to avoid circular dependency
         from pythonbpf.helper import HelperHandlerRegistry, handle_helper_call
 
-        if isinstance(expr.func, ast.Name):
+        if isinstance(expr.func, ast.Name) and HelperHandlerRegistry.has_handler(
-            # check deref
+            expr.func.id
-            if expr.func.id == "deref":
+        ):
-                logger.info(f"Handling deref {ast.dump(expr)}")
+            return handle_helper_call(
-                if len(expr.args) != 1:
+                expr,
-                    logger.info("deref takes exactly one argument")
+                module,
-                    return None
+                builder,
-                arg = expr.args[0]
+                func,
-                if (
+                local_sym_tab,
-                    isinstance(arg, ast.Call)
+                map_sym_tab,
-                    and isinstance(arg.func, ast.Name)
+                structs_sym_tab,
-                    and arg.func.id == "deref"
+            )
-                ):
-                    logger.info("Multiple deref not supported")
-                    return None
-                if isinstance(arg, ast.Name):
-                    if arg.id in local_sym_tab:
-                        arg = local_sym_tab[arg.id].var
-                    else:
-                        logger.info(f"Undefined variable {arg.id}")
-                        return None
-                if arg is None:
-                    logger.info("Failed to evaluate deref argument")
-                    return None
-                # Since we are handling only name case, directly take type from sym tab
-                val = builder.load(arg)
-                return val, local_sym_tab[expr.args[0].id].ir_type
-
-            # check for helpers
-            if HelperHandlerRegistry.has_handler(expr.func.id):
-                return handle_helper_call(
-                    expr,
-                    module,
-                    builder,
-                    func,
-                    local_sym_tab,
-                    map_sym_tab,
-                    structs_sym_tab,
-                )
         elif isinstance(expr.func, ast.Attribute):
             logger.info(f"Handling method call: {ast.dump(expr.func)}")
             if isinstance(expr.func.value, ast.Call) and isinstance(
@@ -106,19 +152,7 @@ def eval_expr(
                             structs_sym_tab,
                         )
     elif isinstance(expr, ast.Attribute):
-        if isinstance(expr.value, ast.Name):
+        return _handle_attribute_expr(expr, local_sym_tab, structs_sym_tab, builder)
-            var_name = expr.value.id
-            attr_name = expr.attr
-            if var_name in local_sym_tab:
-                var_ptr, var_type, var_metadata = local_sym_tab[var_name]
-                logger.info(f"Loading attribute {attr_name} from variable {var_name}")
-                logger.info(f"Variable type: {var_type}, Variable ptr: {var_ptr}")
-                metadata = structs_sym_tab[var_metadata]
-                if attr_name in metadata.fields:
-                    gep = metadata.gep(builder, var_ptr, attr_name)
-                    val = builder.load(gep)
-                    field_type = metadata.field_type(attr_name)
-                    return val, field_type
     logger.info("Unsupported expression evaluation")
     return None
 

pythonbpf/functions_pass.py

@@ -146,8 +146,7 @@ def handle_assign(
                     local_sym_tab[var_name].var,
                 )
                 logger.info(
-                    f"Assigned {call_type} constant "
+                    f"Assigned {call_type} constant {rval.args[0].value} to {var_name}"
-                    f"{rval.args[0].value} to {var_name}"
                 )
             elif HelperHandlerRegistry.has_handler(call_type):
                 # var = builder.alloca(ir.IntType(64), name=var_name)
@@ -192,8 +191,23 @@ def handle_assign(
         elif isinstance(rval.func, ast.Attribute):
             logger.info(f"Assignment call attribute: {ast.dump(rval.func)}")
             if isinstance(rval.func.value, ast.Name):
-                # TODO: probably a struct access
+                if rval.func.value.id in map_sym_tab:
-                logger.info(f"TODO STRUCT ACCESS {ast.dump(rval)}")
+                    map_name = rval.func.value.id
+                    method_name = rval.func.attr
+                    if HelperHandlerRegistry.has_handler(method_name):
+                        val = handle_helper_call(
+                            rval,
+                            module,
+                            builder,
+                            func,
+                            local_sym_tab,
+                            map_sym_tab,
+                            structs_sym_tab,
+                        )
+                        builder.store(val[0], local_sym_tab[var_name].var)
+                else:
+                    # TODO: probably a struct access
+                    logger.info(f"TODO STRUCT ACCESS {ast.dump(rval)}")
             elif isinstance(rval.func.value, ast.Call) and isinstance(
                 rval.func.value.func, ast.Name
             ):
@@ -218,9 +232,7 @@ def handle_assign(
         else:
             logger.info("Unsupported assignment call function type")
     elif isinstance(rval, ast.BinOp):
-        handle_binary_op(
+        handle_binary_op(rval, module, builder, var_name, local_sym_tab)
-            rval, module, builder, var_name, local_sym_tab, map_sym_tab, func
-        )
     else:
         logger.info("Unsupported assignment value type")
 
@@ -470,8 +482,7 @@ def allocate_mem(
                         var = builder.alloca(ir_type, name=var_name)
                         has_metadata = True
                         logger.info(
-                            f"Pre-allocated variable {var_name} "
+                            f"Pre-allocated variable {var_name} for struct {call_type}"
-                            f"for struct {call_type}"
                         )
                 elif isinstance(rval.func, ast.Attribute):
                     ir_type = ir.PointerType(ir.IntType(64))

pythonbpf/helper/bpf_helper_handler.py

@@ -62,7 +62,7 @@ def bpf_map_lookup_elem_emitter(
     """
     if not call.args or len(call.args) != 1:
         raise ValueError(
-            "Map lookup expects exactly one argument (key), got " f"{len(call.args)}"
+            f"Map lookup expects exactly one argument (key), got {len(call.args)}"
         )
     key_ptr = get_or_create_ptr_from_arg(call.args[0], builder, local_sym_tab)
     map_void_ptr = builder.bitcast(map_ptr, ir.PointerType())
@@ -145,8 +145,7 @@ def bpf_map_update_elem_emitter(
     """
     if not call.args or len(call.args) < 2 or len(call.args) > 3:
         raise ValueError(
-            "Map update expects 2 or 3 args (key, value, flags), "
+            f"Map update expects 2 or 3 args (key, value, flags), got {len(call.args)}"
-            f"got {len(call.args)}"
         )
 
     key_arg = call.args[0]
@@ -196,7 +195,7 @@ def bpf_map_delete_elem_emitter(
     """
     if not call.args or len(call.args) != 1:
         raise ValueError(
-            "Map delete expects exactly one argument (key), got " f"{len(call.args)}"
+            f"Map delete expects exactly one argument (key), got {len(call.args)}"
         )
     key_ptr = get_or_create_ptr_from_arg(call.args[0], builder, local_sym_tab)
     map_void_ptr = builder.bitcast(map_ptr, ir.PointerType())
@@ -255,7 +254,7 @@ def bpf_perf_event_output_handler(
 ):
     if len(call.args) != 1:
         raise ValueError(
-            "Perf event output expects exactly one argument, " f"got {len(call.args)}"
+            f"Perf event output expects exactly one argument, got {len(call.args)}"
         )
     data_arg = call.args[0]
     ctx_ptr = func.args[0]  # First argument to the function is ctx

pythonbpf/helper/helper_utils.py

@@ -270,7 +270,7 @@ def _prepare_expr_args(expr, func, module, builder, local_sym_tab, struct_sym_ta
                 val = builder.sext(val, ir.IntType(64))
         else:
             logger.warning(
-                "Only int and ptr supported in bpf_printk args. " "Others default to 0."
+                "Only int and ptr supported in bpf_printk args. Others default to 0."
             )
             val = ir.Constant(ir.IntType(64), 0)
         return val

pythonbpf/maps/maps_pass.py

@@ -278,9 +278,7 @@ def process_bpf_map(func_node, module):
         if handler:
             return handler(map_name, rval, module)
         else:
-            logger.warning(
+            logger.warning(f"Unknown map type {rval.func.id}, defaulting to HashMap")
-                f"Unknown map type " f"{rval.func.id}, defaulting to HashMap"
-            )
             return process_hash_map(map_name, rval, module)
     else:
         raise ValueError("Function under @map must return a map")

tests/passing_tests/binops.py

@@ -3,9 +3,9 @@ from ctypes import c_void_p, c_int64
 
 
 @bpf
-@section("sometag1")
+@section("tracepoint/syscalls/sys_enter_sync")
 def sometag(ctx: c_void_p) -> c_int64:
-    a = 1 + 2 + 1
+    a = 1 + 2 + 1 + 12 + 13
     print(f"{a}")
     return c_int64(0)
 

tests/passing_tests/binops1.py

@@ -3,11 +3,12 @@ from ctypes import c_void_p, c_int64
 
 
 @bpf
-@section("sometag1")
+@section("tracepoint/syscalls/sys_enter_sync")
 def sometag(ctx: c_void_p) -> c_int64:
     b = 1 + 2
     a = 1 + b
-    return c_int64(a)
+    print(f"{a}")
+    return c_int64(0)
 
 
 @bpf