1365 lines
82 KiB
Plaintext
1365 lines
82 KiB
Plaintext
from stdint import *
|
|
import ast
|
|
import mlirlite
|
|
import memhub
|
|
import string
|
|
import viperlib
|
|
import lib.core.Gen.Translator as HT
|
|
import lib.core.Gen.GenApi as GenApi
|
|
import lib.core.Gen.GenTypes as GenTypes
|
|
from . import CallGenBase
|
|
|
|
|
|
# CallGenCBuiltin - c.*/asm/llvmir builtins
|
|
|
|
|
|
# Constants (kept consistent with TPC-side HandlesExprCall)
|
|
define _CEXPORT_MAX = 256
|
|
define ASM_MAX_OPERANDS = 16
|
|
# Clobber (~{...}) capacity is decoupled from the operand limit: vipersimd x8
|
|
# needs 21 entries, so ASM_MAX_OPERANDS=16 silently truncated it to 16.
|
|
define ASM_MAX_CLOBBERS = 32
|
|
# ASM_TEXT_BUF_SIZE holds the whole inline-asm template (a kernel switch statement
|
|
# template is already 2245 bytes). Overflow is fail-fast in _asm_append_cstr, never
|
|
# silently truncated: a cut-in-half template used to surface as a bogus llc parse
|
|
# error (e.g. a dangling `mov` with its operands chopped off).
|
|
define ASM_TEXT_BUF_SIZE = 8192
|
|
# Constraint buffer base size; the real capacity scales with operand/clobber count.
|
|
define ASM_CONST_BUF_SIZE = 512
|
|
define ASM_ARGS_BUF_SIZE = 512
|
|
define ASM_LINE_BUF_SIZE = 4096
|
|
define LLVMIR_MAX_OPS = 16
|
|
# Raw LLVM IR templates (c.LLVMIR) are multi-instruction text, not one-liners.
|
|
define LLVMIR_TEMPLATE_BUF = 4096
|
|
|
|
|
|
# CallGenCBuiltin - c.*/asm/llvmir builtins
|
|
novirtual class CallGenCBuiltin(CallGenBase.CallGenBase):
|
|
"""Translate c.* builtins, inline asm and raw LLVM IR."""
|
|
|
|
def translate_c_deref(self, pool: memhub.MemBuddy*, builder: mlirlite.IRBuilder*, mod: mlirlite.LLVMModule*, cl: ast.Call*, trans: HT.Translator* = None) -> mlirlite.Value*:
|
|
"""Load *ptr; the read width is decided solely by the pointee type."""
|
|
if cl is None: return None
|
|
cargs: list[ast.AST*]* = cl.args
|
|
if cargs is None or len(cargs) < 1: return None
|
|
ptr_val: mlirlite.Value* = self.Gen.ExprGen.translate_value(builder, pool, mod, cargs.get(0), None, 0, trans)
|
|
if ptr_val is None: return None
|
|
# rawptr[t.CVolatile | T] arg: the deref load in c.Deref(p) is volatile.
|
|
# 1 only when the arg resolves to VarEntry/FieldEntry, otherwise 0.
|
|
vol_deref: int = self.Gen.ExprGenAttr.base_pointee_is_volatile(pool, trans, cargs.get(0))
|
|
# Read width is decided solely by the pointer type: load one pointee
|
|
# element. i8 pointee always reads 1 byte; wider reads must cast first.
|
|
if self.Gen.ExprGenBase.is_ptr_type(ptr_val.Ty) != 0:
|
|
pointee: mlirlite.LLVMType* = ptr_val.Ty.Pointee
|
|
if pointee is not None: return mlirlite.build_load(builder, pointee, ptr_val, vol_deref)
|
|
# Non-pointer arg means degraded type inference: fail-fast, never read as i8.
|
|
self.Gen.TypeGenErr.fatal_error(cl, "c.Deref argument is not a pointer type (type inference degraded)", "TypeError")
|
|
return None
|
|
|
|
|
|
def translate_c_derefas(self, pool: memhub.MemBuddy*, builder: mlirlite.IRBuilder*, mod: mlirlite.LLVMModule*, cl: ast.Call*, trans: HT.Translator* = None) -> mlirlite.Value*:
|
|
"""Store val to ptr after a bitcast; the single-arg form reads *ptr."""
|
|
if cl is None: return None
|
|
cargs: list[ast.AST*]* = cl.args
|
|
if cargs is None or len(cargs) < 1: return None
|
|
# Single-arg form is a deref read: previously len<2 returned None and
|
|
# fell through to an undefined call @DerefAs, so reuse translate_c_deref.
|
|
if len(cargs) < 2: return self.translate_c_deref(pool, builder, mod, cl, trans)
|
|
|
|
ptr_val: mlirlite.Value* = self.Gen.ExprGen.translate_value(builder, pool, mod, cargs.get(0), None, 0, trans)
|
|
val: mlirlite.Value* = self.Gen.ExprGen.translate_value(builder, pool, mod, cargs.get(1), None, 0, trans)
|
|
if ptr_val is None or val is None: return None
|
|
|
|
# When both sides point to the same struct type, copy the struct value
|
|
# instead of the pointer, or a REnum variant tag would stay 0x0.
|
|
if self.Gen.ExprGenBase.is_ptr_type(ptr_val.Ty) != 0 and self.Gen.ExprGenBase.is_ptr_type(val.Ty) != 0:
|
|
ptr_pointee: mlirlite.LLVMType* = ptr_val.Ty.Pointee
|
|
val_pointee: mlirlite.LLVMType* = val.Ty.Pointee
|
|
if ptr_pointee is not None and val_pointee is not None:
|
|
# ptr_pointee is a registered struct type (checked via find_struct_by_type)
|
|
if self.Gen.StructGen.find_struct_by_type(ptr_pointee) is not None:
|
|
if ptr_pointee is val_pointee:
|
|
# Same struct type: load the value then store it (struct copy)
|
|
loaded: mlirlite.Value* = mlirlite.build_load(builder, val_pointee, val)
|
|
if loaded is not None:
|
|
# bitcast ptr to a struct pointer, then store
|
|
struct_ptr_ty: mlirlite.LLVMType* = mlirlite.Ptr(pool, ptr_pointee)
|
|
casted_ptr: mlirlite.Value* = mlirlite.build_bitcast(builder, ptr_val, struct_ptr_ty)
|
|
if casted_ptr is not None: mlirlite.build_store(builder, loaded, casted_ptr)
|
|
return val
|
|
|
|
# bitcast ptr to val.Ty* and store
|
|
val_ptr_ty: mlirlite.LLVMType* = mlirlite.Ptr(pool, val.Ty)
|
|
casted_ptr: mlirlite.Value* = mlirlite.build_bitcast(builder, ptr_val, val_ptr_ty)
|
|
if casted_ptr is None: return None
|
|
mlirlite.build_store(builder, val, casted_ptr)
|
|
return val
|
|
|
|
|
|
def translate_c_set(self, pool: memhub.MemBuddy*, builder: mlirlite.IRBuilder*, mod: mlirlite.LLVMModule*, cl: ast.Call*, trans: HT.Translator* = None) -> mlirlite.Value*:
|
|
"""Assign b to the lvalue a."""
|
|
if cl is None: return None
|
|
cargs: list[ast.AST*]* = cl.args
|
|
if cargs is None or len(cargs) < 2: return None
|
|
a_node: ast.AST* = cargs.get(0)
|
|
b_val: mlirlite.Value* = self.Gen.ExprGen.translate_value(builder, pool, mod, cargs.get(1), None, 0, trans)
|
|
if b_val is None: return None
|
|
|
|
# Form 0: c.Set(*ptr, b) -> *ptr = b. In an argument list a leading '*' is
|
|
# parsed as Starred (unpacking), so the new-syntax deref lvalue arrives as
|
|
# Starred(value=ptr) (UnaryOp/Deref also accepted). The old c.Deref(ptr)
|
|
# spelling is Form 1; without either the store is silently dropped.
|
|
ptr_expr: ast.AST* = None
|
|
if a_node is not None and a_node.kind() == ast.ASTKind.Starred:
|
|
st_a: ast.Starred* = ast.Starred*(a_node)
|
|
if st_a.value is not None: ptr_expr = st_a.value
|
|
elif a_node is not None and a_node.kind() == ast.ASTKind.UnaryOp:
|
|
uo_a: ast.UnaryOp* = ast.UnaryOp*(a_node)
|
|
if uo_a.op == ast.OpKind.Deref and uo_a.operand is not None: ptr_expr = uo_a.operand
|
|
if ptr_expr is not None:
|
|
ptr_a: mlirlite.Value* = self.Gen.ExprGen.translate_value(builder, pool, mod, ptr_expr, None, 0, trans)
|
|
if ptr_a is None or ptr_a.Ty is None or self.Gen.ExprGenBase.is_ptr_type(ptr_a.Ty) == 0:
|
|
self.Gen.TypeGenErr.fatal_error(a_node, "c.Set dereference target must be a pointer type (type inference degraded)", "TypeError")
|
|
pointee_a: mlirlite.LLVMType* = ptr_a.Ty.Pointee
|
|
if pointee_a is None:
|
|
self.Gen.TypeGenErr.fatal_error(a_node, "c.Set dereference target pointee type missing", "TypeError")
|
|
sv_a: mlirlite.Value* = self.Gen.ExprGenBase.coerce_to_type(builder, b_val, pointee_a, a_node, trans)
|
|
if sv_a is not None: mlirlite.build_store(builder, sv_a, ptr_a)
|
|
return b_val
|
|
|
|
# Form 1: c.Set(c.Deref(ptr), b) -> *ptr = b
|
|
if a_node is not None and a_node.kind() == ast.ASTKind.Call:
|
|
d_call: ast.Call* = ast.Call*(a_node)
|
|
if d_call.func is not None and d_call.func.kind() == ast.ASTKind.Attribute:
|
|
d_at: ast.Attribute* = ast.Attribute*(d_call.func)
|
|
if d_at.attr is not None and string.strcmp(d_at.attr, "Deref") == 0:
|
|
d_args: list[ast.AST*]* = d_call.args
|
|
if d_args is not None and len(d_args) >= 1:
|
|
ptr_val: mlirlite.Value* = self.Gen.ExprGen.translate_value(builder, pool, mod, d_args.get(0), None, 0, trans)
|
|
if ptr_val is not None:
|
|
# Store width follows the lvalue pointer's element type:
|
|
# coerce v to T first. Untyped (i8) pointers keep old behavior.
|
|
store_ptr: mlirlite.Value* = ptr_val
|
|
store_val: mlirlite.Value* = b_val
|
|
typed_elem: int = 0
|
|
elem_ty: mlirlite.LLVMType* = None
|
|
if ptr_val.Ty is not None: elem_ty = ptr_val.Ty.Pointee
|
|
if elem_ty is not None:
|
|
eb: int = self.Gen.ExprGenBase.get_llvm_type_bits(elem_ty)
|
|
if eb != 0 and eb != 8: typed_elem = 1
|
|
elif self.Gen.ExprGenBase.get_llvm_float_bits(elem_ty) != 0: typed_elem = 1
|
|
elif self.Gen.ExprGenBase.is_ptr_type(elem_ty) != 0: typed_elem = 1
|
|
elif self.Gen.ExprGenBase.is_array_type(elem_ty) != 0: typed_elem = 1
|
|
if typed_elem != 0: store_val = self.Gen.ExprGenBase.coerce_to_type(builder, b_val, elem_ty, a_node)
|
|
else:
|
|
val_ptr_ty: mlirlite.LLVMType* = mlirlite.Ptr(pool, b_val.Ty)
|
|
casted_ptr: mlirlite.Value* = mlirlite.build_bitcast(builder, ptr_val, val_ptr_ty)
|
|
if casted_ptr is not None: store_ptr = casted_ptr
|
|
if store_ptr is not None and store_val is not None: mlirlite.build_store(builder, store_val, store_ptr)
|
|
return b_val
|
|
# Other Call forms cannot be an lvalue
|
|
return b_val
|
|
|
|
# Form 2: assign to a Name variable
|
|
if a_node is not None and a_node.kind() == ast.ASTKind.Name and trans is not None:
|
|
nm_set: ast.Name* = ast.Name*(a_node)
|
|
if nm_set.id is not None:
|
|
if GenApi.is_global_name(trans, nm_set.id) != 0:
|
|
mod_alloca: mlirlite.Value* = self.Gen.VarGen.lookup_module_var(trans.SymTab, nm_set.id)
|
|
if mod_alloca is not None:
|
|
tg_ty: mlirlite.LLVMType* = None
|
|
if mod_alloca.Ty is not None: tg_ty = mod_alloca.Ty.Pointee
|
|
sv: mlirlite.Value* = b_val
|
|
if tg_ty is not None: sv = self.Gen.ExprGenBase.coerce_to_type(builder, b_val, tg_ty, a_node)
|
|
mlirlite.build_store(builder, sv, mod_alloca)
|
|
return b_val
|
|
if GenApi.is_nonlocal_name(trans, nm_set.id) != 0:
|
|
nl_ptr: mlirlite.Value* = self.Gen.StmtGenDecl.get_nonlocal_var_ptr(trans, nm_set.id)
|
|
if nl_ptr is not None:
|
|
nl_ty: mlirlite.LLVMType* = None
|
|
if nl_ptr.Ty is not None: nl_ty = nl_ptr.Ty.Pointee
|
|
sv2: mlirlite.Value* = b_val
|
|
if nl_ty is not None: sv2 = self.Gen.ExprGenBase.coerce_to_type(builder, b_val, nl_ty, a_node)
|
|
mlirlite.build_store(builder, sv2, nl_ptr)
|
|
return b_val
|
|
alloca: mlirlite.Value* = self.Gen.VarGen.get_or_create_sym(trans.SymTab, pool, builder, nm_set.id, b_val.Ty)
|
|
if alloca is not None:
|
|
ac_ty: mlirlite.LLVMType* = None
|
|
if alloca.Ty is not None: ac_ty = alloca.Ty.Pointee
|
|
sv3: mlirlite.Value* = b_val
|
|
if ac_ty is not None: sv3 = self.Gen.ExprGenBase.coerce_to_type(builder, b_val, ac_ty, a_node)
|
|
mlirlite.build_store(builder, sv3, alloca)
|
|
return b_val
|
|
return b_val
|
|
|
|
# Form 3: assign to an Attribute field
|
|
if a_node is not None and a_node.kind() == ast.ASTKind.Attribute:
|
|
field_ptr: mlirlite.Value* = self.Gen.ExprGenAttr.get_attribute_ptr(builder, pool, mod, a_node, trans)
|
|
if field_ptr is not None:
|
|
fd_ty: mlirlite.LLVMType* = None
|
|
if field_ptr.Ty is not None: fd_ty = field_ptr.Ty.Pointee
|
|
sv4: mlirlite.Value* = b_val
|
|
if fd_ty is not None: sv4 = self.Gen.ExprGenBase.coerce_to_type(builder, b_val, fd_ty, a_node)
|
|
mlirlite.build_store(builder, sv4, field_ptr)
|
|
return b_val
|
|
|
|
return b_val
|
|
|
|
|
|
def translate_c_addr(self, pool: memhub.MemBuddy*, builder: mlirlite.IRBuilder*, mod: mlirlite.LLVMModule*, cl: ast.Call*, trans: HT.Translator* = None) -> mlirlite.Value*:
|
|
"""Return the variable's alloca pointer without loading it."""
|
|
if cl is None: return None
|
|
cargs: list[ast.AST*]* = cl.args
|
|
if cargs is None or len(cargs) < 1: return None
|
|
|
|
arg0: ast.AST* = cargs.get(0)
|
|
if arg0 is None: return None
|
|
|
|
# Name form: c.Addr(var) returns the variable's alloca (no load)
|
|
if arg0.kind() == ast.ASTKind.Name:
|
|
nm: ast.Name* = ast.Name*(arg0)
|
|
if nm.id is None: return None
|
|
if trans is not None:
|
|
# self/cls object refs: c.Addr(self) returns the object pointer
|
|
# itself (Ptr(Struct)), not the address of the pointer variable.
|
|
if string.strcmp(nm.id, "self") == 0 or string.strcmp(nm.id, "cls") == 0:
|
|
self_entry: GenTypes.VarEntry* = self.Gen.VarGen.lookup_var_entry(trans.SymTab, nm.id)
|
|
if self_entry is not None and self_entry.Alloca is not None and self_entry.Alloca.Ty is not None:
|
|
match self_entry.Alloca.Ty:
|
|
case mlirlite.LLVMType.Ptr(inner1):
|
|
match inner1:
|
|
case mlirlite.LLVMType.Ptr(inner2):
|
|
obj_ty: mlirlite.LLVMType* = mlirlite.Ptr(pool, inner2)
|
|
return mlirlite.build_load(builder, obj_ty, self_entry.Alloca)
|
|
case _:
|
|
pass
|
|
case _:
|
|
pass
|
|
# nonlocal vars: read the object pointer from env (load_nonlocal_var);
|
|
# lookup_var must not hit the parent frame's alloca across functions.
|
|
if trans is not None:
|
|
if GenApi.is_nonlocal_name(trans, nm.id) != 0:
|
|
nl_addr: mlirlite.Value* = self.Gen.StmtGenDecl.load_nonlocal_var(trans, nm.id)
|
|
if nl_addr is not None: return nl_addr
|
|
return_var: mlirlite.Value* = self.Gen.VarGen.lookup_var(trans.SymTab, nm.id)
|
|
# REPL session var addressing: c.Addr(x) yields the ctx slot address.
|
|
# Runs after local lookup and before module globals/functions.
|
|
if return_var is None and trans is not None and trans.ReplCtx is not None:
|
|
sess_addr: mlirlite.Value* = self.Gen.VarGen.repl_try_addr(trans, nm.id, arg0)
|
|
if sess_addr is not None: return sess_addr
|
|
if return_var is None and mod is not None:
|
|
# Module global c.Addr(g) returns the global pointer; wrap via make_global_ref into a quoted Ptr(Ty) so ptrtoint renders correctly.
|
|
gv_ref_nm: mlirlite.GlobalVariable* = self.Gen.ExprGenAttr.find_global_in_module(mod, nm.id)
|
|
if gv_ref_nm is not None and gv_ref_nm.Name is not None and gv_ref_nm.Ty is not None: return_var = self.Gen.ExprGenAttr.make_global_ref(pool, gv_ref_nm.Name, gv_ref_nm.Ty)
|
|
# Module function address: c.Addr(fn) yields the symbol itself.
|
|
# Previously it returned None and fell through to an undefined @Addr.
|
|
if return_var is None and mod is not None:
|
|
f_addr_ref: mlirlite.Function* = self.Gen.CallGenBase.find_func_in_module(mod, nm.id)
|
|
if f_addr_ref is not None:
|
|
f_addr_name: str = mlirlite.function_get_name(f_addr_ref)
|
|
if f_addr_name is not None:
|
|
# Param chains and ParamNode chains are unrelated classes:
|
|
# rebuild via _FuncTyFromFunction.
|
|
fn_ty_ca: mlirlite.LLVMType* = self.Gen.CallGenBase._FuncTyFromFunction(pool, f_addr_ref)
|
|
# Quote the function reference name when needed (sha1-prefixed
|
|
# names start with a digit).
|
|
fnlen_ca: sizet = string.strlen(f_addr_name)
|
|
needs_q_ca: int = self.Gen.ClassGenVTable._vtable_name_needs_quote(f_addr_name)
|
|
faddr_buf_ca: str = pool.alloc(fnlen_ca + 4)
|
|
if faddr_buf_ca is not None and fn_ty_ca is not None:
|
|
if needs_q_ca != 0: viperlib.snprintf(faddr_buf_ca, fnlen_ca + 4, "@\"%s\"", f_addr_name)
|
|
else: viperlib.snprintf(faddr_buf_ca, fnlen_ca + 4, "@%s", f_addr_name)
|
|
return_var = mlirlite.SSAValue(pool, mlirlite.Ptr(pool, fn_ty_ca), faddr_buf_ca)
|
|
# Closure var: c.Addr(name) returns the closure object pointer (one load);
|
|
# the closure alloca is i8** holding {fn_ptr, env_ptr}.
|
|
if return_var is not None and return_var.Ty is not None:
|
|
if self.Gen.CallGenLeafKit.is_closure_name(nm.id) != 0:
|
|
i8_ty_cb: mlirlite.LLVMType* = mlirlite.Int8(pool)
|
|
i8_ptr_ty_cb: mlirlite.LLVMType* = mlirlite.Ptr(pool, i8_ty_cb)
|
|
return mlirlite.build_load(builder, i8_ptr_ty_cb, return_var)
|
|
if return_var is not None and return_var.Ty is not None:
|
|
# Object-pointer variable (alloca is Ptr(Ptr(Struct))): c.Addr(v)
|
|
# returns the object pointer itself (one load), like self/cls.
|
|
match return_var.Ty:
|
|
case mlirlite.LLVMType.Ptr(addr_inner1):
|
|
match addr_inner1:
|
|
case mlirlite.LLVMType.Ptr(addr_inner2):
|
|
match addr_inner2:
|
|
case mlirlite.LLVMType.Struct(_, _, _):
|
|
addr_obj_ty: mlirlite.LLVMType* = mlirlite.Ptr(pool, addr_inner2)
|
|
return mlirlite.build_load(builder, addr_obj_ty, return_var)
|
|
case _:
|
|
pass
|
|
case _:
|
|
pass
|
|
case _:
|
|
pass
|
|
return return_var
|
|
|
|
# Attribute form: c.Addr(self.field) takes the field address (GEP, no load),
|
|
# used by lock ops like atom.__atomic_test_and_set(c.Addr(self.lock_val)).
|
|
if arg0.kind() == ast.ASTKind.Attribute:
|
|
if trans is None: return None
|
|
at_addr: ast.Attribute* = ast.Attribute*(arg0)
|
|
if at_addr is None or at_addr.attr is None or at_addr.value is None: return None
|
|
# Cross-module function address c.Addr(serial.puts) yields the symbol; do not fall back to a global or it collides with the injected declare.
|
|
if at_addr.value.kind() == ast.ASTKind.Name and trans is not None and trans._imported_modules is not None:
|
|
mod_nm2: ast.Name* = ast.Name*(at_addr.value)
|
|
if mod_nm2.id is not None:
|
|
if self.Gen.ImportsGen.is_module_imported(trans._imported_modules, mod_nm2.id) != 0:
|
|
f_ref2: mlirlite.Function* = self.Gen.CallGenBase.find_func_in_module(mod, at_addr.attr)
|
|
if f_ref2 is not None:
|
|
fname2: str = mlirlite.function_get_name(f_ref2)
|
|
if fname2 is not None:
|
|
# Build an SSAValue with @ name (Ptr(FuncTy)): returning a Function node formats as void; rebuild the type from RetTy+Params (Params is a GSList, use function_get_param_head).
|
|
# Same: rebuild the ParamNode chain from the Function's Param chain.
|
|
fn_ty2: mlirlite.LLVMType* = self.Gen.CallGenBase._FuncTyFromFunction(pool, f_ref2)
|
|
# Quote the function reference name when needed
|
|
# (sha1-prefixed names start with a digit).
|
|
fnlen2: sizet = string.strlen(fname2)
|
|
needs_q2: int = self.Gen.ClassGenVTable._vtable_name_needs_quote(fname2)
|
|
faddr_buf2: str = pool.alloc(fnlen2 + 4)
|
|
if faddr_buf2 is not None and fn_ty2 is not None:
|
|
if needs_q2 != 0: viperlib.snprintf(faddr_buf2, fnlen2 + 4, "@\"%s\"", fname2)
|
|
else: viperlib.snprintf(faddr_buf2, fnlen2 + 4, "@%s", fname2)
|
|
return mlirlite.SSAValue(pool, mlirlite.Ptr(pool, fn_ty2), faddr_buf2)
|
|
else:
|
|
# Module-qualified global c.Addr(gdt.gp) yields the symbol; wrap via make_global_ref into a quoted Ptr(Ty) (a raw GlobalVariable renders "ptrtoint void").
|
|
g_ref2: mlirlite.GlobalVariable* = self.Gen.ExprGenAttr.find_global_in_module(mod, at_addr.attr)
|
|
if g_ref2 is not None and g_ref2.Name is not None and g_ref2.Ty is not None: return self.Gen.ExprGenAttr.make_global_ref(pool, g_ref2.Name, g_ref2.Ty)
|
|
# Resolve the base (Name var / Subscript array element) to an object pointer
|
|
obj_ptr: mlirlite.Value* = None
|
|
struct_ty: mlirlite.LLVMType* = None
|
|
if at_addr.value.kind() == ast.ASTKind.Subscript:
|
|
# c.Addr(s.threads[0].rsp): base is an array element, so GEP to the
|
|
# element first, then to the field; Name-only base used to fail.
|
|
sub_base: ast.Subscript* = ast.Subscript*(at_addr.value)
|
|
if sub_base.value is None or sub_base.slice is None: return None
|
|
bval: mlirlite.Value* = self.Gen.ExprGen.translate_value(builder, pool, mod, sub_base.value, None, 0, trans)
|
|
bidx: mlirlite.Value* = self.Gen.ExprGen.translate_value(builder, pool, mod, sub_base.slice, None, 0, trans)
|
|
if bval is None or bidx is None or bval.Ty is None: return None
|
|
bpointee: mlirlite.LLVMType* = None
|
|
if self.Gen.ExprGenBase.is_ptr_type(bval.Ty) != 0: bpointee = bval.Ty.Pointee
|
|
if bpointee is not None:
|
|
match bpointee:
|
|
case mlirlite.LLVMType.Array(bet, _):
|
|
obj_ptr = mlirlite.build_gep_array(builder, bpointee, bet, bval, bidx)
|
|
struct_ty = bet
|
|
case _:
|
|
return None
|
|
else: return None
|
|
elif at_addr.value.kind() == ast.ASTKind.Name:
|
|
self_nm: ast.Name* = ast.Name*(at_addr.value)
|
|
if self_nm.id is None: return None
|
|
self_alloca: mlirlite.Value* = self.Gen.VarGen.lookup_var(trans.SymTab, self_nm.id)
|
|
if self_alloca is None or self_alloca.Ty is None: return None
|
|
# Extract the struct type from the self type (Ptr(Struct) or Ptr(Ptr(Struct)))
|
|
self_is_ptr_ptr: int = 0
|
|
match self_alloca.Ty:
|
|
case mlirlite.LLVMType.Ptr(inner1):
|
|
match inner1:
|
|
case mlirlite.LLVMType.Ptr(inner2):
|
|
struct_ty = inner2
|
|
self_is_ptr_ptr = 1
|
|
case _:
|
|
struct_ty = inner1
|
|
case _:
|
|
return None
|
|
# When self_alloca is Ptr(Ptr(Struct)), load it into a Ptr(Struct) object pointer
|
|
obj_ptr = self_alloca
|
|
if self_is_ptr_ptr == 1:
|
|
self_obj_ty: mlirlite.LLVMType* = mlirlite.Ptr(pool, struct_ty)
|
|
obj_ptr = mlirlite.build_load(builder, self_obj_ty, self_alloca)
|
|
else: return None
|
|
if obj_ptr is None or struct_ty is None: return None
|
|
# Look up the field
|
|
fe_addr: GenTypes.FieldEntry* = self.Gen.StructGen.lookup_field(struct_ty, at_addr.attr)
|
|
if fe_addr is None: return None
|
|
# GEP to the field address
|
|
return mlirlite.build_gep_struct(builder, struct_ty, fe_addr.Ty, obj_ptr, fe_addr.Index)
|
|
|
|
# Subscript form: c.Addr(arr[i]) yields the element address (GEP, no load),
|
|
# via get_subscript_ptr which handles nested indices and ptr/str* forms.
|
|
if arg0.kind() == ast.ASTKind.Subscript:
|
|
if trans is None: return None
|
|
elem_ptr_ca: mlirlite.Value* = self.Gen.ExprGenName.get_subscript_ptr(builder, pool, mod, arg0, trans)
|
|
if elem_ptr_ca is not None: return elem_ptr_ca
|
|
# Fallback: single-level array base GEP (when get_subscript_ptr misses)
|
|
sub_addr: ast.Subscript* = ast.Subscript*(arg0)
|
|
if sub_addr is None or sub_addr.value is None or sub_addr.slice is None: return None
|
|
arr_val: mlirlite.Value* = self.Gen.ExprGen.translate_value(builder, pool, mod, sub_addr.value, None, 0, trans)
|
|
if arr_val is None or arr_val.Ty is None: return None
|
|
idx_val: mlirlite.Value* = self.Gen.ExprGen.translate_value(builder, pool, mod, sub_addr.slice, None, 0, trans)
|
|
if idx_val is None: return None
|
|
# Index zext is handled inside mlirlite.build_gep/build_gep_array (single source of truth).
|
|
arr_pointee_ca: mlirlite.LLVMType* = None
|
|
if self.Gen.ExprGenBase.is_ptr_type(arr_val.Ty) != 0: arr_pointee_ca = arr_val.Ty.Pointee
|
|
if arr_pointee_ca is not None:
|
|
match arr_pointee_ca:
|
|
case mlirlite.LLVMType.Array(arr_et_ca, _):
|
|
return mlirlite.build_gep_array(builder, arr_pointee_ca, arr_et_ca, arr_val, idx_val)
|
|
case _:
|
|
# Scalar/pointer elements (e.g. string a[4]) use a simple GEP;
|
|
# a scalar pointee previously fell through to an undefined @Addr.
|
|
return mlirlite.build_gep(builder, arr_pointee_ca, arr_val, idx_val)
|
|
return None
|
|
|
|
# Call form: c.Addr(expr) evaluates expr into a temp entry alloca and
|
|
# returns its address, e.g. tt: Coroutine = c.Addr(task()).
|
|
if arg0.kind() == ast.ASTKind.Call:
|
|
call_val: mlirlite.Value* = self.Gen.ExprGen.translate_value(builder, pool, mod, arg0, None, 0, trans)
|
|
if call_val is None or call_val.Ty is None: return None
|
|
tmp_slot: mlirlite.Value* = mlirlite.build_alloca_at_entry(builder, call_val.Ty)
|
|
if tmp_slot is None: return None
|
|
mlirlite.build_store(builder, call_val, tmp_slot)
|
|
return tmp_slot
|
|
|
|
# Other arg0 forms fail-fast: c.Addr is a compile-time instruction and must
|
|
# never fall through to a runtime call @Addr.
|
|
self.Gen.TypeGenErr.fatal_error(cl, f"c.Addr unsupported operand form (kind={arg0.kind()}); c.Addr only supports variable/global/function/array element/field", "TypeError")
|
|
return None
|
|
|
|
|
|
def translate_c_load(self, pool: memhub.MemBuddy*, builder: mlirlite.IRBuilder*, mod: mlirlite.LLVMModule*, cl: ast.Call*, trans: HT.Translator* = None) -> mlirlite.Value*:
|
|
"""Load *b and store it into *a."""
|
|
if cl is None: return None
|
|
cargs: list[ast.AST*]* = cl.args
|
|
if cargs is None or len(cargs) < 2: return None
|
|
dst_ptr: mlirlite.Value* = self.Gen.ExprGen.translate_value(builder, pool, mod, cargs.get(0), None, 0, trans)
|
|
src_ptr: mlirlite.Value* = self.Gen.ExprGen.translate_value(builder, pool, mod, cargs.get(1), None, 0, trans)
|
|
if dst_ptr is None or src_ptr is None: return None
|
|
# Determine the pointee type (prefer src's pointee, fall back to dst's)
|
|
pointee: mlirlite.LLVMType* = None
|
|
if src_ptr.Ty is not None: pointee = src_ptr.Ty.Pointee
|
|
if pointee is None and dst_ptr.Ty is not None: pointee = dst_ptr.Ty.Pointee
|
|
if pointee is None: return None
|
|
# bitcast src to pointee* and load
|
|
target_ptr_ty: mlirlite.LLVMType* = mlirlite.Ptr(pool, pointee)
|
|
src_cast: mlirlite.Value* = mlirlite.build_bitcast(builder, src_ptr, target_ptr_ty)
|
|
if src_cast is None: return None
|
|
loaded: mlirlite.Value* = mlirlite.build_load(builder, pointee, src_cast)
|
|
if loaded is None: return None
|
|
# bitcast dst to pointee* and store
|
|
dst_cast: mlirlite.Value* = mlirlite.build_bitcast(builder, dst_ptr, target_ptr_ty)
|
|
if dst_cast is None: return None
|
|
mlirlite.build_store(builder, loaded, dst_cast)
|
|
return loaded
|
|
|
|
|
|
def _asm_append_cstr(self, dst: str, dst_size: sizet, src: str, what: str = "inline asm"):
|
|
"""Append the C string src to the end of dst; fail-fast when it does not fit.
|
|
|
|
Silent truncation corrupts the generated text (a template cut in the middle of an
|
|
instruction yields a bogus llc/verifier error much later), so overflow is reported
|
|
here at the real cause.
|
|
"""
|
|
if dst is None or src is None: return
|
|
dlen: sizet = string.strlen(dst)
|
|
slen: sizet = string.strlen(src)
|
|
# Capacity includes the terminating NUL.
|
|
if dlen + slen + 1 > dst_size:
|
|
self.Gen.TypeGenErr.fatal_error(None, f"{what} text does not fit the fixed buffer: {dlen} byte(s) already used + {slen} byte(s) to append + 1 NUL > capacity {dst_size} byte(s); shorten or split the template (silent truncation would generate broken code)", "TypeError")
|
|
return
|
|
i: sizet = 0
|
|
while i < slen:
|
|
dst[dlen + i] = src[i]
|
|
i += 1
|
|
dst[dlen + i] = '\0'
|
|
|
|
|
|
def _asm_mangle_global_symbols(self, pool: memhub.MemBuddy*, asm_text: str, asm_size: sizet, mod: mlirlite.LLVMModule*) -> str:
|
|
"""Fail-fast when inline asm references a SHA1-mangled module global by bare name."""
|
|
if asm_text is None or mod is None: return asm_text
|
|
src_len: sizet = string.strlen(asm_text)
|
|
if src_len == 0: return asm_text
|
|
out: str = pool.alloc(asm_size * 2)
|
|
if out is None: return asm_text
|
|
out[0] = '\0'
|
|
out_pos: sizet = 0
|
|
i: sizet = 0
|
|
while i < src_len:
|
|
matched: int = 0
|
|
cur: mlirlite.GlobalVariable* = mod.GlobalHead
|
|
while cur is not None:
|
|
gname: str = cur.Name
|
|
if gname is not None and string.strchr(gname, 46) is not None:
|
|
dot_g: str = string.strchr(gname, 46)
|
|
bare_g: str = dot_g + 1
|
|
bare_len: sizet = string.strlen(bare_g)
|
|
if bare_len > 0 and i + bare_len <= src_len:
|
|
if string.strncmp(asm_text + i, bare_g, bare_len) == 0:
|
|
# Word boundary: neighbors are not identifier chars (letter/digit/_)
|
|
prev_ok: int = 1
|
|
next_ok: int = 1
|
|
if i > 0:
|
|
prev_ch: char = asm_text[i - 1]
|
|
if (prev_ch >= 'a' and prev_ch <= 'z') or (prev_ch >= 'A' and prev_ch <= 'Z') or (prev_ch >= '0' and prev_ch <= '9') or prev_ch == '_': prev_ok = 0
|
|
if i + bare_len < src_len:
|
|
next_ch: char = asm_text[i + bare_len]
|
|
if (next_ch >= 'a' and next_ch <= 'z') or (next_ch >= 'A' and next_ch <= 'Z') or (next_ch >= '0' and next_ch <= '9') or next_ch == '_': next_ok = 0
|
|
if prev_ok != 0 and next_ok != 0:
|
|
# fail-fast: an asm template referencing a SHA1-mangled
|
|
# global cannot be used in LLVM MC; mark it t.CExport.
|
|
self.Gen.TypeGenErr.fatal_error(None, f"Global symbol '{bare_g}' referenced by the asm template has a SHA1 mangling prefix ({gname}); inline assembly must reference bare-name symbols, so mark that global definition as t.CExport", "TypeError")
|
|
return asm_text
|
|
cur = cur.Next
|
|
if matched == 0:
|
|
# The output buffer is 2x the input, so this cannot trigger for a plain copy;
|
|
# keep it fail-fast so a future longer rewrite (mangled expansion) can never
|
|
# silently drop characters.
|
|
if out_pos + 1 >= asm_size * 2:
|
|
self.Gen.TypeGenErr.fatal_error(None, f"inline asm text overflows the symbol-mangling buffer (capacity {asm_size * 2} byte(s)); shorten the template", "TypeError")
|
|
return asm_text
|
|
out[out_pos] = asm_text[i]
|
|
out_pos += 1
|
|
i += 1
|
|
out[out_pos] = '\0'
|
|
return out
|
|
|
|
|
|
def _asm_escape_for_ir(self, pool: memhub.MemBuddy*, src: str) -> str:
|
|
"""Escape asm text for an LLVM IR string literal."""
|
|
if src is None: return None
|
|
slen: sizet = string.strlen(src)
|
|
buf: str = pool.alloc(slen * 4 + 8)
|
|
if buf is None: return None
|
|
pos: sizet = 0
|
|
for ch in src:
|
|
if ch == '\n':
|
|
buf[pos] = '\\'
|
|
pos += 1
|
|
buf[pos] = '0'
|
|
pos += 1
|
|
buf[pos] = 'A'
|
|
pos += 1
|
|
elif ch == '"':
|
|
buf[pos] = '\\'
|
|
pos += 1
|
|
buf[pos] = '2'
|
|
pos += 1
|
|
buf[pos] = '2'
|
|
pos += 1
|
|
elif ch == '\\':
|
|
buf[pos] = '\\'
|
|
pos += 1
|
|
buf[pos] = '5'
|
|
pos += 1
|
|
buf[pos] = 'C'
|
|
pos += 1
|
|
else:
|
|
buf[pos] = ch
|
|
pos += 1
|
|
buf[pos] = '\0'
|
|
return buf
|
|
|
|
|
|
def _resolve_register(self, attr_name: str) -> str:
|
|
"""Map an ASM_DESCR attribute name to its constraint string."""
|
|
if attr_name is None: return ""
|
|
|
|
# Clobber constraints
|
|
if string.strcmp(attr_name, "CLOBBER_MEMORY") == 0: return "memory"
|
|
if string.strcmp(attr_name, "CLOBBER_CC") == 0: return "cc"
|
|
if string.strcmp(attr_name, "CLOBBER_RAX") == 0: return "rax"
|
|
if string.strcmp(attr_name, "CLOBBER_RBX") == 0: return "rbx"
|
|
if string.strcmp(attr_name, "CLOBBER_RCX") == 0: return "rcx"
|
|
if string.strcmp(attr_name, "CLOBBER_RDX") == 0: return "rdx"
|
|
if string.strcmp(attr_name, "CLOBBER_RSI") == 0: return "rsi"
|
|
if string.strcmp(attr_name, "CLOBBER_RDI") == 0: return "rdi"
|
|
if string.strcmp(attr_name, "CLOBBER_RBP") == 0: return "rbp"
|
|
if string.strcmp(attr_name, "CLOBBER_RSP") == 0: return "rsp"
|
|
if string.strcmp(attr_name, "CLOBBER_R8") == 0: return "r8"
|
|
if string.strcmp(attr_name, "CLOBBER_R9") == 0: return "r9"
|
|
if string.strcmp(attr_name, "CLOBBER_R10") == 0: return "r10"
|
|
if string.strcmp(attr_name, "CLOBBER_R11") == 0: return "r11"
|
|
if string.strcmp(attr_name, "CLOBBER_R12") == 0: return "r12"
|
|
if string.strcmp(attr_name, "CLOBBER_R13") == 0: return "r13"
|
|
if string.strcmp(attr_name, "CLOBBER_R14") == 0: return "r14"
|
|
if string.strcmp(attr_name, "CLOBBER_R15") == 0: return "r15"
|
|
if string.strcmp(attr_name, "CLOBBER_EAX") == 0: return "eax"
|
|
if string.strcmp(attr_name, "CLOBBER_EBX") == 0: return "ebx"
|
|
if string.strcmp(attr_name, "CLOBBER_ECX") == 0: return "ecx"
|
|
if string.strcmp(attr_name, "CLOBBER_EDX") == 0: return "edx"
|
|
if string.strcmp(attr_name, "CLOBBER_ESI") == 0: return "esi"
|
|
if string.strcmp(attr_name, "CLOBBER_EDI") == 0: return "edi"
|
|
if string.strcmp(attr_name, "CLOBBER_DX") == 0: return "dx"
|
|
if string.strcmp(attr_name, "CLOBBER_AX") == 0: return "ax"
|
|
if string.strcmp(attr_name, "CLOBBER_CX") == 0: return "cx"
|
|
if string.strcmp(attr_name, "CLOBBER_SI") == 0: return "si"
|
|
if string.strcmp(attr_name, "CLOBBER_DI") == 0: return "di"
|
|
# 8-bit register clobbers (aligned with the t.py constant set): a missing AL
|
|
# dropped ~{al} on `rep stosb` and let LLVM clobber the page address in RAX.
|
|
if string.strcmp(attr_name, "CLOBBER_AL") == 0: return "al"
|
|
if string.strcmp(attr_name, "CLOBBER_AH") == 0: return "ah"
|
|
if string.strcmp(attr_name, "CLOBBER_BL") == 0: return "bl"
|
|
if string.strcmp(attr_name, "CLOBBER_BH") == 0: return "bh"
|
|
if string.strcmp(attr_name, "CLOBBER_CL") == 0: return "cl"
|
|
if string.strcmp(attr_name, "CLOBBER_CH") == 0: return "ch"
|
|
if string.strcmp(attr_name, "CLOBBER_DL") == 0: return "dl"
|
|
if string.strcmp(attr_name, "CLOBBER_DH") == 0: return "dh"
|
|
|
|
# Output constraints
|
|
if string.strcmp(attr_name, "OUTPUT_REG") == 0: return "=r"
|
|
if string.strcmp(attr_name, "OUTPUT_MEM") == 0: return "=m"
|
|
if string.strcmp(attr_name, "OUTPUT_EAX") == 0: return "=a"
|
|
if string.strcmp(attr_name, "OUTPUT_EBX") == 0: return "=b"
|
|
if string.strcmp(attr_name, "OUTPUT_ECX") == 0: return "=c"
|
|
if string.strcmp(attr_name, "OUTPUT_EDX") == 0: return "=d"
|
|
if string.strcmp(attr_name, "OUTPUT_ESI") == 0: return "=S"
|
|
if string.strcmp(attr_name, "OUTPUT_EDI") == 0: return "=D"
|
|
if string.strcmp(attr_name, "OUTPUT_RAX") == 0: return "=a"
|
|
if string.strcmp(attr_name, "OUTPUT_RBX") == 0: return "=b"
|
|
if string.strcmp(attr_name, "OUTPUT_RCX") == 0: return "=c"
|
|
if string.strcmp(attr_name, "OUTPUT_RDX") == 0: return "=d"
|
|
if string.strcmp(attr_name, "OUTPUT_RSI") == 0: return "=S"
|
|
if string.strcmp(attr_name, "OUTPUT_RDI") == 0: return "=D"
|
|
|
|
# Input/register constraints
|
|
if string.strcmp(attr_name, "REG_ANY") == 0: return "r"
|
|
if string.strcmp(attr_name, "REG_EAX") == 0: return "a"
|
|
if string.strcmp(attr_name, "REG_EBX") == 0: return "b"
|
|
if string.strcmp(attr_name, "REG_ECX") == 0: return "c"
|
|
if string.strcmp(attr_name, "REG_EDX") == 0: return "d"
|
|
if string.strcmp(attr_name, "REG_ESI") == 0: return "S"
|
|
if string.strcmp(attr_name, "REG_EDI") == 0: return "D"
|
|
if string.strcmp(attr_name, "REG_RAX") == 0: return "a"
|
|
if string.strcmp(attr_name, "REG_RBX") == 0: return "b"
|
|
if string.strcmp(attr_name, "REG_RCX") == 0: return "c"
|
|
if string.strcmp(attr_name, "REG_RDX") == 0: return "d"
|
|
if string.strcmp(attr_name, "REG_RSI") == 0: return "S"
|
|
if string.strcmp(attr_name, "REG_RDI") == 0: return "D"
|
|
|
|
if string.strcmp(attr_name, "INPUT_REG") == 0: return "r"
|
|
if string.strcmp(attr_name, "INPUT_MEM") == 0: return "m"
|
|
if string.strcmp(attr_name, "INPUT_EAX") == 0: return "a"
|
|
if string.strcmp(attr_name, "INPUT_EBX") == 0: return "b"
|
|
if string.strcmp(attr_name, "INPUT_ECX") == 0: return "c"
|
|
if string.strcmp(attr_name, "INPUT_EDX") == 0: return "d"
|
|
if string.strcmp(attr_name, "INPUT_ESI") == 0: return "S"
|
|
if string.strcmp(attr_name, "INPUT_EDI") == 0: return "D"
|
|
if string.strcmp(attr_name, "INPUT_RAX") == 0: return "a"
|
|
if string.strcmp(attr_name, "INPUT_RBX") == 0: return "b"
|
|
if string.strcmp(attr_name, "INPUT_RCX") == 0: return "c"
|
|
if string.strcmp(attr_name, "INPUT_RDX") == 0: return "d"
|
|
if string.strcmp(attr_name, "INPUT_RSI") == 0: return "S"
|
|
if string.strcmp(attr_name, "INPUT_RDI") == 0: return "D"
|
|
|
|
return ""
|
|
|
|
|
|
def _resolve_asm_descr(self, pool: memhub.MemBuddy*, node: ast.AST*) -> str:
|
|
"""Resolve a constraint expression recursively into its constraint string."""
|
|
if node is None: return ""
|
|
|
|
k: int = node.kind()
|
|
|
|
# BinOp with BitOr: concatenate left and right
|
|
if k == ast.ASTKind.BinOp:
|
|
bop: ast.BinOp* = ast.BinOp*(node)
|
|
if bop.op == ast.OpKind.BitOr:
|
|
left_str: str = self._resolve_asm_descr(pool, bop.left)
|
|
right_str: str = self._resolve_asm_descr(pool, bop.right)
|
|
llen: sizet = string.strlen(left_str)
|
|
rlen: sizet = string.strlen(right_str)
|
|
buf: str = pool.alloc(llen + rlen + 1)
|
|
if buf is None: return ""
|
|
string.strcpy(buf, left_str)
|
|
for i in range(int(rlen)): buf[llen + i] = right_str[i]
|
|
buf[llen + rlen] = '\0'
|
|
return buf
|
|
return ""
|
|
|
|
# Attribute: ASM_DESCR.XXX
|
|
if k == ast.ASTKind.Attribute:
|
|
at: ast.Attribute* = ast.Attribute*(node)
|
|
if at.value is not None and at.value.kind() == ast.ASTKind.Name:
|
|
mod_nm2: ast.Name* = ast.Name*(at.value)
|
|
if mod_nm2.id is not None and string.strcmp(mod_nm2.id, "ASM_DESCR") == 0: return self._resolve_register(at.attr)
|
|
return ""
|
|
|
|
# 裸枚举名（不带 ASM_DESCR. / t. 前缀）：`op=[CLOBBER_MEMORY, CLOBBER_RAX]`。
|
|
# 只有确实解析成 ASM_DESCR 成员时才接受（_resolve_register 对未知名给不出非空串），
|
|
# 否则返回空串交由调用方按"未知约束"处理，避免把普通变量名误当约束串。
|
|
if k == ast.ASTKind.Name:
|
|
nm_b: ast.Name* = ast.Name*(node)
|
|
if nm_b.id is not None:
|
|
rs_b: str = self._resolve_register(nm_b.id)
|
|
if rs_b is not None and rs_b[0] != '\0': return rs_b
|
|
return ""
|
|
|
|
# Constant: string constant
|
|
if k == ast.ASTKind.Constant:
|
|
cn: ast.Constant* = ast.Constant*(node)
|
|
if cn.const_kind == ast.CONST_STR: return cn.str_val
|
|
return ""
|
|
|
|
return ""
|
|
|
|
|
|
def _asm_get_operand(self, base: GenTypes.AsmOperand*, idx: int) -> GenTypes.AsmOperand*:
|
|
"""Return a pointer to operand idx in the operand array."""
|
|
entry_size: sizet = GenTypes.AsmOperand.__sizeof__()
|
|
entry_addr: uint64 = uint64(base) + idx * entry_size
|
|
return GenTypes.AsmOperand*(entry_addr)
|
|
|
|
|
|
def _asm_is_c_call(self, node: ast.Call*) -> str:
|
|
"""Return the canonical name for an operand-marker call, else None."""
|
|
if node is None or node.func is None: return None
|
|
if node.func.kind() == ast.ASTKind.Name:
|
|
nm: ast.Name* = ast.Name*(node.func)
|
|
if nm.id is not None:
|
|
if string.strcmp(nm.id, "asminp") == 0: return "AsmInp"
|
|
if string.strcmp(nm.id, "asmout") == 0: return "AsmOut"
|
|
if string.strcmp(nm.id, "irinp") == 0: return "LInp"
|
|
if string.strcmp(nm.id, "irout") == 0: return "LOut"
|
|
return None
|
|
return None
|
|
|
|
|
|
def _asm_name_is_mangled(self, name: str) -> int:
|
|
"""Return 1 when the LLVM name carries a SHA1-mangled prefix."""
|
|
if name is None: return 0
|
|
n: str = name
|
|
nlen: sizet = string.strlen(n)
|
|
# Strip the '@"..."' wrapper (reference name)
|
|
if nlen >= 3 and n[0] == '@' and n[1] == '"' and n[nlen - 1] == '"': n = n + 2
|
|
elif nlen >= 1 and n[0] == '@': n = n + 1
|
|
if GenApi.sha1_prefix_len(n) != 0: return 1
|
|
return 0
|
|
|
|
|
|
def _asm_add_operand(self, operands: GenTypes.AsmOperand*, count: int, val: mlirlite.Value*, constraint: str, is_output: int) -> int:
|
|
"""Append an operand, dedup by value and direction, and return the new count."""
|
|
# fail-fast: the operand array is fixed at ASM_MAX_OPERANDS slots; dropping the
|
|
# excess operand here would silently change the generated constraint/argument lists.
|
|
if count >= ASM_MAX_OPERANDS:
|
|
self.Gen.TypeGenErr.fatal_error(None, f"inline asm has more than {ASM_MAX_OPERANDS} operands (compiler limit); split the asm block into several ones", "TypeError")
|
|
return count
|
|
# fail-fast: AsmInp/AsmOut operands must not carry SHA1-mangled symbols;
|
|
# LLVM MC cannot parse digit-leading names, so mark them t.CExport.
|
|
if val is not None and val.Name is not None:
|
|
if self._asm_name_is_mangled(val.Name) != 0: self.Gen.TypeGenErr.fatal_error(None, f"__asm__ operand (AsmInp/AsmOut) does not allow a symbol with a SHA1 mangling prefix '{val.Name}'; mark the corresponding function/global definition as t.CExport (bare name)", "TypeError")
|
|
if val is not None:
|
|
for ei in range(int(count)):
|
|
eop: GenTypes.AsmOperand* = self._asm_get_operand(operands, ei)
|
|
if eop is not None and eop.Value == val and eop.IsOutput == is_output: return count
|
|
op: GenTypes.AsmOperand* = self._asm_get_operand(operands, count)
|
|
op.Value = val
|
|
# Default constraint: AsmInp(reg) with one arg has no descr, causing an
|
|
# llc mismatch. Input defaults to "r", output to "=r".
|
|
if constraint is None or string.strlen(constraint) == 0:
|
|
if is_output != 0: constraint = "=r"
|
|
else: constraint = "r"
|
|
op.Constraint = constraint
|
|
op.IsOutput = is_output
|
|
return count + 1
|
|
|
|
|
|
def translate_c_asm(self, pool: memhub.MemBuddy*, builder: mlirlite.IRBuilder*, mod: mlirlite.LLVMModule*, cl: ast.Call*, trans: HT.Translator* = None) -> mlirlite.Value*:
|
|
"""Translate an __asm__ block and return its result Value or None."""
|
|
if cl is None: return None
|
|
|
|
cargs: list[ast.AST*]* = cl.args
|
|
if cargs is None or len(cargs) < 1: return None
|
|
|
|
# Allocate the operand array
|
|
operand_size: sizet = GenTypes.AsmOperand.__sizeof__()
|
|
operands: GenTypes.AsmOperand* = pool.alloc(operand_size * ASM_MAX_OPERANDS)
|
|
if operands is None: return None
|
|
string.memset(operands, 0, operand_size * ASM_MAX_OPERANDS)
|
|
|
|
# Clobber name array: 8 bytes/slot, capacity ASM_MAX_CLOBBERS, decoupled from
|
|
# the operand limit; a single-level rawptr buffer with slots cast to str*.
|
|
clobbers: rawptr = pool.alloc(8 * ASM_MAX_CLOBBERS)
|
|
if clobbers is None: return None
|
|
string.memset(clobbers, 0, 8 * ASM_MAX_CLOBBERS)
|
|
|
|
# Allocate the asm text buffer
|
|
asm_text: str = pool.alloc(ASM_TEXT_BUF_SIZE)
|
|
if asm_text is None: return None
|
|
asm_text[0] = '\0'
|
|
|
|
operand_count: int = 0
|
|
clobber_count: int = 0
|
|
fv_count: int = 0
|
|
# Cache the first output's element type at collection time (like the Python
|
|
# reference), avoiding an unstable re-read that left ret as Void.
|
|
out_ret_ty_first: mlirlite.LLVMType* = None
|
|
# Cache all output element types in order (multi-output like vrandom's
|
|
# val+ok), taken from the alloca pointee at collection time.
|
|
out_ptys: sizet* = pool.alloc(8 * ASM_MAX_OPERANDS)
|
|
out_pty_n: int = 0
|
|
if out_ptys is not None: string.memset(out_ptys, 0, 8 * ASM_MAX_OPERANDS)
|
|
|
|
# fv index array: records each FormattedValue's original operand index
|
|
fv_orig_indices: int* = pool.alloc(4 * ASM_MAX_OPERANDS)
|
|
if fv_orig_indices is None: return None
|
|
string.memset(fv_orig_indices, 0, 4 * ASM_MAX_OPERANDS)
|
|
|
|
# 1. Parse the asm template (JoinedStr or Constant) - first pass: collect
|
|
# operands only; $N placeholders are numbered after reordering.
|
|
tmpl_node: ast.AST* = cargs.get(0)
|
|
if tmpl_node is not None:
|
|
tk: int = tmpl_node.kind()
|
|
|
|
if tk == ast.ASTKind.JoinedStr:
|
|
js: ast.JoinedStr* = ast.JoinedStr*(tmpl_node)
|
|
jvalues: list[ast.AST*]* = js.values
|
|
if jvalues is not None:
|
|
jvlen: sizet = len(jvalues)
|
|
for vi in range(int(jvlen)):
|
|
part: ast.AST* = jvalues.get(vi)
|
|
if part is None: continue
|
|
pk: int = part.kind()
|
|
|
|
if pk == ast.ASTKind.FormattedValue:
|
|
fv: ast.FormattedValue* = ast.FormattedValue*(part)
|
|
fexpr: ast.AST* = fv.value
|
|
if fexpr is None or fexpr.kind() != ast.ASTKind.Call: continue
|
|
fcall: ast.Call* = ast.Call*(fexpr)
|
|
attr_nm: str = self._asm_is_c_call(fcall)
|
|
if attr_nm is None: continue
|
|
|
|
is_out: int = 0
|
|
if string.strcmp(attr_nm, "AsmOut") == 0: is_out = 1
|
|
elif string.strcmp(attr_nm, "AsmInp") == 0: is_out = 0
|
|
else: continue
|
|
|
|
fargs: list[ast.AST*]* = fcall.args
|
|
if fargs is None or len(fargs) < 1: continue
|
|
|
|
val_node: ast.AST* = fargs.get(0)
|
|
cons_str: str = ""
|
|
if len(fargs) >= 2: cons_str = self._resolve_asm_descr(pool, fargs.get(1))
|
|
|
|
if is_out != 0:
|
|
# Output: get the variable alloca (Name local/global or Attribute field address)
|
|
if val_node is None: continue
|
|
alloca: mlirlite.Value* = None
|
|
if val_node.kind() == ast.ASTKind.Name:
|
|
nm: ast.Name* = ast.Name*(val_node)
|
|
if nm.id is None: continue
|
|
alloca = self.Gen.VarGen.lookup_var(trans.SymTab, nm.id)
|
|
if alloca is None:
|
|
# Module-level global (lookup_var only sees locals):
|
|
# fall back to make_global_ref into a quoted Ptr(Ty).
|
|
gv_asm: mlirlite.GlobalVariable* = self.Gen.ExprGenAttr.find_global_in_module(mod, nm.id)
|
|
if gv_asm is not None and gv_asm.Name is not None and gv_asm.Ty is not None: alloca = self.Gen.ExprGenAttr.make_global_ref(pool, gv_asm.Name, gv_asm.Ty)
|
|
elif val_node.kind() == ast.ASTKind.Attribute:
|
|
# AsmOut(p.pml4_root): GEP to the field address, like
|
|
# translate_c_addr's Attribute branch; skipping it left a void operand.
|
|
at_a: ast.Attribute* = ast.Attribute*(val_node)
|
|
if at_a.attr is not None and at_a.value is not None and at_a.value.kind() == ast.ASTKind.Name:
|
|
base_nm_a: ast.Name* = ast.Name*(at_a.value)
|
|
if base_nm_a.id is not None:
|
|
base_alloca_a: mlirlite.Value* = self.Gen.VarGen.lookup_var(trans.SymTab, base_nm_a.id)
|
|
if base_alloca_a is not None and base_alloca_a.Ty is not None:
|
|
struct_ty_a: mlirlite.LLVMType* = None
|
|
self_is_ptr_ptr_a: int = 0
|
|
match base_alloca_a.Ty:
|
|
case mlirlite.LLVMType.Ptr(inner1):
|
|
match inner1:
|
|
case mlirlite.LLVMType.Ptr(inner2):
|
|
struct_ty_a = inner2
|
|
self_is_ptr_ptr_a = 1
|
|
case _:
|
|
struct_ty_a = inner1
|
|
case _:
|
|
pass
|
|
if struct_ty_a is not None:
|
|
fe_a: GenTypes.FieldEntry* = self.Gen.StructGen.lookup_field(struct_ty_a, at_a.attr)
|
|
if fe_a is not None:
|
|
obj_ptr_a: mlirlite.Value* = base_alloca_a
|
|
if self_is_ptr_ptr_a == 1: obj_ptr_a = mlirlite.build_load(builder, mlirlite.Ptr(pool, struct_ty_a), base_alloca_a)
|
|
if obj_ptr_a is not None: alloca = mlirlite.build_gep_struct(builder, struct_ty_a, fe_a.Ty, obj_ptr_a, fe_a.Index)
|
|
if alloca is None: continue
|
|
operand_count = self._asm_add_operand(operands, operand_count, alloca, cons_str, 1)
|
|
if out_ret_ty_first is None and alloca is not None and alloca.Ty is not None and alloca.Ty.Pointee != 0: out_ret_ty_first = alloca.Ty.Pointee
|
|
if out_ptys is not None and out_pty_n < ASM_MAX_OPERANDS and alloca is not None and alloca.Ty is not None and alloca.Ty.Pointee != 0:
|
|
out_ptys[out_pty_n] = uint64(alloca.Ty.Pointee)
|
|
out_pty_n += 1
|
|
else:
|
|
# Input: translate the value
|
|
ival: mlirlite.Value* = self.Gen.ExprGen.translate_value(builder, pool, mod, val_node, None, 0, trans)
|
|
if ival is None: continue
|
|
operand_count = self._asm_add_operand(operands, operand_count, ival, cons_str, 0)
|
|
|
|
# Record the fv's original operand index
|
|
if fv_count < ASM_MAX_OPERANDS:
|
|
fv_orig_indices[fv_count] = operand_count - 1
|
|
fv_count += 1
|
|
|
|
# 2. Parse keyword args out=/inp=/op=/clobber=
|
|
keywords: list[ast.AST*]* = cl.keywords
|
|
if keywords is not None:
|
|
kwlen: sizet = len(keywords)
|
|
for ki in range(int(kwlen)):
|
|
kw: ast.Keyword* = ast.Keyword*(keywords.get(ki))
|
|
if kw is None or kw.arg is None or kw.value is None: continue
|
|
kwk: int = kw.value.kind()
|
|
|
|
if string.strcmp(kw.arg, "out") == 0:
|
|
# Output operand list
|
|
if kwk != ast.ASTKind.List: continue
|
|
out_lst: ast.List* = ast.List*(kw.value)
|
|
out_elts: list[ast.AST*]* = out_lst.elts
|
|
if out_elts is None: continue
|
|
oelen: sizet = len(out_elts)
|
|
for oi in range(int(oelen)):
|
|
oelt: ast.AST* = out_elts.get(oi)
|
|
if oelt is None or oelt.kind() != ast.ASTKind.Call: continue
|
|
ocall: ast.Call* = ast.Call*(oelt)
|
|
oattr: str = self._asm_is_c_call(ocall)
|
|
if oattr is None or string.strcmp(oattr, "AsmOut") != 0: continue
|
|
oargs: list[ast.AST*]* = ocall.args
|
|
if oargs is None or len(oargs) < 1: continue
|
|
oval_node: ast.AST* = oargs.get(0)
|
|
ocons: str = ""
|
|
if len(oargs) >= 2: ocons = self._resolve_asm_descr(pool, oargs.get(1))
|
|
if oval_node is None or oval_node.kind() != ast.ASTKind.Name: continue
|
|
onm: ast.Name* = ast.Name*(oval_node)
|
|
if onm.id is None: continue
|
|
oalloca: mlirlite.Value* = self.Gen.VarGen.lookup_var(trans.SymTab, onm.id)
|
|
if oalloca is None: continue
|
|
operand_count = self._asm_add_operand(operands, operand_count, oalloca, ocons, 1)
|
|
if out_ret_ty_first is None and oalloca is not None and oalloca.Ty is not None and oalloca.Ty.Pointee != 0: out_ret_ty_first = oalloca.Ty.Pointee
|
|
if out_ptys is not None and out_pty_n < ASM_MAX_OPERANDS and oalloca is not None and oalloca.Ty is not None and oalloca.Ty.Pointee != 0:
|
|
out_ptys[out_pty_n] = uint64(oalloca.Ty.Pointee)
|
|
out_pty_n += 1
|
|
|
|
elif string.strcmp(kw.arg, "inp") == 0 or string.strcmp(kw.arg, "inputs") == 0:
|
|
# Input operand list
|
|
if kwk != ast.ASTKind.List: continue
|
|
in_lst: ast.List* = ast.List*(kw.value)
|
|
in_elts: list[ast.AST*]* = in_lst.elts
|
|
if in_elts is None: continue
|
|
ielen: sizet = len(in_elts)
|
|
for ii in range(int(ielen)):
|
|
ielt: ast.AST* = in_elts.get(ii)
|
|
if ielt is None or ielt.kind() != ast.ASTKind.Call: continue
|
|
icall: ast.Call* = ast.Call*(ielt)
|
|
iattr: str = self._asm_is_c_call(icall)
|
|
if iattr is None or string.strcmp(iattr, "AsmInp") != 0: continue
|
|
iargs: list[ast.AST*]* = icall.args
|
|
if iargs is None or len(iargs) < 1: continue
|
|
ival_node: ast.AST* = iargs.get(0)
|
|
icons: str = ""
|
|
if len(iargs) >= 2: icons = self._resolve_asm_descr(pool, iargs.get(1))
|
|
ival2: mlirlite.Value* = self.Gen.ExprGen.translate_value(builder, pool, mod, ival_node, None, 0, trans)
|
|
if ival2 is None: continue
|
|
operand_count = self._asm_add_operand(operands, operand_count, ival2, icons, 0)
|
|
|
|
elif string.strcmp(kw.arg, "op") == 0 or string.strcmp(kw.arg, "clobber") == 0:
|
|
# Clobber list
|
|
if kwk != ast.ASTKind.List: continue
|
|
cl_lst: ast.List* = ast.List*(kw.value)
|
|
cl_elts: list[ast.AST*]* = cl_lst.elts
|
|
if cl_elts is None: continue
|
|
clen: sizet = len(cl_elts)
|
|
for ci in range(int(clen)):
|
|
celt: ast.AST* = cl_elts.get(ci)
|
|
if celt is None: continue
|
|
cstr: str = self._resolve_asm_descr(pool, celt)
|
|
if cstr is None or cstr[0] == '\0': continue
|
|
# fail-fast: the clobber slot array is fixed at ASM_MAX_CLOBBERS;
|
|
# dropping the excess would silently weaken the clobber list.
|
|
if clobber_count >= ASM_MAX_CLOBBERS:
|
|
self.Gen.TypeGenErr.fatal_error(celt, f"inline asm has more than {ASM_MAX_CLOBBERS} clobbers (compiler limit); remove duplicates or split the asm block", "TypeError")
|
|
return None
|
|
cl_addr: uint64 = uint64(clobbers) + clobber_count * 8
|
|
cl_ptr: str* = (str*)(cl_addr)
|
|
cl_ptr[0] = cstr
|
|
clobber_count += 1
|
|
|
|
# 3. Parse the second positional arg as the clobber list
|
|
if len(cargs) >= 2:
|
|
pos_node: ast.AST* = cargs.get(1)
|
|
if pos_node is not None and pos_node.kind() == ast.ASTKind.List:
|
|
pos_lst: ast.List* = ast.List*(pos_node)
|
|
pos_elts: list[ast.AST*]* = pos_lst.elts
|
|
if pos_elts is not None:
|
|
plen: sizet = len(pos_elts)
|
|
for pi in range(int(plen)):
|
|
pelt: ast.AST* = pos_elts.get(pi)
|
|
if pelt is None: continue
|
|
pstr: str = self._resolve_asm_descr(pool, pelt)
|
|
if pstr is None or pstr[0] == '\0': continue
|
|
if clobber_count >= ASM_MAX_CLOBBERS:
|
|
self.Gen.TypeGenErr.fatal_error(pelt, f"inline asm has more than {ASM_MAX_CLOBBERS} clobbers (compiler limit); remove duplicates or split the asm block", "TypeError")
|
|
return None
|
|
pcl_addr: uint64 = uint64(clobbers) + clobber_count * 8
|
|
pcl_ptr: str* = (str*)(pcl_addr)
|
|
pcl_ptr[0] = pstr
|
|
clobber_count += 1
|
|
|
|
# 4. Count outputs/inputs and determine the return type
|
|
output_count: int = 0
|
|
input_count: int = 0
|
|
first_output_idx: int = -1
|
|
for oi2 in range(int(operand_count)):
|
|
op2: GenTypes.AsmOperand* = self._asm_get_operand(operands, oi2)
|
|
if op2.IsOutput != 0:
|
|
if first_output_idx < 0: first_output_idx = oi2
|
|
output_count += 1
|
|
else: input_count += 1
|
|
|
|
# Determine the return type. Multiple outputs return an anonymous struct
|
|
# {ty1, ty2, ...}; LLVM asm requires output constraints == struct elements.
|
|
ret_ty: mlirlite.LLVMType* = mlirlite.Void(pool)
|
|
if output_count > 0 and first_output_idx >= 0:
|
|
if output_count > 1:
|
|
# The multi-output struct field list is a ParamNode chain (not
|
|
# Function*); annotating it as Function* broke implicit conversion.
|
|
out_pn_head: mlirlite.ParamNode* = None
|
|
out_pn_last: mlirlite.ParamNode* = None
|
|
out_pn_n: int = 0
|
|
out_seq: int = 0
|
|
for oi5 in range(int(operand_count)):
|
|
op5: GenTypes.AsmOperand* = self._asm_get_operand(operands, oi5)
|
|
if op5 is None or op5.IsOutput == 0: continue
|
|
pty5: mlirlite.LLVMType* = None
|
|
# Prefer the type cached in order at collection, then fall back to reading the slot
|
|
if out_ptys is not None and out_seq < out_pty_n: pty5 = mlirlite.LLVMType*(out_ptys[out_seq])
|
|
elif op5.Value is not None and op5.Value.Ty is not None and op5.Value.Ty.Pointee != 0: pty5 = op5.Value.Ty.Pointee
|
|
out_seq += 1
|
|
if pty5 is None: continue
|
|
pn5: mlirlite.ParamNode* = mlirlite.new_param_node(pool, pty5)
|
|
if pn5 is not None:
|
|
if out_pn_head is None: out_pn_head = pn5
|
|
else: out_pn_last.Next = pn5
|
|
out_pn_last = pn5
|
|
out_pn_n += 1
|
|
if out_pn_head is not None and out_pn_n > 0: ret_ty = mlirlite.Struct(pool, out_pn_head, out_pn_n, None)
|
|
else:
|
|
self.Gen.TypeGenErr.fatal_error(cl, "__asm__ output operand type missing (variable alloca type degraded)", "TypeError")
|
|
ret_ty = mlirlite.Int32(pool)
|
|
else:
|
|
out_op: GenTypes.AsmOperand* = self._asm_get_operand(operands, first_output_idx)
|
|
out_pt: mlirlite.LLVMType* = None
|
|
# Prefer the element type cached at collection, then fall back to reading the slot
|
|
if out_ret_ty_first is not None: out_pt = out_ret_ty_first
|
|
elif out_op is not None and out_op.Value is not None and out_op.Value.Ty is not None and out_op.Value.Ty.Pointee != 0: out_pt = out_op.Value.Ty.Pointee
|
|
if out_pt is not None: ret_ty = out_pt
|
|
else:
|
|
self.Gen.TypeGenErr.fatal_error(cl, "__asm__ output operand type missing (variable alloca type degraded)", "TypeError")
|
|
ret_ty = mlirlite.Int32(pool)
|
|
|
|
# Determine void directly from output_count to avoid match type issues
|
|
is_void: int = 1
|
|
if output_count > 0: is_void = 0
|
|
|
|
# [FIX] Outputs exist but ret is still Void: rescan all output operands
|
|
# before emitting, otherwise a named void asm reaches llc. Else fail-fast.
|
|
if is_void == 0:
|
|
match ret_ty:
|
|
case mlirlite.LLVMType.Void():
|
|
ret_re: mlirlite.LLVMType* = None
|
|
for re_i in range(int(operand_count)):
|
|
re_op: GenTypes.AsmOperand* = self._asm_get_operand(operands, re_i)
|
|
if re_op is None or re_op.IsOutput == 0: continue
|
|
if re_op.Value is not None and re_op.Value.Ty is not None and re_op.Value.Ty.Pointee != 0:
|
|
ret_re = re_op.Value.Ty.Pointee
|
|
break
|
|
if ret_re is None: self.Gen.TypeGenErr.fatal_error(cl, "__asm__ output operand type missing (variable alloca type degraded)", "TypeError")
|
|
ret_ty = ret_re
|
|
case _:
|
|
pass
|
|
|
|
# 4.5 Reorder operands: outputs first, inputs after (LLVM IR requirement).
|
|
# new_order maps new->orig; orig_to_new maps orig->new for $N numbering.
|
|
new_order: int* = pool.alloc(4 * (operand_count + 1))
|
|
orig_to_new: int* = pool.alloc(4 * (operand_count + 1))
|
|
if new_order is None or orig_to_new is None: return None
|
|
|
|
new_idx: int = 0
|
|
# Outputs first
|
|
for oi3 in range(int(operand_count)):
|
|
op3: GenTypes.AsmOperand* = self._asm_get_operand(operands, oi3)
|
|
if op3.IsOutput != 0:
|
|
new_order[new_idx] = oi3
|
|
new_idx += 1
|
|
# Then inputs
|
|
for oi4 in range(int(operand_count)):
|
|
op4: GenTypes.AsmOperand* = self._asm_get_operand(operands, oi4)
|
|
if op4.IsOutput == 0:
|
|
new_order[new_idx] = oi4
|
|
new_idx += 1
|
|
# Build the orig -> new mapping
|
|
for ni2 in range(int(operand_count)): orig_to_new[new_order[ni2]] = ni2
|
|
|
|
# 4.6 Generate asm text (second f-string pass, $N from reordered indices).
|
|
# The project uses Intel syntax via the IR inteldialect keyword.
|
|
if tmpl_node is not None:
|
|
tk2: int = tmpl_node.kind()
|
|
if tk2 == ast.ASTKind.JoinedStr:
|
|
js2: ast.JoinedStr* = ast.JoinedStr*(tmpl_node)
|
|
jvalues2: list[ast.AST*]* = js2.values
|
|
if jvalues2 is not None:
|
|
jvlen2: sizet = len(jvalues2)
|
|
fv_fi: int = 0
|
|
for vi2 in range(int(jvlen2)):
|
|
part2: ast.AST* = jvalues2.get(vi2)
|
|
if part2 is None: continue
|
|
pk2: int = part2.kind()
|
|
if pk2 == ast.ASTKind.Constant:
|
|
cn3: ast.Constant* = ast.Constant*(part2)
|
|
if cn3.const_kind == ast.CONST_STR and cn3.str_val is not None: self._asm_append_cstr(asm_text, ASM_TEXT_BUF_SIZE, cn3.str_val)
|
|
elif pk2 == ast.ASTKind.FormattedValue:
|
|
if fv_fi < fv_count:
|
|
orig_idx2: int = fv_orig_indices[fv_fi]
|
|
new_idx2: int = orig_to_new[orig_idx2]
|
|
ph_buf2: str = pool.alloc(16)
|
|
if ph_buf2 is not None:
|
|
viperlib.snprintf(ph_buf2, 16, "$%d", new_idx2)
|
|
self._asm_append_cstr(asm_text, ASM_TEXT_BUF_SIZE, ph_buf2)
|
|
fv_fi += 1
|
|
elif tk2 == ast.ASTKind.Constant:
|
|
cn4: ast.Constant* = ast.Constant*(tmpl_node)
|
|
if cn4.const_kind == ast.CONST_STR and cn4.str_val is not None: self._asm_append_cstr(asm_text, ASM_TEXT_BUF_SIZE, cn4.str_val)
|
|
|
|
# 5. Build the constraint string in reordered order (outputs first).
|
|
# Capacity scales with the operand/clobber count: a 32-entry clobber list alone is
|
|
# ~300 bytes, so the old fixed 512-byte cap could silently cut it. Overflow of this
|
|
# (or any asm text buffer) is fail-fast in _asm_append_cstr.
|
|
const_cap: sizet = ASM_CONST_BUF_SIZE + sizet(operand_count + clobber_count + 1) * 64
|
|
const_buf: str = pool.alloc(const_cap)
|
|
if const_buf is None: return None
|
|
const_buf[0] = '\0'
|
|
|
|
first_const: int = 1
|
|
for ci2 in range(int(operand_count)):
|
|
orig_i: int = new_order[ci2]
|
|
cop: GenTypes.AsmOperand* = self._asm_get_operand(operands, orig_i)
|
|
cons_val: str = cop.Constraint
|
|
if cons_val is None: cons_val = "r"
|
|
|
|
if first_const == 0: self._asm_append_cstr(const_buf, const_cap, ",")
|
|
first_const = 0
|
|
|
|
if cop.IsOutput != 0:
|
|
# Output constraint: ensure it starts with =
|
|
if cons_val[0] != '=': self._asm_append_cstr(const_buf, const_cap, "=")
|
|
self._asm_append_cstr(const_buf, const_cap, cons_val)
|
|
else: self._asm_append_cstr(const_buf, const_cap, cons_val)
|
|
|
|
# Append clobber constraints ~{name}
|
|
for cidx in range(int(clobber_count)):
|
|
cl_addr2: uint64 = uint64(clobbers) + cidx * 8
|
|
cname: str = (str*)(cl_addr2)[0]
|
|
if cname is None or cname[0] == '\0': continue
|
|
if first_const == 0: self._asm_append_cstr(const_buf, const_cap, ",")
|
|
first_const = 0
|
|
self._asm_append_cstr(const_buf, const_cap, "~{")
|
|
self._asm_append_cstr(const_buf, const_cap, cname)
|
|
self._asm_append_cstr(const_buf, const_cap, "}")
|
|
|
|
# 6. Build the argument list text (input operands only): each arg is type text
|
|
# (TypePrint is given a 4096-byte buffer below) plus the value name, so size the
|
|
# buffer from that worst case instead of underestimating it (544 bytes/operand
|
|
# silently cut wide inlined named structs).
|
|
asm_arg_cap: sizet = sizet(operand_count + 1) * 4224 + 64
|
|
args_buf: str = pool.alloc(asm_arg_cap)
|
|
if args_buf is None: return None
|
|
args_buf[0] = '\0'
|
|
|
|
first_arg: int = 1
|
|
for ai3 in range(int(operand_count)):
|
|
orig_i2: int = new_order[ai3]
|
|
aop: GenTypes.AsmOperand* = self._asm_get_operand(operands, orig_i2)
|
|
if aop.IsOutput != 0: continue
|
|
aval: mlirlite.Value* = aop.Value
|
|
if aval is None or aval.Ty is None or aval.Name is None: continue
|
|
|
|
if first_arg == 0: self._asm_append_cstr(args_buf, asm_arg_cap, ", ")
|
|
first_arg = 0
|
|
|
|
# Type text
|
|
ty_buf: str = pool.alloc_tagged(4096, memhub.DETSITE_CALLGENCBUILTIN_1150)
|
|
if ty_buf is not None:
|
|
ty_buf[0] = '\0'
|
|
mlirlite.TypePrint(ty_buf, 4096, aval.Ty, pool)
|
|
self._asm_append_cstr(args_buf, asm_arg_cap, ty_buf)
|
|
self._asm_append_cstr(args_buf, asm_arg_cap, " ")
|
|
self._asm_append_cstr(args_buf, asm_arg_cap, aval.Name)
|
|
|
|
# 7. Escape the asm text. First replace bare symbols with mangled names
|
|
# (lea rax, [rip + gdt] -> [rip + 054f5e56cbefcaa4.gdt]).
|
|
mangled_asm: str = self._asm_mangle_global_symbols(pool, asm_text, ASM_TEXT_BUF_SIZE, mod)
|
|
if mangled_asm is None: mangled_asm = asm_text
|
|
escaped_asm: str = self._asm_escape_for_ir(pool, mangled_asm)
|
|
if escaped_asm is None: return None
|
|
|
|
# 8. Generate and emit the IR line
|
|
# The line buffer is sized after ret_ty_buf is ready (see line_cap below)
|
|
|
|
ssa_name: str = None
|
|
if is_void == 0:
|
|
ssa_name = pool.alloc(16)
|
|
if ssa_name is not None:
|
|
viperlib.snprintf(ssa_name, 16, "%%%d", builder.Counter)
|
|
builder.Counter += 1
|
|
|
|
# Get the return type text
|
|
ret_ty_buf: str = pool.alloc_tagged(4096, memhub.DETSITE_CALLGENCBUILTIN_1176)
|
|
if ret_ty_buf is not None:
|
|
ret_ty_buf[0] = '\0'
|
|
mlirlite.TypePrint(ret_ty_buf, 4096, ret_ty, pool)
|
|
|
|
# Size the line buffer by actual content (type text can be 512 bytes; asm/constraints may be long)
|
|
line_cap: sizet = 512 + string.strlen(escaped_asm) + string.strlen(args_buf)
|
|
if const_buf is not None: line_cap += string.strlen(const_buf)
|
|
if ret_ty_buf is not None: line_cap += string.strlen(ret_ty_buf)
|
|
line: str = pool.alloc(line_cap)
|
|
if line is None: return None
|
|
|
|
if is_void == 1:
|
|
viperlib.snprintf(line, line_cap, "call %s asm sideeffect inteldialect \"%s\", \"%s\"(%s)", ret_ty_buf, escaped_asm, const_buf, args_buf)
|
|
else:
|
|
viperlib.snprintf(line, line_cap, "%s = call %s asm sideeffect inteldialect \"%s\", \"%s\"(%s)", ssa_name, ret_ty_buf, escaped_asm, const_buf, args_buf)
|
|
|
|
# Emit the IR into the current block
|
|
mlirlite.block_append_text(pool, builder.CurBlock, line)
|
|
|
|
# 9. Handle outputs: store results into the output variables
|
|
if is_void == 0 and first_output_idx >= 0:
|
|
result_val: mlirlite.Value* = mlirlite.SSAValue(pool, ret_ty, ssa_name)
|
|
out_emit_idx: int = 0
|
|
for oi_out in range(int(operand_count)):
|
|
orig_o: int = new_order[oi_out]
|
|
oo: GenTypes.AsmOperand* = self._asm_get_operand(operands, orig_o)
|
|
if oo is None or oo.IsOutput == 0: continue
|
|
if output_count > 1:
|
|
# Multi-output: extractvalue index out_emit_idx, then store
|
|
if oo.Value is not None and oo.Value.Ty is not None and oo.Value.Ty.Pointee != 0:
|
|
ev_name: str = pool.alloc(32)
|
|
# Size the line from its actual parts: ret_ty_buf alone can be ~4096
|
|
# bytes, so the old fixed cap could cut the instruction in half.
|
|
ev_cap: sizet = ASM_LINE_BUF_SIZE + 64
|
|
if ret_ty_buf is not None: ev_cap += string.strlen(ret_ty_buf)
|
|
if ssa_name is not None: ev_cap += string.strlen(ssa_name)
|
|
ev_line: str = pool.alloc(ev_cap)
|
|
if ev_name is not None and ev_line is not None:
|
|
# ssa_name is "%N"; build a unique "%asm.N.e{i}" (letter-
|
|
# initial) so %N.e{i} is not parsed as id plus a bad suffix.
|
|
viperlib.snprintf(ev_name, 32, "%%asm.%s.e%d", ssa_name + 1, out_emit_idx)
|
|
viperlib.snprintf(ev_line, ev_cap, "%s = extractvalue %s %s, %d", ev_name, ret_ty_buf, ssa_name, out_emit_idx)
|
|
mlirlite.block_append_text(pool, builder.CurBlock, ev_line)
|
|
ev_val: mlirlite.Value* = mlirlite.SSAValue(pool, oo.Value.Ty.Pointee, ev_name)
|
|
mlirlite.build_store(builder, ev_val, oo.Value)
|
|
else:
|
|
if oo.Value is not None: mlirlite.build_store(builder, result_val, oo.Value)
|
|
out_emit_idx += 1
|
|
return result_val
|
|
|
|
return None
|
|
|
|
|
|
def translate_c_llvmir(self, pool: memhub.MemBuddy*, builder: mlirlite.IRBuilder*, mod: mlirlite.LLVMModule*, cl: ast.Call*, trans: HT.Translator* = None) -> mlirlite.Value*:
|
|
"""Inline raw LLVM IR text into the current basic block; returns None."""
|
|
if cl is None or builder is None or pool is None or trans is None: return None
|
|
|
|
cargs: list[ast.AST*]* = cl.args
|
|
if cargs is None or len(cargs) < 1: self.Gen.TypeGenErr.fatal_error(cl, "c.LLVMIR missing template argument", "TypeError")
|
|
|
|
# LOut writeback records (alloca pointer + register name), up to LLVMIR_MAX_OPS
|
|
out_alloca: sizet* = pool.alloc(8 * LLVMIR_MAX_OPS)
|
|
out_regname: sizet* = pool.alloc(8 * LLVMIR_MAX_OPS)
|
|
if out_alloca is None or out_regname is None: return None
|
|
string.memset(out_alloca, 0, 8 * LLVMIR_MAX_OPS)
|
|
string.memset(out_regname, 0, 8 * LLVMIR_MAX_OPS)
|
|
out_count: int = 0
|
|
|
|
# Template text buffer
|
|
text: str = pool.alloc(LLVMIR_TEMPLATE_BUF)
|
|
if text is None: return None
|
|
text[0] = '\0'
|
|
|
|
# 1. Parse the IR template (JoinedStr or Constant), replacing LInp/LOut/exprs with value text
|
|
first_arg: ast.AST* = cargs.get(0)
|
|
if first_arg is None: return None
|
|
|
|
tk: int = first_arg.kind()
|
|
|
|
if tk == ast.ASTKind.JoinedStr:
|
|
js: ast.JoinedStr* = ast.JoinedStr*(first_arg)
|
|
jvalues: list[ast.AST*]* = js.values
|
|
if jvalues is not None:
|
|
jvlen: sizet = len(jvalues)
|
|
for vi in range(int(jvlen)):
|
|
part: ast.AST* = jvalues.get(vi)
|
|
if part is None: continue
|
|
pk: int = part.kind()
|
|
|
|
if pk == ast.ASTKind.Constant:
|
|
# String literal fragment
|
|
cn: ast.Constant* = ast.Constant*(part)
|
|
if cn.str_val is not None: self._asm_append_cstr(text, LLVMIR_TEMPLATE_BUF, cn.str_val, "c.LLVMIR")
|
|
|
|
elif pk == ast.ASTKind.FormattedValue:
|
|
fv: ast.FormattedValue* = ast.FormattedValue*(part)
|
|
fexpr: ast.AST* = fv.value
|
|
if fexpr is None: continue
|
|
# Detect c.LInp / c.LOut
|
|
if fexpr.kind() == ast.ASTKind.Call:
|
|
fcall: ast.Call* = ast.Call*(fexpr)
|
|
attr_nm: str = self._asm_is_c_call(fcall)
|
|
if attr_nm is not None:
|
|
fargs: list[ast.AST*]* = fcall.args
|
|
if fargs is None or len(fargs) < 1: continue
|
|
val_node: ast.AST* = fargs.get(0)
|
|
|
|
if string.strcmp(attr_nm, "LInp") == 0:
|
|
# Input operand: translate to an LLVM value reference text (%x or constant)
|
|
inp_val: mlirlite.Value* = self.Gen.ExprGen.translate_value(builder, pool, mod, val_node, None, 0, trans)
|
|
if inp_val is not None and inp_val.Name is not None: self._asm_append_cstr(text, LLVMIR_TEMPLATE_BUF, inp_val.Name, "c.LLVMIR")
|
|
|
|
elif string.strcmp(attr_nm, "LOut") == 0:
|
|
# Output operand: allocate a unique SSA register
|
|
# %llvmirN and record the writeback to the alloca.
|
|
if val_node is not None and val_node.kind() == ast.ASTKind.Name:
|
|
nm: ast.Name* = ast.Name*(val_node)
|
|
if nm.id is not None:
|
|
alloca: mlirlite.Value* = self.Gen.VarGen.lookup_var(trans.SymTab, nm.id)
|
|
if alloca is None or out_count >= LLVMIR_MAX_OPS: self.Gen.TypeGenErr.fatal_error(fcall, f"c.LOut variable '{nm.id}' is undefined or the output count exceeds {LLVMIR_MAX_OPS}", "TypeError")
|
|
self.Gen.CallGenBase.LLVMIRRegSeq += 1
|
|
reg_buf: str = pool.alloc(32)
|
|
if reg_buf is not None:
|
|
viperlib.snprintf(reg_buf, 32, "%%llvmir_%d", self.Gen.CallGenBase.LLVMIRRegSeq)
|
|
self._asm_append_cstr(text, LLVMIR_TEMPLATE_BUF, reg_buf, "c.LLVMIR")
|
|
out_alloca[out_count] = sizet(alloca)
|
|
out_regname[out_count] = sizet(reg_buf)
|
|
out_count += 1
|
|
continue
|
|
# Non-LInp/LOut f-string expression: translate and embed the value text
|
|
ival: mlirlite.Value* = self.Gen.ExprGen.translate_value(builder, pool, mod, fexpr, None, 0, trans)
|
|
if ival is not None and ival.Name is not None: self._asm_append_cstr(text, LLVMIR_TEMPLATE_BUF, ival.Name, "c.LLVMIR")
|
|
|
|
elif tk == ast.ASTKind.Constant:
|
|
cn2: ast.Constant* = ast.Constant*(first_arg)
|
|
if cn2.str_val is not None:
|
|
# A bare strcpy is unbounded and could overflow the pool block, so
|
|
# use the same bounded append as the JoinedStr branch.
|
|
self._asm_append_cstr(text, LLVMIR_TEMPLATE_BUF, cn2.str_val, "c.LLVMIR")
|
|
|
|
# 2. Embed the template text directly (no instruction parsing) + LOut writeback
|
|
mlirlite.block_append_text(pool, builder.CurBlock, text)
|
|
|
|
# LOut writeback: store <ty> %llvmirN, <ty>* %var
|
|
oi: int
|
|
for oi in range(int(out_count)):
|
|
oa: mlirlite.Value* = mlirlite.Value*(out_alloca[oi])
|
|
rn: str = str(out_regname[oi])
|
|
if oa is None or oa.Ty is None or oa.Ty.Pointee == 0 or rn is None: continue
|
|
reg_val: mlirlite.Value* = mlirlite.new_value(pool)
|
|
if reg_val is None: continue
|
|
reg_val.Ty = oa.Ty.Pointee
|
|
reg_val.Name = rn
|
|
reg_val.IsConst = 0
|
|
mlirlite.build_store(builder, reg_val, oa)
|
|
|
|
return None
|
|
|
|
# _apply_struct_defaults - apply default values to struct fields, after
|
|
# zeroinitializer and before explicit args (which later overwrite defaults).
|