nasm

std › x86_64 › nasm

NASM-flavored x86-64 assembly: everything std.x86_64.intel provides, plus the NASM spellings it doesn’t have.

from std.x86_64.nasm import *

lea rsi, [rel msg]
mov eax, [rel counter]
add [rel total], rcx

msg:
    db "Hello, World!", 10
counter:
    dd 0
total:
    dq 0

[rip+disp] from std.x86_64.intel takes a displacement you already know; [rel label] takes a label and computes the displacement once the code is laid out. The two can’t share a spelling: a label is a plain int too, so [rip+label] would be exactly as well-typed as [rip+disp].

Not covered: NASM’s $/$$, equ, times, resb, and global/extern (use const, @for, and pub labels instead).

Re-exports std.x86_64.intel.

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

rel

[rel label]: the memory at label, addressed relative to the next instruction, so the code works wherever it’s loaded.

from std.x86_64.nasm import *

lea rsi, [rel msg]    # msg is 6 bytes past the end of this instruction
mov eax, [rel msg]    # and right after this one

msg:
    db "Hi", 10

48 8d 35 06 00 00 00
8b 05 00 00 00 00
48 69 0a

data_int

value as width little-endian bytes, truncated the way NASM does.

data_string

A string literal’s UTF-8 bytes, with no terminator.

db

dw

dd

dq

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.