Load an operand directly into %rcx, avoiding the push/pop pattern. This is the key optimization: instead of loading to rax, pushing, loading the other

Load a 128-bit operand into t0 (low) : t1 (high).

Load a 128-bit operand into x0 (low) : x1 (high).

Parse an abstract declarator suffix: pointer(s), parenthesized pointer groups, and array dimensions after a type name. Used by cast expressions, sizeo

Preferred (natural) alignment in bytes, as returned by GCC's __alignof__. On i686, this differs from align_ctx() for long long (8 vs 4) and double (8

Replace `\param` in a macro body line with the argument value, but only when `\param` is followed by a non-identifier character (or end of string). G

Resolve .set/.equ aliases in an expression string. Replaces symbol names (like `.L__gpr_num_t0`) with their numeric values.

Set the __FILE__ macro body without allocating a full MacroDef. If __FILE__ already exists in the table, only its body is updated. Otherwise, a new en

Compute sizeof for an expression operand (sizeof expr). Returns the size in bytes of the expression's type.

Strip trailing comment from a line using x86 comment style (`#`).

Extract as i128 (integer constants only; floats return None). Unlike to_i64(), this preserves the full 128-bit value.

Convert an AST TypeSpecifier to a CType. Delegates to the shared `TypeConvertContext::resolve_type_spec_to_ctype` default method, which handles all 22

Returns true if the target uses x86-64 style packed _Complex float ABI (two F32s packed into a single F64/xmm register). Returns false for ARM/RISC-V

Write a Make-compatible dependency file for the given input/output. Format: "output: input\n" This is a minimal dependency file that tells make the ob

Classify an x87 value for arithmetic special-case handling. Returns (is_unnormal, is_inf, is_nan). For unnormals/pseudo-values, the caller should retu

Align `offset` up to the next multiple of `align`.

Extract a constant floating-point value, resolving through const map.

Bitcast a float/double to its integer bit representation via memory. F32 -> I32, F64 -> I64. Uses alloca+store+load for a true bitcast. Note: F128 cla

