intel

std › x86_64 › intel

Intel-syntax x86-64 assembly: destination first, registers by name, and memory operands in brackets.

from std.x86_64.intel import *

mov rax, [rsp+8]
add eax, 1
mov r8, [rbx+rcx*4+0x10]

48 8b 44 24 08
81 c0 01 00 00 00
4c 8b 44 8b 10

The operand size comes from the register’s name: rax, r8 and the other Regs are 64-bit, and eax, r8d and the other Reg32s are 32-bit. Memory operands are [base], [base+disp], [base+index*scale+disp] and [rip+disp]. Every instruction of std.x86_64.impl stays available in its explicit form too, with the operand size as a final argument: mov rax, rbx, 0.

For NASM’s [rel label] and data directives, use std.x86_64.nasm.

Re-exports std.x86_64.impl.

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

shl_cl

shr

rd = rd >> imm, shifting in zeros.

shr_cl

sar

sar_cl

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.

assert_valid_reg

Fails to compile unless r is a register number, 0 to 15. The instructions here use it to check their operands.

mov_load_base

mov_load_base_disp

mov_load_indexed

mov_load_rip

mov_store_base

mov_store_base_disp

mov_store_indexed

mov_store_rip

lea_base

lea_base_disp

lea_indexed

lea_rip

shr_imm

Re-exported

From std.x86_64.impl: Reg, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, rax, rcx, rdx, rbx, rsp, rbp, rsi, rdi, Reg32, eax, ecx, edx, ebx, esp, ebp, esi, edi, r8d, r9d, r10d, r11d, r12d, r13d, r14d, r15d, Byte, Bytes, MemBase, MemSib, MemRip, MemOperand, Rel32Instr, Rel32Instr2, RipLabel, RipRelInstr, RipRelInstrRex.