mirror of
https://github.com/varun-r-mallya/Python-BPF.git
synced 2025-12-31 21:06:25 +00:00
66 lines
2.8 KiB
Python
66 lines
2.8 KiB
Python
import ast
|
|
from llvmlite import ir
|
|
from logging import Logger
|
|
import logging
|
|
|
|
logger: Logger = logging.getLogger(__name__)
|
|
|
|
|
|
def recursive_dereferencer(var, builder):
|
|
"""dereference until primitive type comes out"""
|
|
# TODO: Not worrying about stack overflow for now
|
|
if isinstance(var.type, ir.PointerType):
|
|
a = builder.load(var)
|
|
return recursive_dereferencer(a, builder)
|
|
elif isinstance(var.type, ir.IntType):
|
|
return var
|
|
else:
|
|
raise TypeError(f"Unsupported type for dereferencing: {var.type}")
|
|
|
|
|
|
def get_operand_value(operand, builder, local_sym_tab):
|
|
"""Extract the value from an operand, handling variables and constants."""
|
|
if isinstance(operand, ast.Name):
|
|
if operand.id in local_sym_tab:
|
|
return recursive_dereferencer(local_sym_tab[operand.id].var, builder)
|
|
raise ValueError(f"Undefined variable: {operand.id}")
|
|
elif isinstance(operand, ast.Constant):
|
|
if isinstance(operand.value, int):
|
|
return ir.Constant(ir.IntType(64), operand.value)
|
|
raise TypeError(f"Unsupported constant type: {type(operand.value)}")
|
|
raise TypeError(f"Unsupported operand type: {type(operand)}")
|
|
|
|
|
|
def handle_binary_op(rval, module, builder, var_name, local_sym_tab, map_sym_tab, func):
|
|
logger.info(f"module {module}")
|
|
op = rval.op
|
|
|
|
left = get_operand_value(rval.left, builder, local_sym_tab)
|
|
right = get_operand_value(rval.right, builder, local_sym_tab)
|
|
logger.info(f"left is {left}, right is {right}, op is {op}")
|
|
|
|
if isinstance(op, ast.Add):
|
|
builder.store(builder.add(left, right), local_sym_tab[var_name].var)
|
|
elif isinstance(op, ast.Sub):
|
|
builder.store(builder.sub(left, right), local_sym_tab[var_name].var)
|
|
elif isinstance(op, ast.Mult):
|
|
builder.store(builder.mul(left, right), local_sym_tab[var_name].var)
|
|
elif isinstance(op, ast.Div):
|
|
builder.store(builder.sdiv(left, right), local_sym_tab[var_name].var)
|
|
elif isinstance(op, ast.Mod):
|
|
builder.store(builder.srem(left, right), local_sym_tab[var_name].var)
|
|
elif isinstance(op, ast.LShift):
|
|
builder.store(builder.shl(left, right), local_sym_tab[var_name].var)
|
|
elif isinstance(op, ast.RShift):
|
|
builder.store(builder.lshr(left, right), local_sym_tab[var_name].var)
|
|
elif isinstance(op, ast.BitOr):
|
|
builder.store(builder.or_(left, right), local_sym_tab[var_name].var)
|
|
elif isinstance(op, ast.BitXor):
|
|
builder.store(builder.xor(left, right), local_sym_tab[var_name].var)
|
|
elif isinstance(op, ast.BitAnd):
|
|
builder.store(builder.and_(left, right), local_sym_tab[var_name].var)
|
|
elif isinstance(op, ast.FloorDiv):
|
|
builder.store(builder.udiv(left, right), local_sym_tab[var_name].var)
|
|
else:
|
|
raise SyntaxError("Unsupported binary operation")
|