Whether r is a short register of reg_name/3: a, c, d, si, di, r8 or r9.

Whether reg_name/3 names the byte and the halfword of the short register r: only of a, c and d.

The byte of the short register r: al, cl and dl as reg_name/3 has them at b, and x86's names for the others (sil, dil, r8b, r9b), which reg_name/3 lacks.

The halfword of the short register r: ax, cx and dx as reg_name/3 has them at h, and x86's names for the others (si, di, r8w, r9w), which reg_name/3 lacks.

As att_suffix/2 at a store width: the suffix of a move of that width. A pointer and an x87 float have none.

As reg_name/3 at a store width: the name of the part of the short register r that a store of the width w writes. Only a, c and d have a byte and a halfword there.

As store_insn/3: the store of the w-sized part of the short register r to (%rax).

As ext_op/5: the mnemonic and suffix of the move that extends the narrow type t to the class k, and its destination register. An unsigned byte or halfword extends the same way at every class; a word extends only to l.

As ext_from/2: the part of %rax that the narrow type t extends.

As ext_insn/3: the move that extends the low part of %rax that t names into %rax at the class k.

As sw_load_op/4: a signed word loads at w with a 32-bit move, and at l as it extends.

As load_op/5: as ext_op, for a load of the type t from memory at the class k. An l, s or d loads only at its own class, an unsigned word loads with a 32-bit move at every class, and an x87 float does not load into %rax.

As load_insn/3: the load of a value of the type t from (%rax) into %rax, extended to the class k.

As alu//4: the x86 two-operand instruction insn at the class k on the two arguments, the first in %rax and the second in %rcx.

As shift//4: the x86 shift insn at the class k of the first argument by the second, a w count in %cl.

As zero_divisor//4: a zero divisor c becomes 1 and the dividend a becomes 0, so that quotient and remainder are 0. With e 1 if c is 0 and else 0, in d: c is c + e and a is a and e - 1.

As minus_one_divisor//5: a signed divisor c of -1 becomes 1 and the dividend a its negation, which wraps the least integer to itself where idiv would fault. With e 1 if c is -1 and else 0, in d: c is c + 2e and a is (a xor -e) + e. An unsigned division needs none of it.

As sign_extension/2: the instruction that sign-extends %eax or %rax at the class k into %edx or %rdx.

As divide//4: %rdx:%rax (or %edx:%eax) divided by the register c, the upper half extended from %rax by the signedness sg.

As division_result//3: for a remainder, its move from %rdx to %rax; the quotient is already there.

As division//5: the division at the class k, signed or unsigned by sg, of the first argument by the second, leaving in %rax the remainder if remainder holds and else the quotient. It is total: the operands are first rewritten, without branches, so that the divide cannot fault.

As cond_code/2: the x86 condition code of the integer comparison c. A float order has none.

As the cmp(Cond, CmpClass) clause of compute_op//4: 1 in %eax if the two arguments, read at the class ck, compare by the integer condition c, else 0.

As the alloc(Align) clause of compute_op//4, which only the plain backend reaches: the size, rounded up to 16 bytes, taken from the stack, the stack pointer aligned further when align is more than 16, and the new stack pointer in %rax.

As float_suffix/2: the suffix of a scalar SSE2 instruction at the float class k, s or d.

As amd64.pl's float_class/1: whether k is s or d, the float classes SSE2 computes.

As float_bits/2: the integer class as wide as the float class k.

As float_compare/2: the unordered compare at the float class k.

As float_compute/2: whether the op o at the class k is SSE2's: arithmetic at a float class, a comparison of floats, the conversions between s and d, between floats and integers, and a cast.

As float_load//4: the bits of the value v of the float class k into the xmm register x, by way of %rax.

The mnemonic stem of the SSE2 arithmetic of the op o, which is its own name.

As float_condition//1: sets %al to the float comparison c after ucomiss, ucomisd or fucomip compared the operands. eq, ne, lt and le also read the parity flag, so that an unordered compare gives 0, or 1 for ne. Writes %cl.

As truncate_float//2: the float of the class f in %xmm0, truncated to an integer of the class k in %rax.

The sign bit of an s and of a d, and 2^63 as the bits of an s and of a d.

As float_integer//4: the float of the class f in %xmm0 to an integer of the class k in %rax, signed or unsigned by sg. An unsigned w is the low half of the signed l. SSE2 has no unsigned l conversion: a float of 2^63 or more has 2^63 subtracted, is converted, and gets bit 63 back.

As convert_integer//2: the integer of the class k in %rax to a float of the class f in %xmm0.

As integer_float//3: the integer of the class k in %rax, signed or unsigned by sg, to the nearest float of the class f in %xmm0. An unsigned w converts as the l it is. An unsigned l with bit 63 set is halved, keeping its low bit as a sticky bit, converted and doubled, which rounds correctly.

As float_op//4: the code of the SSE2 op o at the class k on args, its result's bits in %rax.

• Arithmetic loads its operands into %xmm0 and %xmm1.
• A negation flips the sign bit in %rax.
• A comparison, whose class is w, is 1 or 0 by float_condition.
• ext(s) widens an s to a d and truncd narrows a d to an s.
• A cast is its operand's bits, read at the class k.
• A float becomes an integer by float_integer and an integer a float by integer_float.

As compute_op//4: the code that computes the op o at the class k on args into %rax, zero-extended for the class w. An SSE2 op (float_compute) is float_op's; the others are the integer clauses, one each. The load(Type) clause has no op here: it is load_insn after the load of the address into %rax.

An x temporary has a 16-byte slot, of which fldt and fstpt use the first 10 bytes. Each instruction pushes its operands on the x87 stack, computes and pops the stack empty again. Scalars and constants go through the red zone below %rsp.

As x87_op/3: whether the op o at the class k is x87's: every op at the class x, a comparison of x values, truncx, xtosi and xtoui. The op's kind, which the Prolog relation also takes, is the op's own.

The low 64 bits and the low 16 bits of an integer.

As x87_push//2: push the x value v: a temporary from its slot, a constant's 10 bytes through the red zone, by %rdx.

As x87_suffix/3: the suffix of an x87 load or store of the float class k, and of the integer move as wide.