impl

std › x86_64 › impl

The x86-64 base instruction set: general-purpose registers, memory operands, and the core integer instructions, each emitted as its machine code.

Import a dialect rather than this module: std.x86_64.intel, std.x86_64.nasm or std.x86_64.att. Here every instruction takes its operands in order, destination first, plus a final w: 1 for 64-bit operands and 0 for 32-bit. The dialects pick w from the register’s name instead (rax or eax).

from std.x86_64.impl import *

mov rax, rbx, 1
mov rax, Mem(rsp, 8), 1

loop:
    sub rcx, 1, 1
    jne loop

48 89 d8
48 8b 44 24 08
48 81 e9 01 00 00 00
0f 85 f3 ff ff ff

Jumps and calls always use a 32-bit offset, worked out by bitter once the program is laid out; there’s no automatic choice of the short form.

Macros

reg_field

The low 3 bits of r’s number: the part a ModRM or SIB field, or an opcode, holds.

reg_ext

Bit 3 of r’s number, which goes in the REX prefix: 1 for r8 to r15.

rex_byte

A REX prefix, 0100WRXB. w selects 64-bit operands; r, x and b are bit 3 of the ModRM.reg, SIB.index and ModRM.rm (or SIB.base, or opcode) register numbers.

modrm_byte

A ModRM byte: mod (2 bits), reg (3) and rm (3).

sib_byte

A SIB byte: scale (2 bits, log2 of the index’s multiplier), index (3) and base (3).

byte_of

Byte index of value, counting from the least significant, byte 0.

mov

add

or

and

sub

xor

cmp

test

Mem

The memory at [base + disp]. A displacement from -128 to 127 takes one byte; any other takes four.

MemIndexed

The memory at [base + index * scale + disp]. scale is 1, 2, 4 or 8, and index can be any register but rsp.

from std.x86_64.impl import *

mov rax, MemIndexed(rbx, r12, 4, 0), 1

4a 8b 04 a3

from std.x86_64.impl import *

mov rax, MemIndexed(rbx, rsp, 4, 0), 1

rsp cannot be a SIB index register

MemRipRelative

The memory at [rip + disp]: disp bytes past the end of the instruction. To address a label, use a RipLabel instead.

jmp

Jumps to the label target.

call

Pushes the address of the next instruction and jumps to the label target.

je

Jumps to the label target if equal (ZF = 1).

jne

Jumps to the label target if not equal (ZF = 0).

jb

Jumps to the label target if below, unsigned (CF = 1).

jae

Jumps to the label target if above or equal, unsigned (CF = 0).

ja

Jumps to the label target if above, unsigned.

jbe

Jumps to the label target if below or equal, unsigned.

jl

Jumps to the label target if less, signed.

jge

Jumps to the label target if greater or equal, signed.

jle

Jumps to the label target if less or equal, signed.

jg

Jumps to the label target if greater, signed.

js

Jumps to the label target if the result was negative (SF = 1).

jns

Jumps to the label target if the result wasn’t negative (SF = 0).

jo

Jumps to the label target on signed overflow (OF = 1).

jno

Jumps to the label target without signed overflow (OF = 0).

jp

Jumps to the label target if the parity flag is set (PF = 1).

jnp

Jumps to the label target if the parity flag is clear (PF = 0).

jz

je, under another name.

jnz

jne, under another name.

jc

jb, under another name.

jnae

jb, under another name.

jnc

jae, under another name.

jnb

jae, under another name.

jnbe

ja, under another name.

jna

jbe, under another name.

jnge

jl, under another name.

jnl

jge, under another name.

jng

jle, under another name.

jnle

jg, under another name.

jpe

jp, under another name.

jpo

jnp, under another name.

ret

Returns: pops an address and jumps to it.

shl

rd = rd << imm.

shl_cl

rd = rd << cl.

shr

rd = rd >> imm, shifting in zeros.

shr_cl

rd = rd >> cl, shifting in zeros.

sar

rd = rd >> imm, shifting in copies of the sign bit.

sar_cl

rd = rd >> cl, shifting in copies of the sign bit.

lea

rip_label_instr

An instruction with opcode opcode whose memory operand is the label addr, and whose other operand is r. The dialects’ [rel label] forms are built on it.

push

Pushes the 64-bit rd onto the stack.

pop

Pops 64 bits off the stack into rd.

syscall

Calls the operating system. On Linux, rax holds the call number and rdi, rsi, rdx, … its arguments.

Types

Reg

type Reg = bits<4>

A register number, 0 to 15. As an operand it means the whole 64-bit register.

Reg32

struct Reg32

The low 32 bits of a register. An instruction given one works on 32 bits instead of 64, and writing one zeroes the register’s upper half.

Byte

type Byte = bits<8>

A byte.

Bytes

struct Bytes<const N: int>

N bytes, packed by bitter in order: an instruction’s encoding.

Some of its fields are generated by @for or @if.

MemBase

struct MemBase

[base + disp]. Mem builds one.

MemSib

struct MemSib

[base + index * scale + disp]. MemIndexed builds one.

MemRip

struct MemRip

[rip + disp]. MemRipRelative builds one.

MemOperand

enum MemOperand

A memory operand, built by Mem, MemIndexed or MemRipRelative.

Rel32Instr

struct Rel32Instr

A jmp or call: an opcode byte and a 32-bit offset bitter works out.

Rel32Instr2

struct Rel32Instr2

A conditional jump: two opcode bytes and a 32-bit offset bitter works out.

RipLabel

struct RipLabel

A label used as a memory operand, addressed relative to the next instruction: NASM’s [rel label].

RipRelInstr

struct RipRelInstr

An instruction with a RipLabel operand and no REX prefix.

RipRelInstrRex

struct RipRelInstrRex

An instruction with a RipLabel operand and a REX prefix.

Constants