Update pythonbpf/functions_pass.py

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

.github/workflows/format.yml

@@ -5,10 +5,7 @@ name: Format
 
 on:
   workflow_dispatch:
-  pull_request:
   push:
-    branches:
-    - master
 
 jobs:
   pre-commit:

.pre-commit-config.yaml

@@ -35,22 +35,21 @@ repos:
   - id: requirements-txt-fixer
   - id: trailing-whitespace
 
-#- repo: https://github.com/astral-sh/ruff-pre-commit
+- repo: https://github.com/astral-sh/ruff-pre-commit
-#  rev: "v0.4.2"
+  rev: "v0.4.2"
-#  hooks:
+  hooks:
-#    - id: ruff
+    - id: ruff
-#      args: ["--fix", "--show-fixes"]
+      args: ["--fix", "--show-fixes"]
-#    - id: ruff-format
+    - id: ruff-format
-#      exclude: ^(docs)
+      exclude: ^(docs)|^(tests)|^(examples)
 
-## Checking static types
+# Checking static types
-#- repo: https://github.com/pre-commit/mirrors-mypy
+- repo: https://github.com/pre-commit/mirrors-mypy
-#  rev: "v1.10.0"
+  rev: "v1.10.0"
-#  hooks:
+  hooks:
-#    - id: mypy
+    - id: mypy
-#      files: "setup.py"
+      exclude: ^(tests)|^(examples)
-#      args: []
+      additional_dependencies: [types-setuptools]
-#      additional_dependencies: [types-setuptools]
 
 # Changes tabs to spaces
 - repo: https://github.com/Lucas-C/pre-commit-hooks

README.md

@@ -1,4 +1,14 @@
-<img src="https://github.com/user-attachments/assets/b175bf39-23cb-475d-a6e1-7b5c99a1ed72" alt="pythonbpf" width="450">
+<picture>
+  <source
+    media="(prefers-color-scheme: light)"
+    srcset="https://github.com/user-attachments/assets/f3738131-d7cb-4b5c-8699-c7010295a159"
+    width="450"
+    alt="Light‐mode image">
+  <img
+    src="https://github.com/user-attachments/assets/b175bf39-23cb-475d-a6e1-7b5c99a1ed72"
+    width="450"
+    alt="Dark‐mode image">
+</picture>
 <!-- Badges -->
 <p align="center">
   <!-- PyPI -->
