Clarify compilation target in package documentation

Updated documentation to clarify that the compilation targets LLVM IR instead of eBPF bytecode directly.

.gitignore

@@ -7,3 +7,4 @@ __pycache__/
 *.ll
 *.o
 .ipynb_checkpoints/
+vmlinux.py

pythonbpf/__init__.py

@@ -1,3 +1,10 @@
+"""
+PythonBPF - A Python frontend for eBPF programs.
+
+This package provides decorators and compilation tools to write BPF programs
+in Python syntax and compile them to LLVM IR that can be compiled to eBPF bytecode.
+"""
+
 from .decorators import bpf, map, section, bpfglobal, struct
 from .codegen import compile_to_ir, compile, BPF
 

pythonbpf/binary_ops.py

@@ -1,3 +1,10 @@
+"""
+Binary operations handling for BPF programs.
+
+This module provides functions to handle binary operations (add, subtract,
+multiply, etc.) and emit the corresponding LLVM IR instructions.
+"""
+
 import ast
 from llvmlite import ir
 from logging import Logger
@@ -35,6 +42,17 @@ def get_operand_value(operand, builder, local_sym_tab):
 
 
 def handle_binary_op_impl(rval, builder, local_sym_tab):
+    """
+    Handle binary operations and emit corresponding LLVM IR instructions.
+
+    Args:
+        rval: The AST BinOp node representing the binary operation
+        builder: LLVM IR builder for emitting instructions
+        local_sym_tab: Symbol table mapping variable names to their IR representations
+
+    Returns:
+        The LLVM IR value representing the result of the binary operation
+    """
     op = rval.op
     left = get_operand_value(rval.left, builder, local_sym_tab)
     right = get_operand_value(rval.right, builder, local_sym_tab)
@@ -63,6 +81,18 @@ def handle_binary_op_impl(rval, builder, local_sym_tab):
 
 
 def handle_binary_op(rval, builder, var_name, local_sym_tab):
