x86-64 registers & flags

The accumulator. mul, div and the string instructions use it without being told to, a syscall number goes in it, and a syscall result comes back in it.

A general register. Called on to survive a function call: a function that writes to it has to put it back before returning.

The counter. loop and the repeated string instructions count down with it, the shift instructions read a variable shift amount from cl, and it carries the fourth argument of a function call. syscall destroys it.

The high half of the product mul writes and of the dividend div reads, and the third argument of a function call or a syscall.

The source pointer of the string instructions, and the second argument of a function call or a syscall.

The destination pointer of the string instructions, and the first argument of a function call or a syscall.

The frame pointer by convention, pointing at the base of the current function's stack frame. Nothing in the hardware requires it, and compilers routinely use it as one more general register.

The stack pointer. push, pop, call and ret move it without being told to, and it must point at usable memory whenever any of them runs.

The eight registers x86-64 added. r8 and r9 carry the fifth and sixth arguments of a function call; r10 replaces rcx as the fourth argument of a syscall, because syscall destroys rcx. r11 is destroyed too.

The instruction pointer. It cannot be read or written directly, but it can be addressed: [rel label] assembles to an offset from rip, which is how position independent code reaches its own data.

The flags, listed below. Arithmetic and logic instructions write them, the conditional jumps and setcc read them, and pushfq and popfq move the whole register to and from the stack.

Carry. Set when an unsigned addition overflowed or an unsigned subtraction borrowed, and by the shift and rotate instructions, which shift the last bit out through it.

Parity. Set when the low byte of the result has an even number of set bits.

Adjust. The carry out of bit 3, which only the decimal adjust instructions read.

Zero. Set when the result was zero, which is what je and jne read after a cmp.

Sign. A copy of the top bit of the result, so it is set when the result is negative read as signed.

Direction. Clear means the string instructions count upwards, set means downwards. cld and std write it, and it is expected to be clear everywhere else.

Overflow. Set when a signed operation produced a result too large for its destination, which is a different question from the one the carry flag answers.

Sixteen 128 bit registers. Read as doubles they are two lanes, read as singles four, and read as raw bits sixteen bytes; the registers panel shows all three, because nothing in the register itself records which one the program meant.

The control and status register of the unit. It holds the rounding mode, the masks that decide whether an invalid operation raises an exception or quietly produces a NaN, and the flags that record which of those conditions has happened since the flags were last cleared. ldmxcsr and stmxcsr move it to and from memory.

Sixteen 256 bit registers. Read as doubles they are four lanes, read as singles eight, and read as raw bits thirty-two bytes. The lower 128 bits are the register of the same number in the SSE file, so a value shown there is the lower half of the row shown here.

The stack registers, listed top first: what the panel calls st0 is whatever the last push left on top, and one more push moves that value to st1. An instruction that pops past the bottom of the stack, or pushes onto a full one, raises the stack fault the status word reports.

The control word: the rounding mode, the precision the unit rounds results to, and the masks that say which exceptions the program wants to be told about. fldcw writes it, which is how code that needs truncation rather than the default round to nearest gets it. The precision field has nothing to decide here, because the stack already holds doubles.

The status word: the exception flags, the condition codes a comparison such as fcom writes, and the three bits that say which register is currently the top of the stack. fstsw ax copies it into ax, which is how an x87 comparison used to reach a conditional jump.

Two bits per register saying whether it holds a number, a zero, a special value such as an infinity, or nothing at all. It is what makes an empty stack slot distinguishable from one holding zero, and what the panel reads to decide which rows to leave blank.