Classify each 8-byte "eightbyte" of this struct/union per the System V AMD64 ABI. Returns a vector with one entry per eightbyte (so 1 entry for size

Compute the address of an array element: base_addr + index * elem_size. For multi-dimensional arrays, uses the correct stride for the subscript depth.

Get the size in bytes for a CType.

Returns true if the target decomposes _Complex long double into 2 F128 scalar components for function argument/parameter passing. On ARM64 (AAPCS64):

Emit `add dest, sp, #offset` handling large offsets. Uses x19 frame base when available, falls back to x17 scratch.

Store the x87 st(0) value as F64 into a destination stack slot. Pops st(0).

Emit memcpy from src to base + byte_offset.

Encode AVX vbroadcastss/vbroadcastsd

Encode FP 1-source ops: FRINTN/P/M/Z/A/X/I Format: 0 00 11110 ftype 1 opcode 10000 Rn Rd

J-type: imm[20|10:1|11|19:12] | rd[11:7] | opcode[6:0]

Encode an SSE instruction with a single memory operand and a ModR/M extension. Format: [opcode bytes] ModR/M(ext, mem) Used for ldmxcsr (0F AE /2) and

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

Try to evaluate a constant expression at compile time. Returns None if the expression cannot be evaluated. This delegates to the richer SemaConstEval

Evaluate an initializer to a scalar constant (handles both Expr and arbitrarily nested brace-wrapped Lists like `{{{42}}}`).

Check if an expression produces packed struct data (non-address value) rather than a pointer to struct data. This happens for small structs (<= 8 byte

Evaluate a binary operation on two constant floats. Uses Rust's native f64 arithmetic which is IEEE 754 compliant.

Get the address space of a pointer expression (e.g., `__seg_gs` from a `typeof(x) __seg_gs *` cast). Returns `AddressSpace::Default` if unknown or the

Look up or create an ID for a name that may not already exist.

Get the pointee type for a pointer expression - i.e., what type you get when dereferencing it.

Return the standard set of linker-defined symbols that all backends should provide. This ensures consistent symbol definitions across x86-64, i686, A

Apply C integer promotion rules (C11 6.3.1.1): Types smaller than int are promoted to int (or unsigned int if int cannot represent all values, but for

Check if an expression is a compile-time constant that evaluates to true (non-zero). Used to detect infinite loops like `while(1)` and `for(;1;)`, and

Check if a string looks like a label (alphanumeric, underscore, dot).

Does this 8-bit register require REX prefix for access (spl, bpl, sil, dil)?

Returns true if this argument is passed on the stack (any kind).

Returns true if `data` starts with the thin archive magic `!<thin>\n`.

Check if a TypeSpecifier resolves to a Bool type (through typedefs).

Look up the pre-annotated CType for an expression from sema's expr_types map. This is O(1) and preserves signedness information (e.g. unsigned int fro

Lower an expression to a complex value, converting if needed. Returns a Value (pointer to the complex {real, imag} pair).

Get the address (as a Value) from an LValue.

Mark a symbol ID as reachable if not already, growing the reachable vec as needed.

Merge two eightbyte classifications per SysV ABI rules: - NoClass + X = X - Integer + anything = Integer - SSE + SSE = SSE

Returns the size (and alignment) in bytes for this enum. Non-packed enums are always 4 bytes (int). Packed enums use the smallest integer type that ca

Parse an AArch64 register name to an internal ID (0-30, or special). x0/w0 → 0, x1/w1 → 1, ..., x30/w30 → 30, sp → 31, xzr/wzr → 32.

Convert a byte buffer to GlobalInit elements by pushing each byte as I8. This is the standard bytes-to-compound conversion used throughout the compoun

Register a struct/union type definition from a TypeSpecifier, computing and caching its layout in self.types.struct_layouts. Also recursively register

Resolve a _Generic selection to the matched association's expression. Returns the matched expression (or the default), or None if no match. Both resol

Resolve a span to a human-readable source location. When a line map is available (preprocessor emitted line markers), resolves through the line map t

Store a scalar result from x0 (or w0) into the dest stack slot.

Check if a CType contains pointer elements (directly or through arrays/structs).

Append an ELF32 section header to `buf`.

Append an ELF64 section header to `buf`.

Get the x87 80-bit byte representation for any float constant. For LongDouble, converts stored f128 bytes to x87 format (lossy: 112→64 bit mantissa).

Get the f64 approximation from x87 bytes, for use when we still need f64. This is a convenience alias for x87_bytes_to_f64.

Analyze all allocas in a function to determine which are address-taken. An alloca is "address-taken" if its value (the pointer) is used by any instru

Perform shared declaration analysis for both local and global variable declarations. Computes all type-related properties (base type, array info, poi

Apply `__attribute__((vector_size(N)))` to this declaration analysis. When a non-typedef variable is declared with an inline vector_size attribute, th

Extract a constant integer value from an operand, resolving through const map.

Assert result is a Copy of I8 constant (used for boolean results).

Backward-compatible wrapper: classifies casts with x86 F128 semantics (F128 treated as F64 approximation).

Convert a libc classification result to a boolean (non-zero -> 1, zero -> 0).

Convert a complex value from one complex type to another (e.g., ComplexFloat -> ComplexDouble).

Compute the magic number for signed 32-bit division by `d`. Returns (magic_number, shift_amount). The result is: mulhi(x, magic) + adjust >> shift, th

Compute the magic number for unsigned 32-bit division by `d`. Returns (magic_number, post_shift, needs_add) where: - If !needs_add: result = (x * magi

Emit `add dest, x29, #offset` handling large offsets. Uses x17 (IP1) as scratch for offsets > 4095.

Emit: `sp = sp + imm`, handling large immediates via t6.

Emit cleanup function calls for variables with __attribute__((cleanup(func))). Calls func(&var) for each cleanup variable, in reverse declaration orde

Load an F128 operand into x87 ST(0), using full 80-bit precision when available. This is used for F128 arithmetic and for pushing F128 call arguments.