Emit sign-extension from 32-bit to 64-bit register if the type is signed. Used after 32-bit ALU operations on callee-saved registers.

Default store implementation: 3-way SlotAddr dispatch for i128 and typed stores. Backends that override `emit_store` should call this for types they d

Emit a large immediate subtraction from sp. Uses x17 (IP1) as scratch.

Emit a cmpxchg-based loop for atomic sub/and/or/xor/nand. Expects: rax = operand val, rcx = ptr address. After: rax = old value.

Emit lui + addiw (or just addi) for a 32-bit signed value into register `rd`. On RV64, the `li` pseudo-instruction uses `lui + addiw` (not `lui + add

Encode NEON compare-to-zero: CMEQ Vd, Vn, #0, CMGE Vd, Vn, #0, etc. Format: 0 Q U 01110 size 10000 opcode 10 Rn Rd

── NEON by-element (non-long) ─────────────────────────────────────────── MUL/MLA/MLS by element: 0 Q U 01111 size L M Rm opcode H 0 Rn Rd

── NEON float compare-to-zero ─────────────────────────────────────────── FCMEQ/FCMLE/FCMLT/FCMGE/FCMGT to zero Format: 0 Q U 01110 size 10000 opcode

S-type: imm[11:5] | rs2[24:20] | rs1[19:15] | funct3[14:12] | imm[4:0] | opcode[6:0]

U-type: imm[31:12] | rd[11:7] | opcode[6:0]

Encode vector arithmetic VV (vector-vector): funct6[31:26] | vm[25] | vs2[24:20] | vs1[19:15] | funct3[14:12]=000 | vd[11:7] | OP_V

Encode vector unit-stride load: vle{8,16,32,64}.v vd, (rs1) Format: nf[31:29] | mew[28] | mop[27:26]=00 | vm[25] | lumop[24:20] | rs1[19:15] | width[1

Encode vector unit-stride store: vse{8,16,32,64}.v vs3, (rs1) Format: nf[31:29] | mew[28] | mop[27:26]=00 | vm[25] | sumop[24:20] | rs1[19:15] | width

Encode a Zbb unary instruction (clz, ctz, cpop, sext.b, sext.h, rev8). These are I-type with funct3=001 and the 12-bit immediate encoding the operatio

Ensure a section exists. If it doesn't, create it with the given properties.

Ensure we're in a text section, creating one if needed.

Try to evaluate a constant expression at compile time. Returns `Some(IrConst)` for expressions that can be fully evaluated using sema state. Returns

Evaluate this binary operation on two i64 operands using wrapping arithmetic. Signed operations use Rust's native i64 arithmetic. Unsigned operations

Evaluate a string literal address expression for static initializers. Handles: `"hello"`, `"hello" + 2`, `"hello" - 1`, `(type*)"hello"`, `&"hello"[2]

Fill a struct/union/array field into byte buffer + ptr_ranges, choosing the pointer-aware path or plain byte path based on whether the type contains p

Look up the struct layout for a member access expression. For direct access (s.field), gets the layout of the base expression. For pointer access (p->

Check if any field in this layout is or contains a pointer/function type. Recursively checks array element types and nested struct/union fields.

Infer operand size from a pair of operands for suffix-less instructions.

Insert a local variable, tracking the change in the current scope frame.

Remove all slot mappings backed by a given register (flat array version).

Returns true if this is a 32-bit pointer directive.

Check if an lvalue expression targets a _Bool variable (requires normalization). Handles direct identifiers, pointer dereferences (*pval), array subsc

Check if a register is a floating-point/SIMD register.

Whether this is a function pointer type: Pointer(Function(_)).

Check whether a symbol name is one that the linker provides during layout. This includes the static list of well-known linker symbols, plus the GNU l

Is this an MM (MMX) register?

Is this a segment register?

Check if a line references a specific register family. This includes both explicit register operands and implicit register uses by instructions like c

Load a value through a pointer operand.

Load the address of va_list storage into %edx. va_list_ptr is an IR value that holds a pointer to the va_list storage. - If va_list_ptr is an alloca

Lower an init expression with bool-aware handling. For bool targets, normalizes to 0/1. For other types, casts to target_ty.

Create a float constant of the appropriate type from an f64 value.

Mark a direct value as escaped (for va_list ptrs etc).

Get the callee-saved register assigned to an operand, if any.

Parse a #define directive line and return a MacroDef. The line should be the text after `#define ` (with leading whitespace stripped). Operates on byt

Parse memory operand inner part: `offset(%base, %index, scale)`.

Parse a parenthesized string argument: ("string1" "string2"...). Returns Some(concatenated) if non-empty, None otherwise.

Process source code, expanding macros and handling conditionals. Returns the preprocessed source with embedded line markers for source tracking.

Propagate copies within a single function.

Create a complex value from a real scalar (real part = scalar, imag = 0).

Remap an offset from old to new using the offset map. If the exact offset is in the map, returns the new offset. Otherwise, interpolates based on the

Resolve archive members: iteratively pull in members that define currently-undefined symbols.

Resolve the CType of a _Generic selection expression.

Resolve a numeric label reference like "1b" or "2f" to a synthetic label name.

Resolve param alloca to (slot, type) for parameter `i`.

Resolve a value to its root alloca, if any.

Resolve `__start_<section>` and `__stop_<section>` symbols against the output sections. GNU ld auto-generates these symbols when there are undefined

Resolve a TypeSpecifier to a CType using sema's type context. This delegates to the type_builder's shared conversion via TypeConvertContext.

Store a definition in a flat Vec, bounds-checked.

Skip C99 type qualifiers and 'static' inside array brackets. In C99 function parameter declarations, array dimensions can include: [static restrict co

Store a value into a bitfield: load storage unit, clear field bits, OR in new value, store back. Handles packed bitfields that span beyond the storage

Strip all blue-paint markers from a string. Used when substituting arguments into ## token paste operations, since the pasted result is a new token th

Strip trailing line comment from a single line, respecting string literals. Scans character by character tracking quote state so that comment charact

Convert a virtual address to a file offset using PT_LOAD program headers.

Zero-extend a narrow value (I8 from Cmp, or I32 from BinOp) to I64. On 32-bit targets (i686), I64 values occupy two 32-bit stack slots; without this c

Zero-initialize a region of memory within an alloca at the given byte offset.

Write the MXCSR register */

Allocate SHN_COMMON symbols into the .bss output section.

Apply all relevant options from a `CodegenOptions` struct.

Consume any pending `__attribute__((vector_size(N)))` or `__attribute__((ext_vector_type(N)))` that was parsed during a type specifier and wrap the gi