+    """
+    Handle binary operations and optionally store the result to a variable.
+
+    Args:
+        rval: The AST BinOp node representing the binary operation
+        builder: LLVM IR builder for emitting instructions
+        var_name: Optional variable name to store the result
+        local_sym_tab: Symbol table mapping variable names to their IR representations
+
+    Returns:
+        A tuple of (result_value, result_type)
+    """
     result = handle_binary_op_impl(rval, builder, local_sym_tab)
     if var_name and var_name in local_sym_tab:
         logger.info(

pythonbpf/codegen.py

@@ -1,3 +1,11 @@
+"""
+Code generation module for PythonBPF.
+
+This module handles the conversion of Python BPF programs to LLVM IR and
+object files. It provides the main compilation pipeline from Python AST
+to BPF bytecode.
+"""
+
 import ast
 from llvmlite import ir
 from .license_pass import license_processing
@@ -37,6 +45,14 @@ def find_bpf_chunks(tree):
 
 
 def processor(source_code, filename, module):
+    """
+    Process Python source code and convert BPF-decorated functions to LLVM IR.
+
+    Args:
+        source_code: The Python source code to process
+        filename: The name of the source file
+        module: The LLVM IR module to populate
+    """
     tree = ast.parse(source_code, filename)
     logger.debug(ast.dump(tree, indent=4))
 
@@ -56,6 +72,17 @@ def processor(source_code, filename, module):
 
 
 def compile_to_ir(filename: str, output: str, loglevel=logging.INFO):
+    """
+    Compile a Python BPF program to LLVM IR.
+
+    Args:
+        filename: Path to the Python source file containing BPF programs
+        output: Path where the LLVM IR (.ll) file will be written
+        loglevel: Logging level for compilation messages
+
+    Returns:
+        Path to the generated LLVM IR file
+    """
     logging.basicConfig(
         level=loglevel, format="%(asctime)s [%(levelname)s] %(name)s: %(message)s"
     )
@@ -129,6 +156,18 @@ def compile_to_ir(filename: str, output: str, loglevel=logging.INFO):
 
 
 def compile(loglevel=logging.INFO) -> bool:
+    """
+    Compile the calling Python BPF program to an object file.
+
+    This function should be called from a Python file containing BPF programs.
+    It will compile the calling file to LLVM IR and then to a BPF object file.
+
+    Args:
+        loglevel: Logging level for compilation messages
+
+    Returns:
+        True if compilation succeeded, False otherwise
+    """
     # Look one level up the stack to the caller of this function
     caller_frame = inspect.stack()[1]
     caller_file = Path(caller_frame.filename).resolve()
@@ -162,6 +201,18 @@ def compile(loglevel=logging.INFO) -> bool:
 
 
 def BPF(loglevel=logging.INFO) -> BpfProgram:
+    """
+    Compile the calling Python BPF program and return a BpfProgram object.
+
+    This function compiles the calling file's BPF programs to an object file
+    and loads it into a BpfProgram object for immediate use.
+
+    Args:
+        loglevel: Logging level for compilation messages
+
+    Returns:
+        A BpfProgram object that can be used to load and attach BPF programs
+    """
     caller_frame = inspect.stack()[1]
     src = inspect.getsource(caller_frame.frame)
     with tempfile.NamedTemporaryFile(

pythonbpf/debuginfo/__init__.py

@@ -1,3 +1,5 @@
+"""Debug information generation for BPF programs (DWARF/BTF)."""
+
 from .dwarf_constants import *  # noqa: F403
 from .dtypes import *  # noqa: F403
 from .debug_info_generator import DebugInfoGenerator

pythonbpf/debuginfo/debug_info_generator.py

@@ -8,11 +8,31 @@ from typing import Any, List
 
 
 class DebugInfoGenerator:
+    """
+    Generator for DWARF/BTF debug information in LLVM IR modules.
+
+    This class provides methods to create debug metadata for BPF programs,
+    including types, structs, globals, and compilation units.
+    """
+
     def __init__(self, module):
+        """
+        Initialize the debug info generator.
+
+        Args:
+            module: LLVM IR module to attach debug info to
+        """
         self.module = module
         self._type_cache = {}  # Cache for common debug types
 
     def generate_file_metadata(self, filename, dirname):
+        """
+        Generate file metadata for debug info.
+
+        Args:
+            filename: Name of the source file
+            dirname: Directory containing the source file
+        """
         self.module._file_metadata = self.module.add_debug_info(
             "DIFile",
             {  # type: ignore
@@ -24,6 +44,15 @@ class DebugInfoGenerator:
     def generate_debug_cu(
         self, language, producer: str, is_optimized: bool, is_distinct: bool
     ):
+        """
+        Generate debug compile unit metadata.
+
+        Args:
+            language: DWARF language code (e.g., DW_LANG_C11)
+            producer: Compiler/producer string
+            is_optimized: Whether the code is optimized
+            is_distinct: Whether the compile unit should be distinct
+        """
         self.module._debug_compile_unit = self.module.add_debug_info(
             "DICompileUnit",
             {  # type: ignore
@@ -83,6 +112,16 @@ class DebugInfoGenerator:
 
     @staticmethod
     def _compute_array_size(base_type: Any, count: int) -> int:
+        """
+        Compute the size of an array in bits.
+
+        Args:
+            base_type: The base type of the array
+            count: Number of elements in the array
+
+        Returns:
+            Total size in bits
+        """
         # Extract size from base_type if possible
         # For simplicity, assuming base_type has a size attribute
         return getattr(base_type, "size", 32) * count

pythonbpf/debuginfo/dtypes.py

@@ -1,7 +1,11 @@
+"""Debug information types and constants."""
+
 import llvmlite.ir as ir
 
 
 class DwarfBehaviorEnum:
+    """DWARF module flag behavior constants for LLVM."""
+
     ERROR_IF_MISMATCH = ir.Constant(ir.IntType(32), 1)
     WARNING_IF_MISMATCH = ir.Constant(ir.IntType(32), 2)
     OVERRIDE_USE_LARGEST = ir.Constant(ir.IntType(32), 7)

pythonbpf/debuginfo/dwarf_constants.py

@@ -1,3 +1,9 @@
+"""
+DWARF debugging format constants.
+
+Generated constants from dwarf.h for use in debug information generation.
+"""
+
 # generated constants from dwarf.h
 
 DW_UT_compile = 0x01

pythonbpf/decorators.py

@@ -1,3 +1,11 @@
+"""
+Decorators for marking BPF functions, maps, structs, and globals.
+
+This module provides the core decorators used to annotate Python code
+for BPF compilation.
+"""
+
+
 def bpf(func):
     """Decorator to mark a function for BPF compilation."""
     func._is_bpf = True
@@ -23,7 +31,18 @@ def struct(cls):
 
 
 def section(name: str):
+    """
+    Decorator to specify the ELF section name for a BPF program.
+
+    Args:
+        name: The section name (e.g., 'xdp', 'tracepoint/syscalls/sys_enter_execve')
+
+    Returns:
+        A decorator function that marks the function with the section name
+    """
+
     def wrapper(fn):
+        """Decorator that sets the section name on the function."""
         fn._section = name
         return fn
 

pythonbpf/expr/__init__.py

@@ -1,3 +1,5 @@
+"""Expression evaluation and processing for BPF programs."""
+
 from .expr_pass import eval_expr, handle_expr
 from .type_normalization import convert_to_bool
 

pythonbpf/expr/expr_pass.py

@@ -1,3 +1,11 @@
+"""
+Expression evaluation and LLVM IR generation.
+
+This module handles the evaluation of Python expressions in BPF programs,
+including variables, constants, function calls, comparisons, boolean
+operations, and more.
+"""
+
 import ast
 from llvmlite import ir
 from logging import Logger
@@ -332,6 +340,21 @@ def eval_expr(
     map_sym_tab,
     structs_sym_tab=None,
 ):
+    """
+    Evaluate an expression and return its LLVM IR value and type.
+
+    Args:
+        func: The LLVM IR function being built
+        module: The LLVM IR module
+        builder: LLVM IR builder
+        expr: The AST expression node to evaluate
+        local_sym_tab: Local symbol table
+        map_sym_tab: Map symbol table
+        structs_sym_tab: Struct symbol table
+
+    Returns:
+        A tuple of (value, type) or None if evaluation fails
+    """
     logger.info(f"Evaluating expression: {ast.dump(expr)}")
     if isinstance(expr, ast.Name):
         return _handle_name_expr(expr, local_sym_tab, builder)

pythonbpf/expr/type_normalization.py

@@ -1,3 +1,10 @@
+"""
+Type normalization and comparison operations for expressions.
+
+This module provides utilities for normalizing types between expressions,
+handling pointer dereferencing, and generating comparison operations.
+"""
+
 from llvmlite import ir
 import logging
 import ast
@@ -17,7 +24,15 @@ COMPARISON_OPS = {
 
 
 def _get_base_type_and_depth(ir_type):
-    """Get the base type for pointer types."""
+    """
+    Get the base type and pointer depth for an LLVM IR type.
+
+    Args:
+        ir_type: The LLVM IR type to analyze
+
+    Returns:
+        A tuple of (base_type, depth) where depth is the number of pointer levels
+    """
     cur_type = ir_type
     depth = 0
     while isinstance(cur_type, ir.PointerType):
@@ -27,7 +42,18 @@ def _get_base_type_and_depth(ir_type):
 
 
 def _deref_to_depth(func, builder, val, target_depth):
-    """Dereference a pointer to a certain depth."""
+    """
+    Dereference a pointer to a certain depth with null checks.
+
+    Args:
+        func: The LLVM IR function being built
+        builder: LLVM IR builder
+        val: The pointer value to dereference
+        target_depth: Number of levels to dereference
+
+    Returns:
+        The dereferenced value, or None if dereferencing fails
+    """
 
     cur_val = val
     cur_type = val.type
@@ -73,7 +99,18 @@ def _deref_to_depth(func, builder, val, target_depth):
 
 
 def _normalize_types(func, builder, lhs, rhs):
-    """Normalize types for comparison."""
+    """
+    Normalize types for comparison by casting or dereferencing as needed.
+
+    Args:
+        func: The LLVM IR function being built
+        builder: LLVM IR builder
+        lhs: Left-hand side value
+        rhs: Right-hand side value
+
+    Returns:
+        A tuple of (normalized_lhs, normalized_rhs) or (None, None) on error
+    """
 
     logger.info(f"Normalizing types: {lhs.type} vs {rhs.type}")
     if isinstance(lhs.type, ir.IntType) and isinstance(rhs.type, ir.IntType):
@@ -99,7 +136,16 @@ def _normalize_types(func, builder, lhs, rhs):
 
 
 def convert_to_bool(builder, val):
-    """Convert a value to boolean."""
+    """
+    Convert an LLVM IR value to a boolean (i1) type.
+
+    Args:
+        builder: LLVM IR builder
+        val: The value to convert
+
+    Returns:
+        An i1 boolean value
+    """
     if val.type == ir.IntType(1):
         return val
     if isinstance(val.type, ir.PointerType):
@@ -110,7 +156,19 @@ def convert_to_bool(builder, val):
 
 
 def handle_comparator(func, builder, op, lhs, rhs):
-    """Handle comparison operations."""
+    """
+    Handle comparison operations between two values.
+
+    Args:
+        func: The LLVM IR function being built
+        builder: LLVM IR builder
+        op: The AST comparison operator node
+        lhs: Left-hand side value
+        rhs: Right-hand side value
+
+    Returns:
+        A tuple of (result, ir.IntType(1)) or None on error
+    """
 
     if lhs.type != rhs.type:
         lhs, rhs = _normalize_types(func, builder, lhs, rhs)

pythonbpf/functions/__init__.py

@@ -1,3 +1,5 @@
+"""BPF function processing and LLVM IR generation."""
+
 from .functions_pass import func_proc
 
 __all__ = ["func_proc"]

pythonbpf/functions/func_registry_handlers.py

@@ -1,3 +1,5 @@
+"""Registry for statement handler functions."""
+
 from typing import Dict
 
 
@@ -11,6 +13,7 @@ class StatementHandlerRegistry:
         """Register a handler for a specific statement type."""
 
         def decorator(handler):
+            """Decorator that registers the handler."""
             cls._handlers[stmt_type] = handler
             return handler
 

pythonbpf/functions/functions_pass.py

@@ -1,3 +1,11 @@
+"""
+BPF function processing and LLVM IR generation.
+
+This module handles the core function processing, converting Python function
+definitions into LLVM IR for BPF programs. It manages local variables,
+control flow, and statement processing.
+"""
+
 from llvmlite import ir
 import ast
 import logging
@@ -17,11 +25,21 @@ logger = logging.getLogger(__name__)
 
 @dataclass
 class LocalSymbol:
+    """
+    Represents a local variable in a BPF function.
+
+    Attributes:
+        var: LLVM IR alloca instruction for the variable
+        ir_type: LLVM IR type of the variable
+        metadata: Optional metadata (e.g., struct type name)
+    """
+
     var: ir.AllocaInstr
     ir_type: ir.Type
     metadata: Any = None
 
     def __iter__(self):
+        """Support tuple unpacking of LocalSymbol."""
         yield self.var
         yield self.ir_type
         yield self.metadata
@@ -243,6 +261,21 @@ def handle_assign(
 def handle_cond(
     func, module, builder, cond, local_sym_tab, map_sym_tab, structs_sym_tab=None
 ):
+    """
+    Evaluate a condition expression and convert it to a boolean value.
+
+    Args:
+        func: The LLVM IR function being built
+        module: The LLVM IR module
+        builder: LLVM IR builder
+        cond: The AST condition node to evaluate
+        local_sym_tab: Local symbol table
+        map_sym_tab: Map symbol table
+        structs_sym_tab: Struct symbol table
+
+    Returns:
+        LLVM IR boolean value representing the condition result
+    """
     val = eval_expr(
         func, module, builder, cond, local_sym_tab, map_sym_tab, structs_sym_tab
     )[0]
@@ -298,6 +331,18 @@ def handle_if(
 
 
 def handle_return(builder, stmt, local_sym_tab, ret_type):
+    """
+    Handle return statements in BPF functions.
+
+    Args:
+        builder: LLVM IR builder
+        stmt: The AST Return node
+        local_sym_tab: Local symbol table
+        ret_type: Expected return type
+
+    Returns:
+        True if a return was emitted, False otherwise
+    """
     logger.info(f"Handling return statement: {ast.dump(stmt)}")
     if stmt.value is None:
         return _handle_none_return(builder)
@@ -329,6 +374,23 @@ def process_stmt(
     did_return,
     ret_type=ir.IntType(64),
 ):
+    """
+    Process a single statement in a BPF function.
+
+    Args:
+        func: The LLVM IR function being built
+        module: The LLVM IR module
+        builder: LLVM IR builder
+        stmt: The AST statement node to process
+        local_sym_tab: Local symbol table
+        map_sym_tab: Map symbol table
+        structs_sym_tab: Struct symbol table
+        did_return: Whether a return has been emitted
+        ret_type: Expected return type
+
+    Returns:
+        True if a return was emitted, False otherwise
+    """
     logger.info(f"Processing statement: {ast.dump(stmt)}")
     if isinstance(stmt, ast.Expr):
         handle_expr(
@@ -363,6 +425,25 @@ def process_stmt(
 def allocate_mem(
     module, builder, body, func, ret_type, map_sym_tab, local_sym_tab, structs_sym_tab
 ):
+    """
+    Pre-allocate stack memory for local variables in a BPF function.
+
+    This function scans the function body and creates alloca instructions
+    for all local variables before processing the function statements.
+
+    Args:
+        module: The LLVM IR module
+        builder: LLVM IR builder
+        body: List of AST statements in the function body
+        func: The LLVM IR function being built
+        ret_type: Expected return type
+        map_sym_tab: Map symbol table
+        local_sym_tab: Local symbol table to populate
+        structs_sym_tab: Struct symbol table
+
+    Returns:
+        Updated local symbol table
+    """
     for stmt in body:
         has_metadata = False
         if isinstance(stmt, ast.If):
@@ -556,6 +637,16 @@ def process_bpf_chunk(func_node, module, return_type, map_sym_tab, structs_sym_t
 
 
 def func_proc(tree, module, chunks, map_sym_tab, structs_sym_tab):
+    """
+    Process all BPF function chunks and generate LLVM IR.
+
+    Args:
+        tree: The Python AST (not used in current implementation)
+        module: The LLVM IR module to add functions to
+        chunks: List of AST function nodes decorated with @bpf
+        map_sym_tab: Map symbol table
+        structs_sym_tab: Struct symbol table
+    """
     for func_node in chunks:
         is_global = False
         for decorator in func_node.decorator_list:
@@ -581,6 +672,18 @@ def func_proc(tree, module, chunks, map_sym_tab, structs_sym_tab):
 
 
 def infer_return_type(func_node: ast.FunctionDef):
+    """
+    Infer the return type of a BPF function from annotations or return statements.
+
+    Args:
+        func_node: The AST function node
+
+    Returns:
+        String representation of the return type (e.g., 'c_int64')
+
+    Raises:
+        TypeError: If func_node is not a FunctionDef
+    """
     if not isinstance(func_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
         raise TypeError("Expected ast.FunctionDef")
     if func_node.returns is not None:
@@ -599,6 +702,7 @@ def infer_return_type(func_node: ast.FunctionDef):
     found_type = None
 
     def _expr_type(e):
+        """Helper function to extract type from an expression."""
         if e is None:
             return "None"
         if isinstance(e, ast.Constant):

pythonbpf/functions/return_utils.py

@@ -1,3 +1,10 @@
+"""
+Utility functions for handling return statements in BPF functions.
+
+Provides handlers for different types of returns including XDP actions,
+None returns, and standard returns.
+"""
+
 import logging
 import ast
 

pythonbpf/globals_pass.py

@@ -1,3 +1,10 @@
+"""
+Global variables and compiler metadata processing.
+
+This module handles BPF global variables and emits the @llvm.compiler.used
+metadata to prevent LLVM from optimizing away important symbols.
+"""
+
 from llvmlite import ir
 import ast
 
@@ -12,6 +19,16 @@ global_sym_tab = []
 
 
 def populate_global_symbol_table(tree, module: ir.Module):
+    """
+    Populate the global symbol table with BPF functions, maps, and globals.
+
+    Args:
+        tree: The Python AST to scan for global symbols
+        module: The LLVM IR module (not used in current implementation)
+
+    Returns:
+        False (legacy return value)
+    """
     for node in tree.body:
         if isinstance(node, ast.FunctionDef):
             for dec in node.decorator_list:
@@ -33,6 +50,17 @@ def populate_global_symbol_table(tree, module: ir.Module):
 
 
 def emit_global(module: ir.Module, node, name):
+    """
+    Emit a BPF global variable into the LLVM IR module.
+
+    Args:
+        module: The LLVM IR module to add the global variable to
+        node: The AST function node containing the global definition
+        name: The name of the global variable
+
+    Returns:
+        The created global variable
+    """
     logger.info(f"global identifier {name} processing")
     # deduce LLVM type from the annotated return
     if not isinstance(node.returns, ast.Name):
@@ -117,7 +145,11 @@ def globals_processing(tree, module):
 
 def emit_llvm_compiler_used(module: ir.Module, names: list[str]):
     """
-    Emit the @llvm.compiler.used global given a list of function/global names.
+    Emit the @llvm.compiler.used global to prevent LLVM from optimizing away symbols.
+
+    Args:
+        module: The LLVM IR module to add the compiler.used metadata to
+        names: List of function/global names that must be preserved
     """
     ptr_ty = ir.PointerType()
     used_array_ty = ir.ArrayType(ptr_ty, len(names))
@@ -138,6 +170,13 @@ def emit_llvm_compiler_used(module: ir.Module, names: list[str]):
 
 
 def globals_list_creation(tree, module: ir.Module):
+    """
+    Collect all BPF symbols and emit @llvm.compiler.used metadata.
+
+    Args:
+        tree: The Python AST to scan for symbols
+        module: The LLVM IR module to add metadata to
+    """
     collected = ["LICENSE"]
 
     for node in tree.body:

pythonbpf/helper/__init__.py

@@ -1,3 +1,5 @@
+"""BPF helper functions and handlers."""
+
 from .helper_utils import HelperHandlerRegistry
 from .bpf_helper_handler import handle_helper_call
 from .helpers import ktime, pid, deref, XDP_DROP, XDP_PASS

pythonbpf/helper/bpf_helper_handler.py

@@ -1,3 +1,11 @@
+"""
+BPF helper function handlers for LLVM IR emission.
+
+This module provides handlers for various BPF helper functions, emitting
+the appropriate LLVM IR to call kernel BPF helpers like map operations,
+printing, time functions, etc.
+"""
+
 import ast
 from llvmlite import ir
 from enum import Enum
@@ -16,6 +24,8 @@ logger: Logger = logging.getLogger(__name__)
 
 
 class BPFHelperID(Enum):
+    """Enumeration of BPF helper function IDs."""
+
     BPF_MAP_LOOKUP_ELEM = 1
     BPF_MAP_UPDATE_ELEM = 2
     BPF_MAP_DELETE_ELEM = 3
@@ -252,6 +262,11 @@ def bpf_perf_event_output_handler(
     local_sym_tab=None,
     struct_sym_tab=None,
 ):
+    """
+    Emit LLVM IR for bpf_perf_event_output helper function call.
+
+    This allows sending data to userspace via a perf event array.
+    """
     if len(call.args) != 1:
         raise ValueError(
             f"Perf event output expects exactly one argument, got {len(call.args)}"
@@ -302,6 +317,7 @@ def handle_helper_call(
 
     # Helper function to get map pointer and invoke handler
     def invoke_helper(method_name, map_ptr=None):
+        """Helper function to look up and invoke a registered handler."""
         handler = HelperHandlerRegistry.get_handler(method_name)
         if not handler:
             raise NotImplementedError(

pythonbpf/helper/helper_utils.py

@@ -1,3 +1,11 @@
+"""
+Utility functions for BPF helper function handling.
+
+This module provides utility functions for processing BPF helper function
+calls, including argument handling, string formatting for bpf_printk,
+and a registry for helper function handlers.
+"""
+
 import ast
 import logging
 from collections.abc import Callable
@@ -18,6 +26,7 @@ class HelperHandlerRegistry:
         """Decorator to register a handler function for a helper"""
 
         def decorator(func):
+            """Decorator that registers the handler function."""
             cls._handlers[helper_name] = func
             return func
 
@@ -35,14 +44,36 @@ class HelperHandlerRegistry:
 
 
 def get_var_ptr_from_name(var_name, local_sym_tab):
-    """Get a pointer to a variable from the symbol table."""
+    """
+    Get a pointer to a variable from the symbol table.
+
+    Args:
+        var_name: Name of the variable to look up
+        local_sym_tab: Local symbol table
+
+    Returns:
+        Pointer to the variable
+
+    Raises:
+        ValueError: If the variable is not found
+    """
     if local_sym_tab and var_name in local_sym_tab:
         return local_sym_tab[var_name].var
     raise ValueError(f"Variable '{var_name}' not found in local symbol table")
 
 
 def create_int_constant_ptr(value, builder, int_width=64):
-    """Create a pointer to an integer constant."""
+    """
+    Create a pointer to an integer constant.
+
+    Args:
+        value: The integer value
+        builder: LLVM IR builder
+        int_width: Width of the integer in bits (default: 64)
+
+    Returns:
+        Pointer to the allocated integer constant
+    """
     # Default to 64-bit integer
     int_type = ir.IntType(int_width)
     ptr = builder.alloca(int_type)
@@ -52,7 +83,20 @@ def create_int_constant_ptr(value, builder, int_width=64):
 
 
 def get_or_create_ptr_from_arg(arg, builder, local_sym_tab):
-    """Extract or create pointer from the call arguments."""
+    """
+    Extract or create pointer from call arguments.
+
+    Args:
+        arg: The AST argument node
+        builder: LLVM IR builder
+        local_sym_tab: Local symbol table
+
+    Returns:
+        Pointer to the argument value
+
+    Raises:
+        NotImplementedError: If the argument type is not supported
+    """
 
     if isinstance(arg, ast.Name):
         ptr = get_var_ptr_from_name(arg.id, local_sym_tab)
@@ -66,7 +110,21 @@ def get_or_create_ptr_from_arg(arg, builder, local_sym_tab):
 
 
 def get_flags_val(arg, builder, local_sym_tab):
-    """Extract or create flags value from the call arguments."""
+    """
+    Extract or create flags value from call arguments.
+
+    Args:
+        arg: The AST argument node for flags
+        builder: LLVM IR builder
+        local_sym_tab: Local symbol table
+
+    Returns:
+        Integer flags value or LLVM IR value
+
+    Raises:
+        ValueError: If a variable is not found in symbol table
+        NotImplementedError: If the argument type is not supported
+    """
     if not arg:
         return 0
 
@@ -85,7 +143,18 @@ def get_flags_val(arg, builder, local_sym_tab):
 
 
 def simple_string_print(string_value, module, builder, func):
-    """Prepare arguments for bpf_printk from a simple string value"""
+    """
+    Prepare arguments for bpf_printk from a simple string value.
+
+    Args:
+        string_value: The string to print
+        module: LLVM IR module
+        builder: LLVM IR builder
+        func: The LLVM IR function being built
+
+    Returns:
+        List of arguments for bpf_printk
+    """
     fmt_str = string_value + "\n\0"
     fmt_ptr = _create_format_string_global(fmt_str, func, module, builder)
 
@@ -101,7 +170,23 @@ def handle_fstring_print(
     local_sym_tab=None,
     struct_sym_tab=None,
 ):
-    """Handle f-string formatting for bpf_printk emitter."""
+    """
+    Handle f-string formatting for bpf_printk emitter.
+
+    Args:
+        joined_str: AST JoinedStr node representing the f-string
+        module: LLVM IR module
+        builder: LLVM IR builder
+        func: The LLVM IR function being built
+        local_sym_tab: Local symbol table
+        struct_sym_tab: Struct symbol table
+
+    Returns:
+        List of arguments for bpf_printk
+
+    Raises:
+        NotImplementedError: If f-string contains unsupported value types
+    """
     fmt_parts = []
     exprs = []
 

pythonbpf/helper/helpers.py

@@ -1,11 +1,31 @@
+"""
+BPF helper function stubs for Python type hints.
+
+This module provides Python stub functions that represent BPF helper functions.
+These stubs are used for type checking and will be replaced with actual BPF
+helper calls during compilation.
+"""
+
 import ctypes
 
 
 def ktime():
+    """
+    Get the current kernel time in nanoseconds.
+
+    Returns:
+        A c_int64 stub value (actual implementation is in BPF runtime)
+    """
     return ctypes.c_int64(0)
 
 
 def pid():
+    """
+    Get the current process ID (PID).
+
+    Returns:
+        A c_int32 stub value (actual implementation is in BPF runtime)
+    """
     return ctypes.c_int32(0)
 
 

pythonbpf/license_pass.py

@@ -1,3 +1,10 @@
+"""
+LICENSE global variable processing for BPF programs.
+
+This module handles the processing of the LICENSE function which is required
+for BPF programs to declare their license (typically "GPL").
+"""
+
 from llvmlite import ir
 import ast
 from logging import Logger
@@ -7,6 +14,16 @@ logger: Logger = logging.getLogger(__name__)
 
 
 def emit_license(module: ir.Module, license_str: str):
+    """
+    Emit a LICENSE global variable into the LLVM IR module.
+
+    Args:
+        module: The LLVM IR module to add the LICENSE variable to
+        license_str: The license string (e.g., 'GPL')
+
+    Returns:
+        The created global variable
+    """
     license_bytes = license_str.encode("utf8") + b"\x00"
     elems = [ir.Constant(ir.IntType(8), b) for b in license_bytes]
     ty = ir.ArrayType(ir.IntType(8), len(elems))

pythonbpf/maps/__init__.py

@@ -1,3 +1,5 @@
+"""BPF map types and processing."""
+
 from .maps import HashMap, PerfEventArray, RingBuf
 from .maps_pass import maps_proc
 

pythonbpf/maps/maps.py

@@ -1,18 +1,60 @@
+"""
+BPF map type definitions for Python type hints.
+
+This module provides Python classes that represent BPF map types.
+These are used for type checking and map definition; the actual BPF maps
+are generated as LLVM IR during compilation.
+"""
+
+
 # This file provides type  and function hints only and does not actually give any functionality.
 class HashMap:
+    """
+    A BPF hash map for storing key-value pairs.
+
+    This is a type hint class used during compilation. The actual BPF map
+    implementation is generated as LLVM IR.
+    """
+
     def __init__(self, key, value, max_entries):
+        """
+        Initialize a HashMap definition.
+
+        Args:
+            key: The ctypes type for keys (e.g., c_int64)
+            value: The ctypes type for values (e.g., c_int64)
+            max_entries: Maximum number of entries the map can hold
+        """
         self.key = key
         self.value = value
         self.max_entries = max_entries
         self.entries = {}
 
     def lookup(self, key):
+        """
+        Look up a value by key in the map.
+
+        Args:
+            key: The key to look up
+
+        Returns:
+            The value if found, None otherwise
+        """
         if key in self.entries:
             return self.entries[key]
         else:
             return None
 
     def delete(self, key):
+        """
+        Delete an entry from the map by key.
+
+        Args:
+            key: The key to delete
+
+        Raises:
+            KeyError: If the key is not found in the map
+        """
         if key in self.entries:
             del self.entries[key]
         else:
@@ -20,6 +62,17 @@ class HashMap:
 
     # TODO: define the flags that can be added
     def update(self, key, value, flags=None):
+        """
+        Update or insert a key-value pair in the map.
+
+        Args:
+            key: The key to update
+            value: The new value
+            flags: Optional flags for update behavior
+
+        Raises:
+            KeyError: If the key is not found in the map
+        """
         if key in self.entries:
             self.entries[key] = value
         else:
@@ -27,25 +80,76 @@ class HashMap:
 
 
 class PerfEventArray:
+    """
+    A BPF perf event array for sending data to userspace.
+
+    This is a type hint class used during compilation.
+    """
+
     def __init__(self, key_size, value_size):
+        """
+        Initialize a PerfEventArray definition.
+
+        Args:
+            key_size: The size/type for keys
+            value_size: The size/type for values
+        """
         self.key_type = key_size
         self.value_type = value_size
         self.entries = {}
 
     def output(self, data):
+        """
+        Output data to the perf event array.
+
+        Args:
+            data: The data to output
+        """
         pass  # Placeholder for output method
 
 
 class RingBuf:
+    """
+    A BPF ring buffer for efficient data transfer to userspace.
+
+    This is a type hint class used during compilation.
+    """
+
     def __init__(self, max_entries):
+        """
+        Initialize a RingBuf definition.
+
+        Args:
+            max_entries: Maximum number of entries the ring buffer can hold
+        """
         self.max_entries = max_entries
 
     def reserve(self, size: int, flags=0):
+        """
+        Reserve space in the ring buffer.
+
+        Args:
+            size: Size in bytes to reserve
+            flags: Optional reservation flags
+
+        Returns:
+            0 as a placeholder (actual implementation is in BPF runtime)
+
+        Raises:
+            ValueError: If size exceeds max_entries
+        """
         if size > self.max_entries:
             raise ValueError("size cannot be greater than set maximum entries")
         return 0
 
     def submit(self, data, flags=0):
+        """
+        Submit data to the ring buffer.
+
+        Args:
+            data: The data to submit
+            flags: Optional submission flags
+        """
         pass
 
     # add discard, output and also give names to flags and stuff

pythonbpf/maps/maps_pass.py

@@ -1,3 +1,10 @@
+"""
+BPF map processing and LLVM IR generation.
+
+This module handles the processing of BPF map definitions decorated with @map,
+converting them to appropriate LLVM IR global variables with BTF debug info.
+"""
+
 import ast
 from logging import Logger
 from llvmlite import ir
@@ -20,6 +27,15 @@ def maps_proc(tree, module, chunks):
 
 
 def is_map(func_node):
+    """
+    Check if a function node is decorated with @map.
+
+    Args:
+        func_node: The AST function node to check
+
+    Returns:
+        True if the function is decorated with @map, False otherwise
+    """
     return any(
         isinstance(decorator, ast.Name) and decorator.id == "map"
         for decorator in func_node.decorator_list
@@ -27,6 +43,8 @@ def is_map(func_node):
 
 
 class BPFMapType(Enum):
+    """Enumeration of BPF map types."""
+
     UNSPEC = 0
     HASH = 1
     ARRAY = 2
@@ -65,7 +83,17 @@ class BPFMapType(Enum):
 
 
 def create_bpf_map(module, map_name, map_params):
-    """Create a BPF map in the module with given parameters and debug info"""
+    """
+    Create a BPF map in the module with given parameters and debug info.
+
+    Args:
+        module: The LLVM IR module to add the map to
+        map_name: The name of the BPF map
+        map_params: Dictionary of map parameters (type, key_size, value_size, max_entries)
+
+    Returns:
+        The created global variable representing the map
+    """
 
     # Create the anonymous struct type for BPF map
     map_struct_type = ir.LiteralStructType(

pythonbpf/maps/maps_utils.py

@@ -1,3 +1,5 @@
+"""Registry for BPF map processor functions."""
+
 from collections.abc import Callable
 from typing import Any
 
@@ -12,6 +14,7 @@ class MapProcessorRegistry:
         """Decorator to register a processor function for a map type"""
 
         def decorator(func):
+            """Decorator that registers the processor function."""
             cls._processors[map_type_name] = func
             return func
 

pythonbpf/structs/__init__.py

@@ -1,3 +1,5 @@
+"""Struct processing for BPF programs."""
+
 from .structs_pass import structs_proc
 
 __all__ = ["structs_proc"]

pythonbpf/structs/struct_type.py

@@ -1,19 +1,72 @@
+"""
+Struct type wrapper for BPF structs.
+
+This module provides a wrapper class for LLVM IR struct types with
+helper methods for field access and manipulation.
+"""
+
 from llvmlite import ir
 
 
 class StructType:
+    """
+    Wrapper class for LLVM IR struct types with field access helpers.
+
+    Attributes:
+        ir_type: The LLVM IR struct type
+        fields: Dictionary mapping field names to their types
+        size: Total size of the struct in bytes
+    """
+
     def __init__(self, ir_type, fields, size):
+        """
+        Initialize a StructType.
+
+        Args:
+            ir_type: The LLVM IR struct type
+            fields: Dictionary mapping field names to their types
+            size: Total size of the struct in bytes
+        """
         self.ir_type = ir_type
         self.fields = fields
         self.size = size
 
     def field_idx(self, field_name):
+        """
+        Get the index of a field in the struct.
+
+        Args:
+            field_name: The name of the field
+
+        Returns:
+            The zero-based index of the field
+        """
         return list(self.fields.keys()).index(field_name)
 
     def field_type(self, field_name):
+        """
+        Get the LLVM IR type of a field.
+
+        Args:
+            field_name: The name of the field
+
+        Returns:
+            The LLVM IR type of the field
+        """
         return self.fields[field_name]
 
     def gep(self, builder, ptr, field_name):
+        """
+        Generate a GEP (GetElementPtr) instruction to access a struct field.
+
+        Args:
+            builder: LLVM IR builder
+            ptr: Pointer to the struct
+            field_name: Name of the field to access
+
+        Returns:
+            A pointer to the field
+        """
         idx = self.field_idx(field_name)
         return builder.gep(
             ptr,
@@ -22,6 +75,18 @@ class StructType:
         )
 
     def field_size(self, field_name):
+        """
+        Calculate the size of a field in bytes.
+
+        Args:
+            field_name: The name of the field
+
+        Returns:
+            The size of the field in bytes
+
+        Raises:
+            TypeError: If the field type is not supported
+        """
         fld = self.fields[field_name]
         if isinstance(fld, ir.ArrayType):
             return fld.count * (fld.element.width // 8)

pythonbpf/structs/structs_pass.py

@@ -1,3 +1,10 @@
+"""
+BPF struct processing and LLVM IR type generation.
+
+This module handles the processing of Python classes decorated with @struct,
+converting them to LLVM IR struct types for use in BPF programs.
+"""
+
 import ast
 import logging
 from llvmlite import ir
@@ -26,6 +33,15 @@ def structs_proc(tree, module, chunks):
 
 
 def is_bpf_struct(cls_node):
+    """
+    Check if a class node is decorated with @struct.
+
+    Args:
+        cls_node: The AST class node to check
+
+    Returns:
+        True if the class is decorated with @struct, False otherwise
+    """
     return any(
         isinstance(decorator, ast.Name) and decorator.id == "struct"
         for decorator in cls_node.decorator_list
@@ -33,7 +49,16 @@ def is_bpf_struct(cls_node):
 
 
 def process_bpf_struct(cls_node, module):
-    """Process a single BPF struct definition"""
+    """
+    Process a single BPF struct definition and create its LLVM IR representation.
+
+    Args:
+        cls_node: The AST class node representing the struct
+        module: The LLVM IR module (not used in current implementation)
+
+    Returns:
+        A StructType object containing the struct's type information
+    """
 
     fields = parse_struct_fields(cls_node)
     field_types = list(fields.values())
@@ -44,7 +69,18 @@ def process_bpf_struct(cls_node, module):
 
 
 def parse_struct_fields(cls_node):
-    """Parse fields of a struct class node"""
+    """
+    Parse fields of a struct class node.
+
+    Args:
+        cls_node: The AST class node representing the struct
+
+    Returns:
+        A dictionary mapping field names to their LLVM IR types
+
+    Raises:
+        TypeError: If a field has an unsupported type annotation
+    """
     fields = {}
 
     for item in cls_node.body:
@@ -57,7 +93,18 @@ def parse_struct_fields(cls_node):
 
 
 def get_type_from_ann(annotation):
-    """Convert an AST annotation node to an LLVM IR type for struct fields"""
+    """
+    Convert an AST annotation node to an LLVM IR type for struct fields.
+
+    Args:
+        annotation: The AST annotation node (e.g., c_int64, str(32))
+
+    Returns:
+        The corresponding LLVM IR type
+
+    Raises:
+        TypeError: If the annotation type is not supported
+    """
     if isinstance(annotation, ast.Call) and isinstance(annotation.func, ast.Name):
         if annotation.func.id == "str":
             # Char array
@@ -72,7 +119,15 @@ def get_type_from_ann(annotation):
 
 
 def calc_struct_size(field_types):
-    """Calculate total size of the struct with alignment and padding"""
+    """
+    Calculate total size of the struct with alignment and padding.
+
+    Args:
+        field_types: List of LLVM IR types for each field
+
+    Returns:
+        The total size of the struct in bytes
+    """
     curr_offset = 0
     for ftype in field_types:
         if isinstance(ftype, ir.IntType):

pythonbpf/type_deducer.py

@@ -1,3 +1,10 @@
+"""
+Type mapping from Python ctypes to LLVM IR types.
+
+This module provides utilities to convert Python ctypes type names
+to their corresponding LLVM IR representations.
+"""
+
 from llvmlite import ir
 
 # TODO: THIS IS NOT SUPPOSED TO MATCH STRINGS :skull:
@@ -19,10 +26,31 @@ mapping = {
 
 
 def ctypes_to_ir(ctype: str):
+    """
+    Convert a ctypes type name to its corresponding LLVM IR type.
+
+    Args:
+        ctype: String name of the ctypes type (e.g., 'c_int64', 'c_void_p')
+
+    Returns:
+        The corresponding LLVM IR type
+
+    Raises:
+        NotImplementedError: If the ctype is not supported
+    """
     if ctype in mapping:
         return mapping[ctype]
     raise NotImplementedError(f"No mapping for {ctype}")
 
 
 def is_ctypes(ctype: str) -> bool:
+    """
+    Check if a given type name is a supported ctypes type.
+
+    Args:
+        ctype: String name of the type to check
+
+    Returns:
+        True if the type is a supported ctypes type, False otherwise
+    """
     return ctype in mapping

tests/passing_tests/ringbuf.py

@@ -33,3 +33,5 @@ compile_to_ir("ringbuf.py", "ringbuf.ll")
 compile()
 b = BPF()
 b.load_and_attach()
+while True:
+    print("running")