varun-r-mallya/python-bpf
1
0
Fork 0
mirror of https://github.com/varun-r-mallya/Python-BPF.git synced 2025-12-31 21:06:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

move field name generation to assignments dict

Browse Source
This commit is contained in:
varun-r-mallya
2025-10-20 21:27:18 +05:30
parent a20643f3a7
commit c9363e62a9
2 changed files with 85 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
pythonbpf/vmlinux_parser/dependency_node.py
View File

@ -18,6 +18,44 @@ class Field:
value: Any = None
ready: bool = False
def __hash__(self):
"""
Create a hash based on the immutable attributes that define this field's identity.
This allows Field objects to be used as dictionary keys.
"""
# Use a tuple of the fields that uniquely identify this field
identity = (
self.name,
id(self.type), # Use id for non-hashable types
id(self.ctype_complex_type) if self.ctype_complex_type else None,
id(self.containing_type) if self.containing_type else None,
self.type_size,
self.bitfield_size,
self.offset,
self.value if self.value else None,
)
return hash(identity)
def __eq__(self, other):
"""
Define equality consistent with the hash function.
Two fields are equal if they have the same name, type, and offset.
"""
# DO ther change here
if not isinstance(other, Field):
return False
return (
self.name == other.name
and self.type is other.type
and self.ctype_complex_type is other.ctype_complex_type
and self.containing_type is other.containing_type
and self.type_size == other.type_size
and self.bitfield_size == other.bitfield_size
and self.offset == other.offset
and self.value == other.value
)
def set_ready(self, is_ready: bool = True) -> None:
"""Set the readiness state of this field."""
self.ready = is_ready

57
pythonbpf/vmlinux_parser/ir_gen/ir_generation.py
View File

@ -1,7 +1,6 @@
import ctypes
import logging
from ..dependency_node import Field
from ..assignment_info import AssignmentInfo, AssignmentType
from ..dependency_handler import DependencyHandler
from .debug_info_gen import debug_info_generation
@ -18,7 +17,8 @@ class IRGenerator:
self.handler: DependencyHandler = handler
self.generated: list[str] = []
self.generated_debug_info: list = []
self.generated_field_names: dict[Field, str] = {}
# Use struct_name and field_name as key instead of Field object
self.generated_field_names: dict[str, dict[str, str]] = {}
self.assignments: dict[str, AssignmentInfo] = assignments
if not handler.is_ready:
raise ImportError(
@ -72,12 +72,30 @@ class IRGenerator:
f"Warning: Dependency {dependency} not found in handler"
)
# Generate IR first to populate field names
self.generated_debug_info.append(
(struct, self.gen_ir(struct, self.generated_debug_info))
)
# Fill the assignments dictionary with struct information
if struct.name not in self.assignments:
# Create a members dictionary for AssignmentInfo
members_dict = {}
for field_name, field in struct.fields.items():
members_dict[field_name] = (self.generated_field_names[field], field)
# Get the generated field name from our dictionary, or use field_name if not found
if (
struct.name in self.generated_field_names
and field_name in self.generated_field_names[struct.name]
):
field_co_re_name = self.generated_field_names[struct.name][
field_name
]
members_dict[field_name] = (field_co_re_name, field)
else:
raise ValueError(
f"llvm global name not found for struct field {field_name}"
)
# members_dict[field_name] = (field_name, field)
# Add struct to assignments dictionary
self.assignments[struct.name] = AssignmentInfo(
@ -90,10 +108,6 @@ class IRGenerator:
)
logger.info(f"Added struct assignment info for {struct.name}")
# Actual processor logic here after dependencies are resolved
self.generated_debug_info.append(
(struct, self.gen_ir(struct, self.generated_debug_info))
)
self.generated.append(struct.name)
finally:
@ -108,6 +122,11 @@ class IRGenerator:
struct, self.llvm_module, generated_debug_info
)
field_index = 0
# Make sure the struct has an entry in our field names dictionary
if struct.name not in self.generated_field_names:
self.generated_field_names[struct.name] = {}
for field_name, field in struct.fields.items():
# does not take arrays and similar types into consideration yet.
if field.ctype_complex_type is not None and issubclass(
@ -117,11 +136,27 @@ class IRGenerator:
containing_type = field.containing_type
if containing_type.__module__ == ctypes.__name__:
containing_type_size = ctypes.sizeof(containing_type)
if array_size == 0:
field_co_re_name = self._struct_name_generator(
struct, field, field_index, True, 0, containing_type_size
)
self.generated_field_names[struct.name][field_name] = (
field_co_re_name
)
globvar = ir.GlobalVariable(
self.llvm_module, ir.IntType(64), name=field_co_re_name
)
globvar.linkage = "external"
globvar.set_metadata("llvm.preserve.access.index", debug_info)
field_index += 1
continue
for i in range(0, array_size):
field_co_re_name = self._struct_name_generator(
struct, field, field_index, True, i, containing_type_size
)
self.generated_field_names[field] = field_co_re_name
self.generated_field_names[struct.name][field_name] = (
field_co_re_name
)
globvar = ir.GlobalVariable(
self.llvm_module, ir.IntType(64), name=field_co_re_name
)
@ -139,7 +174,9 @@ class IRGenerator:
field_co_re_name = self._struct_name_generator(
struct, field, field_index, True, i, containing_type_size
)
self.generated_field_names[field] = field_co_re_name
self.generated_field_names[struct.name][field_name] = (
field_co_re_name
)
globvar = ir.GlobalVariable(
self.llvm_module, ir.IntType(64), name=field_co_re_name
)
@ -150,7 +187,7 @@ class IRGenerator:
field_co_re_name = self._struct_name_generator(
struct, field, field_index
)
self.generated_field_names[field] = field_co_re_name
self.generated_field_names[struct.name][field_name] = field_co_re_name
field_index += 1
globvar = ir.GlobalVariable(
self.llvm_module, ir.IntType(64), name=field_co_re_name