From 22289821f94a861c8fc722e5636f4bad78b174dd Mon Sep 17 00:00:00 2001 From: varun-r-mallya Date: Thu, 9 Oct 2025 10:06:17 +0530 Subject: [PATCH] format chore --- pythonbpf/binary_ops.py | 8 ++-- pythonbpf/codegen.py | 18 ++++----- pythonbpf/debuginfo/debug_info_generator.py | 14 +++---- pythonbpf/debuginfo/dtypes.py | 1 + pythonbpf/decorators.py | 5 ++- pythonbpf/expr/expr_pass.py | 4 +- pythonbpf/expr/type_normalization.py | 20 +++++----- pythonbpf/functions/functions_pass.py | 29 ++++++++------- pythonbpf/globals_pass.py | 12 +++--- pythonbpf/helper/bpf_helper_handler.py | 3 +- pythonbpf/helper/helper_utils.py | 32 ++++++++-------- pythonbpf/helper/helpers.py | 4 +- pythonbpf/license_pass.py | 4 +- pythonbpf/maps/maps.py | 41 +++++++++++---------- pythonbpf/maps/maps_pass.py | 9 +++-- pythonbpf/structs/struct_type.py | 24 ++++++------ pythonbpf/structs/structs_pass.py | 24 ++++++------ pythonbpf/type_deducer.py | 10 ++--- 18 files changed, 134 insertions(+), 128 deletions(-) diff --git a/pythonbpf/binary_ops.py b/pythonbpf/binary_ops.py index 77bdc2c..9b8203e 100644 --- a/pythonbpf/binary_ops.py +++ b/pythonbpf/binary_ops.py @@ -44,12 +44,12 @@ 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 """ @@ -83,13 +83,13 @@ 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) """ diff --git a/pythonbpf/codegen.py b/pythonbpf/codegen.py index 31aa2ad..7c4845e 100644 --- a/pythonbpf/codegen.py +++ b/pythonbpf/codegen.py @@ -47,7 +47,7 @@ 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 @@ -74,12 +74,12 @@ 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 """ @@ -158,13 +158,13 @@ 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 """ @@ -203,13 +203,13 @@ 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 """ diff --git a/pythonbpf/debuginfo/debug_info_generator.py b/pythonbpf/debuginfo/debug_info_generator.py index bb7b30a..0cc1c49 100644 --- a/pythonbpf/debuginfo/debug_info_generator.py +++ b/pythonbpf/debuginfo/debug_info_generator.py @@ -10,15 +10,15 @@ 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 """ @@ -28,7 +28,7 @@ class DebugInfoGenerator: 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 @@ -46,7 +46,7 @@ class DebugInfoGenerator: ): """ Generate debug compile unit metadata. - + Args: language: DWARF language code (e.g., DW_LANG_C11) producer: Compiler/producer string @@ -114,11 +114,11 @@ class DebugInfoGenerator: 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 """ diff --git a/pythonbpf/debuginfo/dtypes.py b/pythonbpf/debuginfo/dtypes.py index ac6068a..7f085b7 100644 --- a/pythonbpf/debuginfo/dtypes.py +++ b/pythonbpf/debuginfo/dtypes.py @@ -5,6 +5,7 @@ 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) diff --git a/pythonbpf/decorators.py b/pythonbpf/decorators.py index 8a8969d..59bc8ed 100644 --- a/pythonbpf/decorators.py +++ b/pythonbpf/decorators.py @@ -33,13 +33,14 @@ 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 diff --git a/pythonbpf/expr/expr_pass.py b/pythonbpf/expr/expr_pass.py index c00b4ef..14e5ac6 100644 --- a/pythonbpf/expr/expr_pass.py +++ b/pythonbpf/expr/expr_pass.py @@ -342,7 +342,7 @@ def eval_expr( ): """ Evaluate an expression and return its LLVM IR value and type. - + Args: func: The LLVM IR function being built module: The LLVM IR module @@ -351,7 +351,7 @@ def eval_expr( 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 """ diff --git a/pythonbpf/expr/type_normalization.py b/pythonbpf/expr/type_normalization.py index 6e1e1ce..157032e 100644 --- a/pythonbpf/expr/type_normalization.py +++ b/pythonbpf/expr/type_normalization.py @@ -26,10 +26,10 @@ COMPARISON_OPS = { def _get_base_type_and_depth(ir_type): """ 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 """ @@ -44,13 +44,13 @@ def _get_base_type_and_depth(ir_type): def _deref_to_depth(func, builder, val, target_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 """ @@ -101,13 +101,13 @@ def _deref_to_depth(func, builder, val, target_depth): def _normalize_types(func, builder, lhs, rhs): """ 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 """ @@ -138,11 +138,11 @@ def _normalize_types(func, builder, lhs, rhs): def convert_to_bool(builder, val): """ 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 """ @@ -158,14 +158,14 @@ def convert_to_bool(builder, val): def handle_comparator(func, builder, op, lhs, rhs): """ 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 """ diff --git a/pythonbpf/functions/functions_pass.py b/pythonbpf/functions/functions_pass.py index 44c2dab..a455428 100644 --- a/pythonbpf/functions/functions_pass.py +++ b/pythonbpf/functions/functions_pass.py @@ -27,12 +27,13 @@ logger = logging.getLogger(__name__) 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 @@ -262,7 +263,7 @@ def handle_cond( ): """ Evaluate a condition expression and convert it to a boolean value. - + Args: func: The LLVM IR function being built module: The LLVM IR module @@ -271,7 +272,7 @@ def handle_cond( 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 """ @@ -332,13 +333,13 @@ 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 """ @@ -375,7 +376,7 @@ def process_stmt( ): """ Process a single statement in a BPF function. - + Args: func: The LLVM IR function being built module: The LLVM IR module @@ -386,7 +387,7 @@ def process_stmt( 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 """ @@ -426,10 +427,10 @@ def allocate_mem( ): """ 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 @@ -439,7 +440,7 @@ def allocate_mem( 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 """ @@ -638,7 +639,7 @@ 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 @@ -673,13 +674,13 @@ 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 """ diff --git a/pythonbpf/globals_pass.py b/pythonbpf/globals_pass.py index 3442cdf..305d982 100644 --- a/pythonbpf/globals_pass.py +++ b/pythonbpf/globals_pass.py @@ -21,11 +21,11 @@ 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) """ @@ -52,12 +52,12 @@ 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 """ @@ -146,7 +146,7 @@ def globals_processing(tree, module): def emit_llvm_compiler_used(module: ir.Module, names: list[str]): """ 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 @@ -172,7 +172,7 @@ 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 diff --git a/pythonbpf/helper/bpf_helper_handler.py b/pythonbpf/helper/bpf_helper_handler.py index 2a8360a..76a17c1 100644 --- a/pythonbpf/helper/bpf_helper_handler.py +++ b/pythonbpf/helper/bpf_helper_handler.py @@ -25,6 +25,7 @@ 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 @@ -263,7 +264,7 @@ def bpf_perf_event_output_handler( ): """ 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: diff --git a/pythonbpf/helper/helper_utils.py b/pythonbpf/helper/helper_utils.py index 03f855f..bf0a89b 100644 --- a/pythonbpf/helper/helper_utils.py +++ b/pythonbpf/helper/helper_utils.py @@ -46,14 +46,14 @@ class HelperHandlerRegistry: def get_var_ptr_from_name(var_name, local_sym_tab): """ 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 """ @@ -65,12 +65,12 @@ def get_var_ptr_from_name(var_name, local_sym_tab): def create_int_constant_ptr(value, builder, int_width=64): """ 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 """ @@ -85,15 +85,15 @@ 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 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 """ @@ -112,15 +112,15 @@ 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 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 @@ -145,13 +145,13 @@ 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. - + 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 """ @@ -172,7 +172,7 @@ def handle_fstring_print( ): """ Handle f-string formatting for bpf_printk emitter. - + Args: joined_str: AST JoinedStr node representing the f-string module: LLVM IR module @@ -180,10 +180,10 @@ def handle_fstring_print( 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 """ diff --git a/pythonbpf/helper/helpers.py b/pythonbpf/helper/helpers.py index e05c0ca..7c9d594 100644 --- a/pythonbpf/helper/helpers.py +++ b/pythonbpf/helper/helpers.py @@ -12,7 +12,7 @@ import ctypes def ktime(): """ Get the current kernel time in nanoseconds. - + Returns: A c_int64 stub value (actual implementation is in BPF runtime) """ @@ -22,7 +22,7 @@ def ktime(): def pid(): """ Get the current process ID (PID). - + Returns: A c_int32 stub value (actual implementation is in BPF runtime) """ diff --git a/pythonbpf/license_pass.py b/pythonbpf/license_pass.py index 95ebf9f..66fc111 100644 --- a/pythonbpf/license_pass.py +++ b/pythonbpf/license_pass.py @@ -16,11 +16,11 @@ 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 """ diff --git a/pythonbpf/maps/maps.py b/pythonbpf/maps/maps.py index 1b443ca..2078df6 100644 --- a/pythonbpf/maps/maps.py +++ b/pythonbpf/maps/maps.py @@ -6,19 +6,20 @@ 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) @@ -32,10 +33,10 @@ class HashMap: 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 """ @@ -47,10 +48,10 @@ class HashMap: 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 """ @@ -63,12 +64,12 @@ class HashMap: 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 """ @@ -81,14 +82,14 @@ 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 @@ -100,7 +101,7 @@ class PerfEventArray: def output(self, data): """ Output data to the perf event array. - + Args: data: The data to output """ @@ -110,14 +111,14 @@ class PerfEventArray: 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 """ @@ -126,14 +127,14 @@ class RingBuf: 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 """ @@ -144,7 +145,7 @@ class RingBuf: def submit(self, data, flags=0): """ Submit data to the ring buffer. - + Args: data: The data to submit flags: Optional submission flags diff --git a/pythonbpf/maps/maps_pass.py b/pythonbpf/maps/maps_pass.py index dda0c2e..d613fe6 100644 --- a/pythonbpf/maps/maps_pass.py +++ b/pythonbpf/maps/maps_pass.py @@ -29,10 +29,10 @@ 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 """ @@ -44,6 +44,7 @@ def is_map(func_node): class BPFMapType(Enum): """Enumeration of BPF map types.""" + UNSPEC = 0 HASH = 1 ARRAY = 2 @@ -84,12 +85,12 @@ 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. - + 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 """ diff --git a/pythonbpf/structs/struct_type.py b/pythonbpf/structs/struct_type.py index d7d3820..5d92add 100644 --- a/pythonbpf/structs/struct_type.py +++ b/pythonbpf/structs/struct_type.py @@ -11,17 +11,17 @@ 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 @@ -34,10 +34,10 @@ class StructType: 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 """ @@ -46,10 +46,10 @@ class StructType: 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 """ @@ -58,12 +58,12 @@ class StructType: 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 """ @@ -77,13 +77,13 @@ 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 """ diff --git a/pythonbpf/structs/structs_pass.py b/pythonbpf/structs/structs_pass.py index 00d8278..481430a 100644 --- a/pythonbpf/structs/structs_pass.py +++ b/pythonbpf/structs/structs_pass.py @@ -35,10 +35,10 @@ 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 """ @@ -51,11 +51,11 @@ def is_bpf_struct(cls_node): def process_bpf_struct(cls_node, module): """ 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 """ @@ -71,13 +71,13 @@ def process_bpf_struct(cls_node, module): def parse_struct_fields(cls_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 """ @@ -95,13 +95,13 @@ 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. - + 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 """ @@ -121,10 +121,10 @@ def get_type_from_ann(annotation): def calc_struct_size(field_types): """ 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 """ diff --git a/pythonbpf/type_deducer.py b/pythonbpf/type_deducer.py index c37bd66..83b88ff 100644 --- a/pythonbpf/type_deducer.py +++ b/pythonbpf/type_deducer.py @@ -28,13 +28,13 @@ 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 """ @@ -46,10 +46,10 @@ def ctypes_to_ir(ctype: str): 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 """