@@ -50,12 +60,13 @@ pip install pythonbpf pylibbpf
 ```python
 import time
 from pythonbpf import bpf, map, section, bpfglobal, BPF
-from pythonbpf.helpers import pid
+from pythonbpf.helper import pid
 from pythonbpf.maps import HashMap
 from pylibbpf import *
 from ctypes import c_void_p, c_int64, c_uint64, c_int32
 import matplotlib.pyplot as plt
 
+
 # This program attaches an eBPF tracepoint to sys_enter_clone,
 # counts per-PID clone syscalls, stores them in a hash map,
 # and then plots the distribution as a histogram using matplotlib.
@@ -66,6 +77,7 @@ import matplotlib.pyplot as plt
 def hist() -> HashMap:
     return HashMap(key=c_int32, value=c_uint64, max_entries=4096)
 
+
 @bpf
 @section("tracepoint/syscalls/sys_enter_clone")
 def hello(ctx: c_void_p) -> c_int64:

examples/binops_demo.py

@@ -1,5 +1,5 @@
 from pythonbpf import bpf, map, section, bpfglobal, compile
-from pythonbpf.helpers import ktime
+from pythonbpf.helper import ktime
 from pythonbpf.maps import HashMap
 
 from ctypes import c_void_p, c_int64, c_uint64

examples/blk_request.py

@@ -1,5 +1,5 @@
 from pythonbpf import bpf, map, section, bpfglobal, compile
-from pythonbpf.helpers import ktime
+from pythonbpf.helper import ktime
 from pythonbpf.maps import HashMap
 
 from ctypes import c_void_p, c_int32, c_uint64

examples/clone-matplotlib.ipynb

@@ -10,7 +10,7 @@
     "import time\n",
     "\n",
     "from pythonbpf import bpf, map, section, bpfglobal, BPF\n",
-    "from pythonbpf.helpers import pid\n",
+    "from pythonbpf.helper import pid\n",
     "from pythonbpf.maps import HashMap\n",
     "from pylibbpf import *\n",
     "from ctypes import c_void_p, c_int64, c_uint64, c_int32\n",

examples/clone_plot.py

@@ -1,9 +1,9 @@
 import time
 
 from pythonbpf import bpf, map, section, bpfglobal, BPF
-from pythonbpf.helpers import pid
+from pythonbpf.helper import pid
 from pythonbpf.maps import HashMap
-from pylibbpf import *
+from pylibbpf import BpfMap
 from ctypes import c_void_p, c_int64, c_uint64, c_int32
 import matplotlib.pyplot as plt
 

examples/struct_and_perf.py

@@ -1,5 +1,5 @@
 from pythonbpf import bpf, map, struct, section, bpfglobal, compile
-from pythonbpf.helpers import ktime, pid
+from pythonbpf.helper import ktime, pid
 from pythonbpf.maps import PerfEventArray
 
 from ctypes import c_void_p, c_int32, c_uint64
@@ -23,13 +23,11 @@ def events() -> PerfEventArray:
 @section("tracepoint/syscalls/sys_enter_clone")
 def hello(ctx: c_void_p) -> c_int32:
     dataobj = data_t()
-    ts = ktime()
-    process_id = pid()
     strobj = "hellohellohello"
     dataobj.pid = pid()
     dataobj.ts = ktime()
     # dataobj.comm = strobj
-    print(f"clone called at {dataobj.ts} by pid {dataobj.pid}, comm {strobj}")
+    print(f"clone called at {dataobj.ts} by pid" f"{dataobj.pid}, comm {strobj}")
     events.output(dataobj)
     return c_int32(0)
 

examples/sys_sync.py

@@ -1,5 +1,5 @@
 from pythonbpf import bpf, map, section, bpfglobal, compile
-from pythonbpf.helpers import ktime
+from pythonbpf.helper import ktime
 from pythonbpf.maps import HashMap
 
 from ctypes import c_void_p, c_int64, c_uint64

examples/xdp_pass.py

@@ -1,5 +1,5 @@
 from pythonbpf import bpf, map, section, bpfglobal, compile
-from pythonbpf.helpers import XDP_PASS
+from pythonbpf.helper import XDP_PASS
 from pythonbpf.maps import HashMap
 
 from ctypes import c_void_p, c_int64

pythonbpf/__init__.py

@@ -1,2 +1,13 @@
 from .decorators import bpf, map, section, bpfglobal, struct
 from .codegen import compile_to_ir, compile, BPF
+
+__all__ = [
+    "bpf",
+    "map",
+    "section",
+    "bpfglobal",
+    "struct",
+    "compile_to_ir",
+    "compile",
+    "BPF",
+]

pythonbpf/binary_ops.py

@@ -25,7 +25,7 @@ def handle_binary_op(rval, module, builder, var_name, local_sym_tab, map_sym_tab
     # Handle left operand
     if isinstance(left, ast.Name):
         if left.id in local_sym_tab:
-            left = recursive_dereferencer(local_sym_tab[left.id][0], builder)
+            left = recursive_dereferencer(local_sym_tab[left.id].var, builder)
         else:
             raise SyntaxError(f"Undefined variable: {left.id}")
     elif isinstance(left, ast.Constant):
@@ -35,7 +35,7 @@ def handle_binary_op(rval, module, builder, var_name, local_sym_tab, map_sym_tab
 
     if isinstance(right, ast.Name):
         if right.id in local_sym_tab:
-            right = recursive_dereferencer(local_sym_tab[right.id][0], builder)
+            right = recursive_dereferencer(local_sym_tab[right.id].var, builder)
         else:
             raise SyntaxError(f"Undefined variable: {right.id}")
     elif isinstance(right, ast.Constant):
@@ -46,26 +46,26 @@ def handle_binary_op(rval, module, builder, var_name, local_sym_tab, map_sym_tab
     print(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][0])
+        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][0])
+        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][0])
+        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][0])
+        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][0])
+        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][0])
+        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][0])
+        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][0])
+        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][0])
+        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][0])
+        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][0])
+        builder.store(builder.udiv(left, right), local_sym_tab[var_name].var)
     else:
         raise SyntaxError("Unsupported binary operation")

pythonbpf/bpf_helper_handler.py

@@ -1,654 +0,0 @@
-import ast
-from llvmlite import ir
-from .expr_pass import eval_expr
-
-
-def bpf_ktime_get_ns_emitter(
-    call,
-    map_ptr,
-    module,
-    builder,
-    func,
-    local_sym_tab=None,
-    struct_sym_tab=None,
-    local_var_metadata=None,
-):
-    """
-    Emit LLVM IR for bpf_ktime_get_ns helper function call.
-    """
-    # func is an arg to just have a uniform signature with other emitters
-    helper_id = ir.Constant(ir.IntType(64), 5)
-    fn_type = ir.FunctionType(ir.IntType(64), [], var_arg=False)
-    fn_ptr_type = ir.PointerType(fn_type)
-    fn_ptr = builder.inttoptr(helper_id, fn_ptr_type)
-    result = builder.call(fn_ptr, [], tail=False)
-    return result, ir.IntType(64)
-
-
-def bpf_map_lookup_elem_emitter(
-    call,
-    map_ptr,
-    module,
-    builder,
-    func,
-    local_sym_tab=None,
-    struct_sym_tab=None,
-    local_var_metadata=None,
-):
-    """
-    Emit LLVM IR for bpf_map_lookup_elem helper function call.
-    """
-    if call.args and len(call.args) != 1:
-        raise ValueError(
-            "Map lookup expects exactly one argument, got " f"{len(call.args)}"
-        )
-    key_arg = call.args[0]
-    if isinstance(key_arg, ast.Name):
-        key_name = key_arg.id
-        if local_sym_tab and key_name in local_sym_tab:
-            key_ptr = local_sym_tab[key_name][0]
-        else:
-            raise ValueError(
-                f"Key variable {key_name} not found in local symbol table."
-            )
-    elif isinstance(key_arg, ast.Constant) and isinstance(key_arg.value, int):
-        # handle constant integer keys
-        key_val = key_arg.value
-        key_type = ir.IntType(64)
-        key_ptr = builder.alloca(key_type)
-        key_ptr.align = key_type // 8
-        builder.store(ir.Constant(key_type, key_val), key_ptr)
-    else:
-        raise NotImplementedError(
-            "Only simple variable names are supported as keys in map lookup."
-        )
-
-    if key_ptr is None:
-        raise ValueError("Key pointer is None.")
-
-    map_void_ptr = builder.bitcast(map_ptr, ir.PointerType())
-
-    fn_type = ir.FunctionType(
-        ir.PointerType(),  # Return type: void*
-        [ir.PointerType(), ir.PointerType()],  # Args: (void*, void*)
-        var_arg=False,
-    )
-    fn_ptr_type = ir.PointerType(fn_type)
-
-    # Helper ID 1 is bpf_map_lookup_elem
-    fn_addr = ir.Constant(ir.IntType(64), 1)
-    fn_ptr = builder.inttoptr(fn_addr, fn_ptr_type)
-
-    result = builder.call(fn_ptr, [map_void_ptr, key_ptr], tail=False)
-
-    return result, ir.PointerType()
-
-
-def bpf_printk_emitter(
-    call,
-    map_ptr,
-    module,
-    builder,
-    func,
-    local_sym_tab=None,
-    struct_sym_tab=None,
-    local_var_metadata=None,
-):
-    if not hasattr(func, "_fmt_counter"):
-        func._fmt_counter = 0
-
-    if not call.args:
-        raise ValueError("print expects at least one argument")
-
-    if isinstance(call.args[0], ast.JoinedStr):
-        fmt_parts = []
-        exprs = []
-
-        for value in call.args[0].values:
-            print("Value in f-string:", ast.dump(value))
-            if isinstance(value, ast.Constant):
-                if isinstance(value.value, str):
-                    fmt_parts.append(value.value)
-                elif isinstance(value.value, int):
-                    fmt_parts.append("%lld")
-                    exprs.append(ir.Constant(ir.IntType(64), value.value))
-                else:
-                    raise NotImplementedError(
-                        "Only string and integer constants are supported in f-string."
-                    )
-            elif isinstance(value, ast.FormattedValue):
-                print("Formatted value:", ast.dump(value))
-                # TODO: Dirty handling here, only checks for int or str
-                if isinstance(value.value, ast.Name):
-                    if local_sym_tab and value.value.id in local_sym_tab:
-                        var_ptr, var_type = local_sym_tab[value.value.id]
-                        if isinstance(var_type, ir.IntType):
-                            fmt_parts.append("%lld")
-                            exprs.append(value.value)
-                        elif var_type == ir.PointerType(ir.IntType(8)):
-                            # Case with string
-                            fmt_parts.append("%s")
-                            exprs.append(value.value)
-                        else:
-                            raise NotImplementedError(
-                                "Only integer and pointer types are supported in formatted values."
-                            )
-                    else:
-                        raise ValueError(
-                            f"Variable {value.value.id} not found in local symbol table."
-                        )
-                elif isinstance(value.value, ast.Attribute):
-                    # object field access from struct
-                    if (
-                        isinstance(value.value.value, ast.Name)
-                        and local_sym_tab
-                        and value.value.value.id in local_sym_tab
-                    ):
-                        var_name = value.value.value.id
-                        field_name = value.value.attr
-                        if local_var_metadata and var_name in local_var_metadata:
-                            var_type = local_var_metadata[var_name]
-                            if var_type in struct_sym_tab:
-                                struct_info = struct_sym_tab[var_type]
-                                if field_name in struct_info.fields:
-                                    field_type = struct_info.field_type(field_name)
-                                    if isinstance(field_type, ir.IntType):
-                                        fmt_parts.append("%lld")
-                                        exprs.append(value.value)
-                                    elif field_type == ir.PointerType(ir.IntType(8)):
-                                        fmt_parts.append("%s")
-                                        exprs.append(value.value)
-                                    else:
-                                        raise NotImplementedError(
-                                            "Only integer and pointer types are supported in formatted values."
-                                        )
-                                else:
-                                    raise ValueError(
-                                        f"Field {field_name} not found in struct {var_type}."
-                                    )
-                            else:
-                                raise ValueError(
-                                    f"Struct type {var_type} for variable {var_name} not found in struct symbol table."
-                                )
-                        else:
-                            raise ValueError(
-                                f"Metadata for variable {var_name} not found in local variable metadata."
-                            )
-                    else:
-                        raise ValueError(
-                            f"Variable {value.value.value.id} not found in local symbol table."
-                        )
-                else:
-                    raise NotImplementedError(
-                        "Only simple variable names are supported in formatted values."
-                    )
-            else:
-                raise NotImplementedError("Unsupported value type in f-string.")
-
-        fmt_str = "".join(fmt_parts) + "\n" + "\0"
-        fmt_name = f"{func.name}____fmt{func._fmt_counter}"
-        func._fmt_counter += 1
-
-        fmt_gvar = ir.GlobalVariable(
-            module, ir.ArrayType(ir.IntType(8), len(fmt_str)), name=fmt_name
-        )
-        fmt_gvar.global_constant = True
-        fmt_gvar.initializer = ir.Constant(  # type: ignore
-            ir.ArrayType(ir.IntType(8), len(fmt_str)), bytearray(fmt_str.encode("utf8"))
-        )
-        fmt_gvar.linkage = "internal"
-        fmt_gvar.align = 1  # type: ignore
-
-        fmt_ptr = builder.bitcast(fmt_gvar, ir.PointerType())
-
-        args = [fmt_ptr, ir.Constant(ir.IntType(32), len(fmt_str))]
-
-        # Only 3 args supported in bpf_printk
-        if len(exprs) > 3:
-            print(
-                "Warning: bpf_printk supports up to 3 arguments, extra arguments will be ignored."
-            )
-
-        for expr in exprs[:3]:
-            print(f"{ast.dump(expr)}")
-            val, _ = eval_expr(
-                func,
-                module,
-                builder,
-                expr,
-                local_sym_tab,
-                None,
-                struct_sym_tab,
-                local_var_metadata,
-            )
-            if val:
-                if isinstance(val.type, ir.PointerType):
-                    val = builder.ptrtoint(val, ir.IntType(64))
-                elif isinstance(val.type, ir.IntType):
-                    if val.type.width < 64:
-                        val = builder.sext(val, ir.IntType(64))
-                else:
-                    print(
-                        "Warning: Only integer and pointer types are supported in bpf_printk arguments. Others will be converted to 0."
-                    )
-                    val = ir.Constant(ir.IntType(64), 0)
-                args.append(val)
-            else:
-                print(
-                    "Warning: Failed to evaluate expression for bpf_printk argument. It will be converted to 0."
-                )
-                args.append(ir.Constant(ir.IntType(64), 0))
-        fn_type = ir.FunctionType(
-            ir.IntType(64), [ir.PointerType(), ir.IntType(32)], var_arg=True
-        )
-        fn_ptr_type = ir.PointerType(fn_type)
-        fn_addr = ir.Constant(ir.IntType(64), 6)
-        fn_ptr = builder.inttoptr(fn_addr, fn_ptr_type)
-        return builder.call(fn_ptr, args, tail=True)
-
-    for arg in call.args:
-        if isinstance(arg, ast.Constant) and isinstance(arg.value, str):
-            fmt_str = arg.value + "\n" + "\0"
-            fmt_name = f"{func.name}____fmt{func._fmt_counter}"
-            func._fmt_counter += 1
-
-            fmt_gvar = ir.GlobalVariable(
-                module, ir.ArrayType(ir.IntType(8), len(fmt_str)), name=fmt_name
-            )
-            fmt_gvar.global_constant = True
-            fmt_gvar.initializer = ir.Constant(  # type: ignore
-                ir.ArrayType(ir.IntType(8), len(fmt_str)),
-                bytearray(fmt_str.encode("utf8")),
-            )
-            fmt_gvar.linkage = "internal"
-            fmt_gvar.align = 1  # type: ignore
-
-            fmt_ptr = builder.bitcast(fmt_gvar, ir.PointerType())
-
-            fn_type = ir.FunctionType(
-                ir.IntType(64), [ir.PointerType(), ir.IntType(32)], var_arg=True
-            )
-            fn_ptr_type = ir.PointerType(fn_type)
-            fn_addr = ir.Constant(ir.IntType(64), 6)
-            fn_ptr = builder.inttoptr(fn_addr, fn_ptr_type)
-
-            builder.call(
-                fn_ptr, [fmt_ptr, ir.Constant(ir.IntType(32), len(fmt_str))], tail=True
-            )
-    return None
-
-
-def bpf_map_update_elem_emitter(
-    call,
-    map_ptr,
-    module,
-    builder,
-    func,
-    local_sym_tab=None,
-    struct_sym_tab=None,
-    local_var_metadata=None,
-):
-    """
-    Emit LLVM IR for bpf_map_update_elem helper function call.
-    Expected call signature: map.update(key, value, flags=0)
-    """
-    if not call.args or len(call.args) < 2 or len(call.args) > 3:
-        raise ValueError(
-            "Map update expects 2 or 3 arguments (key, value, flags), got "
-            f"{len(call.args)}"
-        )
-
-    key_arg = call.args[0]
-    value_arg = call.args[1]
-    flags_arg = call.args[2] if len(call.args) > 2 else None
-
-    # Handle key
-    if isinstance(key_arg, ast.Name):
-        key_name = key_arg.id
-        if local_sym_tab and key_name in local_sym_tab:
-            key_ptr = local_sym_tab[key_name][0]
-        else:
-            raise ValueError(
-                f"Key variable {key_name} not found in local symbol table."
-            )
-    elif isinstance(key_arg, ast.Constant) and isinstance(key_arg.value, int):
-        # Handle constant integer keys
-        key_val = key_arg.value
-        key_type = ir.IntType(64)
-        key_ptr = builder.alloca(key_type)
-        key_ptr.align = key_type.width // 8
-        builder.store(ir.Constant(key_type, key_val), key_ptr)
-    else:
-        raise NotImplementedError(
-            "Only simple variable names and integer constants are supported as keys in map update."
-        )
-
-    # Handle value
-    if isinstance(value_arg, ast.Name):
-        value_name = value_arg.id
-        if local_sym_tab and value_name in local_sym_tab:
-            value_ptr = local_sym_tab[value_name][0]
-        else:
-            raise ValueError(
-                f"Value variable {value_name} not found in local symbol table."
-            )
-    elif isinstance(value_arg, ast.Constant) and isinstance(value_arg.value, int):
-        # Handle constant integers
-        value_val = value_arg.value
-        value_type = ir.IntType(64)
-        value_ptr = builder.alloca(value_type)
-        value_ptr.align = value_type.width // 8
-        builder.store(ir.Constant(value_type, value_val), value_ptr)
-    else:
-        raise NotImplementedError(
-            "Only simple variable names and integer constants are supported as values in map update."
-        )
-
-    # Handle flags argument (defaults to 0)
-    if flags_arg is not None:
-        if isinstance(flags_arg, ast.Constant) and isinstance(flags_arg.value, int):
-            flags_val = flags_arg.value
-        elif isinstance(flags_arg, ast.Name):
-            flags_name = flags_arg.id
-            if local_sym_tab and flags_name in local_sym_tab:
-                # Assume it's a stored integer value, load it
-                flags_ptr = local_sym_tab[flags_name][0]
-                flags_val = builder.load(flags_ptr)
-            else:
-                raise ValueError(
-                    f"Flags variable {flags_name} not found in local symbol table."
-                )
-        else:
-            raise NotImplementedError(
-                "Only integer constants and simple variable names are supported as flags in map update."
-            )
-    else:
-        flags_val = 0
-
-    if key_ptr is None or value_ptr is None:
-        raise ValueError("Key pointer or value pointer is None.")
-
-    map_void_ptr = builder.bitcast(map_ptr, ir.PointerType())
-    fn_type = ir.FunctionType(
-        ir.IntType(64),
-        [ir.PointerType(), ir.PointerType(), ir.PointerType(), ir.IntType(64)],
-        var_arg=False,
-    )
-    fn_ptr_type = ir.PointerType(fn_type)
-
-    # helper id
-    fn_addr = ir.Constant(ir.IntType(64), 2)
-    fn_ptr = builder.inttoptr(fn_addr, fn_ptr_type)
-
-    if isinstance(flags_val, int):
-        flags_const = ir.Constant(ir.IntType(64), flags_val)
-    else:
-        flags_const = flags_val
-
-    result = builder.call(
-        fn_ptr, [map_void_ptr, key_ptr, value_ptr, flags_const], tail=False
-    )
-
-    return result, None
-
-
-def bpf_map_delete_elem_emitter(
-    call,
-    map_ptr,
-    module,
-    builder,
-    func,
-    local_sym_tab=None,
-    struct_sym_tab=None,
-    local_var_metadata=None,
-):
-    """
-    Emit LLVM IR for bpf_map_delete_elem helper function call.
-    Expected call signature: map.delete(key)
-    """
-    # Check for correct number of arguments
-    if not call.args or len(call.args) != 1:
-        raise ValueError(
-            "Map delete expects exactly 1 argument (key), got " f"{len(call.args)}"
-        )
-
-    key_arg = call.args[0]
-
-    # Handle key argument
-    if isinstance(key_arg, ast.Name):
-        key_name = key_arg.id
-        if local_sym_tab and key_name in local_sym_tab:
-            key_ptr = local_sym_tab[key_name][0]
-        else:
-            raise ValueError(
-                f"Key variable {key_name} not found in local symbol table."
-            )
-    elif isinstance(key_arg, ast.Constant) and isinstance(key_arg.value, int):
-        # Handle constant integer keys
-        key_val = key_arg.value
-        key_type = ir.IntType(64)
-        key_ptr = builder.alloca(key_type)
-        key_ptr.align = key_type.width // 8
-        builder.store(ir.Constant(key_type, key_val), key_ptr)
-    else:
-        raise NotImplementedError(
-            "Only simple variable names and integer constants are supported as keys in map delete."
-        )
-
-    if key_ptr is None:
-        raise ValueError("Key pointer is None.")
-
-    # Cast map pointer to void*
-    map_void_ptr = builder.bitcast(map_ptr, ir.PointerType())
-
-    # Define function type for bpf_map_delete_elem
-    fn_type = ir.FunctionType(
-        ir.IntType(64),  # Return type: int64 (status code)
-        [ir.PointerType(), ir.PointerType()],  # Args: (void*, void*)
-        var_arg=False,
-    )
-    fn_ptr_type = ir.PointerType(fn_type)
-
-    # Helper ID 3 is bpf_map_delete_elem
-    fn_addr = ir.Constant(ir.IntType(64), 3)
-    fn_ptr = builder.inttoptr(fn_addr, fn_ptr_type)
-
-    # Call the helper function
-    result = builder.call(fn_ptr, [map_void_ptr, key_ptr], tail=False)
-
-    return result, None
-
-
-def bpf_get_current_pid_tgid_emitter(
-    call,
-    map_ptr,
-    module,
-    builder,
-    func,
-    local_sym_tab=None,
-    struct_sym_tab=None,
-    local_var_metadata=None,
-):
-    """
-    Emit LLVM IR for bpf_get_current_pid_tgid helper function call.
-    """
-    # func is an arg to just have a uniform signature with other emitters
-    helper_id = ir.Constant(ir.IntType(64), 14)
-    fn_type = ir.FunctionType(ir.IntType(64), [], var_arg=False)
-    fn_ptr_type = ir.PointerType(fn_type)
-    fn_ptr = builder.inttoptr(helper_id, fn_ptr_type)
-    result = builder.call(fn_ptr, [], tail=False)
-
-    # Extract the lower 32 bits (PID) using bitwise AND with 0xFFFFFFFF
-    mask = ir.Constant(ir.IntType(64), 0xFFFFFFFF)
-    pid = builder.and_(result, mask)
-    return pid, ir.IntType(64)
-
-
-def bpf_perf_event_output_handler(
-    call,
-    map_ptr,
-    module,
-    builder,
-    func,
-    local_sym_tab=None,
-    struct_sym_tab=None,
-    local_var_metadata=None,
-):
-    if len(call.args) != 1:
-        raise ValueError(
-            "Perf event output expects exactly one argument (data), got "
-            f"{len(call.args)}"
-        )
-    data_arg = call.args[0]
-    ctx_ptr = func.args[0]  # First argument to the function is ctx
-
-    if isinstance(data_arg, ast.Name):
-        data_name = data_arg.id
-        if local_sym_tab and data_name in local_sym_tab:
-            data_ptr = local_sym_tab[data_name][0]
-        else:
-            raise ValueError(
-                f"Data variable {data_name} not found in local symbol table."
-            )
-        # Check is data_name is a struct
-        if local_var_metadata and data_name in local_var_metadata:
-            data_type = local_var_metadata[data_name]
-            if data_type in struct_sym_tab:
-                struct_info = struct_sym_tab[data_type]
-                size_val = ir.Constant(ir.IntType(64), struct_info.size)
-            else:
-                raise ValueError(
-                    f"Struct type {data_type} for variable {data_name} not found in struct symbol table."
-                )
-        else:
-            raise ValueError(
-                f"Metadata for variable {data_name} not found in local variable metadata."
-            )
-
-        # BPF_F_CURRENT_CPU is -1 in 32 bit
-        flags_val = ir.Constant(ir.IntType(64), 0xFFFFFFFF)
-
-        map_void_ptr = builder.bitcast(map_ptr, ir.PointerType())
-        data_void_ptr = builder.bitcast(data_ptr, ir.PointerType())
-        fn_type = ir.FunctionType(
-            ir.IntType(64),
-            [
-                ir.PointerType(ir.IntType(8)),
-                ir.PointerType(),
-                ir.IntType(64),
-                ir.PointerType(),
-                ir.IntType(64),
-            ],
-            var_arg=False,
-        )
-        fn_ptr_type = ir.PointerType(fn_type)
-
-        # helper id
-        fn_addr = ir.Constant(ir.IntType(64), 25)
-        fn_ptr = builder.inttoptr(fn_addr, fn_ptr_type)
-
-        result = builder.call(
-            fn_ptr,
-            [ctx_ptr, map_void_ptr, flags_val, data_void_ptr, size_val],
-            tail=False,
-        )
-        return result, None
-    else:
-        raise NotImplementedError(
-            "Only simple object names are supported as data in perf event output."
-        )
-
-
-helper_func_list = {
-    "lookup": bpf_map_lookup_elem_emitter,
-    "print": bpf_printk_emitter,
-    "ktime": bpf_ktime_get_ns_emitter,
-    "update": bpf_map_update_elem_emitter,
-    "delete": bpf_map_delete_elem_emitter,
-    "pid": bpf_get_current_pid_tgid_emitter,
-    "output": bpf_perf_event_output_handler,
-}
-
-
-def handle_helper_call(
-    call,
-    module,
-    builder,
-    func,
-    local_sym_tab=None,
-    map_sym_tab=None,
-    struct_sym_tab=None,
-    local_var_metadata=None,
-):
-    print(local_var_metadata)
-    if isinstance(call.func, ast.Name):
-        func_name = call.func.id
-        if func_name in helper_func_list:
-            # it is not a map method call
-            return helper_func_list[func_name](
-                call,
-                None,
-                module,
-                builder,
-                func,
-                local_sym_tab,
-                struct_sym_tab,
-                local_var_metadata,
-            )
-        else:
-            raise NotImplementedError(
-                f"Function {func_name} is not implemented as a helper function."
-            )
-    elif isinstance(call.func, ast.Attribute):
-        # likely a map method call
-        if isinstance(call.func.value, ast.Call) and isinstance(
-            call.func.value.func, ast.Name
-        ):
-            map_name = call.func.value.func.id
-            method_name = call.func.attr
-            if map_sym_tab and map_name in map_sym_tab:
-                map_ptr = map_sym_tab[map_name]
-                if method_name in helper_func_list:
-                    print(local_var_metadata)
-                    return helper_func_list[method_name](
-                        call,
-                        map_ptr,
-                        module,
-                        builder,
-                        func,
-                        local_sym_tab,
-                        struct_sym_tab,
-                        local_var_metadata,
-                    )
-                else:
-                    raise NotImplementedError(
-                        f"Map method {method_name} is not implemented as a helper function."
-                    )
-            else:
-                raise ValueError(f"Map variable {map_name} not found in symbol tables.")
-        elif isinstance(call.func.value, ast.Name):
-            obj_name = call.func.value.id
-            method_name = call.func.attr
-            if map_sym_tab and obj_name in map_sym_tab:
-                map_ptr = map_sym_tab[obj_name]
-                if method_name in helper_func_list:
-                    return helper_func_list[method_name](
-                        call,
-                        map_ptr,
-                        module,
-                        builder,
-                        func,
-                        local_sym_tab,
-                        struct_sym_tab,
-                        local_var_metadata,
-                    )
-                else:
-                    raise NotImplementedError(
-                        f"Map method {method_name} is not implemented as a helper function."
-                    )
-            else:
-                raise ValueError(f"Map variable {obj_name} not found in symbol tables.")
-        else:
-            raise NotImplementedError("Attribute not supported for map method calls.")
-    return None

pythonbpf/codegen.py

@@ -141,7 +141,7 @@ def compile() -> bool:
     success = True
     success = compile_to_ir(str(caller_file), str(ll_file)) and success
 
-    success = (
+    success = bool(
         subprocess.run(
             [
                 "llc",

pythonbpf/debuginfo/__init__.py

@@ -1,3 +1,5 @@
-from .dwarf_constants import *
+from .dwarf_constants import *  # noqa: F403
-from .dtypes import *
+from .dtypes import *  # noqa: F403
 from .debug_info_generator import DebugInfoGenerator
+
+__all__ = ["DebugInfoGenerator"]

pythonbpf/debuginfo/debug_info_generator.py

@@ -21,6 +21,10 @@ class DebugInfoGenerator:
             )
         return self._type_cache[key]
 
+    def get_int32_type(self) -> Any:
+        """Get debug info for signed 32-bit integer"""
+        return self.get_basic_type("int", 32, dc.DW_ATE_signed)
+
     def get_uint32_type(self) -> Any:
         """Get debug info for unsigned 32-bit integer"""
         return self.get_basic_type("unsigned int", 32, dc.DW_ATE_unsigned)

pythonbpf/expr_pass.py

@@ -10,15 +10,13 @@ def eval_expr(
     local_sym_tab,
     map_sym_tab,
     structs_sym_tab=None,
-    local_var_metadata=None,
 ):
     print(f"Evaluating expression: {ast.dump(expr)}")
-    print(local_var_metadata)
     if isinstance(expr, ast.Name):
         if expr.id in local_sym_tab:
-            var = local_sym_tab[expr.id][0]
+            var = local_sym_tab[expr.id].var
             val = builder.load(var)
-            return val, local_sym_tab[expr.id][1]  # return value and type
+            return val, local_sym_tab[expr.id].ir_type  # return value and type
         else:
             print(f"Undefined variable {expr.id}")
             return None
@@ -32,7 +30,7 @@ def eval_expr(
             return None
     elif isinstance(expr, ast.Call):
         # delayed import to avoid circular dependency
-        from .bpf_helper_handler import helper_func_list, handle_helper_call
+        from pythonbpf.helper import HelperHandlerRegistry, handle_helper_call
 
         if isinstance(expr.func, ast.Name):
             # check deref
@@ -51,7 +49,7 @@ def eval_expr(
                     return None
                 if isinstance(arg, ast.Name):
                     if arg.id in local_sym_tab:
-                        arg = local_sym_tab[arg.id][0]
+                        arg = local_sym_tab[arg.id].var
                     else:
                         print(f"Undefined variable {arg.id}")
                         return None
@@ -60,10 +58,10 @@ def eval_expr(
                     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][1]
+                return val, local_sym_tab[expr.args[0].id].ir_type
 
             # check for helpers
-            if expr.func.id in helper_func_list:
+            if HelperHandlerRegistry.has_handler(expr.func.id):
                 return handle_helper_call(
                     expr,
                     module,
@@ -72,7 +70,6 @@ def eval_expr(
                     local_sym_tab,
                     map_sym_tab,
                     structs_sym_tab,
-                    local_var_metadata,
                 )
         elif isinstance(expr.func, ast.Attribute):
             print(f"Handling method call: {ast.dump(expr.func)}")
@@ -80,7 +77,7 @@ def eval_expr(
                 expr.func.value.func, ast.Name
             ):
                 method_name = expr.func.attr
-                if method_name in helper_func_list:
+                if HelperHandlerRegistry.has_handler(method_name):
                     return handle_helper_call(
                         expr,
                         module,
@@ -89,13 +86,12 @@ def eval_expr(
                         local_sym_tab,
                         map_sym_tab,
                         structs_sym_tab,
-                        local_var_metadata,
                     )
             elif isinstance(expr.func.value, ast.Name):
                 obj_name = expr.func.value.id
                 method_name = expr.func.attr
                 if obj_name in map_sym_tab:
-                    if method_name in helper_func_list:
+                    if HelperHandlerRegistry.has_handler(method_name):
                         return handle_helper_call(
                             expr,
                             module,
@@ -104,24 +100,21 @@ def eval_expr(
                             local_sym_tab,
                             map_sym_tab,
                             structs_sym_tab,
-                            local_var_metadata,
                         )
     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 = local_sym_tab[var_name]
+                var_ptr, var_type, var_metadata = local_sym_tab[var_name]
-                print(f"Loading attribute " f"{attr_name} from variable {var_name}")
+                print(f"Loading attribute {attr_name} from variable {var_name}")
                 print(f"Variable type: {var_type}, Variable ptr: {var_ptr}")
-                print(local_var_metadata)
+                metadata = structs_sym_tab[var_metadata]
-                if local_var_metadata and var_name in local_var_metadata:
+                if attr_name in metadata.fields:
-                    metadata = structs_sym_tab[local_var_metadata[var_name]]
+                    gep = metadata.gep(builder, var_ptr, attr_name)
-                    if attr_name in metadata.fields:
+                    val = builder.load(gep)
-                        gep = metadata.gep(builder, var_ptr, attr_name)
+                    field_type = metadata.field_type(attr_name)
-                        val = builder.load(gep)
+                    return val, field_type
-                        field_type = metadata.field_type(attr_name)
-                        return val, field_type
     print("Unsupported expression evaluation")
     return None
 
@@ -134,11 +127,9 @@ def handle_expr(
     local_sym_tab,
     map_sym_tab,
     structs_sym_tab,
-    local_var_metadata,
 ):
     """Handle expression statements in the function body."""
     print(f"Handling expression: {ast.dump(expr)}")
-    print(local_var_metadata)
     call = expr.value
     if isinstance(call, ast.Call):
         eval_expr(
@@ -149,7 +140,6 @@ def handle_expr(
             local_sym_tab,
             map_sym_tab,
             structs_sym_tab,
-            local_var_metadata,
         )
     else:
         print("Unsupported expression type")

pythonbpf/functions_pass.py

@@ -1,13 +1,27 @@
 from llvmlite import ir
 import ast
+import logging
+from typing import Any
+from dataclasses import dataclass
 
-
+from .helper import HelperHandlerRegistry, handle_helper_call
-from .bpf_helper_handler import helper_func_list, handle_helper_call
 from .type_deducer import ctypes_to_ir
 from .binary_ops import handle_binary_op
 from .expr_pass import eval_expr, handle_expr
 
-local_var_metadata = {}
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class LocalSymbol:
+    var: ir.AllocaInstr
+    ir_type: ir.Type
+    metadata: Any = None
+
+    def __iter__(self):
+        yield self.var
+        yield self.ir_type
+        yield self.metadata
 
 
 def get_probe_string(func_node):
@@ -47,13 +61,12 @@ def handle_assign(
     if isinstance(target, ast.Attribute):
         # struct field assignment
         field_name = target.attr
-        if var_name in local_sym_tab and var_name in local_var_metadata:
+        if var_name in local_sym_tab:
-            struct_type = local_var_metadata[var_name]
+            struct_type = local_sym_tab[var_name].metadata
             struct_info = structs_sym_tab[struct_type]
-
             if field_name in struct_info.fields:
                 field_ptr = struct_info.gep(
-                    builder, local_sym_tab[var_name][0], field_name
+                    builder, local_sym_tab[var_name].var, field_name
                 )
                 val = eval_expr(
                     func,
@@ -83,18 +96,21 @@ def handle_assign(
     elif isinstance(rval, ast.Constant):
         if isinstance(rval.value, bool):
             if rval.value:
-                builder.store(ir.Constant(ir.IntType(1), 1), local_sym_tab[var_name][0])
+                builder.store(
+                    ir.Constant(ir.IntType(1), 1), local_sym_tab[var_name].var
+                )
             else:
-                builder.store(ir.Constant(ir.IntType(1), 0), local_sym_tab[var_name][0])
+                builder.store(
+                    ir.Constant(ir.IntType(1), 0), local_sym_tab[var_name].var
+                )
             print(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)
             # var.align = 8
             builder.store(
-                ir.Constant(ir.IntType(64), rval.value), local_sym_tab[var_name][0]
+                ir.Constant(ir.IntType(64), rval.value), local_sym_tab[var_name].var
             )
-            # local_sym_tab[var_name] = var
             print(f"Assigned constant {rval.value} to {var_name}")
         elif isinstance(rval.value, str):
             str_val = rval.value.encode("utf-8") + b"\x00"
@@ -108,7 +124,7 @@ def handle_assign(
             global_str.global_constant = True
             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][0])
+            builder.store(str_ptr, local_sym_tab[var_name].var)
             print(f"Assigned string constant '{rval.value}' to {var_name}")
         else:
             print("Unsupported constant type")
@@ -126,14 +142,14 @@ def handle_assign(
                 # var = builder.alloca(ir_type, name=var_name)
                 # var.align = ir_type.width // 8
                 builder.store(
-                    ir.Constant(ir_type, rval.args[0].value), local_sym_tab[var_name][0]
+                    ir.Constant(ir_type, rval.args[0].value),
+                    local_sym_tab[var_name].var,
                 )
                 print(
                     f"Assigned {call_type} constant "
                     f"{rval.args[0].value} to {var_name}"
                 )
-                # local_sym_tab[var_name] = var
+            elif HelperHandlerRegistry.has_handler(call_type):
-            elif call_type in helper_func_list:
                 # var = builder.alloca(ir.IntType(64), name=var_name)
                 # var.align = 8
                 val = handle_helper_call(
@@ -144,10 +160,8 @@ def handle_assign(
                     local_sym_tab,
                     map_sym_tab,
                     structs_sym_tab,
-                    local_var_metadata,
                 )
-                builder.store(val[0], local_sym_tab[var_name][0])
+                builder.store(val[0], local_sym_tab[var_name].var)
-                # local_sym_tab[var_name] = var
                 print(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)}")
@@ -164,18 +178,15 @@ def handle_assign(
                     print("Failed to evaluate deref argument")
                     return
                 print(f"Dereferenced value: {val}, storing in {var_name}")
-                builder.store(val[0], local_sym_tab[var_name][0])
+                builder.store(val[0], local_sym_tab[var_name].var)
-                # local_sym_tab[var_name] = var
                 print(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][0])
+                builder.store(ir.Constant(ir_type, None), local_sym_tab[var_name].var)
-                local_var_metadata[var_name] = call_type
                 print(f"Assigned struct {call_type} to {var_name}")
-                # local_sym_tab[var_name] = var
             else:
                 print(f"Unsupported assignment call type: {call_type}")
         elif isinstance(rval.func, ast.Attribute):
@@ -189,8 +200,7 @@ def handle_assign(
                 map_name = rval.func.value.func.id
                 method_name = rval.func.attr
                 if map_name in map_sym_tab:
-                    map_ptr = map_sym_tab[map_name]
+                    if HelperHandlerRegistry.has_handler(method_name):
-                    if method_name in helper_func_list:
                         val = handle_helper_call(
                             rval,
                             module,
@@ -199,12 +209,10 @@ def handle_assign(
                             local_sym_tab,
                             map_sym_tab,
                             structs_sym_tab,
-                            local_var_metadata,
                         )
                         # var = builder.alloca(ir.IntType(64), name=var_name)
                         # var.align = 8
-                        builder.store(val[0], local_sym_tab[var_name][0])
+                        builder.store(val[0], local_sym_tab[var_name].var)
-                        # local_sym_tab[var_name] = var
             else:
                 print("Unsupported assignment call structure")
         else:
@@ -228,7 +236,7 @@ def handle_cond(func, module, builder, cond, local_sym_tab, map_sym_tab):
             return None
     elif isinstance(cond, ast.Name):
         if cond.id in local_sym_tab:
-            var = local_sym_tab[cond.id][0]
+            var = local_sym_tab[cond.id].var
             val = builder.load(var)
             if val.type != ir.IntType(1):
                 # Convert nonzero values to true, zero to false
@@ -289,7 +297,7 @@ def handle_if(
 ):
     """Handle if statements in the function body."""
     print("Handling if statement")
-    start = builder.block.parent
+    # start = builder.block.parent
     then_block = func.append_basic_block(name="if.then")
     merge_block = func.append_basic_block(name="if.end")
     if stmt.orelse:
@@ -343,7 +351,6 @@ def process_stmt(
 ):
     print(f"Processing statement: {ast.dump(stmt)}")
     if isinstance(stmt, ast.Expr):
-        print(local_var_metadata)
         handle_expr(
             func,
             module,
@@ -352,7 +359,6 @@ def process_stmt(
             local_sym_tab,
             map_sym_tab,
             structs_sym_tab,
-            local_var_metadata,
         )
     elif isinstance(stmt, ast.Assign):
         handle_assign(
@@ -402,6 +408,7 @@ def allocate_mem(
     module, builder, body, func, ret_type, map_sym_tab, local_sym_tab, structs_sym_tab
 ):
     for stmt in body:
+        has_metadata = False
         if isinstance(stmt, ast.If):
             if stmt.body:
                 local_sym_tab = allocate_mem(
@@ -443,7 +450,7 @@ def allocate_mem(
                         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}")
-                    elif call_type in helper_func_list:
+                    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)
@@ -459,9 +466,10 @@ def allocate_mem(
                         struct_info = structs_sym_tab[call_type]
                         ir_type = struct_info.ir_type
                         var = builder.alloca(ir_type, name=var_name)
-                        local_var_metadata[var_name] = call_type
+                        has_metadata = True
                         print(
-                            f"Pre-allocated variable {var_name} for struct {call_type}"
+                            f"Pre-allocated variable {var_name} "
+                            f"for struct {call_type}"
                         )
                 elif isinstance(rval.func, ast.Attribute):
                     ir_type = ir.PointerType(ir.IntType(64))
@@ -500,7 +508,11 @@ def allocate_mem(
             else:
                 print("Unsupported assignment value type")
                 continue
-            local_sym_tab[var_name] = (var, ir_type)
+
+            if has_metadata:
+                local_sym_tab[var_name] = LocalSymbol(var, ir_type, call_type)
+            else:
+                local_sym_tab[var_name] = LocalSymbol(var, ir_type)
     return local_sym_tab
 
 
@@ -656,13 +668,13 @@ def infer_return_type(func_node: ast.FunctionDef):
         except Exception:
             return type(e).__name__
 
-    for node in ast.walk(func_node):
+    for walked_node in ast.walk(func_node):
-        if isinstance(node, ast.Return):
+        if isinstance(walked_node, ast.Return):
-            t = _expr_type(node.value)
+            t = _expr_type(walked_node.value)
             if found_type is None:
                 found_type = t
             elif found_type != t:
-                raise ValueError("Conflicting return types:" f"{found_type} vs {t}")
+                raise ValueError(f"Conflicting return types: {found_type} vs {t}")
     return found_type or "None"
 
 
@@ -674,7 +686,7 @@ def assign_string_to_array(builder, target_array_ptr, source_string_ptr, array_l
     Copy a string (i8*) to a fixed-size array ([N x i8]*)
     """
     # Create a loop to copy characters one by one
-    entry_block = builder.block
+    # entry_block = builder.block
     copy_block = builder.append_basic_block("copy_char")
     end_block = builder.append_basic_block("copy_end")
 

pythonbpf/helper/__init__.py

@@ -0,0 +1,13 @@
+from .helper_utils import HelperHandlerRegistry
+from .bpf_helper_handler import handle_helper_call
+from .helpers import ktime, pid, deref, XDP_DROP, XDP_PASS
+
+__all__ = [
+    "HelperHandlerRegistry",
+    "handle_helper_call",
+    "ktime",
+    "pid",
+    "deref",
+    "XDP_DROP",
+    "XDP_PASS",
+]

pythonbpf/helper/bpf_helper_handler.py

@@ -0,0 +1,344 @@
+import ast
+from llvmlite import ir
+from enum import Enum
+from .helper_utils import (
+    HelperHandlerRegistry,
+    get_or_create_ptr_from_arg,
+    get_flags_val,
+    handle_fstring_print,
+    simple_string_print,
+    get_data_ptr_and_size,
+)
+
+
+class BPFHelperID(Enum):
+    BPF_MAP_LOOKUP_ELEM = 1
+    BPF_MAP_UPDATE_ELEM = 2
+    BPF_MAP_DELETE_ELEM = 3
+    BPF_KTIME_GET_NS = 5
+    BPF_PRINTK = 6
+    BPF_GET_CURRENT_PID_TGID = 14
+    BPF_PERF_EVENT_OUTPUT = 25
+
+
+@HelperHandlerRegistry.register("ktime")
+def bpf_ktime_get_ns_emitter(
+    call,
+    map_ptr,
+    module,
+    builder,
+    func,
+    local_sym_tab=None,
+    struct_sym_tab=None,
+):
+    """
+    Emit LLVM IR for bpf_ktime_get_ns helper function call.
+    """
+    # func is an arg to just have a uniform signature with other emitters
+    helper_id = ir.Constant(ir.IntType(64), BPFHelperID.BPF_KTIME_GET_NS.value)
+    fn_type = ir.FunctionType(ir.IntType(64), [], var_arg=False)
+    fn_ptr_type = ir.PointerType(fn_type)
+    fn_ptr = builder.inttoptr(helper_id, fn_ptr_type)
+    result = builder.call(fn_ptr, [], tail=False)
+    return result, ir.IntType(64)
+
+
+@HelperHandlerRegistry.register("lookup")
+def bpf_map_lookup_elem_emitter(
+    call,
+    map_ptr,
+    module,
+    builder,
+    func,
+    local_sym_tab=None,
+    struct_sym_tab=None,
+):
+    """
+    Emit LLVM IR for bpf_map_lookup_elem helper function call.
+    """
+    if not call.args or len(call.args) != 1:
+        raise ValueError(
+            "Map lookup expects exactly one argument (key), got " f"{len(call.args)}"
+        )
+    key_ptr = get_or_create_ptr_from_arg(call.args[0], builder, local_sym_tab)
+    map_void_ptr = builder.bitcast(map_ptr, ir.PointerType())
+
+    fn_type = ir.FunctionType(
+        ir.PointerType(),  # Return type: void*
+        [ir.PointerType(), ir.PointerType()],  # Args: (void*, void*)
+        var_arg=False,
+    )
+    fn_ptr_type = ir.PointerType(fn_type)
+
+    fn_addr = ir.Constant(ir.IntType(64), BPFHelperID.BPF_MAP_LOOKUP_ELEM.value)
+    fn_ptr = builder.inttoptr(fn_addr, fn_ptr_type)
+
+    result = builder.call(fn_ptr, [map_void_ptr, key_ptr], tail=False)
+
+    return result, ir.PointerType()
+
+
+@HelperHandlerRegistry.register("print")
+def bpf_printk_emitter(
+    call,
+    map_ptr,
+    module,
+    builder,
+    func,
+    local_sym_tab=None,
+    struct_sym_tab=None,
+):
+    """Emit LLVM IR for bpf_printk helper function call."""
+    if not hasattr(func, "_fmt_counter"):
+        func._fmt_counter = 0
+
+    if not call.args:
+        raise ValueError("bpf_printk expects at least one argument (format string)")
+
+    args = []
+    if isinstance(call.args[0], ast.JoinedStr):
+        args = handle_fstring_print(
+            call.args[0],
+            module,
+            builder,
+            func,
+            local_sym_tab,
+            struct_sym_tab,
+        )
+    elif isinstance(call.args[0], ast.Constant) and isinstance(call.args[0].value, str):
+        # TODO: We are only supporting single arguments for now.
+        # In case of multiple args, the first one will be taken.
+        args = simple_string_print(call.args[0].value, module, builder, func)
+    else:
+        raise NotImplementedError(
+            "Only simple strings or f-strings are supported in bpf_printk."
+        )
+
+    fn_type = ir.FunctionType(
+        ir.IntType(64), [ir.PointerType(), ir.IntType(32)], var_arg=True
+    )
+    fn_ptr_type = ir.PointerType(fn_type)
+    fn_addr = ir.Constant(ir.IntType(64), BPFHelperID.BPF_PRINTK.value)
+    fn_ptr = builder.inttoptr(fn_addr, fn_ptr_type)
+
+    builder.call(fn_ptr, args, tail=True)
+    return None
+
+
+@HelperHandlerRegistry.register("update")
+def bpf_map_update_elem_emitter(
+    call,
+    map_ptr,
+    module,
+    builder,
+    func,
+    local_sym_tab=None,
+    struct_sym_tab=None,
+):
+    """
+    Emit LLVM IR for bpf_map_update_elem helper function call.
+    Expected call signature: map.update(key, value, flags=0)
+    """
+    if not call.args or len(call.args) < 2 or len(call.args) > 3:
+        raise ValueError(
+            "Map update expects 2 or 3 args (key, value, flags), "
+            f"got {len(call.args)}"
+        )
+
+    key_arg = call.args[0]
+    value_arg = call.args[1]
+    flags_arg = call.args[2] if len(call.args) > 2 else None
+
+    key_ptr = get_or_create_ptr_from_arg(key_arg, builder, local_sym_tab)
+    value_ptr = get_or_create_ptr_from_arg(value_arg, builder, local_sym_tab)
+    flags_val = get_flags_val(flags_arg, builder, local_sym_tab)
+
+    map_void_ptr = builder.bitcast(map_ptr, ir.PointerType())
+    fn_type = ir.FunctionType(
+        ir.IntType(64),
+        [ir.PointerType(), ir.PointerType(), ir.PointerType(), ir.IntType(64)],
+        var_arg=False,
+    )
+    fn_ptr_type = ir.PointerType(fn_type)
+
+    fn_addr = ir.Constant(ir.IntType(64), BPFHelperID.BPF_MAP_UPDATE_ELEM.value)
+    fn_ptr = builder.inttoptr(fn_addr, fn_ptr_type)
+
+    if isinstance(flags_val, int):
+        flags_const = ir.Constant(ir.IntType(64), flags_val)
+    else:
+        flags_const = flags_val
+
+    result = builder.call(
+        fn_ptr, [map_void_ptr, key_ptr, value_ptr, flags_const], tail=False
+    )
+
+    return result, None
+
+
+@HelperHandlerRegistry.register("delete")
+def bpf_map_delete_elem_emitter(
+    call,
+    map_ptr,
+    module,
+    builder,
+    func,
+    local_sym_tab=None,
+    struct_sym_tab=None,
+):
+    """
+    Emit LLVM IR for bpf_map_delete_elem helper function call.
+    Expected call signature: map.delete(key)
+    """
+    if not call.args or len(call.args) != 1:
+        raise ValueError(
+            "Map delete expects exactly one argument (key), got " f"{len(call.args)}"
+        )
+    key_ptr = get_or_create_ptr_from_arg(call.args[0], builder, local_sym_tab)
+    map_void_ptr = builder.bitcast(map_ptr, ir.PointerType())
+
+    # Define function type for bpf_map_delete_elem
+    fn_type = ir.FunctionType(
+        ir.IntType(64),  # Return type: int64 (status code)
+        [ir.PointerType(), ir.PointerType()],  # Args: (void*, void*)
+        var_arg=False,
+    )
+    fn_ptr_type = ir.PointerType(fn_type)
+
+    fn_addr = ir.Constant(ir.IntType(64), BPFHelperID.BPF_MAP_DELETE_ELEM.value)
+    fn_ptr = builder.inttoptr(fn_addr, fn_ptr_type)
+
+    result = builder.call(fn_ptr, [map_void_ptr, key_ptr], tail=False)
+
+    return result, None
+
+
+@HelperHandlerRegistry.register("pid")
+def bpf_get_current_pid_tgid_emitter(
+    call,
+    map_ptr,
+    module,
+    builder,
+    func,
+    local_sym_tab=None,
+    struct_sym_tab=None,
+):
+    """
+    Emit LLVM IR for bpf_get_current_pid_tgid helper function call.
+    """
+    # func is an arg to just have a uniform signature with other emitters
+    helper_id = ir.Constant(ir.IntType(64), BPFHelperID.BPF_GET_CURRENT_PID_TGID.value)
+    fn_type = ir.FunctionType(ir.IntType(64), [], var_arg=False)
+    fn_ptr_type = ir.PointerType(fn_type)
+    fn_ptr = builder.inttoptr(helper_id, fn_ptr_type)
+    result = builder.call(fn_ptr, [], tail=False)
+
+    # Extract the lower 32 bits (PID) using bitwise AND with 0xFFFFFFFF
+    mask = ir.Constant(ir.IntType(64), 0xFFFFFFFF)
+    pid = builder.and_(result, mask)
+    return pid, ir.IntType(64)
+
+
+@HelperHandlerRegistry.register("output")
+def bpf_perf_event_output_handler(
+    call,
+    map_ptr,
+    module,
+    builder,
+    func,
+    local_sym_tab=None,
+    struct_sym_tab=None,
+):
+    if len(call.args) != 1:
+        raise ValueError(
+            "Perf event output expects exactly one argument, " f"got {len(call.args)}"
+        )
+    data_arg = call.args[0]
+    ctx_ptr = func.args[0]  # First argument to the function is ctx
+
+    data_ptr, size_val = get_data_ptr_and_size(data_arg, local_sym_tab, struct_sym_tab)
+
+    # BPF_F_CURRENT_CPU is -1 in 32 bit
+    flags_val = ir.Constant(ir.IntType(64), 0xFFFFFFFF)
+
+    map_void_ptr = builder.bitcast(map_ptr, ir.PointerType())
+    data_void_ptr = builder.bitcast(data_ptr, ir.PointerType())
+    fn_type = ir.FunctionType(
+        ir.IntType(64),
+        [
+            ir.PointerType(ir.IntType(8)),
+            ir.PointerType(),
+            ir.IntType(64),
+            ir.PointerType(),
+            ir.IntType(64),
+        ],
+        var_arg=False,
+    )
+    fn_ptr_type = ir.PointerType(fn_type)
+
+    # helper id
+    fn_addr = ir.Constant(ir.IntType(64), BPFHelperID.BPF_PERF_EVENT_OUTPUT.value)
+    fn_ptr = builder.inttoptr(fn_addr, fn_ptr_type)
+
+    result = builder.call(
+        fn_ptr, [ctx_ptr, map_void_ptr, flags_val, data_void_ptr, size_val], tail=False
+    )
+    return result, None
+
+
+def handle_helper_call(
+    call,
+    module,
+    builder,
+    func,
+    local_sym_tab=None,
+    map_sym_tab=None,
+    struct_sym_tab=None,
+):
+    """Process a BPF helper function call and emit the appropriate LLVM IR."""
+
+    # Helper function to get map pointer and invoke handler
+    def invoke_helper(method_name, map_ptr=None):
+        handler = HelperHandlerRegistry.get_handler(method_name)
+        if not handler:
+            raise NotImplementedError(
+                f"Helper function '{method_name}' is not implemented."
+            )
+        return handler(
+            call,
+            map_ptr,
+            module,
+            builder,
+            func,
+            local_sym_tab,
+            struct_sym_tab,
+        )
+
+    # Handle direct function calls (e.g., print(), ktime())
+    if isinstance(call.func, ast.Name):
+        return invoke_helper(call.func.id)
+
+    # Handle method calls (e.g., map.lookup(), map.update())
+    elif isinstance(call.func, ast.Attribute):
+        method_name = call.func.attr
+        value = call.func.value
+        print(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)
+            map_name = value.func.id
+        elif isinstance(value, ast.Name):
+            # Direct style: my_map.lookup(key)
+            map_name = value.id
+        else:
+            raise NotImplementedError(
+                f"Unsupported map access pattern: {ast.dump(value)}"
+            )
+
+        # Verify map exists and get pointer
+        if not map_sym_tab or map_name not in map_sym_tab:
+            raise ValueError(f"Map '{map_name}' not found in symbol table")
+
+        return invoke_helper(method_name, map_sym_tab[map_name])
+
+    return None

pythonbpf/helper/helper_utils.py

@@ -0,0 +1,307 @@
+import ast
+import logging
+from collections.abc import Callable
+
+from llvmlite import ir
+from pythonbpf.expr_pass import eval_expr
+
+logger = logging.getLogger(__name__)
+
+
+class HelperHandlerRegistry:
+    """Registry for BPF helpers"""
+
+    _handlers: dict[str, Callable] = {}
+
+    @classmethod
+    def register(cls, helper_name):
+        """Decorator to register a handler function for a helper"""
+
+        def decorator(func):
+            cls._handlers[helper_name] = func
+            return func
+
+        return decorator
+
+    @classmethod
+    def get_handler(cls, helper_name):
+        """Get the handler function for a helper"""
+        return cls._handlers.get(helper_name)
+
+    @classmethod
+    def has_handler(cls, helper_name):
+        """Check if a handler function is registered for a helper"""
+        return helper_name in cls._handlers
+
+
+def get_var_ptr_from_name(var_name, local_sym_tab):
+    """Get a pointer to a variable from the symbol table."""
+    if local_sym_tab and var_name in local_sym_tab:
+        return local_sym_tab[var_name].var
+    raise ValueError(f"Variable '{var_name}' not found in local symbol table")
+
+
+def create_int_constant_ptr(value, builder, int_width=64):
+    """Create a pointer to an integer constant."""
+    # Default to 64-bit integer
+    int_type = ir.IntType(int_width)
+    ptr = builder.alloca(int_type)
+    ptr.align = int_type.width // 8
+    builder.store(ir.Constant(int_type, value), ptr)
+    return ptr
+
+
+def get_or_create_ptr_from_arg(arg, builder, local_sym_tab):
+    """Extract or create pointer from the call arguments."""
+
+    if isinstance(arg, ast.Name):
+        ptr = get_var_ptr_from_name(arg.id, local_sym_tab)
+    elif isinstance(arg, ast.Constant) and isinstance(arg.value, int):
+        ptr = create_int_constant_ptr(arg.value, builder)
+    else:
+        raise NotImplementedError(
+            "Only simple variable names are supported as args in map helpers."
+        )
+    return ptr
+
+
+def get_flags_val(arg, builder, local_sym_tab):
+    """Extract or create flags value from the call arguments."""
+    if not arg:
+        return 0
+
+    if isinstance(arg, ast.Name):
+        if local_sym_tab and arg.id in local_sym_tab:
+            flags_ptr = local_sym_tab[arg.id].var
+            return builder.load(flags_ptr)
+        else:
+            raise ValueError(f"Variable '{arg.id}' not found in local symbol table")
+    elif isinstance(arg, ast.Constant) and isinstance(arg.value, int):
+        return arg.value
+
+    raise NotImplementedError(
+        "Only var names or int consts are supported as map helpers flags."
+    )
+
+
+def simple_string_print(string_value, module, builder, func):
+    """Prepare arguments for bpf_printk from a simple string value"""
+    fmt_str = string_value + "\n\0"
+    fmt_ptr = _create_format_string_global(fmt_str, func, module, builder)
+
+    args = [fmt_ptr, ir.Constant(ir.IntType(32), len(fmt_str))]
+    return args
+
+
+def handle_fstring_print(
+    joined_str,
+    module,
+    builder,
+    func,
+    local_sym_tab=None,
+    struct_sym_tab=None,
+):
+    """Handle f-string formatting for bpf_printk emitter."""
+    fmt_parts = []
+    exprs = []
+
+    for value in joined_str.values:
+        logger.debug(f"Processing f-string value: {ast.dump(value)}")
+
+        if isinstance(value, ast.Constant):
+            _process_constant_in_fstring(value, fmt_parts, exprs)
+        elif isinstance(value, ast.FormattedValue):
+            _process_fval(
+                value,
+                fmt_parts,
+                exprs,
+                local_sym_tab,
+                struct_sym_tab,
+            )
+        else:
+            raise NotImplementedError(f"Unsupported f-string value type: {type(value)}")
+
+    fmt_str = "".join(fmt_parts)
+    args = simple_string_print(fmt_str, module, builder, func)
+
+    # NOTE: Process expressions (limited to 3 due to BPF constraints)
+    if len(exprs) > 3:
+        logger.warning("bpf_printk supports up to 3 args, extra args will be ignored.")
+
+    for expr in exprs[:3]:
+        arg_value = _prepare_expr_args(
+            expr,
+            func,
+            module,
+            builder,
+            local_sym_tab,
+            struct_sym_tab,
+        )
+        args.append(arg_value)
+
+    return args
+
+
+def _process_constant_in_fstring(cst, fmt_parts, exprs):
+    """Process constant values in f-string."""
+    if isinstance(cst.value, str):
+        fmt_parts.append(cst.value)
+    elif isinstance(cst.value, int):
+        fmt_parts.append("%lld")
+        exprs.append(ir.Constant(ir.IntType(64), cst.value))
+    else:
+        raise NotImplementedError(
+            f"Unsupported constant type in f-string: {type(cst.value)}"
+        )
+
+
+def _process_fval(fval, fmt_parts, exprs, local_sym_tab, struct_sym_tab):
+    """Process formatted values in f-string."""
+    logger.debug(f"Processing formatted value: {ast.dump(fval)}")
+
+    if isinstance(fval.value, ast.Name):
+        _process_name_in_fval(fval.value, fmt_parts, exprs, local_sym_tab)
+    elif isinstance(fval.value, ast.Attribute):
+        _process_attr_in_fval(
+            fval.value,
+            fmt_parts,
+            exprs,
+            local_sym_tab,
+            struct_sym_tab,
+        )
+    else:
+        raise NotImplementedError(
+            f"Unsupported formatted value in f-string: {type(fval.value)}"
+        )
+
+
+def _process_name_in_fval(name_node, fmt_parts, exprs, local_sym_tab):
+    """Process name nodes in formatted values."""
+    if local_sym_tab and name_node.id in local_sym_tab:
+        _, var_type, tmp = local_sym_tab[name_node.id]
+        _populate_fval(var_type, name_node, fmt_parts, exprs)
+
+
+def _process_attr_in_fval(attr_node, fmt_parts, exprs, local_sym_tab, struct_sym_tab):
+    """Process attribute nodes in formatted values."""
+    if (
+        isinstance(attr_node.value, ast.Name)
+        and local_sym_tab
+        and attr_node.value.id in local_sym_tab
+    ):
+        var_name = attr_node.value.id
+        field_name = attr_node.attr
+
+        var_type = local_sym_tab[var_name].metadata
+        if var_type not in struct_sym_tab:
+            raise ValueError(
+                f"Struct '{var_type}' for '{var_name}' not in symbol table"
+            )
+
+        struct_info = struct_sym_tab[var_type]
+        if field_name not in struct_info.fields:
+            raise ValueError(f"Field '{field_name}' not found in struct '{var_type}'")
+
+        field_type = struct_info.field_type(field_name)
+        _populate_fval(field_type, attr_node, fmt_parts, exprs)
+    else:
+        raise NotImplementedError(
+            "Only simple attribute on local vars is supported in f-strings."
+        )
+
+
+def _populate_fval(ftype, node, fmt_parts, exprs):
+    """Populate format parts and expressions based on field type."""
+    if isinstance(ftype, ir.IntType):
+        # TODO: We print as signed integers only for now
+        if ftype.width == 64:
+            fmt_parts.append("%lld")
+            exprs.append(node)
+        elif ftype.width == 32:
+            fmt_parts.append("%d")
+            exprs.append(node)
+        else:
+            raise NotImplementedError(
+                f"Unsupported integer width in f-string: {ftype.width}"
+            )
+    elif ftype == ir.PointerType(ir.IntType(8)):
+        # NOTE: We assume i8* is a string
+        fmt_parts.append("%s")
+        exprs.append(node)
+    else:
+        raise NotImplementedError(f"Unsupported field type in f-string: {ftype}")
+
+
+def _create_format_string_global(fmt_str, func, module, builder):
+    """Create a global variable for the format string."""
+    fmt_name = f"{func.name}____fmt{func._fmt_counter}"
+    func._fmt_counter += 1
+
+    fmt_gvar = ir.GlobalVariable(
+        module, ir.ArrayType(ir.IntType(8), len(fmt_str)), name=fmt_name
+    )
+    fmt_gvar.global_constant = True
+    fmt_gvar.initializer = ir.Constant(
+        ir.ArrayType(ir.IntType(8), len(fmt_str)), bytearray(fmt_str.encode("utf8"))
+    )
+    fmt_gvar.linkage = "internal"
+    fmt_gvar.align = 1
+
+    return builder.bitcast(fmt_gvar, ir.PointerType())
+
+
+def _prepare_expr_args(expr, func, module, builder, local_sym_tab, struct_sym_tab):
+    """Evaluate and prepare an expression to use as an arg for bpf_printk."""
+    val, _ = eval_expr(
+        func,
+        module,
+        builder,
+        expr,
+        local_sym_tab,
+        None,
+        struct_sym_tab,
+    )
+
+    if val:
+        if isinstance(val.type, ir.PointerType):
+            val = builder.ptrtoint(val, ir.IntType(64))
+        elif isinstance(val.type, ir.IntType):
+            if val.type.width < 64:
+                val = builder.sext(val, ir.IntType(64))
+        else:
+            logger.warning(
+                "Only int and ptr supported in bpf_printk args. " "Others default to 0."
+            )
+            val = ir.Constant(ir.IntType(64), 0)
+        return val
+    else:
+        logger.warning(
+            "Failed to evaluate expression for bpf_printk argument. "
+            "It will be converted to 0."
+        )
+        return ir.Constant(ir.IntType(64), 0)
+
+
+def get_data_ptr_and_size(data_arg, local_sym_tab, struct_sym_tab):
+    """Extract data pointer and size information for perf event output."""
+    if isinstance(data_arg, ast.Name):
+        data_name = data_arg.id
+        if local_sym_tab and data_name in local_sym_tab:
+            data_ptr = local_sym_tab[data_name].var
+        else:
+            raise ValueError(
+                f"Data variable {data_name} not found in local symbol table."
+            )
+
+        # Check if data_name is a struct
+        data_type = local_sym_tab[data_name].metadata
+        if data_type in struct_sym_tab:
+            struct_info = struct_sym_tab[data_type]
+            size_val = ir.Constant(ir.IntType(64), struct_info.size)
+            return data_ptr, size_val
+        else:
+            raise ValueError(f"Struct {data_type} for {data_name} not in symbol table.")
+    else:
+        raise NotImplementedError(
+            "Only simple object names are supported as data in perf event output."
+        )

pythonbpf/maps/__init__.py

@@ -1,2 +1,4 @@
-from .maps import HashMap, PerfEventArray
+from .maps import HashMap, PerfEventArray, RingBuf
 from .maps_pass import maps_proc
+
+__all__ = ["HashMap", "PerfEventArray", "maps_proc", "RingBuf"]

pythonbpf/maps/maps.py

@@ -1,3 +1,4 @@
+# This file provides type  and function hints only and does not actually give any functionality.
 class HashMap:
     def __init__(self, key, value, max_entries):
         self.key = key
@@ -33,3 +34,18 @@ class PerfEventArray:
 
     def output(self, data):
         pass  # Placeholder for output method
+
+
+class RingBuf:
+    def __init__(self, max_entries):
+        self.max_entries = max_entries
+
+    def reserve(self, size: int, flags=0):
+        if size > self.max_entries:
+            raise ValueError("size cannot be greater than set maximum entries")
+        return 0
+
+    def submit(self, data, flags=0):
+        pass
+
+    # add discard, output and also give names to flags and stuff

pythonbpf/maps/maps_pass.py

@@ -1,11 +1,12 @@
 import ast
+from logging import Logger
 from llvmlite import ir
 from enum import Enum
 from .maps_utils import MapProcessorRegistry
 from ..debuginfo import DebugInfoGenerator
 import logging
 
-logger = logging.getLogger(__name__)
+logger: Logger = logging.getLogger(__name__)
 
 
 def maps_proc(tree, module, chunks):
@@ -13,7 +14,7 @@ def maps_proc(tree, module, chunks):
     map_sym_tab = {}
     for func_node in chunks:
         if is_map(func_node):
-            print(f"Found BPF map: {func_node.name}")
+            logger.info(f"Found BPF map: {func_node.name}")
             map_sym_tab[func_node.name] = process_bpf_map(func_node, module)
     return map_sym_tab
 
@@ -26,8 +27,41 @@ def is_map(func_node):
 
 
 class BPFMapType(Enum):
+    UNSPEC = 0
     HASH = 1
+    ARRAY = 2
+    PROG_ARRAY = 3
     PERF_EVENT_ARRAY = 4
+    PERCPU_HASH = 5
+    PERCPU_ARRAY = 6
+    STACK_TRACE = 7
+    CGROUP_ARRAY = 8
+    LRU_HASH = 9
+    LRU_PERCPU_HASH = 10
+    LPM_TRIE = 11
+    ARRAY_OF_MAPS = 12
+    HASH_OF_MAPS = 13
+    DEVMAP = 14
+    SOCKMAP = 15
+    CPUMAP = 16
+    XSKMAP = 17
+    SOCKHASH = 18
+    CGROUP_STORAGE_DEPRECATED = 19
+    CGROUP_STORAGE = 19
+    REUSEPORT_SOCKARRAY = 20
+    PERCPU_CGROUP_STORAGE_DEPRECATED = 21
+    PERCPU_CGROUP_STORAGE = 21
+    QUEUE = 22
+    STACK = 23
+    SK_STORAGE = 24
+    DEVMAP_HASH = 25
+    STRUCT_OPS = 26
+    RINGBUF = 27
+    INODE_STORAGE = 28
+    TASK_STORAGE = 29
+    BLOOM_FILTER = 30
+    USER_RINGBUF = 31
+    CGRP_STORAGE = 32
 
 
 def create_bpf_map(module, map_name, map_params):
@@ -51,13 +85,13 @@ def create_bpf_map(module, map_name, map_params):
 
 
 def create_map_debug_info(module, map_global, map_name, map_params):
-    """Generate debug information metadata for BPF map"""
+    """Generate debug info metadata for BPF maps HASH and PERF_EVENT_ARRAY"""
     generator = DebugInfoGenerator(module)
 
     uint_type = generator.get_uint32_type()
     ulong_type = generator.get_uint64_type()
     array_type = generator.create_array_type(
-        uint_type, map_params.get("type", BPFMapType.HASH).value
+        uint_type, map_params.get("type", BPFMapType.UNSPEC).value
     )
     type_ptr = generator.create_pointer_type(array_type, 64)
     key_ptr = generator.create_pointer_type(
@@ -112,6 +146,62 @@ def create_map_debug_info(module, map_global, map_name, map_params):
     return global_var
 
 
+def create_ringbuf_debug_info(module, map_global, map_name, map_params):
+    """Generate debug information metadata for BPF RINGBUF map"""
+    generator = DebugInfoGenerator(module)
+
+    int_type = generator.get_int32_type()
+
+    type_array = generator.create_array_type(
+        int_type, map_params.get("type", BPFMapType.RINGBUF).value
+    )
+    type_ptr = generator.create_pointer_type(type_array, 64)
+    type_member = generator.create_struct_member("type", type_ptr, 0)
+
+    max_entries_array = generator.create_array_type(
+        int_type, map_params["max_entries"])
+    max_entries_ptr = generator.create_pointer_type(max_entries_array, 64)
+    max_entries_member = generator.create_struct_member(
+        "max_entries", max_entries_ptr, 64
+    )
+
+    elements_arr = [type_member, max_entries_member]
+
+    struct_type = generator.create_struct_type(
+        elements_arr, 128, is_distinct=True)
+
+    global_var = generator.create_global_var_debug_info(
+        map_name, struct_type, is_local=False
+    )
+    map_global.set_metadata("dbg", global_var)
+    return global_var
+
+
+@MapProcessorRegistry.register("RingBuf")
+def process_ringbuf_map(map_name, rval, module):
+    """Process a BPF_RINGBUF map declaration"""
+    logger.info(f"Processing Ringbuf: {map_name}")
+    map_params = {"type": BPFMapType.RINGBUF}
+
+    # Parse max_entries if present
+    if len(rval.args) >= 1 and isinstance(rval.args[0], ast.Constant):
+        const_val = rval.args[0].value
+        if isinstance(const_val, int):
+            map_params["max_entries"] = const_val
+
+    for keyword in rval.keywords:
+        if keyword.arg == "max_entries" and isinstance(keyword.value, ast.Constant):
+            const_val = keyword.value.value
+            if isinstance(const_val, int):
+                map_params["max_entries"] = const_val
+
+    logger.info(f"Ringbuf map parameters: {map_params}")
+
+    map_global = create_bpf_map(module, map_name, map_params)
+    create_ringbuf_debug_info(module, map_global, map_name, map_params)
+    return map_global
+
+
 @MapProcessorRegistry.register("HashMap")
 def process_hash_map(map_name, rval, module):
     """Process a BPF_HASH map declaration"""

pythonbpf/maps/maps_utils.py

@@ -1,7 +1,11 @@
+from collections.abc import Callable
+from typing import Any
+
+
 class MapProcessorRegistry:
     """Registry for map processor functions"""
 
-    _processors = {}
+    _processors: dict[str, Callable[..., Any]] = {}
 
     @classmethod
     def register(cls, map_type_name):

pythonbpf/structs/__init__.py

@@ -1 +1,3 @@
 from .structs_pass import structs_proc
+
+__all__ = ["structs_proc"]

tests/c-form/ex8.bpf.c

@@ -1,47 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-#include <linux/bpf.h>
-#include <bpf/bpf_helpers.h>
-#include <bpf/bpf_tracing.h>
-#include <linux/blkdev.h>
-#define __TARGET_ARCH_aarch64
-#define u64 unsigned long long
-
-struct {
-    __uint(type, BPF_MAP_TYPE_HASH);
-    __uint(max_entries, 10240);
-    __type(key, struct request *);
-    __type(value, u64);
-} start SEC(".maps");
-
-SEC("kprobe/blk_start_request")
-int BPF_KPROBE(trace_start_req, struct request *req)
-{
-    u64 ts = bpf_ktime_get_ns();
-    bpf_map_update_elem(&start, &req, &ts, BPF_ANY);
-    return 0;
-}
-
-SEC("kprobe/blk_mq_start_request")
-int BPF_KPROBE(trace_start_mq, struct request *req)
-{
-    u64 ts = bpf_ktime_get_ns();
-    bpf_map_update_elem(&start, &req, &ts, BPF_ANY);
-    return 0;
-}
-
-SEC("kprobe/blk_account_io_completion")
-int BPF_KPROBE(trace_completion, struct request *req)
-{
-    u64 *tsp, delta;
-
-    tsp = bpf_map_lookup_elem(&start, &req);
-    if (tsp) {
-        delta = bpf_ktime_get_ns() - *tsp;
-        bpf_printk("%d %x %d\n", req->__data_len,
-                  req->cmd_flags, delta / 1000);
-        bpf_map_delete_elem(&start, &req);
-    }
-    return 0;
-}
-
-char LICENSE[] SEC("license") = "GPL";

tests/c-form/ringbuf.bpf.c

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
+#include <linux/bpf.h>
+#include <bpf/bpf_helpers.h>
+#include <bpf/bpf_tracing.h>
+#include <linux/types.h>
+
+// Define the structure to be sent via ringbuf
+struct event {
+    __u32 pid;
+    __u32 uid;
+    __u64 timestamp;
+    char comm[16];  // Process name
+};
+
+// Define the ringbuffer map
+struct {
+    __uint(type, BPF_MAP_TYPE_RINGBUF);
+    __uint(max_entries, 256 * 1024); // 256 KB
+} events SEC(".maps");
+
+// Tracepoint for execve system calls
+SEC("tracepoint/syscalls/sys_enter_execve")
+int trace_execve(void *ctx)
+{
+    struct event *e;
+    __u64 pid_tgid;
+    __u64 uid_gid;
+
+    // Reserve space in the ringbuffer
+    e = bpf_ringbuf_reserve(&events, sizeof(*e), 0);
+    if (!e)
+        return 0;
+
+    // Fill the struct with data
+    pid_tgid = bpf_get_current_pid_tgid();
+    e->pid = pid_tgid >> 32;
+
+    uid_gid = bpf_get_current_uid_gid();
+    e->uid = uid_gid & 0xFFFFFFFF;
+
+    e->timestamp = bpf_ktime_get_ns();
+
+    bpf_get_current_comm(&e->comm, sizeof(e->comm));
+
+    // Submit the event to ringbuffer
+    bpf_ringbuf_submit(e, 0);
+
+    return 0;
+}
+
+char LICENSE[] SEC("license") = "GPL";

tests/failing_tests/binops.py

@@ -6,6 +6,7 @@ from ctypes import c_void_p, c_int64
 @section("sometag1")
 def sometag(ctx: c_void_p) -> c_int64:
     a = 1 + 2 + 1
+    print(f"{a}")
     return c_int64(0)
 
 

tests/failing_tests/direct_assign.py

@@ -1,5 +1,5 @@
 from pythonbpf import bpf, map, section, bpfglobal, compile
-from pythonbpf.helpers import XDP_PASS
+from pythonbpf.helper import XDP_PASS
 from pythonbpf.maps import HashMap
 
 from ctypes import c_void_p, c_int64

tests/failing_tests/license.py

@@ -7,6 +7,7 @@ from ctypes import c_void_p, c_int64
 @section("sometag1")
 def sometag(ctx: c_void_p) -> c_int64:
     a = 1 + 2
+    print(f"{a}")
     return c_int64(0)
 
 

tests/passing_tests/perf_buffer_map.py

@@ -0,0 +1,51 @@
+from pythonbpf import bpf, map, struct, section, bpfglobal, compile, compile_to_ir, BPF
+from pythonbpf.helper import ktime, pid
+from pythonbpf.maps import PerfEventArray
+
+from ctypes import c_void_p, c_int32, c_uint64
+
+
+# PLACEHOLDER EXAMPLE. THIS SHOULD TECHNICALLY STILL FAIL TESTS
+@bpf
+@struct
+class data_t:
+    pid: c_uint64
+    ts: c_uint64
+    comm: str(16)
+
+
+@bpf
+@map
+def events() -> PerfEventArray:
+    return PerfEventArray(key_size=c_int32, value_size=c_int32)
+
+
+@bpf
+@section("tracepoint/syscalls/sys_enter_clone")
+def hello(ctx: c_void_p) -> c_int32:
+    dataobj = data_t()
+    ts = ktime()
+    strobj = "hellohellohello"
+    dataobj.pid = pid()
+    dataobj.ts = ktime()
+    # dataobj.comm = strobj
+    print(
+        f"clone called at {dataobj.ts} by pid {dataobj.pid}, comm {strobj} at time {ts}"
+    )
+    events.output(dataobj)
+    return c_int32(0)
+
+
+@bpf
+@bpfglobal
+def LICENSE() -> str:
+    return "GPL"
+
+
+compile()
+compile_to_ir("perf_buffer_map.py", "perf_buffer_map.ll")
+b = BPF()
+b.load_and_attach()
+
+while True:
+    print("running")

tests/passing_tests/ringbuf.py

@@ -0,0 +1,35 @@
+from pythonbpf import bpf, BPF, map, bpfglobal, section, compile, compile_to_ir
+from pythonbpf.maps import RingBuf, HashMap
+from ctypes import c_int32, c_void_p
+
+
+# Define a map
+@bpf
+@map
+def mymap() -> RingBuf:
+    return RingBuf(max_entries=(1024))
+
+
+@bpf
+@map
+def mymap2() -> HashMap:
+    return HashMap(key=c_int32, value=c_int32, max_entries=1024)
+
+
+@bpf
+@section("tracepoint/syscalls/sys_enter_clone")
+def random_section(ctx: c_void_p) -> c_int32:
+    print("Hello")
+    return c_int32(0)
+
+
+@bpf
+@bpfglobal
+def LICENSE() -> str:
+    return "GPL"
+
+
+compile_to_ir("ringbuf.py", "ringbuf.ll")
+compile()
+b = BPF()
+b.load_and_attach()