Complete example 1, albeit hardcoded somewhat. Implement body function processing skeleton

pythonbpf/functions_pass.py

@@ -58,11 +58,101 @@ def get_probe_string(func_node):
     return "helper"
 
 
+def process_func_body(module, builder, func_node, func):
+    """Process the body of a bpf function"""
+    # TODO: A lot.  We just have print -> bpf_trace_printk for now
+    did_return = False
+
+    for stmt in func_node.body:
+        if isinstance(stmt, ast.Expr) and isinstance(stmt.value, ast.Call):
+            call = stmt.value
+            if isinstance(call.func, ast.Name) and call.func.id == "print":
+                # Handle print statement
+                for arg in call.args:
+                    if isinstance(arg, ast.Constant) and isinstance(arg.value, str):
+                        fmt_str = arg.value + "\n"
+                        # Create a global variable for the format string
+                        fmt_gvar = ir.GlobalVariable(
+                            module, ir.ArrayType(ir.IntType(8), len(fmt_str)), name=f"{func.name}____fmt")
+                        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
+
+                        # Cast the global variable to i8*
+                        fmt_ptr = builder.bitcast(
+                            fmt_gvar, ir.PointerType())
+
+                        # Call bpf_trace_printk (assumed to be at address 6)
+                        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)
+
+                        # Call the function
+                        builder.call(fn_ptr, [fmt_ptr, ir.Constant(
+                            ir.IntType(32), len(fmt_str))], tail=True)
+        elif isinstance(stmt, ast.Return):
+            if stmt.value is None:
+                builder.ret(ir.Constant(ir.IntType(32), 0))
+                did_return = True
+            elif isinstance(stmt.value, ast.Call) and isinstance(stmt.value.func, ast.Name) and stmt.value.func.id == "c_int32" and len(stmt.value.args) == 1 and isinstance(stmt.value.args[0], ast.Constant) and isinstance(stmt.value.args[0].value, int):
+                builder.ret(ir.Constant(ir.IntType(
+                    32), stmt.value.args[0].value))
+                did_return = True
+            else:
+                print("Unsupported return value")
+    if not did_return:
+        builder.ret(ir.Constant(ir.IntType(32), 0))
+
+
+def process_bpf_chunk(func_node, module):
+    """Process a single BPF chunk (function) and emit corresponding LLVM IR."""
+
+    func_name = func_node.name
+
+    # TODO: parse return type
+    ret_type = ir.IntType(32)
+
+    # TODO: parse parameters
+    param_types = []
+    if func_node.args.args:
+        # Assume first arg to be ctx
+        param_types.append(ir.PointerType())
+
+    func_ty = ir.FunctionType(ret_type, param_types)
+    func = ir.Function(module, func_ty, func_name)
+
+    func.linkage = "dso_local"
+    func.attributes.add("nounwind")
+
+    if func_node.args.args:
+        # Only look at the first argument for now
+        param = func.args[0]
+        param.add_attribute("nocapture")
+
+    func.section = get_probe_string(func_node)
+
+    block = func.append_basic_block(name="entry")
+    builder = ir.IRBuilder(block)
+
+    process_func_body(module, builder, func_node, func)
+
+    print(func)
+    return func
+
+
 def func_proc(tree, module, chunks):
     for func_node in chunks:
         func_type = get_probe_string(func_node)
         print(f"Found probe_string of {func_node.name}: {func_type}")
 
+        process_bpf_chunk(func_node, module)
+
 
 def functions_processing(tree, module):
     bpf_functions = []