Add deref

Fix map calling convention

examples/sys_sync.py

@@ -21,17 +21,17 @@ def last() -> HashMap:
 @section("tracepoint/syscalls/sys_enter_sync")
 def do_trace(ctx: c_void_p) -> c_int64:
     key = 0
-    tsp = last().lookup(key)
+    tsp = last.lookup(key)
     if tsp:
         kt = ktime()
         delta = kt - tsp
         if delta < 1000000000:
             time_ms = delta // 1000000
             print(f"sync called within last second, last {time_ms} ms ago")
-        last().delete(key)
+        last.delete(key)
     else:
         kt = ktime()
-        last().update(key, kt)
+        last.update(key, kt)
     return c_int64(0)
 
 

pythonbpf/codegen.py

@@ -5,7 +5,7 @@ from .functions_pass import func_proc
 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
@@ -60,33 +60,17 @@ def compile_to_ir(filename: str, output: str, loglevel=logging.WARNING):
     module.triple = "bpf"
 
     if not hasattr(module, "_debug_compile_unit"):
-        module._file_metadata = module.add_debug_info(
+        debug_generator = DebugInfoGenerator(module)
-            "DIFile",
+        debug_generator.generate_file_metadata(filename, os.path.dirname(filename))
-            {  # type: ignore
+        debug_generator.generate_debug_cu(
-                "filename": filename,
+            DW_LANG_C11,
-                "directory": os.path.dirname(filename),
+            f"PythonBPF {VERSION}",
-            },
+            True,  # TODO: This is probably not true
-        )
-
-        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,
+            True,
-                "emissionKind": 1,
-                "splitDebugInlining": False,
-                "nameTableKind": 0,
-            },
-            is_distinct=True,
         )
 
-        module.add_named_metadata("llvm.dbg.cu", module._debug_compile_unit)  # type: ignore
-
     processor(source, filename, module)
 
     wchar_size = module.add_metadata(

pythonbpf/debuginfo/debug_info_generator.py

@@ -12,6 +12,34 @@ class DebugInfoGenerator:
         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

@@ -2,10 +2,93 @@ import ast
 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 _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 _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 _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,
@@ -17,55 +100,19 @@ def eval_expr(
 ):
     logger.info(f"Evaluating expression: {ast.dump(expr)}")
     if isinstance(expr, ast.Name):
-        if expr.id in local_sym_tab:
+        return _handle_name_expr(expr, local_sym_tab, builder)
-            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
     elif isinstance(expr, ast.Constant):
-        if isinstance(expr.value, int):
+        return _handle_constant_expr(expr)
-            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
     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):
+        if isinstance(expr.func, ast.Name) and HelperHandlerRegistry.has_handler(
-            # check deref
+            expr.func.id
-            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,
@@ -106,19 +153,7 @@ def eval_expr(
                             structs_sym_tab,
                         )
     elif isinstance(expr, ast.Attribute):
-        if isinstance(expr.value, ast.Name):
+        return _handle_attribute_expr(expr, local_sym_tab, structs_sym_tab, builder)
-            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
     logger.info("Unsupported expression evaluation")
     return None
 

pythonbpf/functions_pass.py

@@ -192,6 +192,21 @@ def handle_assign(
         elif isinstance(rval.func, ast.Attribute):
             logger.info(f"Assignment call attribute: {ast.dump(rval.func)}")
             if isinstance(rval.func.value, ast.Name):
+                if rval.func.value.id in map_sym_tab:
+                    map_name = rval.func.value.id
+                    method_name = rval.func.attr
+                    if HelperHandlerRegistry.has_handler(method_name):
+                        val = handle_helper_call(
+                            rval,
+                            module,
+                            builder,
+                            func,
+                            local_sym_tab,
+                            map_sym_tab,
+                            structs_sym_tab,
+                        )
+                        builder.store(val[0], local_sym_tab[var_name].var)
+                else:
                     # TODO: probably a struct access
                     logger.info(f"TODO STRUCT ACCESS {ast.dump(rval)}")
             elif isinstance(rval.func.value, ast.Call) and isinstance(