From 469ca43eaaca27051056ce7ed01f1d8a82878114 Mon Sep 17 00:00:00 2001 From: varun-r-mallya Date: Thu, 2 Oct 2025 17:46:27 +0530 Subject: [PATCH 1/3] replace prints with logger.info --- pythonbpf/binary_ops.py | 7 +- pythonbpf/codegen.py | 12 ++-- pythonbpf/expr_pass.py | 31 +++++---- pythonbpf/functions_pass.py | 96 +++++++++++++------------- pythonbpf/helper/bpf_helper_handler.py | 6 +- pythonbpf/license_pass.py | 8 ++- pythonbpf/structs/structs_pass.py | 2 +- 7 files changed, 90 insertions(+), 72 deletions(-) diff --git a/pythonbpf/binary_ops.py b/pythonbpf/binary_ops.py index 9138f95..16f94f6 100644 --- a/pythonbpf/binary_ops.py +++ b/pythonbpf/binary_ops.py @@ -1,6 +1,9 @@ import ast from llvmlite import ir +from logging import Logger +import logging +logger: Logger = logging.getLogger(__name__) def recursive_dereferencer(var, builder): """dereference until primitive type comes out""" @@ -17,7 +20,7 @@ def recursive_dereferencer(var, builder): def handle_binary_op(rval, module, builder, var_name, local_sym_tab, map_sym_tab, func): - print(module) + logger.info(f"module {module}") left = rval.left right = rval.right op = rval.op @@ -43,7 +46,7 @@ def handle_binary_op(rval, module, builder, var_name, local_sym_tab, map_sym_tab else: raise SyntaxError("Unsupported right operand type") - print(f"left is {left}, right is {right}, op is {op}") + logger.info(f"left is {left}, right is {right}, op is {op}") if isinstance(op, ast.Add): builder.store(builder.add(left, right), local_sym_tab[var_name].var) diff --git a/pythonbpf/codegen.py b/pythonbpf/codegen.py index f7dfaa7..2056682 100644 --- a/pythonbpf/codegen.py +++ b/pythonbpf/codegen.py @@ -12,6 +12,10 @@ from pathlib import Path from pylibbpf import BpfProgram import tempfile +from logging import Logger +import logging + +logger: Logger = logging.getLogger(__name__) VERSION = "v0.1.3" @@ -30,11 +34,11 @@ def find_bpf_chunks(tree): def processor(source_code, filename, module): tree = ast.parse(source_code, filename) - print(ast.dump(tree, indent=4)) + logger.debug(ast.dump(tree, indent=4)) bpf_chunks = find_bpf_chunks(tree) for func_node in bpf_chunks: - print(f"Found BPF function/struct: {func_node.name}") + logger.info(f"Found BPF function/struct: {func_node.name}") structs_sym_tab = structs_proc(tree, module, bpf_chunks) map_sym_tab = maps_proc(tree, module, bpf_chunks) @@ -121,7 +125,7 @@ def compile_to_ir(filename: str, output: str): module.add_named_metadata("llvm.ident", [f"PythonBPF {VERSION}"]) - print(f"IR written to {output}") + logger.info(f"IR written to {output}") with open(output, "w") as f: f.write(f'source_filename = "{filename}"\n') f.write(str(module)) @@ -157,7 +161,7 @@ def compile() -> bool: and success ) - print(f"Object written to {o_file}") + logger.info(f"Object written to {o_file}") return success diff --git a/pythonbpf/expr_pass.py b/pythonbpf/expr_pass.py index d506f8a..4c77722 100644 --- a/pythonbpf/expr_pass.py +++ b/pythonbpf/expr_pass.py @@ -1,6 +1,9 @@ import ast from llvmlite import ir +from logging import Logger +import logging +logger: Logger = logging.getLogger(__name__) def eval_expr( func, @@ -11,14 +14,14 @@ def eval_expr( map_sym_tab, structs_sym_tab=None, ): - print(f"Evaluating expression: {ast.dump(expr)}") + logger.info(f"Evaluating expression: {ast.dump(expr)}") if isinstance(expr, ast.Name): 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 # return value and type else: - print(f"Undefined variable {expr.id}") + logger.info(f"Undefined variable {expr.id}") return None elif isinstance(expr, ast.Constant): if isinstance(expr.value, int): @@ -26,7 +29,7 @@ def eval_expr( elif isinstance(expr.value, bool): return ir.Constant(ir.IntType(1), int(expr.value)), ir.IntType(1) else: - print("Unsupported constant type") + logger.info("Unsupported constant type") return None elif isinstance(expr, ast.Call): # delayed import to avoid circular dependency @@ -35,9 +38,9 @@ def eval_expr( if isinstance(expr.func, ast.Name): # check deref if expr.func.id == "deref": - print(f"Handling deref {ast.dump(expr)}") + logger.info(f"Handling deref {ast.dump(expr)}") if len(expr.args) != 1: - print("deref takes exactly one argument") + logger.info("deref takes exactly one argument") return None arg = expr.args[0] if ( @@ -45,16 +48,16 @@ def eval_expr( and isinstance(arg.func, ast.Name) and arg.func.id == "deref" ): - print("Multiple deref not supported") + 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: - print(f"Undefined variable {arg.id}") + logger.info(f"Undefined variable {arg.id}") return None if arg is None: - print("Failed to evaluate deref argument") + 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) @@ -72,7 +75,7 @@ def eval_expr( structs_sym_tab, ) elif isinstance(expr.func, ast.Attribute): - print(f"Handling method call: {ast.dump(expr.func)}") + logger.info(f"Handling method call: {ast.dump(expr.func)}") if isinstance(expr.func.value, ast.Call) and isinstance( expr.func.value.func, ast.Name ): @@ -107,15 +110,15 @@ def eval_expr( attr_name = expr.attr if var_name in local_sym_tab: var_ptr, var_type, var_metadata = local_sym_tab[var_name] - print(f"Loading attribute {attr_name} from variable {var_name}") - print(f"Variable type: {var_type}, Variable ptr: {var_ptr}") + 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 - print("Unsupported expression evaluation") + logger.info("Unsupported expression evaluation") return None @@ -129,7 +132,7 @@ def handle_expr( structs_sym_tab, ): """Handle expression statements in the function body.""" - print(f"Handling expression: {ast.dump(expr)}") + logger.info(f"Handling expression: {ast.dump(expr)}") call = expr.value if isinstance(call, ast.Call): eval_expr( @@ -142,4 +145,4 @@ def handle_expr( structs_sym_tab, ) else: - print("Unsupported expression type") + logger.info("Unsupported expression type") diff --git a/pythonbpf/functions_pass.py b/pythonbpf/functions_pass.py index fc3ddc3..9d9bd8b 100644 --- a/pythonbpf/functions_pass.py +++ b/pythonbpf/functions_pass.py @@ -46,15 +46,15 @@ def handle_assign( ): """Handle assignment statements in the function body.""" if len(stmt.targets) != 1: - print("Unsupported multiassignment") + logger.info("Unsupported multiassignment") return num_types = ("c_int32", "c_int64", "c_uint32", "c_uint64") target = stmt.targets[0] - print(f"Handling assignment to {ast.dump(target)}") + logger.info(f"Handling assignment to {ast.dump(target)}") if not isinstance(target, ast.Name) and not isinstance(target, ast.Attribute): - print("Unsupported assignment target") + logger.info("Unsupported assignment target") return var_name = target.id if isinstance(target, ast.Name) else target.value.id rval = stmt.value @@ -87,11 +87,11 @@ def handle_assign( # print(f"Assigned to struct field {var_name}.{field_name}") pass if val is None: - print("Failed to evaluate struct field assignment") + logger.info("Failed to evaluate struct field assignment") return - print(field_ptr) + logger.info(field_ptr) builder.store(val[0], field_ptr) - print(f"Assigned to struct field {var_name}.{field_name}") + logger.info(f"Assigned to struct field {var_name}.{field_name}") return elif isinstance(rval, ast.Constant): if isinstance(rval.value, bool): @@ -103,7 +103,7 @@ def handle_assign( builder.store( ir.Constant(ir.IntType(1), 0), local_sym_tab[var_name].var ) - print(f"Assigned constant {rval.value} to {var_name}") + logger.info(f"Assigned constant {rval.value} to {var_name}") elif isinstance(rval.value, int): # Assume c_int64 for now # var = builder.alloca(ir.IntType(64), name=var_name) @@ -111,7 +111,7 @@ def handle_assign( builder.store( ir.Constant(ir.IntType(64), rval.value), local_sym_tab[var_name].var ) - print(f"Assigned constant {rval.value} to {var_name}") + logger.info(f"Assigned constant {rval.value} to {var_name}") elif isinstance(rval.value, str): str_val = rval.value.encode("utf-8") + b"\x00" str_const = ir.Constant( @@ -125,13 +125,13 @@ def handle_assign( global_str.initializer = str_const str_ptr = builder.bitcast(global_str, ir.PointerType(ir.IntType(8))) builder.store(str_ptr, local_sym_tab[var_name].var) - print(f"Assigned string constant '{rval.value}' to {var_name}") + logger.info(f"Assigned string constant '{rval.value}' to {var_name}") else: - print("Unsupported constant type") + logger.info("Unsupported constant type") elif isinstance(rval, ast.Call): if isinstance(rval.func, ast.Name): call_type = rval.func.id - print(f"Assignment call type: {call_type}") + logger.info(f"Assignment call type: {call_type}") if ( call_type in num_types and len(rval.args) == 1 @@ -145,7 +145,7 @@ def handle_assign( ir.Constant(ir_type, rval.args[0].value), local_sym_tab[var_name].var, ) - print( + logger.info( f"Assigned {call_type} constant " f"{rval.args[0].value} to {var_name}" ) @@ -162,9 +162,9 @@ def handle_assign( structs_sym_tab, ) builder.store(val[0], local_sym_tab[var_name].var) - print(f"Assigned constant {rval.func.id} to {var_name}") + logger.info(f"Assigned constant {rval.func.id} to {var_name}") elif call_type == "deref" and len(rval.args) == 1: - print(f"Handling deref assignment {ast.dump(rval)}") + logger.info(f"Handling deref assignment {ast.dump(rval)}") val = eval_expr( func, module, @@ -175,25 +175,25 @@ def handle_assign( structs_sym_tab, ) if val is None: - print("Failed to evaluate deref argument") + logger.info("Failed to evaluate deref argument") return - print(f"Dereferenced value: {val}, storing in {var_name}") + logger.info(f"Dereferenced value: {val}, storing in {var_name}") builder.store(val[0], local_sym_tab[var_name].var) - print(f"Dereferenced and assigned to {var_name}") + logger.info(f"Dereferenced and assigned to {var_name}") elif call_type in structs_sym_tab and len(rval.args) == 0: struct_info = structs_sym_tab[call_type] ir_type = struct_info.ir_type # var = builder.alloca(ir_type, name=var_name) # Null init builder.store(ir.Constant(ir_type, None), local_sym_tab[var_name].var) - print(f"Assigned struct {call_type} to {var_name}") + logger.info(f"Assigned struct {call_type} to {var_name}") else: - print(f"Unsupported assignment call type: {call_type}") + logger.info(f"Unsupported assignment call type: {call_type}") elif isinstance(rval.func, ast.Attribute): - print(f"Assignment call attribute: {ast.dump(rval.func)}") + logger.info(f"Assignment call attribute: {ast.dump(rval.func)}") if isinstance(rval.func.value, ast.Name): # TODO: probably a struct access - print(f"TODO STRUCT ACCESS {ast.dump(rval)}") + logger.info(f"TODO STRUCT ACCESS {ast.dump(rval)}") elif isinstance(rval.func.value, ast.Call) and isinstance( rval.func.value.func, ast.Name ): @@ -214,15 +214,15 @@ def handle_assign( # var.align = 8 builder.store(val[0], local_sym_tab[var_name].var) else: - print("Unsupported assignment call structure") + logger.info("Unsupported assignment call structure") else: - print("Unsupported assignment call function type") + logger.info("Unsupported assignment call function type") elif isinstance(rval, ast.BinOp): handle_binary_op( rval, module, builder, var_name, local_sym_tab, map_sym_tab, func ) else: - print("Unsupported assignment value type") + logger.info("Unsupported assignment value type") def handle_cond(func, module, builder, cond, local_sym_tab, map_sym_tab): @@ -232,7 +232,7 @@ def handle_cond(func, module, builder, cond, local_sym_tab, map_sym_tab): elif isinstance(cond.value, int): return ir.Constant(ir.IntType(1), int(bool(cond.value))) else: - print("Unsupported constant type in condition") + logger.info("Unsupported constant type in condition") return None elif isinstance(cond, ast.Name): if cond.id in local_sym_tab: @@ -249,12 +249,12 @@ def handle_cond(func, module, builder, cond, local_sym_tab, map_sym_tab): val = builder.icmp_signed("!=", val, zero) return val else: - print(f"Undefined variable {cond.id} in condition") + logger.info(f"Undefined variable {cond.id} in condition") return None elif isinstance(cond, ast.Compare): lhs = eval_expr(func, module, builder, cond.left, local_sym_tab, map_sym_tab)[0] if len(cond.ops) != 1 or len(cond.comparators) != 1: - print("Unsupported complex comparison") + logger.info("Unsupported complex comparison") return None rhs = eval_expr( func, module, builder, cond.comparators[0], local_sym_tab, map_sym_tab @@ -269,7 +269,7 @@ def handle_cond(func, module, builder, cond, local_sym_tab, map_sym_tab): elif lhs.type.width > rhs.type.width: rhs = builder.sext(rhs, lhs.type) else: - print("Type mismatch in comparison") + logger.info("Type mismatch in comparison") return None if isinstance(op, ast.Eq): @@ -285,10 +285,10 @@ def handle_cond(func, module, builder, cond, local_sym_tab, map_sym_tab): elif isinstance(op, ast.GtE): return builder.icmp_signed(">=", lhs, rhs) else: - print("Unsupported comparison operator") + logger.info("Unsupported comparison operator") return None else: - print("Unsupported condition expression") + logger.info("Unsupported condition expression") return None @@ -296,7 +296,7 @@ def handle_if( func, module, builder, stmt, map_sym_tab, local_sym_tab, structs_sym_tab=None ): """Handle if statements in the function body.""" - print("Handling if statement") + logger.info("Handling if statement") # start = builder.block.parent then_block = func.append_basic_block(name="if.then") merge_block = func.append_basic_block(name="if.end") @@ -349,7 +349,7 @@ def process_stmt( did_return, ret_type=ir.IntType(64), ): - print(f"Processing statement: {ast.dump(stmt)}") + logger.info(f"Processing statement: {ast.dump(stmt)}") if isinstance(stmt, ast.Expr): handle_expr( func, @@ -434,11 +434,11 @@ def allocate_mem( ) elif isinstance(stmt, ast.Assign): if len(stmt.targets) != 1: - print("Unsupported multiassignment") + logger.info("Unsupported multiassignment") continue target = stmt.targets[0] if not isinstance(target, ast.Name): - print("Unsupported assignment target") + logger.info("Unsupported assignment target") continue var_name = target.id rval = stmt.value @@ -449,25 +449,25 @@ def allocate_mem( ir_type = ctypes_to_ir(call_type) var = builder.alloca(ir_type, name=var_name) var.align = ir_type.width // 8 - print(f"Pre-allocated variable {var_name} of type {call_type}") + logger.info(f"Pre-allocated variable {var_name} of type {call_type}") elif HelperHandlerRegistry.has_handler(call_type): # Assume return type is int64 for now ir_type = ir.IntType(64) var = builder.alloca(ir_type, name=var_name) var.align = ir_type.width // 8 - print(f"Pre-allocated variable {var_name} for helper") + logger.info(f"Pre-allocated variable {var_name} for helper") elif call_type == "deref" and len(rval.args) == 1: # Assume return type is int64 for now ir_type = ir.IntType(64) var = builder.alloca(ir_type, name=var_name) var.align = ir_type.width // 8 - print(f"Pre-allocated variable {var_name} for deref") + logger.info(f"Pre-allocated variable {var_name} for deref") elif call_type in structs_sym_tab: struct_info = structs_sym_tab[call_type] ir_type = struct_info.ir_type var = builder.alloca(ir_type, name=var_name) has_metadata = True - print( + logger.info( f"Pre-allocated variable {var_name} " f"for struct {call_type}" ) @@ -475,38 +475,38 @@ def allocate_mem( ir_type = ir.PointerType(ir.IntType(64)) var = builder.alloca(ir_type, name=var_name) # var.align = ir_type.width // 8 - print(f"Pre-allocated variable {var_name} for map") + logger.info(f"Pre-allocated variable {var_name} for map") else: - print("Unsupported assignment call function type") + logger.info("Unsupported assignment call function type") continue elif isinstance(rval, ast.Constant): if isinstance(rval.value, bool): ir_type = ir.IntType(1) var = builder.alloca(ir_type, name=var_name) var.align = 1 - print(f"Pre-allocated variable {var_name} of type c_bool") + logger.info(f"Pre-allocated variable {var_name} of type c_bool") elif isinstance(rval.value, int): # Assume c_int64 for now ir_type = ir.IntType(64) var = builder.alloca(ir_type, name=var_name) var.align = ir_type.width // 8 - print(f"Pre-allocated variable {var_name} of type c_int64") + logger.info(f"Pre-allocated variable {var_name} of type c_int64") elif isinstance(rval.value, str): ir_type = ir.PointerType(ir.IntType(8)) var = builder.alloca(ir_type, name=var_name) var.align = 8 - print(f"Pre-allocated variable {var_name} of type string") + logger.info(f"Pre-allocated variable {var_name} of type string") else: - print("Unsupported constant type") + logger.info("Unsupported constant type") continue elif isinstance(rval, ast.BinOp): # Assume c_int64 for now ir_type = ir.IntType(64) var = builder.alloca(ir_type, name=var_name) var.align = ir_type.width // 8 - print(f"Pre-allocated variable {var_name} of type c_int64") + logger.info(f"Pre-allocated variable {var_name} of type c_int64") else: - print("Unsupported assignment value type") + logger.info("Unsupported assignment value type") continue if has_metadata: @@ -537,7 +537,7 @@ def process_func_body( structs_sym_tab, ) - print(f"Local symbol table: {local_sym_tab.keys()}") + logger.info(f"Local symbol table: {local_sym_tab.keys()}") for stmt in func_node.body: did_return = process_stmt( @@ -609,7 +609,7 @@ def func_proc(tree, module, chunks, map_sym_tab, structs_sym_tab): if is_global: continue func_type = get_probe_string(func_node) - print(f"Found probe_string of {func_node.name}: {func_type}") + logger.info(f"Found probe_string of {func_node.name}: {func_type}") process_bpf_chunk( func_node, diff --git a/pythonbpf/helper/bpf_helper_handler.py b/pythonbpf/helper/bpf_helper_handler.py index 96382f6..e3ed1df 100644 --- a/pythonbpf/helper/bpf_helper_handler.py +++ b/pythonbpf/helper/bpf_helper_handler.py @@ -9,6 +9,10 @@ simple_string_print, get_data_ptr_and_size, ) +from logging import Logger +import logging + +logger: Logger = logging.getLogger(__name__) class BPFHelperID(Enum): @@ -322,7 +326,7 @@ def invoke_helper(method_name, map_ptr=None): elif isinstance(call.func, ast.Attribute): method_name = call.func.attr value = call.func.value - print(f"Handling method call: {ast.dump(call.func)}") + logger.info(f"Handling method call: {ast.dump(call.func)}") # Get map pointer from different styles of map access if isinstance(value, ast.Call) and isinstance(value.func, ast.Name): # Func style: my_map().lookup(key) diff --git a/pythonbpf/license_pass.py b/pythonbpf/license_pass.py index 59ed3fe..c3d3dc0 100644 --- a/pythonbpf/license_pass.py +++ b/pythonbpf/license_pass.py @@ -1,5 +1,9 @@ from llvmlite import ir import ast +from logging import Logger +import logging + +logger: Logger = logging.getLogger(__name__) def emit_license(module: ir.Module, license_str: str): @@ -41,9 +45,9 @@ def license_processing(tree, module): emit_license(module, node.body[0].value.value) return "LICENSE" else: - print("ERROR: LICENSE() must return a string literal") + logger.info("ERROR: LICENSE() must return a string literal") return None else: - print("ERROR: LICENSE already defined") + logger.info("ERROR: LICENSE already defined") return None return None diff --git a/pythonbpf/structs/structs_pass.py b/pythonbpf/structs/structs_pass.py index a91c6df..d79fe0e 100644 --- a/pythonbpf/structs/structs_pass.py +++ b/pythonbpf/structs/structs_pass.py @@ -19,7 +19,7 @@ def structs_proc(tree, module, chunks): structs_sym_tab = {} for cls_node in chunks: if is_bpf_struct(cls_node): - print(f"Found BPF struct: {cls_node.name}") + logger.info(f"Found BPF struct: {cls_node.name}") struct_info = process_bpf_struct(cls_node, module) structs_sym_tab[cls_node.name] = struct_info return structs_sym_tab From 89b0a0741983e70f991ee8de0673b8295b44334f Mon Sep 17 00:00:00 2001 From: varun-r-mallya Date: Thu, 2 Oct 2025 17:57:37 +0530 Subject: [PATCH 2/3] add logging level control --- pythonbpf/codegen.py | 14 +++++++++----- tests/passing_tests/perf_buffer_map.py | 4 ++-- 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/pythonbpf/codegen.py b/pythonbpf/codegen.py index 2056682..cc9e7bf 100644 --- a/pythonbpf/codegen.py +++ b/pythonbpf/codegen.py @@ -48,7 +48,11 @@ def processor(source_code, filename, module): globals_processing(tree, module) -def compile_to_ir(filename: str, output: str): +def compile_to_ir(filename: str, output: str, loglevel=logging.WARNING): + logging.basicConfig( + level=loglevel, + format="%(asctime)s [%(levelname)s] %(name)s: %(message)s" + ) with open(filename) as f: source = f.read() @@ -134,7 +138,7 @@ def compile_to_ir(filename: str, output: str): return output -def compile() -> bool: +def compile(loglevel=logging.WARNING) -> bool: # Look one level up the stack to the caller of this function caller_frame = inspect.stack()[1] caller_file = Path(caller_frame.filename).resolve() @@ -143,7 +147,7 @@ def compile() -> bool: o_file = caller_file.with_suffix(".o") success = True - success = compile_to_ir(str(caller_file), str(ll_file)) and success + success = compile_to_ir(str(caller_file), str(ll_file), loglevel=loglevel) and success success = bool( subprocess.run( @@ -165,7 +169,7 @@ def compile() -> bool: return success -def BPF() -> BpfProgram: +def BPF(loglevel=logging.WARNING) -> BpfProgram: caller_frame = inspect.stack()[1] src = inspect.getsource(caller_frame.frame) with tempfile.NamedTemporaryFile( @@ -178,7 +182,7 @@ def BPF() -> BpfProgram: f.write(src) f.flush() source = f.name - compile_to_ir(source, str(inter.name)) + compile_to_ir(source, str(inter.name), loglevel=loglevel) subprocess.run( [ "llc", diff --git a/tests/passing_tests/perf_buffer_map.py b/tests/passing_tests/perf_buffer_map.py index 0a3e5d1..560212f 100644 --- a/tests/passing_tests/perf_buffer_map.py +++ b/tests/passing_tests/perf_buffer_map.py @@ -1,7 +1,7 @@ from pythonbpf import bpf, map, struct, section, bpfglobal, compile, compile_to_ir, BPF from pythonbpf.helper import ktime, pid from pythonbpf.maps import PerfEventArray - +import logging from ctypes import c_void_p, c_int32, c_uint64 @@ -42,8 +42,8 @@ def LICENSE() -> str: return "GPL" -compile() compile_to_ir("perf_buffer_map.py", "perf_buffer_map.ll") +compile(loglevel=logging.INFO) b = BPF() b.load_and_attach() From 4d0dd68d5646adf396876963f865fe97c6a16894 Mon Sep 17 00:00:00 2001 From: varun-r-mallya Date: Thu, 2 Oct 2025 17:58:24 +0530 Subject: [PATCH 3/3] fix formatting --- pythonbpf/binary_ops.py | 1 + pythonbpf/codegen.py | 7 ++++--- pythonbpf/expr_pass.py | 1 + pythonbpf/functions_pass.py | 4 +++- 4 files changed, 9 insertions(+), 4 deletions(-) diff --git a/pythonbpf/binary_ops.py b/pythonbpf/binary_ops.py index 16f94f6..e0b69f3 100644 --- a/pythonbpf/binary_ops.py +++ b/pythonbpf/binary_ops.py @@ -5,6 +5,7 @@ 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))): diff --git a/pythonbpf/codegen.py b/pythonbpf/codegen.py index cc9e7bf..a5824eb 100644 --- a/pythonbpf/codegen.py +++ b/pythonbpf/codegen.py @@ -50,8 +50,7 @@ def processor(source_code, filename, module): def compile_to_ir(filename: str, output: str, loglevel=logging.WARNING): logging.basicConfig( - level=loglevel, - format="%(asctime)s [%(levelname)s] %(name)s: %(message)s" + level=loglevel, format="%(asctime)s [%(levelname)s] %(name)s: %(message)s" ) with open(filename) as f: source = f.read() @@ -147,7 +146,9 @@ def compile(loglevel=logging.WARNING) -> bool: o_file = caller_file.with_suffix(".o") success = True - success = compile_to_ir(str(caller_file), str(ll_file), loglevel=loglevel) and success + success = ( + compile_to_ir(str(caller_file), str(ll_file), loglevel=loglevel) and success + ) success = bool( subprocess.run( diff --git a/pythonbpf/expr_pass.py b/pythonbpf/expr_pass.py index 4c77722..1befbb4 100644 --- a/pythonbpf/expr_pass.py +++ b/pythonbpf/expr_pass.py @@ -5,6 +5,7 @@ logger: Logger = logging.getLogger(__name__) + def eval_expr( func, module, diff --git a/pythonbpf/functions_pass.py b/pythonbpf/functions_pass.py index 9d9bd8b..37728e1 100644 --- a/pythonbpf/functions_pass.py +++ b/pythonbpf/functions_pass.py @@ -449,7 +449,9 @@ def allocate_mem( ir_type = ctypes_to_ir(call_type) var = builder.alloca(ir_type, name=var_name) var.align = ir_type.width // 8 - logger.info(f"Pre-allocated variable {var_name} of type {call_type}") + logger.info( + f"Pre-allocated variable {var_name} of type {call_type}" + ) elif HelperHandlerRegistry.has_handler(call_type): # Assume return type is int64 for now ir_type = ir.IntType(64)