Merge branch 'master' into fix-maps

Author: r41k0u

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythonbpf"
-version = "0.1.3"
+version = "0.1.4"
 description = "Reduced Python frontend for eBPF"
 authors = [
   { name = "r41k0u", email="[email protected]" },

pythonbpf/binary_ops.py

@@ -1,5 +1,9 @@
 import ast
 from llvmlite import ir
+from logging import Logger
+import logging
+
+logger: Logger = logging.getLogger(__name__)
 
 
 def recursive_dereferencer(var, builder):
@@ -17,7 +21,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 +47,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)

pythonbpf/codegen.py

@@ -5,15 +5,19 @@
 from .maps import maps_proc
 from .structs import structs_proc
 from .globals_pass import globals_processing
-from .debuginfo import DW_LANG_C11, DwarfBehaviorEnum
+from .debuginfo import DW_LANG_C11, DwarfBehaviorEnum, DebugInfoGenerator
 import os
 import subprocess
 import inspect
 from pathlib import Path
 from pylibbpf import BpfProgram
 import tempfile
+from logging import Logger
+import logging
 
-VERSION = "v0.1.3"
+logger: Logger = logging.getLogger(__name__)
+
+VERSION = "v0.1.4"
 
 
 def find_bpf_chunks(tree):
@@ -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)
@@ -44,7 +48,10 @@ 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()
 
@@ -53,33 +60,17 @@ def compile_to_ir(filename: str, output: str):
     module.triple = "bpf"
 
     if not hasattr(module, "_debug_compile_unit"):
-        module._file_metadata = module.add_debug_info(
-            "DIFile",
-            {  # type: ignore
-                "filename": filename,
-                "directory": os.path.dirname(filename),
-            },
-        )
-
-        module._debug_compile_unit = module.add_debug_info(
-            "DICompileUnit",
-            {  # type: ignore
-                "language": DW_LANG_C11,
-                "file": module._file_metadata,  # type: ignore
-                "producer": f"PythonBPF {VERSION}",
-                "isOptimized": True,  # TODO: This is probably not true
-                # TODO: add a global field here that keeps track of all the globals. Works without it, but I think it might
-                # be required for kprobes.
-                "runtimeVersion": 0,
-                "emissionKind": 1,
-                "splitDebugInlining": False,
-                "nameTableKind": 0,
-            },
-            is_distinct=True,
+        debug_generator = DebugInfoGenerator(module)
+        debug_generator.generate_file_metadata(filename, os.path.dirname(filename))
+        debug_generator.generate_debug_cu(
+            DW_LANG_C11,
+            f"PythonBPF {VERSION}",
+            True,  # TODO: This is probably not true
+            # TODO: add a global field here that keeps track of all the globals. Works without it, but I think it might
+            # be required for kprobes.
+            True,
         )
 
-        module.add_named_metadata("llvm.dbg.cu", module._debug_compile_unit)  # type: ignore
-
     processor(source, filename, module)
 
     wchar_size = module.add_metadata(
@@ -121,7 +112,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))
@@ -130,7 +121,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()
@@ -139,7 +130,9 @@ 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(
@@ -157,11 +150,11 @@ def compile() -> bool:
         and success
     )
 
-    print(f"Object written to {o_file}")
+    logger.info(f"Object written to {o_file}")
     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(
@@ -174,7 +167,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",

pythonbpf/debuginfo/debug_info_generator.py

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

pythonbpf/expr_pass.py

@@ -1,5 +1,9 @@
 import ast
 from llvmlite import ir
+from logging import Logger
+import logging
+
+logger: Logger = logging.getLogger(__name__)
 
 
 def eval_expr(
@@ -11,22 +15,22 @@ 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):
             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:
-            print("Unsupported constant type")
+            logger.info("Unsupported constant type")
             return None
     elif isinstance(expr, ast.Call):
         # delayed import to avoid circular dependency
@@ -35,26 +39,26 @@ 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 (
                     isinstance(arg, ast.Call)
                     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 +76,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 +111,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 +133,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 +146,4 @@ def handle_expr(
             structs_sym_tab,
         )
     else:
-        print("Unsupported expression type")
+        logger.info("Unsupported expression type")