From 44cbcccb6ca5eafec0617ad347f1e2e54ffc86dd Mon Sep 17 00:00:00 2001 From: Pragyansh Chaturvedi Date: Thu, 2 Oct 2025 22:43:54 +0530 Subject: [PATCH 01/11] Create _handle_name_expr --- pythonbpf/expr_pass.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/pythonbpf/expr_pass.py b/pythonbpf/expr_pass.py index 1befbb4..65fe019 100644 --- a/pythonbpf/expr_pass.py +++ b/pythonbpf/expr_pass.py @@ -2,10 +2,22 @@ from llvmlite import ir from logging import Logger import logging +from typing import Dict logger: Logger = logging.getLogger(__name__) +def _handle_name_expr(expr: ast.Name, local_sym_tab: Dict, builder: ir.IRBuilder): + """Handle ast.Name expressions.""" + if expr.id in local_sym_tab: + var = local_sym_tab[expr.id].var + val = builder.load(var) + return val, local_sym_tab[expr.id].ir_type + else: + logger.info(f"Undefined variable {expr.id}") + return None + + def eval_expr( func, module, From 729270b34b3aed6f34a0e819922da65012df30aa Mon Sep 17 00:00:00 2001 From: Pragyansh Chaturvedi Date: Thu, 2 Oct 2025 22:50:21 +0530 Subject: [PATCH 02/11] Use _handle_name_expr in eval_expr --- pythonbpf/expr_pass.py | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) diff --git a/pythonbpf/expr_pass.py b/pythonbpf/expr_pass.py index 65fe019..8e413bd 100644 --- a/pythonbpf/expr_pass.py +++ b/pythonbpf/expr_pass.py @@ -29,13 +29,7 @@ def eval_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: - logger.info(f"Undefined variable {expr.id}") - return None + return _handle_name_expr(expr, local_sym_tab, builder) elif isinstance(expr, ast.Constant): if isinstance(expr.value, int): return ir.Constant(ir.IntType(64), expr.value), ir.IntType(64) @@ -123,8 +117,10 @@ 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] - logger.info(f"Loading attribute {attr_name} from variable {var_name}") - logger.info(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) From 3a819dcaeecd5bb2e8ac203366d9b9971374f997 Mon Sep 17 00:00:00 2001 From: Pragyansh Chaturvedi Date: Thu, 2 Oct 2025 22:54:38 +0530 Subject: [PATCH 03/11] Add _handle_constant_expr --- pythonbpf/expr_pass.py | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/pythonbpf/expr_pass.py b/pythonbpf/expr_pass.py index 8e413bd..3516a20 100644 --- a/pythonbpf/expr_pass.py +++ b/pythonbpf/expr_pass.py @@ -18,6 +18,17 @@ def _handle_name_expr(expr: ast.Name, local_sym_tab: Dict, builder: ir.IRBuilder return None +def _handle_constant_expr(expr: ast.Constant): + """Handle ast.Constant expressions.""" + if isinstance(expr.value, int): + return ir.Constant(ir.IntType(64), expr.value), ir.IntType(64) + elif isinstance(expr.value, bool): + return ir.Constant(ir.IntType(1), int(expr.value)), ir.IntType(1) + else: + logger.info("Unsupported constant type") + return None + + def eval_expr( func, module, @@ -31,13 +42,7 @@ def eval_expr( if isinstance(expr, ast.Name): return _handle_name_expr(expr, local_sym_tab, builder) elif isinstance(expr, ast.Constant): - if isinstance(expr.value, int): - return ir.Constant(ir.IntType(64), expr.value), ir.IntType(64) - elif isinstance(expr.value, bool): - return ir.Constant(ir.IntType(1), int(expr.value)), ir.IntType(1) - else: - logger.info("Unsupported constant type") - return None + return _handle_constant_expr(expr) elif isinstance(expr, ast.Call): # delayed import to avoid circular dependency from pythonbpf.helper import HelperHandlerRegistry, handle_helper_call @@ -117,10 +122,8 @@ 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] - logger.info(f"Loading attribute { - attr_name} from variable {var_name}") - logger.info(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) From a4f1363aedfaf7dd32bd4741143401e13e51b159 Mon Sep 17 00:00:00 2001 From: Pragyansh Chaturvedi Date: Fri, 3 Oct 2025 01:50:59 +0530 Subject: [PATCH 04/11] Add _handle_attribute_expr --- pythonbpf/expr_pass.py | 38 +++++++++++++++++++++++++------------- 1 file changed, 25 insertions(+), 13 deletions(-) diff --git a/pythonbpf/expr_pass.py b/pythonbpf/expr_pass.py index 3516a20..001cc89 100644 --- a/pythonbpf/expr_pass.py +++ b/pythonbpf/expr_pass.py @@ -29,6 +29,30 @@ def _handle_constant_expr(expr: ast.Constant): return None +def _handle_attribute_expr( + expr: ast.Attribute, + local_sym_tab: Dict, + structs_sym_tab: Dict, + builder: ir.IRBuilder, +): + """Handle ast.Attribute expressions for struct field access.""" + if isinstance(expr.value, ast.Name): + var_name = expr.value.id + attr_name = expr.attr + if var_name in local_sym_tab: + var_ptr, var_type, var_metadata = local_sym_tab[var_name] + logger.info(f"Loading attribute {attr_name} from variable {var_name}") + logger.info(f"Variable type: {var_type}, Variable ptr: {var_ptr}") + + metadata = structs_sym_tab[var_metadata] + if attr_name in metadata.fields: + gep = metadata.gep(builder, var_ptr, attr_name) + val = builder.load(gep) + field_type = metadata.field_type(attr_name) + return val, field_type + return None + + def eval_expr( func, module, @@ -117,19 +141,7 @@ def eval_expr( structs_sym_tab, ) elif isinstance(expr, ast.Attribute): - if isinstance(expr.value, ast.Name): - var_name = expr.value.id - attr_name = expr.attr - if var_name in local_sym_tab: - var_ptr, var_type, var_metadata = local_sym_tab[var_name] - logger.info(f"Loading attribute {attr_name} from variable {var_name}") - logger.info(f"Variable type: {var_type}, Variable ptr: {var_ptr}") - metadata = structs_sym_tab[var_metadata] - if attr_name in metadata.fields: - gep = metadata.gep(builder, var_ptr, attr_name) - val = builder.load(gep) - field_type = metadata.field_type(attr_name) - return val, field_type + return _handle_attribute_expr(expr, local_sym_tab, structs_sym_tab, builder) logger.info("Unsupported expression evaluation") return None From a622c53e0f48f94a3ba434eb4ada928008f20048 Mon Sep 17 00:00:00 2001 From: Pragyansh Chaturvedi Date: Fri, 3 Oct 2025 02:00:01 +0530 Subject: [PATCH 05/11] Add deref --- pythonbpf/expr_pass.py | 92 ++++++++++++++++++++++++------------------ 1 file changed, 52 insertions(+), 40 deletions(-) diff --git a/pythonbpf/expr_pass.py b/pythonbpf/expr_pass.py index 001cc89..22c659c 100644 --- a/pythonbpf/expr_pass.py +++ b/pythonbpf/expr_pass.py @@ -41,7 +41,8 @@ def _handle_attribute_expr( attr_name = expr.attr if var_name in local_sym_tab: var_ptr, var_type, var_metadata = local_sym_tab[var_name] - logger.info(f"Loading attribute {attr_name} from variable {var_name}") + logger.info(f"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] @@ -53,6 +54,41 @@ def _handle_attribute_expr( return None +def _handle_deref_call(expr: ast.Call, local_sym_tab: Dict, builder: ir.IRBuilder): + """Handle deref function calls.""" + logger.info(f"Handling deref {ast.dump(expr)}") + if len(expr.args) != 1: + logger.info("deref takes exactly one argument") + return None + + arg = expr.args[0] + if ( + isinstance(arg, ast.Call) + and isinstance(arg.func, ast.Name) + and arg.func.id == "deref" + ): + logger.info("Multiple deref not supported") + return None + + if isinstance(arg, ast.Name): + if arg.id in local_sym_tab: + arg_ptr = local_sym_tab[arg.id].var + else: + logger.info(f"Undefined variable {arg.id}") + return None + else: + logger.info("Unsupported argument type for deref") + return None + + if arg_ptr is None: + logger.info("Failed to evaluate deref argument") + return None + + # Load the value from pointer + val = builder.load(arg_ptr) + return val, local_sym_tab[arg.id].ir_type + + def eval_expr( func, module, @@ -68,48 +104,24 @@ def eval_expr( elif isinstance(expr, ast.Constant): return _handle_constant_expr(expr) elif isinstance(expr, ast.Call): + if isinstance(expr.func, ast.Name) and expr.func.id == "deref": + return _handle_deref_call(expr, local_sym_tab, builder) + # delayed import to avoid circular dependency from pythonbpf.helper import HelperHandlerRegistry, handle_helper_call - if isinstance(expr.func, ast.Name): - # check deref - if expr.func.id == "deref": - logger.info(f"Handling deref {ast.dump(expr)}") - if len(expr.args) != 1: - logger.info("deref takes exactly one argument") - return None - arg = expr.args[0] - if ( - isinstance(arg, ast.Call) - and isinstance(arg.func, ast.Name) - and arg.func.id == "deref" - ): - logger.info("Multiple deref not supported") - return None - if isinstance(arg, ast.Name): - if arg.id in local_sym_tab: - arg = local_sym_tab[arg.id].var - else: - logger.info(f"Undefined variable {arg.id}") - return None - if arg is None: - logger.info("Failed to evaluate deref argument") - return None - # Since we are handling only name case, directly take type from sym tab - val = builder.load(arg) - return val, local_sym_tab[expr.args[0].id].ir_type - - # check for helpers - if HelperHandlerRegistry.has_handler(expr.func.id): - return handle_helper_call( - expr, - module, - builder, - func, - local_sym_tab, - map_sym_tab, - structs_sym_tab, - ) + if isinstance(expr.func, ast.Name) and HelperHandlerRegistry.has_handler( + expr.func.id + ): + return handle_helper_call( + expr, + module, + builder, + func, + local_sym_tab, + map_sym_tab, + structs_sym_tab, + ) elif isinstance(expr.func, ast.Attribute): logger.info(f"Handling method call: {ast.dump(expr.func)}") if isinstance(expr.func.value, ast.Call) and isinstance( From c9ee6e4f17e07c3f5f56f69f4911eb4ebb80185d Mon Sep 17 00:00:00 2001 From: Pragyansh Chaturvedi Date: Fri, 3 Oct 2025 13:35:15 +0530 Subject: [PATCH 06/11] Fix recursive_dereferencer in binops --- pythonbpf/binary_ops.py | 5 +---- pythonbpf/expr_pass.py | 3 +-- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/pythonbpf/binary_ops.py b/pythonbpf/binary_ops.py index e0b69f3..eaf2e42 100644 --- a/pythonbpf/binary_ops.py +++ b/pythonbpf/binary_ops.py @@ -8,10 +8,7 @@ def recursive_dereferencer(var, builder): """dereference until primitive type comes out""" - if var.type == ir.PointerType(ir.PointerType(ir.IntType(64))): - a = builder.load(var) - return recursive_dereferencer(a, builder) - elif var.type == ir.PointerType(ir.IntType(64)): + if isinstance(var.type, ir.PointerType): a = builder.load(var) return recursive_dereferencer(a, builder) elif var.type == ir.IntType(64): diff --git a/pythonbpf/expr_pass.py b/pythonbpf/expr_pass.py index 22c659c..40d0800 100644 --- a/pythonbpf/expr_pass.py +++ b/pythonbpf/expr_pass.py @@ -41,8 +41,7 @@ def _handle_attribute_expr( attr_name = expr.attr if var_name in local_sym_tab: var_ptr, var_type, var_metadata = local_sym_tab[var_name] - logger.info(f"Loading attribute { - attr_name} from variable {var_name}") + logger.info(f"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] From 6d5895ebc223b7d59a8c0825c4830df2934a0fe2 Mon Sep 17 00:00:00 2001 From: Pragyansh Chaturvedi Date: Fri, 3 Oct 2025 13:46:52 +0530 Subject: [PATCH 07/11] More fixes to recursive dereferencer, add get_operand value --- pythonbpf/binary_ops.py | 41 +++++++++++++++++------------------------ 1 file changed, 17 insertions(+), 24 deletions(-) diff --git a/pythonbpf/binary_ops.py b/pythonbpf/binary_ops.py index eaf2e42..5594856 100644 --- a/pythonbpf/binary_ops.py +++ b/pythonbpf/binary_ops.py @@ -8,42 +8,35 @@ def recursive_dereferencer(var, builder): """dereference until primitive type comes out""" + # TODO: Not worrying about stack overflow for now if isinstance(var.type, ir.PointerType): a = builder.load(var) return recursive_dereferencer(a, builder) - elif var.type == ir.IntType(64): + elif isinstance(var.type, ir.IntType): return var else: raise TypeError(f"Unsupported type for dereferencing: {var.type}") +def get_operand_value(operand, builder, local_sym_tab): + """Extract the value from an operand, handling variables and constants.""" + if isinstance(operand, ast.Name): + if operand.id in local_sym_tab: + return recursive_dereferencer(local_sym_tab[operand.id].var, builder) + raise ValueError(f"Undefined variable: {operand.id}") + elif isinstance(operand, ast.Constant): + if isinstance(operand.value, int): + return ir.Constant(ir.IntType(64), operand.value) + raise TypeError(f"Unsupported constant type: {type(operand.value)}") + raise TypeError(f"Unsupported operand type: {type(operand)}") + + def handle_binary_op(rval, module, builder, var_name, local_sym_tab, map_sym_tab, func): logger.info(f"module {module}") - left = rval.left - right = rval.right op = rval.op - # Handle left operand - if isinstance(left, ast.Name): - if left.id in local_sym_tab: - left = recursive_dereferencer(local_sym_tab[left.id].var, builder) - else: - raise SyntaxError(f"Undefined variable: {left.id}") - elif isinstance(left, ast.Constant): - left = ir.Constant(ir.IntType(64), left.value) - else: - raise SyntaxError("Unsupported left operand type") - - if isinstance(right, ast.Name): - if right.id in local_sym_tab: - right = recursive_dereferencer(local_sym_tab[right.id].var, builder) - else: - raise SyntaxError(f"Undefined variable: {right.id}") - elif isinstance(right, ast.Constant): - right = ir.Constant(ir.IntType(64), right.value) - else: - raise SyntaxError("Unsupported right operand type") - + left = get_operand_value(rval.left, builder, local_sym_tab) + right = get_operand_value(rval.right, builder, local_sym_tab) logger.info(f"left is {left}, right is {right}, op is {op}") if isinstance(op, ast.Add): From d593969408034f03f472e30fe15f7c4f21162f2b Mon Sep 17 00:00:00 2001 From: Pragyansh Chaturvedi Date: Fri, 3 Oct 2025 14:04:38 +0530 Subject: [PATCH 08/11] Refactor ugly if-elif chain in handle_binary_op --- pythonbpf/binary_ops.py | 42 ++++++++++++++++++----------------------- 1 file changed, 18 insertions(+), 24 deletions(-) diff --git a/pythonbpf/binary_ops.py b/pythonbpf/binary_ops.py index 5594856..26d59cd 100644 --- a/pythonbpf/binary_ops.py +++ b/pythonbpf/binary_ops.py @@ -32,34 +32,28 @@ def get_operand_value(operand, builder, local_sym_tab): def handle_binary_op(rval, module, builder, var_name, local_sym_tab, map_sym_tab, func): - logger.info(f"module {module}") op = rval.op - left = get_operand_value(rval.left, builder, local_sym_tab) right = get_operand_value(rval.right, builder, local_sym_tab) 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) - elif isinstance(op, ast.Sub): - builder.store(builder.sub(left, right), local_sym_tab[var_name].var) - elif isinstance(op, ast.Mult): - builder.store(builder.mul(left, right), local_sym_tab[var_name].var) - elif isinstance(op, ast.Div): - builder.store(builder.sdiv(left, right), local_sym_tab[var_name].var) - elif isinstance(op, ast.Mod): - builder.store(builder.srem(left, right), local_sym_tab[var_name].var) - elif isinstance(op, ast.LShift): - builder.store(builder.shl(left, right), local_sym_tab[var_name].var) - elif isinstance(op, ast.RShift): - builder.store(builder.lshr(left, right), local_sym_tab[var_name].var) - elif isinstance(op, ast.BitOr): - builder.store(builder.or_(left, right), local_sym_tab[var_name].var) - elif isinstance(op, ast.BitXor): - builder.store(builder.xor(left, right), local_sym_tab[var_name].var) - elif isinstance(op, ast.BitAnd): - builder.store(builder.and_(left, right), local_sym_tab[var_name].var) - elif isinstance(op, ast.FloorDiv): - builder.store(builder.udiv(left, right), local_sym_tab[var_name].var) + # Map AST operation nodes to LLVM IR builder methods + op_map = { + ast.Add: builder.add, + ast.Sub: builder.sub, + ast.Mult: builder.mul, + ast.Div: builder.sdiv, + ast.Mod: builder.srem, + ast.LShift: builder.shl, + ast.RShift: builder.lshr, + ast.BitOr: builder.or_, + ast.BitXor: builder.xor, + ast.BitAnd: builder.and_, + ast.FloorDiv: builder.udiv, + } + + if type(op) in op_map: + result = op_map[type(op)](left, right) + builder.store(result, local_sym_tab[var_name].var) else: raise SyntaxError("Unsupported binary operation") From a8b3f4f86c9ce55cb94f57c13f9e08a69207171c Mon Sep 17 00:00:00 2001 From: Pragyansh Chaturvedi Date: Fri, 3 Oct 2025 17:08:41 +0530 Subject: [PATCH 09/11] Fix recursive binops, move failing binops to passing --- pythonbpf/binary_ops.py | 17 ++++++++++++----- pythonbpf/codegen.py | 2 +- pythonbpf/functions_pass.py | 4 +--- .../{failing_tests => passing_tests}/binops.py | 2 +- 4 files changed, 15 insertions(+), 10 deletions(-) rename tests/{failing_tests => passing_tests}/binops.py (84%) diff --git a/pythonbpf/binary_ops.py b/pythonbpf/binary_ops.py index 26d59cd..5ab393f 100644 --- a/pythonbpf/binary_ops.py +++ b/pythonbpf/binary_ops.py @@ -18,7 +18,7 @@ def recursive_dereferencer(var, builder): raise TypeError(f"Unsupported type for dereferencing: {var.type}") -def get_operand_value(operand, builder, local_sym_tab): +def get_operand_value(operand, module, builder, local_sym_tab): """Extract the value from an operand, handling variables and constants.""" if isinstance(operand, ast.Name): if operand.id in local_sym_tab: @@ -28,13 +28,15 @@ def get_operand_value(operand, builder, local_sym_tab): if isinstance(operand.value, int): return ir.Constant(ir.IntType(64), operand.value) raise TypeError(f"Unsupported constant type: {type(operand.value)}") + elif isinstance(operand, ast.BinOp): + return handle_binary_op_impl(operand, module, builder, local_sym_tab) raise TypeError(f"Unsupported operand type: {type(operand)}") -def handle_binary_op(rval, module, builder, var_name, local_sym_tab, map_sym_tab, func): +def handle_binary_op_impl(rval, module, builder, local_sym_tab): op = rval.op - left = get_operand_value(rval.left, builder, local_sym_tab) - right = get_operand_value(rval.right, builder, local_sym_tab) + left = get_operand_value(rval.left, module, builder, local_sym_tab) + right = get_operand_value(rval.right, module, builder, local_sym_tab) logger.info(f"left is {left}, right is {right}, op is {op}") # Map AST operation nodes to LLVM IR builder methods @@ -54,6 +56,11 @@ def handle_binary_op(rval, module, builder, var_name, local_sym_tab, map_sym_tab if type(op) in op_map: result = op_map[type(op)](left, right) - builder.store(result, local_sym_tab[var_name].var) + return result else: raise SyntaxError("Unsupported binary operation") + + +def handle_binary_op(rval, module, builder, var_name, local_sym_tab): + result = handle_binary_op_impl(rval, module, builder, local_sym_tab) + builder.store(result, local_sym_tab[var_name].var) diff --git a/pythonbpf/codegen.py b/pythonbpf/codegen.py index 5de23a5..c50d316 100644 --- a/pythonbpf/codegen.py +++ b/pythonbpf/codegen.py @@ -121,7 +121,7 @@ def compile_to_ir(filename: str, output: str, loglevel=logging.WARNING): return output -def compile(loglevel=logging.WARNING) -> bool: +def compile(loglevel=logging.INFO) -> 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() diff --git a/pythonbpf/functions_pass.py b/pythonbpf/functions_pass.py index 6653677..430b55f 100644 --- a/pythonbpf/functions_pass.py +++ b/pythonbpf/functions_pass.py @@ -233,9 +233,7 @@ def handle_assign( else: 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 - ) + handle_binary_op(rval, module, builder, var_name, local_sym_tab) else: logger.info("Unsupported assignment value type") diff --git a/tests/failing_tests/binops.py b/tests/passing_tests/binops.py similarity index 84% rename from tests/failing_tests/binops.py rename to tests/passing_tests/binops.py index 3a86765..14c5eef 100644 --- a/tests/failing_tests/binops.py +++ b/tests/passing_tests/binops.py @@ -3,7 +3,7 @@ @bpf -@section("sometag1") +@section("tracepoint/syscalls/sys_enter_sync") def sometag(ctx: c_void_p) -> c_int64: a = 1 + 2 + 1 print(f"{a}") From cc626c38f7de8f316f0b682387f58d8249dc537f Mon Sep 17 00:00:00 2001 From: Pragyansh Chaturvedi Date: Fri, 3 Oct 2025 17:13:02 +0530 Subject: [PATCH 10/11] Move binops1 to tests/passing --- tests/passing_tests/binops.py | 2 +- tests/{failing_tests => passing_tests}/binops1.py | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) rename tests/{failing_tests => passing_tests}/binops1.py (72%) diff --git a/tests/passing_tests/binops.py b/tests/passing_tests/binops.py index 14c5eef..1fdff54 100644 --- a/tests/passing_tests/binops.py +++ b/tests/passing_tests/binops.py @@ -5,7 +5,7 @@ @bpf @section("tracepoint/syscalls/sys_enter_sync") def sometag(ctx: c_void_p) -> c_int64: - a = 1 + 2 + 1 + a = 1 + 2 + 1 + 12 + 13 print(f"{a}") return c_int64(0) diff --git a/tests/failing_tests/binops1.py b/tests/passing_tests/binops1.py similarity index 72% rename from tests/failing_tests/binops1.py rename to tests/passing_tests/binops1.py index a3a06cc..a16158c 100644 --- a/tests/failing_tests/binops1.py +++ b/tests/passing_tests/binops1.py @@ -3,11 +3,12 @@ @bpf -@section("sometag1") +@section("tracepoint/syscalls/sys_enter_sync") def sometag(ctx: c_void_p) -> c_int64: b = 1 + 2 a = 1 + b - return c_int64(a) + print(f"{a}") + return c_int64(0) @bpf From c3db609a90868fe6a98b810bb1684acb8a214d08 Mon Sep 17 00:00:00 2001 From: Pragyansh Chaturvedi Date: Fri, 3 Oct 2025 17:35:57 +0530 Subject: [PATCH 11/11] Revert to using Warning loglevel as default --- pythonbpf/codegen.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pythonbpf/codegen.py b/pythonbpf/codegen.py index c50d316..5de23a5 100644 --- a/pythonbpf/codegen.py +++ b/pythonbpf/codegen.py @@ -121,7 +121,7 @@ def compile_to_ir(filename: str, output: str, loglevel=logging.WARNING): return output -def compile(loglevel=logging.INFO) -> 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()