from __future__ import annotations from typing import TYPE_CHECKING, Any if TYPE_CHECKING: from lib.core.translator import Translator import ast import sys import llvmlite.ir as ir from lib.core.Handles.HandlesBase import BaseHandle, CTypeInfo, FuncMeta from lib.core.VLogger import get_logger as _vlog from lib.core.ConstEvaluator import ConstEvaluator, EvalContext from lib.constants.config import mode as _config_mode from lib.includes import t from lib.includes.t import CTypeRegistry from lib.core.SymbolUtils import IsTModule, ParseListAnnotation, AnnotationContainsName class AssignHandle(BaseHandle): def __init__(self, translator: "Translator") -> None: super().__init__(translator) self._CurrentCpythonObjectClass: str | None = None @staticmethod def _contains_identified_struct(var_type: ir.Type) -> bool: if isinstance(var_type, ir.IdentifiedStructType): return True if isinstance(var_type, ir.ArrayType): return AssignHandle._contains_identified_struct(var_type.element) if isinstance(var_type, ir.PointerType): return AssignHandle._contains_identified_struct(var_type.pointee) if isinstance(var_type, ir.BaseStructType): if var_type.elements: return any(AssignHandle._contains_identified_struct(e) for e in var_type.elements) return False def HandleExprLlvm(self, Node: ast.expr, VarType: ir.Type | None = None) -> ir.Value | None: return self.Trans.ExprHandler.HandleExprLlvm(Node, VarType) def _HandleAssignLlvm(self, Node: ast.Assign) -> None: Gen: "Translator.LlvmGen" = self.Trans.LlvmGen Gen._set_node_info(Node, "Assign") if len(Node.targets) == 1: Target: ast.expr = Node.targets[0] if isinstance(Target, ast.Name): VarName: str = Target.id if VarName in Gen.var_const_flags: src_info: str = Gen._get_node_info() _vlog().error(f"不能对 const 变量 '{VarName}' 赋值{src_info}") sys.exit(1) if isinstance(Node.value, ast.Attribute) and isinstance(Node.value.value, ast.Name) and IsTModule(Node.value.value.id, self.Trans.SymbolTable): AttrName: str = Node.value.attr Gen.var_type_info[VarName] = {'type': 't_type', 'name': AttrName} Gen.var_type_assignments.setdefault(VarName, []).append({'type': 't_type', 'name': AttrName}) c_type_name: str = '' resolved: tuple[type, int] | None = CTypeRegistry.ResolveName(AttrName) if resolved is not None: ctype_cls: type = resolved[0] ptr_level: int = resolved[1] c_type_name = CTypeRegistry.CTypeToName(ctype_cls) if ptr_level > 0 and c_type_name: c_type_name = c_type_name + ' *' if not c_type_name: if AttrName == 'CPtr': c_type_name = 'void *' is_unsigned: bool = Gen._is_type_unsigned(c_type_name) if c_type_name else False fmt_str: str = "%u\n" if is_unsigned else "%d\n" fmt_ptr: ir.Value = Gen._create_string_global(fmt_str) fmt_var_name: str = f"__{VarName}_fmt" if fmt_var_name not in Gen.variables: fmt_alloca: ir.AllocaInstr = Gen._allocaEntry(ir.PointerType(ir.IntType(8)), name=fmt_var_name) Gen.variables[fmt_var_name] = fmt_alloca Gen.builder.store(fmt_ptr, Gen.variables[fmt_var_name]) kind_var_name: str = f"__{VarName}_kind" if kind_var_name not in Gen.variables: kind_alloca: ir.AllocaInstr = Gen._allocaEntry(ir.IntType(32), name=kind_var_name) Gen.variables[kind_var_name] = kind_alloca Gen.builder.store(ir.Constant(ir.IntType(32), 0), Gen.variables[kind_var_name]) if VarName not in Gen.variables: dummy_var: ir.AllocaInstr = Gen._alloca(ir.IntType(8), name=VarName) Gen.variables[VarName] = dummy_var return if isinstance(Node.value, ast.Name) and Node.value.id in Gen.structs: ClassName: str = Node.value.id Gen.var_type_info[VarName] = {'type': 'class_cast', 'name': ClassName} Gen.var_type_assignments.setdefault(VarName, []).append({'type': 'class_cast', 'name': ClassName}) fmt_str: str = "%p\n" fmt_ptr: ir.Value = Gen._create_string_global(fmt_str) fmt_var_name: str = f"__{VarName}_fmt" if fmt_var_name not in Gen.variables: fmt_alloca: ir.AllocaInstr = Gen._allocaEntry(ir.PointerType(ir.IntType(8)), name=fmt_var_name) Gen.variables[fmt_var_name] = fmt_alloca Gen.builder.store(fmt_ptr, Gen.variables[fmt_var_name]) kind_var_name: str = f"__{VarName}_kind" if kind_var_name not in Gen.variables: kind_alloca: ir.AllocaInstr = Gen._allocaEntry(ir.IntType(32), name=kind_var_name) Gen.variables[kind_var_name] = kind_alloca Gen.builder.store(ir.Constant(ir.IntType(32), 1), Gen.variables[kind_var_name]) if VarName not in Gen.variables: dummy_var: ir.AllocaInstr = Gen._alloca(ir.IntType(8), name=VarName) Gen.variables[VarName] = dummy_var return if isinstance(Node.value, ast.Call) and isinstance(Node.value.func, ast.Name) and Node.value.func.id == 'va_list': va_list_ptr: ir.AllocaInstr = Gen._allocaEntry(ir.IntType(8).as_pointer(), name="va_list") Gen.variables[VarName] = va_list_ptr return IsStructCtor: bool = (isinstance(Node.value, ast.Call) and isinstance(Node.value.func, ast.Name) and Node.value.func.id in Gen.structs) if IsStructCtor: ClassName: str = Node.value.func.id StructType: ir.Type = Gen.structs[ClassName] IsUnion: bool = False TypeInfo: "SymbolTable.SymbolInfo | None" = self.Trans.SymbolTable.lookup(ClassName) if TypeInfo and TypeInfo.IsUnion: IsUnion = True if IsUnion: Value: ir.Value | None = self.HandleExprLlvm(Node.value) if Value: var: ir.AllocaInstr = Gen._allocaEntry(Value.type, name=VarName) Gen._store(Value, var) Gen.variables[VarName] = var return ExistingPtr: ir.Value | None = None if VarName in Gen.variables and Gen.variables[VarName] is not None: VarPtr: ir.Value = Gen.variables[VarName] if isinstance(VarPtr.type.pointee, ir.PointerType): ExistingPtr = VarPtr elif VarName in Gen._reg_values: OldVal: ir.Value = Gen._reg_values[VarName] if isinstance(OldVal.type, ir.PointerType): var: ir.AllocaInstr = Gen._allocaEntry(OldVal.type, name=VarName) Gen._store(OldVal, var) Gen.variables[VarName] = var del Gen._reg_values[VarName] ExistingPtr = var elif VarName in Gen._direct_values: OldVal: ir.Value = Gen._direct_values.pop(VarName) if isinstance(OldVal.type, ir.PointerType): var: ir.AllocaInstr = Gen._allocaEntry(OldVal.type, name=VarName) Gen._store(OldVal, var) Gen.variables[VarName] = var ExistingPtr = var if ExistingPtr: pointee: ir.Type = ExistingPtr.type.pointee # 仅当 alloca 直接存储结构体值（pointee 不是指针）时才 in-place 初始化。 # 当 pointee 是 PointerType 时，alloca 存储的是堆对象指针： # - 若 AnnAssign 分支未执行，alloca 内容是未初始化的栈垃圾 # （可能恰好等于 pool 地址），_InitStructAtPtr 会向垃圾地址写字段 → 内存损坏 # - 即使指针有效，node = Class(...) 的语义也是创建新对象并更新指针， # 而非在旧对象位置 in-place 重初始化 # 此时必须 fall through 到通用路径 HandleExprLlvm → _HandleClassNewLlvm # 以正确调用 __new__/__before_init__/__init__ 构造新对象。 if not isinstance(pointee, ir.PointerType) and pointee == StructType: self._InitStructAtPtr(Node.value, ClassName, ExistingPtr) return if isinstance(Node.value, ast.Attribute): enum_type_name: str | None = self._CheckEnumMemberAssignment(Node.value) if enum_type_name: Gen.var_type_info[VarName] = {'type': 'enum', 'name': enum_type_name} var_type_for_list: ir.Type | None = None if isinstance(Node.value, ast.List) and VarName in Gen.var_type_info: type_info: dict[str, str] = Gen.var_type_info[VarName] if type_info.get('type') == 'CArray': var_type_for_list = type_info.get('full_type') Value: ir.Value | None = self.HandleExprLlvm(Node.value, VarType=var_type_for_list) # 闭包变量追踪：当赋值右侧是返回闭包的函数调用时，记录变量为闭包类型 if isinstance(Node.value, ast.Call) and isinstance(Node.value.func, ast.Name): CalledName: str = Node.value.func.id if CalledName in Gen._closure_return_types: Gen._closure_var_types[VarName] = Gen._closure_return_types[CalledName] if not Value: return if isinstance(Value.type, ir.VoidType): return Gen._UnregisterTempPtr(Value) # 大端局部变量：赋值时 bswap Value = Gen._apply_bswap_if_big(Value, Gen.local_var_byteorders.get(VarName, ""), f"bswap_assign_{VarName}") if isinstance(Value.type, ir.PointerType) and isinstance(Value.type.pointee, (ir.LiteralStructType, ir.IdentifiedStructType)): found_class: str | None = None found: tuple[str, ir.Type] | None = Gen.find_struct_by_pointee(Value.type.pointee) if found: CN: str = found[0] ST: ir.Type = found[1] found_class = CN Gen.var_struct_class[VarName] = CN Gen._var_to_heap_ptr[VarName] = Value if found_class is None and isinstance(Value.type.pointee, ir.IdentifiedStructType): pointee_name: str = Value.type.pointee.name pointee_short: str = Gen._extract_short_name(pointee_name) best_elem_count: int = 0 for CN, ST in Gen.structs.items(): if isinstance(ST, ir.IdentifiedStructType): st_short: str = Gen._extract_short_name(ST.name) if st_short == pointee_short: elem_count: int = len(ST.elements) if ST.elements else 0 if elem_count > best_elem_count: found_class = CN best_elem_count = elem_count if found_class: Gen.var_struct_class[VarName] = found_class Gen._var_to_heap_ptr[VarName] = Value # 泛型类特化触发：返回类型是泛型类特化（如 list[str]）但结构体尚未创建， # 或虽然找到了结构体但它是 opaque（来自 stub 声明，尚未发射方法体） _fd_struct_opaque: bool = False if found_class and found_class in Gen.structs: _fd_st: ir.IdentifiedStructType = Gen.structs[found_class] if isinstance(_fd_st, ir.IdentifiedStructType) and (_fd_st.elements is None or len(_fd_st.elements) == 0): _fd_struct_opaque = True if (found_class is None or _fd_struct_opaque) and isinstance(Value.type.pointee, ir.IdentifiedStructType): pn: str = Value.type.pointee.name short_pn: str = pn if '.' in pn: pn_parts: list[str] = pn.split('.', 1) if len(pn_parts[0]) >= 8 and all(c in '0123456789abcdef' for c in pn_parts[0]): short_pn = pn_parts[1] if '[' in short_pn and short_pn.endswith(']'): gc_base: str = short_pn.split('[')[0] gc_args_raw: str = short_pn[len(gc_base):] gc_type_args: list[str] = [] for gc_arg_part in gc_args_raw.split(']['): gc_arg_part = gc_arg_part.strip('[]') if gc_arg_part: gc_type_args.append(gc_arg_part) if (gc_type_args and hasattr(self.Trans.ClassHandler, '_generic_class_templates') and gc_base in self.Trans.ClassHandler._generic_class_templates): gc_type_names: list[str] = [] for gc_ta in gc_type_args: gc_tn: str = gc_ta if gc_ta == 'int': gc_tn = 'CInt' elif gc_ta == 'double': gc_tn = 'CDouble' elif gc_ta == 'float': gc_tn = 'CFloat' elif gc_ta == 'char': gc_tn = 'CChar' elif gc_ta == 'bool': gc_tn = 'CBool' gc_type_names.append(gc_tn) gc_spec: str | None = self.Trans.ClassHandler._specialize_generic_class( gc_base, gc_type_args, Gen, type_names=gc_type_names) if gc_spec and gc_spec in Gen.structs: found_class = gc_spec Gen.var_struct_class[VarName] = gc_spec Gen._var_to_heap_ptr[VarName] = Value else: if VarName in ('mctx', 's1ctx', 's2ctx', 's5ctx'): pass if isinstance(Value.type, ir.PointerType) and isinstance(Value.type.pointee, (ir.LiteralStructType, ir.IdentifiedStructType)): if VarName in Gen.variables and Gen.variables[VarName] is not None: Gen._store(Value, Gen.variables[VarName]) else: var: ir.AllocaInstr = Gen._allocaEntry(Value.type, name=VarName) Gen._store(Value, var) Gen.variables[VarName] = var if isinstance(Node.value, ast.Call) and isinstance(Node.value.func, ast.Name): call_func_name: str = Node.value.func.id if call_func_name in Gen.var_type_info: type_info: dict[str, str] = Gen.var_type_info[call_func_name] if type_info['type'] in ('t_type', 'class_cast'): src_fmt_var: str = f"__{call_func_name}_fmt" dst_fmt_var: str = f"__{VarName}_fmt" if src_fmt_var in Gen.variables: if dst_fmt_var not in Gen.variables: dst_alloca: ir.AllocaInstr = Gen._allocaEntry(ir.PointerType(ir.IntType(8)), name=dst_fmt_var) Gen.variables[dst_fmt_var] = dst_alloca src_fmt_ptr: ir.Value = Gen._load(Gen.variables[src_fmt_var], name=f"Load_{call_func_name}_fmt_for_{VarName}") Gen.builder.store(src_fmt_ptr, Gen.variables[dst_fmt_var]) src_kind_var: str = f"__{call_func_name}_kind" dst_kind_var: str = f"__{VarName}_kind" if src_kind_var in Gen.variables: if dst_kind_var not in Gen.variables: dst_kind_alloca: ir.AllocaInstr = Gen._allocaEntry(ir.IntType(32), name=dst_kind_var) Gen.variables[dst_kind_var] = dst_kind_alloca src_kind_val: ir.Value = Gen._load(Gen.variables[src_kind_var], name=f"Load_{call_func_name}_kind_for_{VarName}") Gen.builder.store(src_kind_val, Gen.variables[dst_kind_var]) Gen.var_type_info[VarName] = {'type': 't_type_runtime', 'source': call_func_name} return if VarName in Gen.global_vars: if VarName in Gen.module.globals: GVar: ir.GlobalVariable = Gen.module.globals[VarName] Gen._store(Value, GVar) Gen.variables[VarName] = GVar if isinstance(Value.type, ir.PointerType) and isinstance(Value.type.pointee, (ir.LiteralStructType, ir.IdentifiedStructType)): found: tuple[str, ir.Type] | None = Gen.find_struct_by_pointee(Value.type.pointee) if found: CN: str = found[0] ST: ir.Type = found[1] Gen.var_struct_class[VarName] = CN elif VarName in Gen.variables and Gen.variables[VarName] is not None: Gen._store(Value, Gen.variables[VarName]) return if VarName in Gen._reg_values: OldVal: ir.Value = Gen._reg_values[VarName] var: ir.AllocaInstr = Gen._allocaEntry(OldVal.type, name=VarName) Gen._store(OldVal, var) Gen.variables[VarName] = var del Gen._reg_values[VarName] if VarName in Gen._direct_values: OldVal: ir.Value = Gen._direct_values.pop(VarName) var: ir.AllocaInstr = Gen._allocaEntry(OldVal.type, name=VarName) Gen._store(OldVal, var) Gen.variables[VarName] = var if VarName in Gen.variables and Gen.variables[VarName] is not None: VarPtr: ir.Value = Gen.variables[VarName] TargetType: ir.Type | None = VarPtr.type.pointee if isinstance(VarPtr.type, ir.PointerType) else None types_differ: bool try: types_differ = TargetType and Value.type != TargetType except AssertionError: types_differ = False if isinstance(Value.type, ir.PointerType) and isinstance(Value.type.pointee, ir.PointerType): LoadedValue: ir.Value = Gen._load(Value, name=f"Load_{VarName}") Loaded_differ: bool try: Loaded_differ = TargetType and LoadedValue.type != TargetType except AssertionError: Loaded_differ = False if Loaded_differ: try: Coerced: ir.Value | None = Gen._coerce_value(LoadedValue, TargetType) if Coerced is not None: LoadedValue = Coerced except AssertionError: pass Gen._store(LoadedValue, VarPtr) elif types_differ: try: Coerced: ir.Value | None = Gen._coerce_value(Value, TargetType) if Coerced is not None: Gen._store(Coerced, VarPtr) else: Gen._store(Value, VarPtr) except AssertionError: Gen._store(Value, VarPtr) else: Gen._store(Value, VarPtr) if VarName not in Gen.variables: # 检查是否为模块级全局变量 # main 函数代表模块级作用域，直接修改全局变量 # 其他函数中，未声明 global 且未先读取的赋值创建局部变量（Python 作用域语义） # 先读取过的变量已通过 HandleExprLlvm 加入 Gen.variables，会走 L289 分支存储到全局 CurrentFuncName: str = getattr(Gen.func, 'name', '') if Gen.func else '' IsMainScope: bool = CurrentFuncName == 'main' or CurrentFuncName.endswith('.main') if VarName in Gen.module.globals and (VarName in Gen.global_vars or IsMainScope): GVar: ir.GlobalVariable = Gen.module.globals[VarName] Gen._store(Value, GVar) Gen.variables[VarName] = GVar elif isinstance(Value.type, ir.PointerType) and isinstance(Value.type.pointee, ir.PointerType): LoadedValue: ir.Value = Gen._load(Value, name=f"Load_{VarName}") var: ir.AllocaInstr = Gen._allocaEntry(LoadedValue.type, name=VarName) Gen._store(LoadedValue, var) Gen.variables[VarName] = var else: var: ir.AllocaInstr = Gen._allocaEntry(Value.type, name=VarName) Gen._store(Value, var) Gen.variables[VarName] = var is_u: bool = Gen._check_node_unsigned(Node.value) Gen._record_var_signedness(VarName, 'unsigned int' if is_u else 'int') if isinstance(Node.value, ast.Call) and isinstance(Node.value.func, ast.Name): call_func_name: str = Node.value.func.id if call_func_name in Gen.var_type_info: type_info: dict[str, str] = Gen.var_type_info[call_func_name] if type_info['type'] in ('t_type', 'class_cast'): src_fmt_var: str = f"__{call_func_name}_fmt" dst_fmt_var: str = f"__{VarName}_fmt" if src_fmt_var in Gen.variables: if dst_fmt_var not in Gen.variables: dst_alloca: ir.AllocaInstr = Gen._allocaEntry(ir.PointerType(ir.IntType(8)), name=dst_fmt_var) Gen.variables[dst_fmt_var] = dst_alloca src_fmt_ptr: ir.Value = Gen._load(Gen.variables[src_fmt_var], name=f"Load_{call_func_name}_fmt_for_{VarName}") Gen.builder.store(src_fmt_ptr, Gen.variables[dst_fmt_var]) src_kind_var: str = f"__{call_func_name}_kind" dst_kind_var: str = f"__{VarName}_kind" if src_kind_var in Gen.variables: if dst_kind_var not in Gen.variables: dst_kind_alloca: ir.AllocaInstr = Gen._allocaEntry(ir.IntType(32), name=dst_kind_var) Gen.variables[dst_kind_var] = dst_kind_alloca src_kind_val: ir.Value = Gen._load(Gen.variables[src_kind_var], name=f"Load_{call_func_name}_kind_for_{VarName}") Gen.builder.store(src_kind_val, Gen.variables[dst_kind_var]) Gen.var_type_info[VarName] = {'type': 't_type_runtime', 'source': call_func_name} else: Gen.var_type_info[VarName] = {'type': 't_type_runtime', 'source': call_func_name} elif isinstance(Target, ast.Attribute): TargetType: ir.Type | None = None AttrName: str = Target.attr VarName: str | None = None if isinstance(Target.value, ast.Name): VarName = Target.value.id if VarName: ClassName: str | None = Gen.var_struct_class.get(VarName) if not ClassName and Gen.global_struct_class: ClassName = Gen.global_struct_class.get(VarName) if ClassName: Gen.var_struct_class[VarName] = ClassName if not ClassName: for CN in Gen.structs: if VarName == CN.lower() or VarName.startswith(CN): ClassName = CN break if ClassName and ClassName in Gen.class_members: for m_name, m_type in Gen.class_members[ClassName]: if m_name == AttrName: TargetType = m_type break Value: ir.Value | None = self.HandleExprLlvm(Node.value, VarType=TargetType) if Value: self._HandleAttributeStoreLlvm(Target, Value) elif isinstance(Target, ast.Subscript): TargetType: ir.Type | None = None SubVarName: str | None = None if isinstance(Target.value, ast.Name): SubVarName = Target.value.id if SubVarName in Gen.var_struct_class: ClassName: str = Gen.var_struct_class[SubVarName] if ClassName in Gen.class_members: for m_name, m_type in Gen.class_members[ClassName]: if m_name == SubVarName: if isinstance(m_type, ir.PointerType): pointee: ir.Type = m_type.pointee if isinstance(pointee, ir.ArrayType): TargetType = pointee.element elif isinstance(m_type, ir.ArrayType): TargetType = m_type.element break if not TargetType and isinstance(Target.value, ast.Name): SubVarName = Target.value.id var_val: ir.Value | None = Gen.variables.get(SubVarName) if var_val is None and SubVarName in Gen._direct_values: var_val = Gen._direct_values[SubVarName] if var_val is not None: var_type: ir.Type = var_val.type if isinstance(var_type, ir.PointerType): pointee: ir.Type = var_type.pointee if isinstance(pointee, ir.ArrayType): TargetType = pointee.element elif isinstance(var_type, ir.ArrayType): TargetType = var_type.element Value: ir.Value | None = self.HandleExprLlvm(Node.value, VarType=TargetType) if Value: self._HandleSubscriptStoreLlvm(Target, Value) elif isinstance(Target, ast.Tuple): if isinstance(Node.value, ast.Call): FuncName: str | None = None ModulePath: str | None = None if isinstance(Node.value.func, ast.Name): FuncName = Node.value.func.id elif isinstance(Node.value.func, ast.Attribute): FuncName = Node.value.func.attr ModulePath = self.Trans.ExprCallHandle._get_ModulePath(Node.value.func.value) CReturnTypes: list[ast.expr] = [] FuncDef: ast.FunctionDef | None = self.Trans.FunctionDefCache.get(FuncName) if FuncName else None if FuncDef: if FuncDef.returns and isinstance(FuncDef.returns, ast.Subscript): if isinstance(FuncDef.returns.value, ast.Name) and FuncDef.returns.value.id == 'tuple': slice_node: ast.expr = FuncDef.returns.slice if isinstance(slice_node, ast.Tuple): CReturnTypes = slice_node.elts else: CReturnTypes = [slice_node] if FuncDef.decorator_list: for decorator in FuncDef.decorator_list: if isinstance(decorator, ast.Call) and isinstance(decorator.func, ast.Attribute): if decorator.func.attr == 'CReturn': for arg in decorator.args: CReturnTypes.append(arg) if not CReturnTypes and FuncName: func: ir.Function | None = Gen.functions.get(FuncName) if func: func_ft: ir.FunctionType | None = getattr(func, 'ftype', None) if func_ft: ret_type: ir.Type = func_ft.return_type if isinstance(ret_type, ir.LiteralStructType): CReturnTypes = [None] * len(ret_type.elements) if not CReturnTypes: sym_key: str = FuncName if not self.Trans.SymbolTable.has(sym_key): if ModulePath: sym_key = f"{ModulePath}.{FuncName}" sym_info: "SymbolTable.SymbolInfo | None" = self.Trans.SymbolTable.lookup(sym_key) if sym_info and sym_info.IsFunction: ret_type_info: CTypeInfo | None = sym_info.FuncPtrReturn param_type_infos: list[tuple[str, CTypeInfo]] = [pt for _, pt in (sym_info.FuncPtrParams or [])] if ret_type_info: if isinstance(ret_type_info, CTypeInfo) and ret_type_info.BaseType: ret_type: ir.Type = ret_type_info.ToLLVM(Gen) else: ret_type = Gen._type_str_to_llvm(str(ret_type_info) if ret_type_info else 'i32', False) if isinstance(ret_type, ir.LiteralStructType): CReturnTypes = [None] * len(ret_type.elements) if FuncName not in Gen.functions: if isinstance(ret_type, ir.VoidType): ret_type = ir.IntType(32) llvm_param_types: list[ir.Type] = [] for pt in param_type_infos: if isinstance(pt, CTypeInfo) and pt.BaseType: lp: ir.Type = pt.ToLLVM(Gen) else: lp = Gen._type_str_to_llvm(str(pt) if pt else 'i32', '*' in str(pt) if isinstance(pt, str) else False) if isinstance(lp, ir.VoidType): lp = ir.IntType(8).as_pointer() llvm_param_types.append(lp) func_type: ir.FunctionType = ir.FunctionType(ret_type, llvm_param_types) MangledName: str = Gen._mangle_func_name(FuncName) func_decl: ir.Function = ir.Function(Gen.module, func_type, name=MangledName) Gen.functions[MangledName] = func_decl Gen.functions[FuncName] = func_decl if not CReturnTypes and FuncName: func: ir.Function | None = Gen.functions.get(FuncName) if func: func_ft: ir.FunctionType | None = getattr(func, 'ftype', None) if func_ft: ret_type: ir.Type = func_ft.return_type if isinstance(ret_type, ir.LiteralStructType): CReturnTypes = [None] * len(ret_type.elements) if CReturnTypes and len(Target.elts) == len(CReturnTypes): CallArgs: list[ir.Value | None] = [] for arg in Node.value.args: ArgVal: ir.Value | None = self.HandleExprLlvm(arg) if ArgVal: CallArgs.append(ArgVal) for kw in Node.value.keywords: pass func: ir.Function | None = Gen.functions.get(FuncName) func_ft: ir.FunctionType | None = getattr(func, 'ftype', None) if func else None func_params: list[ir.Type] = list(getattr(func_ft, 'args', []) or []) if func_ft else [] while len(CallArgs) < len(func_params): FuncDef: ast.FunctionDef | None = self.Trans.FunctionDefCache.get(FuncName) if FuncDef and len(CallArgs) < len(FuncDef.args.args): arg_def: list[ast.expr] = FuncDef.args.defaults arg_idx: int = len(CallArgs) total_args: int = len(FuncDef.args.args) default_start: int = total_args - len(arg_def) if arg_idx >= default_start: def_idx: int = arg_idx - default_start if def_idx < len(arg_def): DefVal: ir.Value | None = self.HandleExprLlvm(arg_def[def_idx]) if DefVal: expected_type: ir.Type = func_params[arg_idx] if DefVal.type != expected_type: if isinstance(expected_type, ir.IntType) and isinstance(DefVal.type, ir.IntType): if DefVal.type.width < expected_type.width: DefVal = Gen.builder.zext(DefVal, expected_type, name=f"zext_default_{arg_idx}") elif DefVal.type.width > expected_type.width: DefVal = Gen.builder.trunc(DefVal, expected_type, name=f"trunc_default_{arg_idx}") CallArgs.append(DefVal) continue if len(CallArgs) < len(func_params): CallArgs.append(ir.Constant(func_params[len(CallArgs)], 0)) else: break adjusted: list[ir.Value] = Gen._adjust_args(CallArgs, func) call_result: ir.Value = Gen.builder.call(func, adjusted, name=f"call_{FuncName}") func_ft: ir.FunctionType | None = getattr(func, 'ftype', None) ret_type: ir.Type | None = getattr(func_ft, 'return_type', None) if func_ft else None for j, elt in enumerate(Target.elts): if isinstance(elt, ast.Name): VarName: str = elt.id field_val: ir.Value = Gen.builder.extract_value(call_result, j, name=f"extract_{FuncName}_{j}") VarType: ir.Type if CReturnTypes[j] is not None: ReturnTypeInfo: CTypeInfo | None = CTypeInfo.FromNode(CReturnTypes[j], self.Trans.SymbolTable) if ReturnTypeInfo is None: ReturnTypeInfo = CTypeInfo() ReturnTypeInfo.BaseType = t.CInt() VarType = Gen._ctype_to_llvm(ReturnTypeInfo) elif ret_type and isinstance(ret_type, ir.LiteralStructType) and j < len(ret_type.elements): VarType = ret_type.elements[j] else: VarType = field_val.type if isinstance(VarType, ir.VoidType): VarType = ir.IntType(32) var: ir.AllocaInstr = Gen._alloca(VarType, name=VarName) Gen.variables[VarName] = var if CReturnTypes[j] is not None: Gen._record_var_signedness(VarName, ReturnTypeStr) elif ret_type and isinstance(ret_type, ir.LiteralStructType) and j < len(ret_type.elements): elem_type: ir.Type = ret_type.elements[j] if isinstance(elem_type, ir.IntType): if elem_type.width == 16: Gen._record_var_signedness(VarName, 'unsigned short') elif elem_type.width == 32: Gen._record_var_signedness(VarName, 'unsigned int') elif elem_type.width == 64: Gen._record_var_signedness(VarName, 'unsigned long long') Gen._store(field_val, var) return def _InitStructAtPtr(self, call_node: ast.Call, ClassName: str, VarPtr: ir.Value) -> None: Gen: "Translator.LlvmGen" = self.Trans.LlvmGen if ClassName not in Gen.structs: return StructType: ir.Type = Gen.structs[ClassName] StructPtrType: ir.PointerType = ir.PointerType(StructType) RawPtr: ir.Value = Gen._load(VarPtr, name=getattr(VarPtr, 'name', 'ptr')) StructPtr: ir.Value = Gen.builder.bitcast(RawPtr, StructPtrType, name=ClassName) members: list[tuple[str, ir.Type]] = Gen.class_members.get(ClassName, []) defaults: dict[str, ir.Value] = Gen.class_member_defaults.get(ClassName, {}) member_values: dict[str, ir.Value] = {} for member_name, member_type in members: if member_name in defaults: member_values[member_name] = defaults[member_name] if call_node.args: for i, arg in enumerate(call_node.args): if i < len(members): member_name: str = members[i][0] val: ir.Value | None = self.HandleExprLlvm(arg) if val: member_values[member_name] = val if call_node.keywords: for kw in call_node.keywords: val: ir.Value | None = self.HandleExprLlvm(kw.value) if val: member_values[kw.arg] = val has_vtable: bool = ClassName in Gen.class_vtable or ClassName in Gen._cross_module_vtable_classes base: int = 1 if has_vtable else 0 for i, (member_name, member_type) in enumerate(members): if isinstance(member_type, ir.VoidType): continue if member_name in member_values: ElemPtr: ir.Value = Gen.builder.gep(StructPtr, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), base + i)], name=f"{ClassName}_{member_name}") try: Gen._store(member_values[member_name], ElemPtr) except Exception as _e: if _config_mode == "strict": self.Trans.LogWarning(f"异常被忽略: {_e}") InitFuncName: str = f'{ClassName}.__init__' if Gen._has_function(InitFuncName): Args: list[ir.Value | None] = [self.HandleExprLlvm(arg) for arg in call_node.args] Args = [a for a in Args if a] Gen.builder.call(Gen._get_function(InitFuncName), [StructPtr] + Args, name=f"call_{InitFuncName}") def _HandleAttributeStoreLlvm(self, Target: ast.Attribute, Value: ir.Value) -> None: Gen: "Translator.LlvmGen" = self.Trans.LlvmGen AttrName: str = Target.attr if isinstance(Target.value, ast.Name) and Target.value.id == 'self': ClassName: str | None = self.Trans._CurrentCpythonObjectClass if ClassName and ClassName in Gen.structs: PropKey: str = f'{ClassName}.{AttrName}' PropInfo: "SymbolTable.SymbolInfo | None" = self.Trans.SymbolTable.lookup(PropKey) if PropInfo and PropInfo.MetaList and FuncMeta.PROPERTY_SETTER in PropInfo.MetaList: SelfVar: ir.Value | None = Gen._get_var_ptr('self') if SelfVar: SelfPtr: ir.Value = Gen._load(SelfVar, name="self") SetterFunc: ir.Function | None = Gen._get_function(PropKey + '$set') if SetterFunc and SelfPtr: Gen.builder.call(SetterFunc, [SelfPtr, Value], name=f"prop_set_{PropKey}") return SelfVar: ir.Value | None = Gen._get_var_ptr('self') if not SelfVar: return if SelfVar: SelfPtr: ir.Value = Gen._load(SelfVar, name="self") is_vtable_method: bool = False method_idx: int = 0 if ClassName in Gen.class_vtable or ClassName in Gen._cross_module_vtable_classes: if ClassName in Gen.class_methods: for mi, mn in enumerate(Gen.class_methods[ClassName]): method_short: str = mn.split('.')[-1] if '.' in mn else mn if method_short == AttrName or mn == AttrName: is_vtable_method = True method_idx = mi break if is_vtable_method: VtableSlotPtr: ir.Value = Gen.builder.gep(SelfPtr, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), 0)], name=f"vtable_slot_{ClassName}") VtablePtr: ir.Value = Gen._load(VtableSlotPtr, name=f"vtable_ptr_{ClassName}") methods: list[str] = Gen.class_methods[ClassName] VtableArrayType: ir.ArrayType = ir.ArrayType(ir.PointerType(ir.IntType(8)), len(methods)) ClassVtable: ir.GlobalVariable | None = Gen.Vtables.get(ClassName) if ClassVtable: ClassVtableAddr: ir.Value = Gen.builder.bitcast(ClassVtable, ir.PointerType(ir.IntType(8)), name=f"class_vtable_addr_{ClassName}") IsSameVtable: ir.Value = Gen.builder.icmp_unsigned('==', VtablePtr, ClassVtableAddr, name=f"is_same_vtable_{ClassName}") CopyBlock: ir.Block = Gen.func.append_basic_block(name=f"vtable_copy_self_{AttrName}") SkipBlock: ir.Block = Gen.func.append_basic_block(name=f"vtable_skip_self_{AttrName}") Gen.builder.cbranch(IsSameVtable, CopyBlock, SkipBlock) Gen.builder.position_at_end(CopyBlock) Gen._vtable_copy_counter += 1 CopyName: str = f"{Gen._mangle_name(ClassName)}_vtable_copy_self_{Gen._vtable_copy_counter}" VtableCopyGlobal: ir.GlobalVariable = ir.GlobalVariable(Gen.module, VtableArrayType, name=CopyName) VtableCopyGlobal.linkage = 'internal' VtableCopyGlobal.initializer = ir.Constant(VtableArrayType, [ir.Constant(ir.PointerType(ir.IntType(8)), None)] * len(methods)) VtableCopyTyped: ir.Value = Gen.builder.bitcast(VtableCopyGlobal, ir.PointerType(ir.IntType(8)), name=f"vtable_copy_typed") SrcTyped: ir.Value = Gen.builder.bitcast(ClassVtable, ir.PointerType(ir.IntType(8)), name=f"src_vtable_typed") VtableSize: int = len(methods) * Gen.ptr_size MemcpyFunc: ir.Function | None = Gen._find_function('llvm.memcpy.p0i8.p0i8.i64') if not MemcpyFunc: MemcpyType: ir.FunctionType = ir.FunctionType(ir.VoidType(), [ir.PointerType(ir.IntType(8)), ir.PointerType(ir.IntType(8)), ir.IntType(64), ir.IntType(1)]) MemcpyFunc = ir.Function(Gen.module, MemcpyType, name='llvm.memcpy.p0i8.p0i8.i64') Gen.functions['llvm.memcpy.p0i8.p0i8.i64'] = MemcpyFunc Gen.builder.call(MemcpyFunc, [VtableCopyTyped, SrcTyped, ir.Constant(ir.IntType(64), VtableSize), ir.Constant(ir.IntType(1), 0)]) VtableCopyGlobalAddr: ir.Value = Gen.builder.bitcast(VtableCopyGlobal, ir.PointerType(ir.IntType(8)), name=f"vtable_copy_addr") Gen._store(VtableCopyGlobalAddr, VtableSlotPtr) Gen.builder.branch(SkipBlock) Gen.builder.position_at_end(SkipBlock) VtablePtr = Gen._load(VtableSlotPtr, name=f"vtable_ptr_{ClassName}_after_copy") VtableTyped: ir.Value = Gen.builder.bitcast(VtablePtr, ir.PointerType(VtableArrayType), name=f"vtable_typed_{ClassName}") MethodPtrAddr: ir.Value = Gen.builder.gep(VtableTyped, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), method_idx)], name=f"vmethod_slot_{AttrName}") FuncPtrI8: ir.Value = Gen.builder.bitcast(Value, ir.PointerType(ir.IntType(8)), name=f"func_ptr_i8_{AttrName}") Gen._store(FuncPtrI8, MethodPtrAddr) return offset: int = Gen._get_member_offset(AttrName, ClassName) struct_type: ir.Type = Gen.structs[ClassName] max_offset: int = len(struct_type.elements) if isinstance(struct_type, ir.IdentifiedStructType) else 0 if offset >= max_offset: VarName: str = f"self.{AttrName}" if VarName not in Gen.variables: NewVar: ir.AllocaInstr = Gen._allocaEntry(Value.type, name=AttrName) Gen.variables[VarName] = NewVar Gen._store(Value, Gen.variables[VarName]) return MemberPtr: ir.Value = Gen.builder.gep(SelfPtr, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), offset)], name=AttrName) self._StoreWithCoerce(Value, MemberPtr) elif isinstance(Target.value, ast.Name): VarName: str = Target.value.id # FakeDuck: 检查是否有影子结构体 a__meta__ (str 变量的 per-instance 字段存储) # 直接通过 a.__field__ = value 访问影子结构体字段 (语法糖) _fd_meta_name: str = f"{VarName}__meta__" if _fd_meta_name in Gen.variables and '_str' in Gen.structs: _fd_offset = Gen._get_member_offset(AttrName, '_str') if _fd_offset is not None: _fd_meta_ptr: ir.Value = Gen.variables[_fd_meta_name] _fd_field_ptr: ir.Value = Gen.builder.gep(_fd_meta_ptr, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), _fd_offset)], name=f"{VarName}_{AttrName}_ptr") self._StoreWithCoerce(Value, _fd_field_ptr) return ClassName: str | None = Gen.var_struct_class.get(VarName) if not ClassName and Gen.global_struct_class: ClassName = Gen.global_struct_class.get(VarName) if ClassName: Gen.var_struct_class[VarName] = ClassName if not ClassName: for CN in Gen.structs: if VarName == CN.lower() or VarName.startswith(CN): ClassName = CN break if not ClassName and VarName in Gen.module.globals: GVar: ir.GlobalVariable = Gen.module.globals[VarName] if isinstance(GVar.type, ir.PointerType) and isinstance(GVar.type.pointee, (ir.IdentifiedStructType, ir.LiteralStructType)): found: tuple[str, ir.Type] | None = Gen.find_struct_by_pointee(GVar.type.pointee) if found: ClassName = found[0] Gen.var_struct_class[VarName] = ClassName if Gen.global_struct_class: Gen.global_struct_class[VarName] = ClassName if not ClassName and VarName in Gen.variables: VarPtr: ir.Value = Gen.variables[VarName] if isinstance(VarPtr.type, ir.PointerType): pointee: ir.Type = VarPtr.type.pointee if isinstance(pointee, ir.PointerType): pointee = pointee.pointee found: tuple[str, ir.Type] | None = Gen.find_struct_by_pointee(pointee) if found: CN: str = found[0] ST: ir.Type = found[1] ClassName = CN elif isinstance(pointee, ir.IdentifiedStructType): # sha1 冲突 fallback：find_struct_by_pointee 因 sha1 前缀不匹配失败时， # 用短名（去掉 sha1 前缀）匹配，优先选字段最多的完整版本 pointee_short: str = Gen._extract_short_name(pointee.name) best_elem_count: int = 0 for CN, ST in Gen.structs.items(): if isinstance(ST, ir.IdentifiedStructType): st_short: str = Gen._extract_short_name(ST.name) if st_short == pointee_short: elem_count: int = len(ST.elements) if ST.elements else 0 if elem_count > best_elem_count: ClassName = CN best_elem_count = elem_count IsUnion: bool = False if ClassName: TypeInfo: "SymbolTable.SymbolInfo | None" = self.Trans.SymbolTable.lookup(ClassName) if TypeInfo and TypeInfo.IsUnion: IsUnion = True if ClassName and ClassName in Gen.structs: PropKey: str = f'{ClassName}.{AttrName}' PropInfo: "SymbolTable.SymbolInfo | None" = self.Trans.SymbolTable.lookup(PropKey) if PropInfo and PropInfo.MetaList and FuncMeta.PROPERTY_SETTER in PropInfo.MetaList: ObjVal: ir.Value | None = self.Trans.ExprHandler.HandleExprLlvm(Target.value) SetterFunc: ir.Function | None = Gen._get_function(PropKey + '$set') if SetterFunc and ObjVal: if isinstance(ObjVal.type, ir.PointerType) and isinstance(ObjVal.type.pointee, ir.PointerType): ObjVal = Gen._load(ObjVal, name=f"Load_{ClassName}") Gen.builder.call(SetterFunc, [ObjVal, Value], name=f"prop_set_{PropKey}") return ObjVal: ir.Value | None = self.Trans.ExprHandler.HandleExprLlvm(Target.value) if ObjVal: if BaseHandle._is_char_pointer(ObjVal): ObjVal = Gen.builder.bitcast(ObjVal, ir.PointerType(Gen.structs[ClassName]), name=f"cast_{ClassName}") if isinstance(ObjVal.type, ir.PointerType) and isinstance(ObjVal.type.pointee, ir.PointerType): ObjVal = Gen._load(ObjVal, name=f"Load_{ClassName}") # 跨模块 opaque 类型：ObjVal.type.pointee 与 Gen.structs[ClassName] 可能是 # 不同的 IdentifiedStructType 对象（虽然 name 相同），== 返回 False。 # 使用 name 匹配作为 fallback，与链式赋值路径（第 926-927 行）一致。 # sha1 冲突时还需短名匹配（如 6bc91356c652f8ca.Function vs 8ad0c0a2934ca5b4.Function） _ObjPointee = ObjVal.type.pointee if isinstance(ObjVal.type, ir.PointerType) else None _TargetStruct = Gen.structs.get(ClassName) _MatchesStruct = (_ObjPointee is not None and _TargetStruct is not None and (_ObjPointee == _TargetStruct or (isinstance(_ObjPointee, ir.IdentifiedStructType) and isinstance(_TargetStruct, ir.IdentifiedStructType) and (_ObjPointee.name == _TargetStruct.name or Gen._extract_short_name(_ObjPointee.name) == Gen._extract_short_name(_TargetStruct.name))))) # opaque 泛型结构体 → 特化版本 bitcast # 当 ObjVal 的 pointee 是 opaque 基础泛型结构体（如 GSList，来自跨模块 stub）， # 而 ClassName 是特化版本（如 GSList[BasicBlock]）时，两者 short name 不同 # （GSList vs GSList[BasicBlock]），_MatchesStruct 失败。 # 验证特化 short name 以 基础名+'[' 开头，bitcast 到特化版本使后续 GEP 能正确访问字段。 if (not _MatchesStruct and isinstance(ObjVal.type, ir.PointerType) and isinstance(_ObjPointee, ir.IdentifiedStructType) and isinstance(_TargetStruct, ir.IdentifiedStructType) and '[' in ClassName): _BaseShort: str = Gen._extract_short_name(_ObjPointee.name) _SpecShort: str = Gen._extract_short_name(_TargetStruct.name) if _BaseShort and _SpecShort.startswith(_BaseShort + '['): ObjVal = Gen.builder.bitcast(ObjVal, ir.PointerType(_TargetStruct), name=f"cast_spec_{ClassName}") _MatchesStruct = True if isinstance(ObjVal.type, ir.PointerType) and _MatchesStruct: if IsUnion: NestedStructName: str = f"{ClassName}_{AttrName}" if NestedStructName in Gen.structs: NestedStructType: ir.Type = Gen.structs[NestedStructName] ObjVal = Gen.builder.bitcast(ObjVal, ir.PointerType(NestedStructType), name=f"cast_{NestedStructName}") offset: int | None = Gen._get_member_offset(AttrName, NestedStructName) if offset is not None and offset < len(NestedStructType.elements): MemberPtr: ir.Value = Gen.builder.gep(ObjVal, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), offset)], name=AttrName) self._StoreWithCoerce(Value, MemberPtr) return bitfield_offsets: dict[str, int] = Gen.class_member_bitoffsets.get(ClassName, {}) if AttrName in bitfield_offsets: self._store_bitfield_member(ObjVal, ClassName, AttrName, Value) return bitfields: dict[str, int] = Gen.class_member_bitfields.get(ClassName, {}) if AttrName in bitfields and bitfields[AttrName] > 0: if ClassName not in Gen.class_member_bitoffsets: Gen.class_member_bitoffsets[ClassName] = {} if AttrName not in Gen.class_member_bitoffsets[ClassName]: bo: int = 0 for bf_name, bf_width in bitfields.items(): if bf_name == AttrName: break bo += bf_width Gen.class_member_bitoffsets[ClassName][AttrName] = bo self._store_bitfield_member(ObjVal, ClassName, AttrName, Value) return is_vtable_method: bool = False method_idx: int = 0 if ClassName in Gen.class_vtable or ClassName in Gen._cross_module_vtable_classes: if ClassName in Gen.class_methods: for mi, mn in enumerate(Gen.class_methods[ClassName]): method_short: str = mn.split('.')[-1] if '.' in mn else mn if method_short == AttrName or mn == AttrName: is_vtable_method = True method_idx = mi break if is_vtable_method: VtableSlotPtr: ir.Value = Gen.builder.gep(ObjVal, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), 0)], name=f"vtable_slot_{ClassName}") VtablePtr: ir.Value = Gen._load(VtableSlotPtr, name=f"vtable_ptr_{ClassName}") methods: list[str] = Gen.class_methods[ClassName] VtableArrayType: ir.ArrayType = ir.ArrayType(ir.PointerType(ir.IntType(8)), len(methods)) ClassVtable: ir.GlobalVariable | None = Gen.Vtables.get(ClassName) if ClassVtable: ClassVtableAddr: ir.Value = Gen.builder.bitcast(ClassVtable, ir.PointerType(ir.IntType(8)), name=f"class_vtable_addr_{ClassName}") IsSameVtable: ir.Value = Gen.builder.icmp_unsigned('==', VtablePtr, ClassVtableAddr, name=f"is_same_vtable_{ClassName}") CopyBlock: ir.Block = Gen.func.append_basic_block(name=f"vtable_copy_{AttrName}") SkipBlock: ir.Block = Gen.func.append_basic_block(name=f"vtable_skip_{AttrName}") Gen.builder.cbranch(IsSameVtable, CopyBlock, SkipBlock) Gen.builder.position_at_end(CopyBlock) Gen._vtable_copy_counter += 1 CopyName: str = f"{Gen._mangle_name(ClassName)}_vtable_copy_{Gen._vtable_copy_counter}" VtableCopyGlobal: ir.GlobalVariable = ir.GlobalVariable(Gen.module, VtableArrayType, name=CopyName) VtableCopyGlobal.linkage = 'internal' VtableCopyGlobal.initializer = ir.Constant(VtableArrayType, [ir.Constant(ir.PointerType(ir.IntType(8)), None)] * len(methods)) VtableCopyTyped: ir.Value = Gen.builder.bitcast(VtableCopyGlobal, ir.PointerType(ir.IntType(8)), name=f"vtable_copy_typed") SrcTyped: ir.Value = Gen.builder.bitcast(ClassVtable, ir.PointerType(ir.IntType(8)), name=f"src_vtable_typed") VtableSize: int = len(methods) * Gen.ptr_size MemcpyFunc: ir.Function | None = Gen._find_function('llvm.memcpy.p0i8.p0i8.i64') if not MemcpyFunc: MemcpyType: ir.FunctionType = ir.FunctionType(ir.VoidType(), [ir.PointerType(ir.IntType(8)), ir.PointerType(ir.IntType(8)), ir.IntType(64), ir.IntType(1)]) MemcpyFunc = ir.Function(Gen.module, MemcpyType, name='llvm.memcpy.p0i8.p0i8.i64') Gen.functions['llvm.memcpy.p0i8.p0i8.i64'] = MemcpyFunc Gen.builder.call(MemcpyFunc, [VtableCopyTyped, SrcTyped, ir.Constant(ir.IntType(64), VtableSize), ir.Constant(ir.IntType(1), 0)]) VtableCopyGlobalAddr: ir.Value = Gen.builder.bitcast(VtableCopyGlobal, ir.PointerType(ir.IntType(8)), name=f"vtable_copy_addr") Gen._store(VtableCopyGlobalAddr, VtableSlotPtr) Gen.builder.branch(SkipBlock) Gen.builder.position_at_end(SkipBlock) VtablePtr = Gen._load(VtableSlotPtr, name=f"vtable_ptr_{ClassName}_after_copy") VtableTyped: ir.Value = Gen.builder.bitcast(VtablePtr, ir.PointerType(VtableArrayType), name=f"vtable_typed_{ClassName}") MethodPtrAddr: ir.Value = Gen.builder.gep(VtableTyped, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), method_idx)], name=f"vmethod_slot_{AttrName}") FuncPtrI8: ir.Value = Gen.builder.bitcast(Value, ir.PointerType(ir.IntType(8)), name=f"func_ptr_i8_{AttrName}") Gen._store(FuncPtrI8, MethodPtrAddr) return offset: int | None = Gen._get_member_offset(AttrName, ClassName) StructType: ir.Type | None = Gen.structs.get(ClassName) if isinstance(StructType, ir.IdentifiedStructType) and (StructType.elements is None or len(StructType.elements) == 0): self.Trans.ImportHandler._TryLoadStructFromStub(ClassName, Gen) StructType = Gen.structs.get(ClassName) if isinstance(StructType, ir.IdentifiedStructType) and (StructType.elements is None or len(StructType.elements) == 0): return # 重新计算 offset：_TryLoadStructFromStub 刚加载了 struct body， # 之前 offset 可能因 struct opaque / class_members 不完整而返回 None offset = Gen._get_member_offset(AttrName, ClassName) # sha1 冲突修复：Gen.structs[ClassName] 可能是字段不全的版本（如 2 字段 Function # 来自 MetaType.py scope，而正确版本是 8 字段 Function 来自 __function.py）。 # _get_member_offset 通过 class_sha1_map 已返回正确的 offset（如 5）， # 但 StructType 可能只有 2 个 elements，导致 offset < len(elements) 失败。 # 在所有 structs 中查找同短名且字段最多的版本。 if offset is not None and isinstance(StructType, ir.IdentifiedStructType) and StructType.elements is not None and offset >= len(StructType.elements): _short: str = Gen._extract_short_name(StructType.name) _best: int = len(StructType.elements) for _cn, _st in Gen.structs.items(): if isinstance(_st, ir.IdentifiedStructType) and _st.elements is not None: if Gen._extract_short_name(_st.name) == _short and len(_st.elements) > _best: StructType = _st _best = len(_st.elements) # bitcast：当 ObjVal 的 pointee 是 opaque 或与 StructType 不是同一个类型对象 # （sha1 前缀不同但短名相同）时，需要 bitcast 到 StructType 才能正确 GEP if StructType is not None and StructType.elements is not None and isinstance(ObjVal.type, ir.PointerType) and isinstance(ObjVal.type.pointee, ir.IdentifiedStructType) and (ObjVal.type.pointee.elements is None or ObjVal.type.pointee != StructType): ObjVal = Gen.builder.bitcast(ObjVal, ir.PointerType(StructType), name=f"cast_{ClassName}") if offset is not None and StructType is not None and StructType.elements is not None and offset < len(StructType.elements): MemberPtr: ir.Value = Gen.builder.gep(ObjVal, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), offset)], name=AttrName) else: return byte_order: str = Gen.class_member_byteorders.get(ClassName, {}).get(AttrName, "") if byte_order == 'big': if StructType is None or StructType.elements is None or len(StructType.elements) == 0: return member_type: ir.Type = StructType.elements[offset] if isinstance(member_type, ir.IntType): Value = Gen._apply_bswap_if_big(Value, byte_order, f"bswap_store_{AttrName}") self._StoreWithCoerce(Value, MemberPtr) if not ClassName: imported_modules: list[str] | None = getattr(self.Trans, '_ImportedModules', None) resolved_mod: str = self.Trans.SymbolTable.resolve_alias(VarName) if imported_modules and (VarName in imported_modules or resolved_mod in imported_modules): PossibleKeys: list[str] = [f"{VarName}.{AttrName}", AttrName] for mod_name in imported_modules: if mod_name.endswith(f".{VarName}") or mod_name == VarName: key: str = f"{mod_name}.{AttrName}" if key not in PossibleKeys: PossibleKeys.append(key) for key in PossibleKeys: if key in Gen.module.globals: GVar: ir.GlobalVariable = Gen.module.globals[key] if isinstance(GVar, ir.Function): return if isinstance(GVar.type, ir.PointerType) and isinstance(GVar.type.pointee, (ir.IdentifiedStructType, ir.LiteralStructType, ir.ArrayType)): return self._StoreWithCoerce(Value, GVar) return ModuleSha1Map: dict[str, str] = Gen.ModuleSha1Map sha1_candidates: list[str] = [VarName, resolved_mod] for mod_name in imported_modules: if mod_name.endswith(f".{VarName}") or mod_name == VarName: if mod_name not in sha1_candidates: sha1_candidates.append(mod_name) for cand in sha1_candidates: sha1: str | None = ModuleSha1Map.get(cand) if sha1: prefixed: str = f"{sha1}.{AttrName}" if prefixed in Gen.module.globals: GVar2: ir.GlobalVariable = Gen.module.globals[prefixed] if isinstance(GVar2, ir.Function): return if isinstance(GVar2.type, ir.PointerType) and isinstance(GVar2.type.pointee, (ir.IdentifiedStructType, ir.LiteralStructType, ir.ArrayType)): return self._StoreWithCoerce(Value, GVar2) return elif isinstance(Target.value, ast.Attribute): ObjVal: ir.Value | None = self.Trans.ExprHandler.HandleExprLlvm(Target.value) if ObjVal and isinstance(ObjVal.type, ir.PointerType): pointee: ir.Type = ObjVal.type.pointee if isinstance(pointee, (ir.LiteralStructType, ir.IdentifiedStructType)): if isinstance(pointee, ir.IdentifiedStructType) and pointee.elements is None: for CN, ST in Gen.structs.items(): if isinstance(ST, ir.IdentifiedStructType) and ST.name == pointee.name and ST.elements is not None: pointee = ST ObjVal = Gen.builder.bitcast(ObjVal, ir.PointerType(ST), name=f"cast_{CN}") break found_match: bool = False for CN, ST in Gen.structs.items(): if pointee == ST or (isinstance(pointee, ir.IdentifiedStructType) and isinstance(ST, ir.IdentifiedStructType) and pointee.name == ST.name): found_match = True if ST.elements is None: self.Trans.ImportHandler._TryLoadStructFromStub(CN, Gen) ST = Gen.structs.get(CN, ST) if ST.elements is not None and isinstance(ObjVal.type, ir.PointerType) and isinstance(ObjVal.type.pointee, ir.IdentifiedStructType) and ObjVal.type.pointee.elements is None: ObjVal = Gen.builder.bitcast(ObjVal, ir.PointerType(ST), name=f"cast_{CN}") bitfield_offsets: dict[str, int] = Gen.class_member_bitoffsets.get(CN, {}) if AttrName in bitfield_offsets: self._store_bitfield_member(ObjVal, CN, AttrName, Value) return offset: int = Gen._get_member_offset(AttrName, CN) if offset is not None and ST.elements is not None and offset < len(ST.elements): MemberPtr: ir.Value = Gen.builder.gep(ObjVal, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), offset)], name=AttrName) self._StoreWithCoerce(Value, MemberPtr) break if not found_match: if isinstance(pointee, ir.IdentifiedStructType): matched_cn: str | None = None for CN in Gen.class_members: members: list[tuple[str, ir.Type]] = Gen.class_members[CN] for mname, mtype in members: if mname == AttrName: matched_cn = CN break if matched_cn: break if matched_cn and matched_cn in Gen.structs: ST: ir.Type = Gen.structs[matched_cn] if isinstance(ST, ir.IdentifiedStructType) and (ST.elements is None or len(ST.elements) == 0): self.Trans.ImportHandler._TryLoadStructFromStub(matched_cn, Gen) ST = Gen.structs.get(matched_cn, ST) if ST.elements is not None and isinstance(ObjVal.type, ir.PointerType) and isinstance(ObjVal.type.pointee, ir.IdentifiedStructType) and ObjVal.type.pointee.elements is None: ObjVal = Gen.builder.bitcast(ObjVal, ir.PointerType(ST), name=f"cast_{matched_cn}") offset: int = Gen._get_member_offset(AttrName, matched_cn) if offset is not None and ST.elements is not None and offset < len(ST.elements): MemberPtr: ir.Value = Gen.builder.gep(ObjVal, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), offset)], name=AttrName) self._StoreWithCoerce(Value, MemberPtr) return elif isinstance(Target.value, ast.Call): # Check if this is c.Deref(...) — we need the pointer, not the Loaded value ObjVal: ir.Value | None = None is_cderef: bool = (isinstance(Target.value.func, ast.Attribute) and isinstance(Target.value.func.value, ast.Name) and Target.value.func.value.id == 'c' and Target.value.func.attr == 'Deref' and Target.value.args) if is_cderef: # Get the pointer from c.Deref argument, don't Load the value deref_arg: ast.expr = Target.value.args[0] inner_val: ir.Value | None = self.HandleExprLlvm(deref_arg) if inner_val and isinstance(inner_val.type, ir.PointerType): if isinstance(inner_val.type.pointee, ir.PointerType): ObjVal = Gen._load(inner_val, name="deref_load_ptr") else: ObjVal = inner_val if ObjVal is None: ObjVal = self.Trans.ExprHandler.HandleExprLlvm(Target.value) if ObjVal and isinstance(ObjVal.type, ir.PointerType): pointee: ir.Type = ObjVal.type.pointee if isinstance(pointee, ir.PointerType): ObjVal = Gen._load(ObjVal, name="load_ptr_for_attr") pointee = ObjVal.type.pointee for CN, ST in Gen.structs.items(): if pointee == ST or (isinstance(pointee, ir.IdentifiedStructType) and isinstance(ST, ir.IdentifiedStructType) and pointee.name == ST.name): if isinstance(ST, ir.IdentifiedStructType) and (ST.elements is None or len(ST.elements) == 0): self.Trans.ImportHandler._TryLoadStructFromStub(CN, Gen) ST = Gen.structs.get(CN, ST) if ST.elements is not None and isinstance(ObjVal.type, ir.PointerType) and isinstance(ObjVal.type.pointee, ir.IdentifiedStructType) and ObjVal.type.pointee.elements is None: ObjVal = Gen.builder.bitcast(ObjVal, ir.PointerType(ST), name=f"cast_{CN}") bitfield_offsets: dict[str, int] = Gen.class_member_bitoffsets.get(CN, {}) if AttrName in bitfield_offsets: self._store_bitfield_member(ObjVal, CN, AttrName, Value) return offset: int = Gen._get_member_offset(AttrName, CN) if offset is not None and ST.elements is not None and offset < len(ST.elements): MemberPtr: ir.Value = Gen.builder.gep(ObjVal, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), offset)], name=AttrName) self._StoreWithCoerce(Value, MemberPtr) break elif isinstance(Target.value, ast.Subscript): SubPtr: ir.Value | None = self.Trans.ExprAttrHandle.HandleSubscriptPtrLlvm(Target.value) if SubPtr and isinstance(SubPtr.type, ir.PointerType): pointee: ir.Type = SubPtr.type.pointee if isinstance(Target.value.value, ast.Attribute): AttrNameSub: str = Target.value.value.attr if AttrNameSub == 'items' and 'Item' in Gen.structs: ObjValCast: ir.Value = Gen.builder.bitcast(SubPtr, ir.PointerType(Gen.structs['Item']), name=f"cast_Item") offset: int = Gen._get_member_offset(AttrName, 'Item') MemberPtr: ir.Value = Gen.builder.gep(ObjValCast, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), offset)], name=AttrName) self._StoreWithCoerce(Value, MemberPtr) return if BaseHandle._is_char_pointer(SubPtr): for CN, ST in Gen.structs.items(): ObjValCast: ir.Value = Gen.builder.bitcast(SubPtr, ir.PointerType(ST), name=f"cast_{CN}") offset: int = Gen._get_member_offset(AttrName, CN) MemberPtr: ir.Value = Gen.builder.gep(ObjValCast, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), offset)], name=AttrName) self._StoreWithCoerce(Value, MemberPtr) break elif isinstance(pointee, (ir.LiteralStructType, ir.IdentifiedStructType)): found: tuple[str, ir.Type] | None = Gen.find_struct_by_pointee(pointee) if found: CN: str = found[0] ST: ir.Type = found[1] if isinstance(ST, ir.IdentifiedStructType) and (ST.elements is None or len(ST.elements) == 0): self.Trans.ImportHandler._TryLoadStructFromStub(CN, Gen) ST = Gen.structs.get(CN, ST) if ST.elements is not None and isinstance(SubPtr.type, ir.PointerType) and isinstance(SubPtr.type.pointee, ir.IdentifiedStructType) and SubPtr.type.pointee.elements is None: SubPtr = Gen.builder.bitcast(SubPtr, ir.PointerType(ST), name=f"cast_{CN}") offset: int = Gen._get_member_offset(AttrName, CN) if offset is not None and ST.elements is not None and offset < len(ST.elements): MemberPtr: ir.Value = Gen.builder.gep(SubPtr, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), offset)], name=AttrName) self._StoreWithCoerce(Value, MemberPtr) elif isinstance(pointee, ir.PointerType): LoadedPtr: ir.Value = Gen._load(SubPtr, name=f"Load_{AttrName}_ptr") if isinstance(LoadedPtr.type, ir.PointerType) and isinstance(LoadedPtr.type.pointee, (ir.IdentifiedStructType, ir.LiteralStructType)): found: tuple[str, ir.Type] | None = Gen.find_struct_by_pointee(LoadedPtr.type.pointee) if found: CN: str = found[0] ST: ir.Type = found[1] offset: int = Gen._get_member_offset(AttrName, CN) MemberPtr: ir.Value = Gen.builder.gep(LoadedPtr, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), offset)], name=AttrName) self._StoreWithCoerce(Value, MemberPtr) def _StoreArrElemWithCoerceBswap(self, Value: ir.Value, Ptr: ir.Value, arr_byte_order: str) -> None: """对数组元素存储应用 bswap 后再 coerce 存储""" Gen: "Translator.LlvmGen" = self.Trans.LlvmGen Value = Gen._apply_bswap_if_big(Value, arr_byte_order, "bswap_arr_store") self._StoreWithCoerce(Value, Ptr) def _HandleSubscriptStoreLlvm(self, Target: ast.Subscript, Value: ir.Value) -> None: Gen: "Translator.LlvmGen" = self.Trans.LlvmGen # 查询数组元素字节序 arr_byte_order: str = '' if isinstance(Target.value, ast.Name) and Target.value.id in Gen.local_var_byteorders: arr_byte_order = Gen.local_var_byteorders[Target.value.id] if isinstance(Target.value, ast.Name): SubVarName: str = Target.value.id if SubVarName in Gen.var_const_flags: src_info: str = Gen._get_node_info() self.Trans.LogError(f"不能对 const 变量 '{SubVarName}' 的元素赋值{src_info}") ClassName: str | None = self.Trans.ExprHandler._get_var_class(Target.value, Gen) if ClassName and Gen._has_function(f'{ClassName}.__setitem__'): obj_val: ir.Value | None = self.Trans.ExprHandler.HandleExprLlvm(Target.value) idx_val: ir.Value | None = self.Trans.ExprHandler.HandleExprLlvm(Target.slice) if obj_val and idx_val: # 处理 obj_val 为 i8（整数）的情况：联合类型 | t.CPtr 降级后可能被 load 为 i8 if isinstance(obj_val.type, ir.IntType) and obj_val.type.width == 8: obj_val = Gen.builder.inttoptr(obj_val, ir.PointerType(ir.IntType(8)), name=f"i8_to_ptr_{ClassName}") if BaseHandle._is_char_pointer(obj_val): obj_val = Gen.builder.bitcast(obj_val, ir.PointerType(Gen.structs[ClassName]), name=f"cast_{ClassName}") setitem_args: list[ir.Value] = [obj_val, idx_val, Value] setitem_func_name: str = f'{ClassName}.__setitem__' setitem_args = Gen._apply_auto_addr(setitem_func_name, setitem_args) setitem_func: ir.Function = Gen._get_function(setitem_func_name) setitem_args = Gen._adjust_args(setitem_args, setitem_func) Gen.builder.call(setitem_func, setitem_args, name=f"call_{setitem_func_name}") return ValueVal: ir.Value | None = self.HandleExprLlvm(Target.value) IndexVal: ir.Value | None = self.HandleExprLlvm(Target.slice) if not ValueVal or not IndexVal: return # 当变量本身是二级指针（如 elem_ptr: T | t.CPtr = AST**）， # 且存储的值也是指针时，elem_ptr[i] = item 应直接存储指针（8 字节）， # 而非解引用后复制结构体（如 48 字节的 AST），避免对象切片 if isinstance(Target.value, ast.Name): VarName: str = Target.value.id if VarName in Gen.variables and Gen.variables[VarName] is not None: VarAlloca: ir.Value = Gen.variables[VarName] if isinstance(VarAlloca.type, ir.PointerType) and isinstance(VarAlloca.type.pointee, ir.PointerType): if (isinstance(ValueVal.type, ir.PointerType) and isinstance(Value.type, ir.PointerType) and isinstance(Value.type.pointee, (ir.IdentifiedStructType, ir.LiteralStructType))): if isinstance(IndexVal.type, ir.IntType) and IndexVal.type.width < 64: IndexVal = Gen.builder.zext(IndexVal, ir.IntType(64), name="zext_ptr_index_store") # ValueVal 是 AST*（加载自 elem_ptr 的基指针）， # 但 GEP 默认将其视为 AST 结构体数组。需要先 bitcast 为 # AST**（指向 AST* 的指针），让 GEP 正确索引 AST* 指针数组， # 而非 AST 结构体数组。然后用 builder.store 直接存储指针， # 避免 _store 的类型强制转换将指针解引用为结构体。 PtrToStruct: ir.Type = Value.type.pointee BaseAsPP: ir.Value = Gen.builder.bitcast(ValueVal, ir.PointerType(ir.PointerType(PtrToStruct)), name="cast_base_pp") ElemPtr: ir.Value = Gen.builder.gep(BaseAsPP, [IndexVal], name="subscript") Gen.builder.store(Value, ElemPtr) return if BaseHandle._is_char_pointer(IndexVal): Loaded_byte: ir.Value = Gen._load(IndexVal, name="Load_char_idx_store") IndexVal = Gen.builder.zext(Loaded_byte, ir.IntType(32), name="char_to_int_idx_store") if isinstance(ValueVal.type, ir.IntType): var_ptr: ir.Value | None = self._get_int_ptr(Target.value) if var_ptr: i8_ptr: ir.Value = Gen.builder.bitcast(var_ptr, ir.PointerType(ir.IntType(8)), name="int_to_i8ptr_store") if isinstance(IndexVal.type, ir.IntType) and IndexVal.type.width < 64: IndexVal = Gen.builder.zext(IndexVal, ir.IntType(64), name="zext_int_index_store") ptr: ir.Value = Gen.builder.gep(i8_ptr, [IndexVal], name="int_subscript_ptr_store") self._StoreWithCoerce(Value, ptr) return if isinstance(ValueVal.type, ir.PointerType) and isinstance(ValueVal.type.pointee, ir.PointerType): if isinstance(IndexVal.type, ir.IntType) and IndexVal.type.width < 64: IndexVal = Gen.builder.zext(IndexVal, ir.IntType(64), name="zext_ptr_index_store") ElemPtr: ir.Value = Gen.builder.gep(ValueVal, [IndexVal], name="subscript") self._StoreArrElemWithCoerceBswap(Value, ElemPtr, arr_byte_order) return if isinstance(ValueVal.type, ir.PointerType): pointee: ir.Type = ValueVal.type.pointee if isinstance(pointee, ir.ArrayType): zero: ir.Constant = ir.Constant(ir.IntType(32), 0) if isinstance(IndexVal.type, ir.IntType) and IndexVal.type.width != 32: if IndexVal.type.width < 32: IndexVal = Gen.builder.zext(IndexVal, ir.IntType(32), name="zext_arr_index") else: IndexVal = Gen.builder.trunc(IndexVal, ir.IntType(32), name="trunc_arr_index") ElemPtr: ir.Value = Gen.builder.gep(ValueVal, [zero, IndexVal], name="subscript") elif (isinstance(pointee, ir.IntType) and pointee.width == 8 and isinstance(Target.value, ast.Name) and (Gen.var_ptr_element.get(Target.value.id, False) or Gen.global_var_ptr_element.get(Target.value.id, False))): # 指针到 str/bytes 的变量 (BinOp 注解如 str | t.CPtr) # elem_ptr 是 i8* 但实际指向 i8* (字符串指针), elem_ptr[0] = item 应存储 8 字节 CastedPtrPtr: ir.Value = Gen.builder.bitcast(ValueVal, ir.PointerType(ir.PointerType(ir.IntType(8))), name="cast_pp_str_store") if isinstance(IndexVal.type, ir.IntType) and IndexVal.type.width < 64: IndexVal = Gen.builder.zext(IndexVal, ir.IntType(64), name="zext_pp_str_index_store") ElemPtr = Gen.builder.gep(CastedPtrPtr, [IndexVal], name="subscript") self._StoreArrElemWithCoerceBswap(Value, ElemPtr, arr_byte_order) return else: ElemPtr: ir.Value = Gen.builder.gep(ValueVal, [IndexVal], name="subscript") self._StoreArrElemWithCoerceBswap(Value, ElemPtr, arr_byte_order) elif isinstance(ValueVal.type, ir.ArrayType): zero: ir.Constant = ir.Constant(ir.IntType(32), 0) if isinstance(Target.value, ast.Name): VarName: str = Target.value.id if VarName in Gen.variables and Gen.variables[VarName] is not None: VarPtr: ir.Value = Gen.variables[VarName] if isinstance(VarPtr.type, ir.PointerType) and isinstance(VarPtr.type.pointee, ir.ArrayType): if isinstance(IndexVal.type, ir.IntType) and IndexVal.type.width != 32: if IndexVal.type.width < 32: IndexVal = Gen.builder.zext(IndexVal, ir.IntType(32), name="zext_arr_index") else: IndexVal = Gen.builder.trunc(IndexVal, ir.IntType(32), name="trunc_arr_index") ElemPtr: ir.Value = Gen.builder.gep(VarPtr, [zero, IndexVal], name="subscript") self._StoreArrElemWithCoerceBswap(Value, ElemPtr, arr_byte_order) return if isinstance(Target.value, ast.Subscript): InnerPtr: ir.Value | None = self.Trans.ExprAttrHandle.HandleSubscriptPtrLlvm(Target.value) if InnerPtr: if isinstance(IndexVal.type, ir.IntType) and IndexVal.type.width != 32: if IndexVal.type.width < 32: IndexVal = Gen.builder.zext(IndexVal, ir.IntType(32), name="zext_arr_index") else: IndexVal = Gen.builder.trunc(IndexVal, ir.IntType(32), name="trunc_arr_index") ElemPtr: ir.Value = Gen.builder.gep(InnerPtr, [zero, IndexVal], name="subscript") self._StoreArrElemWithCoerceBswap(Value, ElemPtr, arr_byte_order) return if isinstance(Target.value, ast.Attribute): AttrPtr: ir.Value | None = self.Trans.ExprAttrHandle._get_attr_ptr(Target.value) if AttrPtr and isinstance(AttrPtr.type, ir.PointerType) and isinstance(AttrPtr.type.pointee, ir.ArrayType): if isinstance(IndexVal.type, ir.IntType) and IndexVal.type.width != 32: if IndexVal.type.width < 32: IndexVal = Gen.builder.zext(IndexVal, ir.IntType(32), name="zext_arr_index") else: IndexVal = Gen.builder.trunc(IndexVal, ir.IntType(32), name="trunc_arr_index") ElemPtr: ir.Value = Gen.builder.gep(AttrPtr, [zero, IndexVal], name="subscript") self._StoreArrElemWithCoerceBswap(Value, ElemPtr, arr_byte_order) return arr_alloc: ir.AllocaInstr = Gen._allocaEntry(ValueVal.type, name="arr_subscript_tmp") Gen._store(ValueVal, arr_alloc) ElemPtr: ir.Value = Gen.builder.gep(arr_alloc, [zero, IndexVal], name="subscript") self._StoreArrElemWithCoerceBswap(Value, ElemPtr, arr_byte_order) ModifiedArr: ir.Value = Gen._load(arr_alloc, name="modified_arr") if isinstance(Target.value, ast.Subscript): OuterPtr: ir.Value | None = self.Trans.ExprAttrHandle.HandleSubscriptPtrLlvm(Target.value) if OuterPtr: Gen._store(ModifiedArr, OuterPtr) elif isinstance(Target.value, ast.Attribute): OuterPtr: ir.Value | None = self.Trans.ExprAttrHandle._get_attr_ptr(Target.value) if OuterPtr: Gen._store(ModifiedArr, OuterPtr) def _StoreWithCoerce(self, Value: ir.Value, Ptr: ir.Value) -> None: Gen: "Translator.LlvmGen" = self.Trans.LlvmGen if isinstance(Ptr.type, ir.PointerType): TargetType: ir.Type = Ptr.type.pointee if Value.type != TargetType: if isinstance(TargetType, ir.ArrayType) and isinstance(Value.type, ir.PointerType): ElemType: ir.Type = TargetType.element ElemSize: int = Gen._get_struct_size(ElemType) for i in range(TargetType.count): DstElem: ir.Value = Gen.builder.gep(Ptr, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), i)], name=f"arr_dst_{i}") SrcPtr: ir.Value if ElemSize == 1: SrcPtr = Gen.builder.gep(Value, [ir.Constant(ir.IntType(32), i)], name=f"arr_src_{i}") else: PtrInt: ir.Value = Gen.builder.ptrtoint(Value, ir.IntType(64)) Offset: ir.Constant = ir.Constant(ir.IntType(64), i * ElemSize) NewPtrInt: ir.Value = Gen.builder.add(PtrInt, Offset) SrcPtr = Gen.builder.inttoptr(NewPtrInt, ir.PointerType(ElemType), name=f"arr_src_{i}") SrcVal: ir.Value = Gen._load(SrcPtr, name=f"arr_elem_{i}") if SrcVal.type != ElemType: try: SrcVal = Gen.builder.bitcast(SrcVal, ElemType, name=f"arr_cast_{i}") except Exception: # 回退：bitcast 失败时跳过该元素 continue Gen._store(SrcVal, DstElem) return if isinstance(TargetType, ir.PointerType) and isinstance(Value, ir.Constant) and Value.constant is None: Value = ir.Constant(TargetType, None) elif isinstance(TargetType, ir.PointerType) and isinstance(Value.type, ir.PointerType): try: Value = Gen.builder.bitcast(Value, TargetType, name="null_ptr_bitcast") except Exception: # 回退：bitcast 失败时设为 null 常量 Value = ir.Constant(TargetType, None) else: Coerced: ir.Value | None = Gen._coerce_value(Value, TargetType) if Coerced is not None: Value = Coerced Gen._store(Value, Ptr) def _get_int_ptr(self, target: ast.expr) -> ir.Value | None: Gen: "Translator.LlvmGen" = self.Trans.LlvmGen if isinstance(target, ast.Name): VarName: str = target.id if VarName in Gen.variables and Gen.variables[VarName] is not None: VarPtr: ir.Value = Gen.variables[VarName] if isinstance(VarPtr.type, ir.PointerType): pointee: ir.Type = VarPtr.type.pointee if isinstance(pointee, ir.ArrayType): return Gen.builder.gep(VarPtr, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), 0)], name=f"arr_start_{VarName}") return None def _EmitGlobalAnnAssignLlvm(self, Node: ast.AnnAssign, Gen: "Translator.LlvmGen") -> None: if isinstance(Node.target, ast.Name): VarName: str = Node.target.id Info: "SymbolTable.SymbolInfo | None" = self.Trans.SymbolTable.lookup(VarName) if Info: if Info.IsTypedef: return parse_result = ParseListAnnotation(Node.annotation) if parse_result: elem_type_node: ast.expr = parse_result.elem_type_node ElemType, ElemTypeInfo = self.ResolveListElementType( elem_type_node, Gen, check_func_ptr=True, void_fallback_width=32, fallback_to_cint=True, ) if parse_result.is_pointer: # 单参数 list[type] → 指针 VarType: ir.Type = ir.PointerType(ElemType) if VarName not in Gen.variables and VarName not in Gen.module.globals: GlobalVar: ir.GlobalVariable = ir.GlobalVariable(Gen.module, VarType, name=VarName) GlobalVar.initializer = ir.Constant(VarType, None) Gen.variables[VarName] = GlobalVar if isinstance(elem_type_node, ast.Name) and elem_type_node.id in Gen.structs: Gen.global_struct_class[VarName] = elem_type_node.id return count_node: ast.expr | None = parse_result.count_node ArrayCount: int = self.ParseArrayCount(count_node, Gen, Node.value, mode='global') VarType = ir.ArrayType(ElemType, ArrayCount) if VarName not in Gen.variables and VarName not in Gen.module.globals: GlobalVar = ir.GlobalVariable(Gen.module, VarType, name=VarName) if isinstance(ElemType, ir.IdentifiedStructType): GlobalVar.linkage = 'common' elif Node.value and isinstance(Node.value, ast.Constant) and isinstance(Node.value.value, str): str_val: str = Node.value.value + '\x00' str_bytes: bytearray = bytearray(str_val, 'utf-8') if len(str_bytes) < ArrayCount: str_bytes.extend(b'\x00' * (ArrayCount - len(str_bytes))) try: GlobalVar.initializer = ir.Constant(VarType, str_bytes[:ArrayCount]) except Exception: # 回退：初始化常量失败时用零值 GlobalVar.initializer = Gen._zero_value_for_type(VarType) else: InitConstants: list[ir.Constant] | None = self.Trans._BuildArrayInitConstants(Node.value, ElemType, elem_type_node, ArrayCount, Gen, byte_order=ElemTypeInfo.ByteOrder if ElemTypeInfo else '') if InitConstants: GlobalVar.initializer = ir.Constant(VarType, InitConstants) elif ArrayCount > 256: GlobalVar.linkage = 'common' else: if self._contains_identified_struct(VarType): GlobalVar.linkage = 'common' else: GlobalVar.initializer = ir.Constant(VarType, [ir.Constant(ElemType, ir.Undefined)] * ArrayCount) Gen.variables[VarName] = GlobalVar if isinstance(elem_type_node, ast.Name) and elem_type_node.id in Gen.structs: Gen.global_struct_class[VarName] = elem_type_node.id return if isinstance(Node.annotation, ast.Name) and Node.annotation.id in Gen.structs: StructName: str = Node.annotation.id VarType: ir.Type = Gen.structs[StructName] if VarName not in Gen.variables and VarName not in Gen.module.globals: GlobalVar: ir.GlobalVariable = ir.GlobalVariable(Gen.module, VarType, name=VarName) if Node.value and isinstance(Node.value, ast.Call) and isinstance(Node.value.func, ast.Name) and Node.value.func.id == StructName: const: ir.Constant | None = self.Trans.ClassHandler._BuildStructConstant(Node.value, StructName, Gen) if const: GlobalVar.initializer = const else: GlobalVar.initializer = ir.Constant(VarType, None) else: GlobalVar.initializer = ir.Constant(VarType, None) Gen.variables[VarName] = GlobalVar Gen.global_struct_class[VarName] = StructName return TypeInfo: CTypeInfo | None = CTypeInfo.FromNode(Node.annotation, self.Trans.SymbolTable) IsCDefine: bool = False if TypeInfo and TypeInfo.BaseType: if isinstance(TypeInfo.BaseType, t._CTypedef): return if isinstance(TypeInfo.BaseType, t.CDefine): IsCDefine = True if not IsCDefine and self._IsTypedefAnnotation(Node.annotation): IsCDefine = True TTypeInfo: CTypeInfo | None = self.Trans.TypeMergeHandler.GetCTypeInfo(Node.annotation) if TTypeInfo: TTypeInfo.IsTypedef = True TTypeInfo.Name = VarName self.Trans.SymbolTable.insert(VarName, TTypeInfo) if IsCDefine: if Node.value: define_constants: dict[str, int | float] = vars(Gen).setdefault('_define_constants', {}) try: const_value: int | float | None = self._eval_const_expr(Node.value, Gen) if const_value is not None: define_constants[VarName] = const_value except Exception as _e: if _config_mode == "strict": self.Trans.LogWarning(f"异常被忽略: {_e}") return if TypeInfo is None: TypeInfo = CTypeInfo() TypeInfo.BaseType = t.CInt() VarType: ir.Type = Gen._ctype_to_llvm(TypeInfo) if isinstance(VarType, ir.VoidType): VarType = ir.IntType(32) if VarName in Gen.variables or VarName in Gen.module.globals: # 时序修复：第一遍创建全局时类未处理（SymbolTable 无枚举成员）， # initializer 回退为 0。第二遍类已处理，尝试用解析出的枚举值更新 initializer。 if VarName in Gen.module.globals and Node.value: existing: Any = Gen.module.globals[VarName] if isinstance(existing, ir.GlobalVariable) and isinstance(VarType, ir.IntType): new_init: ir.Constant | None = self._eval_global_const(Node.value, VarType, Gen) if new_init is not None: existing.initializer = new_init return if isinstance(VarType, (ir.IdentifiedStructType, ir.LiteralStructType)): GlobalVar: ir.GlobalVariable = ir.GlobalVariable(Gen.module, VarType, name=VarName) GlobalVar.initializer = ir.Constant(VarType, None) Gen.variables[VarName] = GlobalVar if TypeInfo and TypeInfo.IsStruct and TypeInfo.Name: Gen.global_struct_class[VarName] = TypeInfo.Name return GlobalVar: ir.GlobalVariable = ir.GlobalVariable(Gen.module, VarType, name=VarName) # 全局变量指针元素标志：bytes|t.CPtr 或 str|t.CPtr 注解的变量， # 使 var[index] 使用 8 字节指针步长（而非 1 字节字符步长） if isinstance(Node.annotation, ast.BinOp) and isinstance(Node.annotation.op, ast.BitOr): if AnnotationContainsName(Node.annotation, 'str') or AnnotationContainsName(Node.annotation, 'bytes'): Gen.global_var_ptr_element[VarName] = True if Node.value: if isinstance(Node.value, ast.Constant) and isinstance(Node.value.value, str) and isinstance(VarType, ir.PointerType): str_val: str = Node.value.value + '\x00' str_bytes: bytes = str_val.encode('utf-8') arr_type: ir.ArrayType = ir.ArrayType(ir.IntType(8), len(str_bytes)) str_gv_name: str = VarName + '_str' str_gv: ir.GlobalVariable if str_gv_name not in Gen.module.globals: str_gv = ir.GlobalVariable(Gen.module, arr_type, name=str_gv_name) str_gv.initializer = ir.Constant(arr_type, bytearray(str_bytes)) str_gv.linkage = 'internal' else: str_gv = Gen.module.globals[str_gv_name] ptr_type: ir.PointerType = ir.PointerType(ir.IntType(8)) ptr_gv: ir.GlobalVariable if VarName not in Gen.module.globals: ptr_gv = ir.GlobalVariable(Gen.module, ptr_type, name=VarName) ptr_gv.initializer = ir.Constant(ptr_type, str_gv) ptr_gv.linkage = 'internal' else: ptr_gv = Gen.module.globals[VarName] Gen.variables[VarName] = ptr_gv elif isinstance(VarType, ir.PointerType) and isinstance(VarType.pointee, ir.FunctionType) and isinstance(Node.value, ast.Name): # 函数指针赋值：f3: t.Callable[[int], int] = f RefName: str = Node.value.id SymInfo: Any = self.Trans.SymbolTable.lookup(RefName) if SymInfo and (SymInfo.IsFunction or SymInfo.IsFuncPtr): MangledName: str = Gen._mangle_func_name(RefName) if MangledName in Gen.module.globals: func: Any = Gen.module.globals[MangledName] if isinstance(func, ir.Function): GlobalVar.initializer = func else: if isinstance(VarType, ir.ArrayType) and isinstance(Node.value, (ast.List, ast.Set)): InitConstants: list[ir.Constant] | None = self.Trans._BuildMultiDimArrayInitConstants(Node.value, VarType, Gen) if InitConstants: GlobalVar.initializer = ir.Constant(VarType, InitConstants) else: if self._contains_identified_struct(VarType): GlobalVar.linkage = 'common' else: zv: ir.Constant | None = Gen._zero_value_for_type(VarType) if zv: GlobalVar.initializer = zv else: GlobalVar.linkage = 'common' else: init_val: ir.Constant | None = self._eval_global_const(Node.value, VarType, Gen) if init_val: GlobalVar.initializer = init_val elif isinstance(VarType, ir.BaseStructType): GlobalVar.linkage = 'common' else: GlobalVar.initializer = Gen._zero_value_for_type(VarType) else: if isinstance(VarType, ir.BaseStructType) or self._contains_identified_struct(VarType): GlobalVar.linkage = 'common' else: GlobalVar.initializer = Gen._zero_value_for_type(VarType) Gen.variables[VarName] = GlobalVar def _eval_global_const(self, value_node: ast.expr, var_type: ir.Type, Gen: "Translator.LlvmGen") -> ir.Constant | None: if isinstance(value_node, ast.Constant): if isinstance(value_node.value, bool): if isinstance(var_type, ir.IntType): return ir.Constant(var_type, int(value_node.value)) elif isinstance(value_node.value, int): if isinstance(var_type, ir.IntType): return ir.Constant(var_type, value_node.value) elif isinstance(var_type, (ir.FloatType, ir.DoubleType)): return ir.Constant(var_type, float(value_node.value)) elif isinstance(value_node.value, float): if isinstance(var_type, (ir.FloatType, ir.DoubleType)): return ir.Constant(var_type, value_node.value) elif isinstance(var_type, ir.IntType): return ir.Constant(var_type, int(value_node.value)) elif isinstance(value_node.value, str): return None # Handle type constructor calls like t.CDouble(1e-9), t.CFloat(3.14), t.CInt(42) if isinstance(value_node, ast.Call): inner_val: ir.Constant | None = self._eval_type_ctor_const(value_node, var_type, Gen) if inner_val is not None: return inner_val if isinstance(value_node, ast.UnaryOp) and isinstance(value_node.op, ast.USub): inner: ir.Constant | None = self._eval_global_const(value_node.operand, var_type, Gen) if inner: return ir.Constant(var_type, -inner.constant) # Handle enum member references like ASTVType.Module (ast.Attribute) if isinstance(value_node, ast.Attribute): attr_name: str = value_node.attr # 优先用带前缀的 key 查找（避免短名被同名函数/变量覆盖） if isinstance(value_node.value, ast.Name): FullKey2: str = f"{value_node.value.id}.{attr_name}" FullInfo: Any = self.Trans.SymbolTable.lookup(FullKey2) if FullInfo and FullInfo.IsEnumMember and isinstance(FullInfo.value, int): if isinstance(var_type, ir.IntType): return ir.Constant(var_type, FullInfo.value) SymInfo: Any = self.Trans.SymbolTable.lookup(attr_name) if SymInfo: if SymInfo.IsEnumMember and isinstance(SymInfo.value, int): if isinstance(var_type, ir.IntType): return ir.Constant(var_type, SymInfo.value) return None def _eval_type_ctor_const(self, call_node: ast.Call, var_type: ir.Type, Gen: "Translator.LlvmGen") -> ir.Constant | None: """Try to evaluate t.CDouble(val), t.CFloat(val), t.CInt(val) etc. as a compile-time constant.""" if not isinstance(call_node.func, ast.Attribute): return None if not isinstance(call_node.func.value, ast.Name): return None if call_node.func.value.id != 't': return None if not call_node.args or len(call_node.args) != 1: return None arg: ast.expr = call_node.args[0] # Recursively evaluate the argument as a constant arg_val: ir.Constant | None = self._eval_global_const(arg, var_type, Gen) if arg_val is not None: return arg_val return None def _store_bitfield_member(self, struct_ptr: ir.Value, ClassName: str, field_name: str, Value: ir.Value) -> bool: Gen: "Translator.LlvmGen" = self.Trans.LlvmGen bitfield_offsets: dict[str, int] = Gen.class_member_bitoffsets.get(ClassName, {}) bitfield_widths: dict[str, int] = Gen.class_member_bitfields.get(ClassName, {}) if field_name not in bitfield_offsets: return False bit_offset: int = bitfield_offsets[field_name] bit_width: int = bitfield_widths.get(field_name, 0) if bit_width == 0: return False struct_type: ir.Type | None = Gen.structs.get(ClassName) if struct_type is None or struct_type.elements is None or len(struct_type.elements) == 0: return False storage_type: ir.Type = struct_type.elements[0] member_ptr: ir.Value = Gen.builder.gep(struct_ptr, [ir.Constant(ir.IntType(32), 0), ir.Constant(ir.IntType(32), 0)], name=f"{field_name}_storage_ptr") old_val: ir.Value = Gen._load(member_ptr, name=f"{field_name}_old_storage") mask: int = (1 << bit_width) - 1 shifted_mask: int = mask << bit_offset inverted_mask: ir.Constant = ir.Constant(storage_type, ~shifted_mask & ((1 << storage_type.width) - 1)) cleared: ir.Value = Gen.builder.and_(old_val, inverted_mask, name=f"{field_name}_cleared") if isinstance(Value.type, ir.IntType) and Value.type.width < storage_type.width: if getattr(Value.type, 'is_signed', False): Value = Gen.builder.sext(Value, storage_type, name=f"{field_name}_sext_store") else: Value = Gen.builder.zext(Value, storage_type, name=f"{field_name}_zext_store") elif Value.type.width != storage_type.width: Value = Gen.builder.trunc(Value, storage_type, name=f"{field_name}_trunc_store") if Value.type.width > storage_type.width else Gen.builder.zext(Value, storage_type, name=f"{field_name}_zext_store") shifted_value: ir.Value = Gen.builder.shl(Value, ir.Constant(storage_type, bit_offset), name=f"{field_name}_shift_store") masked_value: ir.Value = Gen.builder.and_(shifted_value, ir.Constant(storage_type, shifted_mask), name=f"{field_name}_mask_store") new_val: ir.Value = Gen.builder.or_(cleared, masked_value, name=f"{field_name}_new_storage") Gen._store(new_val, member_ptr) return True def _CheckEnumMemberAssignment(self, node: ast.expr) -> str | None: def _get_attr_path(n: ast.expr) -> str | None: if isinstance(n, ast.Name): return n.id elif isinstance(n, ast.Attribute): return f"{_get_attr_path(n.value)}.{n.attr}" return None attr_path: str | None = _get_attr_path(node) if not attr_path: return None parts: list[str] = attr_path.split('.') if len(parts) >= 2: enum_class_name: str = parts[-2] member_name: str = parts[-1] qualified_name: str = f"{enum_class_name}.{member_name}" info: "SymbolTable.SymbolInfo | None" = self.Trans.SymbolTable.lookup(qualified_name) if info: if info.IsEnumMember and info.EnumName: return info.EnumName under_name: str = f"{enum_class_name}_{member_name}" if self.Trans.SymbolTable.has(under_name): info: "SymbolTable.SymbolInfo" = self.Trans.SymbolTable[under_name] if info.IsEnumMember and info.EnumName: return info.EnumName for key in self.Trans.SymbolTable: if key == member_name: info: "SymbolTable.SymbolInfo" = self.Trans.SymbolTable[key] if info.IsEnumMember and info.EnumName and info.EnumName == enum_class_name: return enum_class_name return None def _IsTypedefAnnotation(self, annotation: ast.expr) -> bool: if isinstance(annotation, ast.Attribute): if annotation.attr in ('CTypedef', 'CDefine'): return True if isinstance(annotation, ast.BinOp) and isinstance(annotation.op, ast.BitOr): return self._IsTypedefAnnotation(annotation.left) or self._IsTypedefAnnotation(annotation.right) if isinstance(annotation, ast.Subscript): return self._IsTypedefAnnotation(annotation.value) return False def _EmitGlobalAssignLlvm(self, Node: ast.Assign, Gen: "Translator.LlvmGen") -> None: if len(Node.targets) == 1 and isinstance(Node.targets[0], ast.Name): VarName: str = Node.targets[0].id if VarName in Gen.variables or VarName in Gen.module.globals: return if isinstance(Node.value, ast.Call) and isinstance(Node.value.func, ast.Name): FuncName: str = Node.value.func.id if FuncName in Gen.structs: IsUnion: bool = False TypeInfo: "SymbolTable.SymbolInfo | None" = self.Trans.SymbolTable.lookup(FuncName) if TypeInfo: if TypeInfo.IsUnion: IsUnion = True if IsUnion: StructType: ir.Type = Gen.structs[FuncName] StructPtrType: ir.PointerType = ir.PointerType(StructType) GlobalVar: ir.GlobalVariable = ir.GlobalVariable(Gen.module, StructPtrType, name=VarName) GlobalVar.initializer = ir.Constant(StructPtrType, None) Gen.variables[VarName] = GlobalVar Gen.global_struct_class[VarName] = FuncName return StructName: str = FuncName VarType: ir.Type = Gen.structs[StructName] GlobalVar: ir.GlobalVariable = ir.GlobalVariable(Gen.module, VarType, name=VarName) const: ir.Constant | None = self.Trans.ClassHandler._BuildStructConstant(Node.value, StructName, Gen) if const: GlobalVar.initializer = const else: GlobalVar.linkage = 'common' Gen.variables[VarName] = GlobalVar Gen.global_struct_class[VarName] = StructName return GlobalVar: ir.GlobalVariable = ir.GlobalVariable(Gen.module, ir.IntType(32), name=VarName) init_val: ir.Constant | None = self._eval_global_const(Node.value, ir.IntType(32), Gen) GlobalVar.initializer = init_val if init_val else ir.Constant(ir.IntType(32), 0) Gen.variables[VarName] = GlobalVar def _eval_const_expr(self, node: ast.expr, Gen: "Translator.LlvmGen") -> int | float | None: """计算常量表达式的值（委托到 ConstEvaluator）""" ctx: EvalContext = EvalContext(Gen=Gen, symtab=self.Trans.SymbolTable, translator=self.Trans) return ConstEvaluator.eval_full(node, ctx) def _eval_global_count(self, node: ast.expr, Gen: "Translator.LlvmGen") -> int | None: val: int | float | None = self._eval_const_expr(node, Gen) if val is not None: if isinstance(val, float): return int(val) if isinstance(val, int): return val return None