X86 assembly

Foglalt szavak

A legtöbb x86-os assembly nyelvben a foglalt szavak két részből állnak: mnemonikokból, amelyek opkódokká fordíthatók le, és direktívákból (vagy „pszeudo-opokból”), amelyek az assembler program olyan funkcióihoz férnek hozzá, amelyek túlmutatnak az opkódok egyszerű fordításán. Az előbbi rész listáját lásd az x86 utasításlistákban. Az utóbbi rész nagymértékben assembly-függő, az Intel-szintaxisú assemblerek között nincs szabvány. Az AT&T-szintaxisú assemblerek közös elnevezési módot használnak a direktívák esetében (minden direktíva ponttal kezdődik, mint például az .ascii), és számos alapvető direktíva, például az .ascii és a .string széles körben támogatott.

Általános célú regiszterek

Ezeknek a regisztereknek hagyományos szerepük van, de használatuk nincs szigorúan kikényszerítve. A programok általában szabadon használhatják őket más célokra.

• AX (Accumulator register): Elsősorban aritmetikai, logikai és adatátviteli műveletekben használják. Előnyben részesítik a szorzást és osztást végző utasítások, valamint a karakterlánc-betöltési és -tárolási műveletek. Az AX-szel történő azonnali ALU műveletek és cserék kompaktabban kódolhatók.
• BX (Base register): Alapmutató a memória-hozzáféréshez. Adatszerkezetek báziscímét tárolhatja, és hasznos indexelt címzési módokban. XLAT-tal együtt használják.
• CX (Count register): Számlálóként szolgál ciklus-, karakterlánc- és eltolás/forgatás utasításokban. Az iteratív műveletek gyakran használják a CX-et annak meghatározására, hogy egy ciklust vagy műveletet hányszor kell végrehajtani.
• DX (Data register): Az AX-szel együtt használják olyan szorzási és osztási műveletekhez, amelyek 16 bitnél nagyobb eredményeket hoznak. I/O portcímeket is tárol az IN és OUT utasításokhoz.
• SP (Stack pointer): A memória veremének tetejére mutat. Automatikusan frissül PUSH és POP műveletek során.
• BP (Base Pointer): A hívásverem tetejére mutat. Elsősorban függvényparaméterek és a hívásvermen belüli lokális változók elérésére használják.
• SI (Source Index): Pointerként szolgál a forrásra karakterlánc- és memóriatömb-műveletekben. Az olyan utasítások, mint a MOVS (move string), az SI-t használják adatok memóriából való olvasására. A BX-hez hasonlóan indexelésre is használható. Hozzáadható a BP-hez vagy a BX-hez dupla indexeléshez.
• DI (Destination Index): Pointerként szolgál a célra karakterlánc- és memóriatömb-műveletekben. Az SI-vel együtt működik az adatokat másoló vagy összehasonlító utasításokban, az eredményeket memóriába írva. A BX-hez hasonlóan indexelésre is használható. Hozzáadható a BP-hez vagy a BX-hez dupla indexeléshez.

Az általános regiszterek mellett léteznek még a következők is:

• Instruction Pointer (IP): A kódszegmensen (CS) belül végrehajtandó következő utasítás eltolási címét tartalmazza. A következő utasítás első bájtjára mutat. Bár az IP regisztert a programozók nem tudják közvetlenül olvasni, az értéke a vezérlési folyamat utasításai, például az ugrások, hívások és megszakítások révén változik, amelyek megváltoztatják a végrehajtás folyamatát.
• FLAGS regiszter: Állapot-, vezérlő- és rendszerjelzők halmazát tartalmazza, amelyek a műveletek eredményét tükrözik és a processzor működését vezérlik.
• Szegmensregiszterek (CS, DS, ES, SS): Meghatározzák, hol kezdődik egy 64k-os szegmens (az FS és GS regiszterek a 80386-os és újabb verziókban kerültek hozzáadásra)
• Extra bővítőregiszterek (MMX, 3DNow!, SSE stb.) (csak Pentium és újabb rendszereken).

Az x86 regisztereket a legtöbb utasítás használhatja. Például az Intel szintaxisában:

mov ax, 1234h ; copies the value 1234hex (4660d) into register AX

mov bx, ax    ; copies the value of the AX register into the BX register

Módok váltása

A processzor bekapcsolás után azonnal valós módban fut, így egy operációs rendszer kernelének vagy más programnak explicit módon át kell váltania egy másik módba, ha nem valós módban kíván futni. Az üzemmódok közötti váltás a processzor vezérlőregisztereinek(wd) bizonyos bitjeinek módosításával történik némi előkészítés után, és a váltás után további beállításokra lehet szükség.

Példák

Egy régebbi BIOS-t futtató számítógépen a BIOS és a rendszerbetöltő valós módban fut. A 64 bites operációs rendszer kernelje ellenőrzi és hosszú módba kapcsolja a CPU-t, majd új kernel módú(wd) szálakat indít 64 bites kód futtatásával.

Egy UEFI-t futtató számítógépen az UEFI firmware (a CSM és a régebbi Option ROM(wd) kivételével), az UEFI rendszerbetöltő és az UEFI operációs rendszer kernelje is hosszú módban(wd) fut.

Stack utasítások

Az x86 architektúra hardveresen támogatja a hívási veremmechanizmust (call stack). Az olyan utasítások, mint a push, pop, call és ret, a megfelelően beállított veremmel együtt használatosak paraméterek átadására, a helyi adatok számára helyfoglalásra, valamint a hívás-visszatérési pontok mentésére és visszaállítására. A ret size utasítás nagyon hasznos a helytakarékos (és gyors) hívási konvenciók(wd) megvalósításához, ahol a hívott fél felelős a paraméterek által elfoglalt veremterület visszanyeréséért.

Amikor egy veremkeretet állítunk be egy rekurzív eljárás lokális adatainak tárolására, számos lehetőség közül választhatunk; a magas szintű enter utasítás (a 80186-ossal bevezetve) egy eljárás-beágyazási mélység argumentumot, valamint egy lokális méret argumentumot is fogad el, és gyorsabb lehet, mint a regiszterek explicitebb manipulálása (például push bp ; mov bp, sp ; sub sp, size). Az, hogy gyorsabb vagy lassabb, az adott x86-processzoros implementációtól, valamint a fordító, a programozó vagy az adott programkód által használt hívási konvenciótól függ; a legtöbb x86-os kódot különböző gyártók x86-processzorain és a processzorok különböző technológiai generációin való futtatásra tervezték, ami nagyon eltérő mikroarchitektúrákat és mikrokód-megoldásokat(wd), valamint változó kapu- és tranzisztorszintű tervezési döntéseket von maga után.

A címzési módok teljes skálája (beleértve az „azonnali”, immediate és az „alap+eltolás”, base+offset módokat is), még olyan utasítások esetén is, mint a push és a pop, egyszerűvé teszi a verem közvetlen használatát az integer, lebegőpontos és cím(wd) adatokhoz, valamint az ABI specifikációit és mechanizmusait viszonylag egyszerűvé teszi egyes RISC architektúrákhoz képest (amelyek explicitebb call stack részleteket igényelnek).

Egész ALU utasítások

Az x86 assembly tartalmazza a standard matematikai műveleteket: összeadás, add, sub, neg, imul és idiv (előjeles egész számokhoz), mul és div (előjel nélküli egész számokhoz); az and, or, xor és not logikai operátorokat; a biteltolásos aritmetikai és logikai műveleteket, sal/sar (előjeles egész számokhoz), shl/shr (előjel nélküli egész számokhoz); forgatást átvitellel és anélkül, rcl/rcr, rol/ror, valamint a BCD aritmetikai utasítások komplementerét, aaa, aad, daa. Az olyan utasítások, mint a cmp és a test(wd), az operandusok módosítása nélkül állítják be a jelzőket.

Lebegőpontos utasítások

Az x86 assembly nyelv utasításokat tartalmaz egy veremalapú lebegőpontos egységhez (FPU). Az FPU egy opcionális, különálló társprocesszor volt a 8086-tól a 80386-ig, chipre integrált opció volt a 80486 sorozathoz, és a Pentiummal kezdve minden Intel x86 CPU-ban szabványos funkció a 80486 óta. Az FPU utasításai közé tartozik az összeadás, kivonás, tagadás, szorzás, osztás, maradék, négyzetgyökvonás, egész csonkolás, tört csonkolás és a kettő hatványán való skálázás. A műveletek konverziós utasításokat is tartalmaznak, amelyek a következő formátumok bármelyikében képesek betölteni vagy tárolni egy értéket a memóriából: bináris kódolású decimális, 32 bites egész, 64 bites egész, 32 bites lebegőpontos, 64 bites lebegőpontos vagy 80 bites lebegőpontos (betöltéskor az érték az aktuálisan használt lebegőpontos módba konvertálódik). Az x86 számos transzcendens függvényt(wd) is tartalmaz, beleértve a szinusz, koszinusz, tangens, arkusztangens függvényt, a 2-es alapú hatványozást és a 2-es, 10-es vagy e-alapú logaritmusokat.

Az utasítások veremregiszterről veremregiszterre való formátuma általában fop st, st(n) vagy fop st(n), st, ahol st egyenértékű az st(0)-val, és st(n) a 8 veremregiszter egyike (st(0), st(1), ..., st(7)). Az egész számokhoz hasonlóan az első operandus egyben az első forrásoperandus és a céloperandus is. Az fsubr és az fdivr utasításokat kell kiemelni, mivel ezek cserélik fel először a forrásoperandusokat a kivonás vagy osztás végrehajtása előtt. Az összeadás, kivonás, szorzás, osztás, tárolás és összehasonlítás utasítások olyan utasításmódokat tartalmaznak, amelyek a műveletük befejezése után a verem tetejét veszik fel. Tehát például az faddp st(1), st végrehajtja az st(1) = st(1) + st(0) számítást, majd eltávolítja az st(0)-t a verem tetejéről, így az st(1)-ben kapott eredmény az st(0) verem tetejére kerül.

SIMD utasítások

A modern x86-os CPU-k SIMD utasításokat tartalmaznak, amelyek nagyrészt ugyanazt a műveletet hajtják végre párhuzamosan számos, széles SIMD regiszterben kódolt értékkel. Különböző utasítástechnológiák támogatják a különböző műveleteket különböző regiszterkészleteken, de teljes egészében (az MMX-től az SSE4.2-ig) általános számításokat tartalmaznak egész vagy lebegőpontos aritmetikában (összeadás, kivonás, szorzás, eltolás, minimalizálás, maximalizálás, összehasonlítás, osztás vagy négyzetgyökvonás). Tehát például a paddw mm0, mm1 4 párhuzamos 16 bites (a w jelzi) egész értéket összead (a padd jelzi) mm0 értékekből mm1-hez, és az eredményt mm0-ban tárolja. A Streaming SIMD Extensions vagy SSE tartalmaz egy lebegőpontos módot is, amelyben a regiszterek legelső értékének módosítása történik meg (az SSE2-ben kibővítve). Néhány más szokatlan utasítást is hozzáadtak, beleértve az abszolút különbségek összegzését(wd) (a videotömörítés során a mozgásbecsléshez(wd) használják, például az MPEG-ben) és egy 16 bites szorzóösszesítő utasítást (hasznos szoftveralapú alfa-keveréshez és digitális szűréshez(wd)). Az SSE (az SSE3 óta) és a 3DNow! kiterjesztések összeadási és kivonási utasításokat tartalmaznak a párosított lebegőpontos értékek komplex számokhoz hasonlóan történő kezelésére.

Ezek az utasításkészletek számos fix részszavas utasítást is tartalmaznak az értékek regisztereken belüli keveréséhez, beszúrásához és kinyeréséhez. Ezenkívül vannak utasítások az adatok egész regiszterek és az XMM (SSE-ben használt)/FPU (MMX-ben használt) regiszterek közötti mozgatásához.

Memória utasítások

Az x86 processzor komplex címzési módokat is tartalmaz a memória azonnali eltolással történő címzéséhez, egy regiszterhez, egy eltolt regiszterhez, egy skálázott regiszterhez eltolással vagy anélkül, valamint egy opcionális eltolt regiszterhez és egy további skálázott regiszterhez. Így például a mov eax, [Table + ebx + esi*4] egyetlen utasításként kódolható, amely 32 bit adatot tölt be a ds szelektorból (Table + ebx + esi * 4) eltolásként kiszámított címről, és az eax regiszterbe tárolja. Általánosságban elmondható, hogy az x86 processzorok a működésük alatt álló regiszter méretéhez igazított memóriát tudnak betölteni és használni. (A SIMD utasítások félig betöltött utasításokat is tartalmaznak.)

A legtöbb 2 operandusú x86 utasítás, beleértve az egészértékű ALU utasításokat is, egy szabványos "címzési mód(wd) bájtot" használ, amelyet gyakran MOD-REG-R/M bájtnak(wd) neveznek. Sok 32 bites x86 utasításnak van egy SIB címzési mód bájtja(wd) is, amely a MOD-REG-R/M bájtot követi.

Elvileg, mivel az utasítás opkódja elkülönül a címzési mód bájtjától, ezek az utasítások ortogonálisak, mivel bármelyik opkód keverhető és illeszthető bármilyen címzési móddal. Az x86 utasításkészletet azonban általában nem ortogonálisnak tekintik, mivel a legtöbb diadikus művelet(wd) nem képes memóriáról memóriára működni, más opkódoknak van valamilyen rögzített címzési módjuk (nincs címzési mód bájtjuk), és minden regiszternek van egy preferált felhasználása.

Az x86 utasításkészlet karakterlánc betöltési, tárolási, mozgatási, szkennelési és összehasonlítási utasításokat (lods, stos, movs, scas és cmps) tartalmaz, amelyek minden műveletet egy megadott méretig hajtanak végre (b a 8 bites bájthoz, w a 16 bites szóhoz, d a 32 bites dupla szóhoz), majd növelik/csökkentik (a DF-től, az irányjelzőtől függően) az implicit címregisztert (si a lods-hoz, di a stos és scas-hoz, és mindkettő a movs és cmps-hez). A betöltési, tárolási és szkennelési műveletekhez az implicit cél/forrás/összehasonlító regiszter az al, ax vagy eax regiszterben található (a mérettől függően). A használt implicit szegmensregiszterek a ds az si-hez és az es a di-hez. A cx vagy ecx regisztert csökkenő számlálóként használják, és a művelet leáll, amikor a számláló eléri a nullát, vagy szkennelések és összehasonlítások esetén, amikor egyenlőséget vagy egyenlőtlenséget észlelnek. Sajnos az évek során ezen utasítások némelyikének teljesítménye elhanyagolódott, és bizonyos esetekben gyorsabb eredményeket lehet elérni elemibb utasításokkal történő kódolással. Az Intel és az AMD azonban frissített néhány utasítást, és 2025-től néhányuk nagyon tiszteletre méltó teljesítményt nyújt.

A verem egy memóriaterület és egy hozzá tartozó veremmutató (stack pointer), amely a verembe utoljára helyezett elemre mutat. A veremmutató értéke csökken az elemek hozzáadása előtt, push, és növekszik az elemek eltávolítása után, pop. 16 bites módban ez az implicit veremmutató SS:[SP], 32 bites módban SS:[ESP], 64 bites módban pedig [RSP] címmel rendelkezik. A veremmutató az utoljára tárolt értékre mutat, feltételezve, hogy a mérete megegyezik a processzor működési módjával (azaz 16, 32 vagy 64 bit), hogy megfeleljen a push/pop/call/ret utasítások alapértelmezett szélességének. Ide tartoznak az enter és leave utasítások is, amelyek adatokat foglalnak le és távolítanak el a verem tetejéről, miközben egy veremkeret-mutatót állítanak be a bp/ebp/rbp regiszterben. Azonban a közvetlen beállítás, vagyis az sp/esp/rsp regiszterhez való hozzáadás és kivonás is támogatott, így az enter/leave utasítások általában szükségtelenek.

Ez a kód egy tipikus magas szintű nyelvi függvény kezdete, amikor a fordítási optimalizálás ki van kapcsolva a hibakeresés megkönnyítése érdekében:

 push    rbp       ; Save the calling function’s stack frame pointer (rbp register)
 mov     rbp, rsp  ; Make a new stack frame below our caller’s stack
 sub     rsp, 32   ; Reserve 32 bytes of stack space for this function’s local variables.
                   ; Local variables will be below rbp and can be referenced relative to rbp,
                   ; again best for ease of debugging, but for best performance rbp will not
                   ; be used at all, and local variables would be referenced relative to rsp
                   ; because, apart from the code saving, rbp then is free for other uses.
  …       …        ; However, if rbp is altered here, its value should be preserved for the caller.
 mov [rbp-8], rdx  ; Example of writing to a local variable (by its memory location) from register rdx

...funkcionálisan egyenértékű egyszerűen a következővel:

 enter   32, 0

A verem manipulálására szolgáló egyéb utasítások közé tartozik a pushfd(32 bites) / pushfq(64 bites) és a popfd/popfq az EFLAGS (32 bites) / RFLAGS (64 bites) regiszter tárolásához és lekéréséhez.

A SIMD betöltés vagy tárolás értékei feltételezhetően a SIMD regiszter szomszédos pozícióiba vannak csomagolva, és szekvenciális little-endian sorrendben igazítják őket. Egyes SSE betöltési és tárolási utasítások megfelelő működéséhez 16 bájtos igazítás szükséges. A SIMD utasításkészletek tartalmaznak "prefetch" utasításokat is, amelyek végrehajtják a betöltést, de nem céloznak meg egyetlen regisztert sem, amelyeket a gyorsítótár betöltéséhez használnak. Az SSE utasításkészletek tartalmaznak nem időbeli tárolási utasításokat is, amelyek közvetlenül a memóriába mentik a mentéseket gyorsítótár-lefoglalás nélkül, ha a cél még nincs gyorsítótárazva (különben úgy fog viselkedni, mint egy normál tárolás).

A legtöbb általános egész és lebegőpontos (de nem SIMD) utasítás egy paramétert használhat komplex címként második forrásparaméterként. Az egész utasítások egy memóriaparamétert is elfogadhatnak céloperandusként.

"Hello, world!" program operációs rendszer nélkül

A "Hello, world!" szöveg kiírható kevés operációs rendszer-segítséggel. A „Call outchr” egy olyan mechanizmust hív meg, amely egy AL-ben lévő karaktert ír ki a konzolra. A nullától eltérő hosszúságú karakterláncokat nulla bájttal kell lezárni. Megjegyzendő, hogy ez a példa egy 16 bites Intel 8086-ra vonatkozik.

hello:            
   mov    si,msg      ; address of string into SI
   cld              ; Clear direction to increment SI
   lodsb            ; Load first char in AL, inc SI 
chrlp:
   call outchr      ; Print character in AL
   lodsb            ; Load next character in AL, inc SI 
   or al, al        ; Is it a zero terminator?
   jnz chrlp        ; If not, continue
   ret              ; Return to caller

msg: db 'Hello, world!', 0xa, 0x0  ; string to be printed

"Hello, world!" program MS-DOS-hoz MASM stílusú assemblyben

A szoftveres megszakítás 21h utasítás használata az MS-DOS operációs rendszer meghívásához a kijelzőre történő kimenethez – más példák a libc C printf() rutinját használják a stdout-ra (szabványos kimenet) íráshoz. Megjegyzendő, hogy ez a példa 16 bites módot használ, mint egy Intel 8086. A következő példa egy Intel 386 kód 32 bites módban. A modern kód 64 bites módban lesz.

.model small
.stack 100h

.data
msg    db    'Hello world!$'

.code
start:
    mov    ah, 09h    ; Sets 8-bit register ‘ah’, the high byte of register ax, to 9, to
                   ; select a sub-function number of an MS-DOS routine called below
                   ; via the software interrupt int 21h to display a message
    lea    dx, msg    ; Takes the address of msg, stores the address in 16-bit register dx
    int    21h        ; Various MS-DOS routines are callable by the software interrupt 21h
                   ; Our required sub-function was set in register ah above

    mov    ax, 4C00h  ; Sets register ax to the sub-function number for MS-DOS’s software
                   ; interrupt int 21h for the service ‘terminate program’.
    int    21h        ; Calling this MS-DOS service never returns, as it ends the program.

end start

"Hello, world!" program Windowshoz MASM és NASM stílusú assemblyben

; requires /coff switch on 6.15 and earlier versions
.386
.model small,c
.stack 1000h

; Image base = 0x00400000
%define RVA(x) (x-0x00400000)

.data
msg     db "Hello world!",0

section .data
msg db "Hello world!"

.code
includelib libcmt.lib
includelib libvcruntime.lib
includelib libucrt.lib
includelib legacy_stdio_definitions.lib

extrn printf:near
extrn exit:near

public main
main proc
        push    offset msg
        call    printf
        push    0
        call    exit
main endp
end

section .text
push dword msg
call dword [printf]
push byte +0
call dword [exit]
ret

section .idata
dd RVA(msvcrt_LookupTable)
dd -1
dd 0
dd RVA(msvcrt_string)
dd RVA(msvcrt_imports)
times 5 dd 0 ; ends the descriptor table

msvcrt_string dd "msvcrt.dll", 0
msvcrt_LookupTable:
dd RVA(msvcrt_printf)
dd RVA(msvcrt_exit)
dd 0

msvcrt_imports:
printf dd RVA(msvcrt_printf)
exit dd RVA(msvcrt_exit)
dd 0

msvcrt_printf:
dw 1
dw "printf", 0

msvcrt_exit:
dw 2
dw "exit", 0
dd 0

"Hello, world!" program Linuxhoz AT&T és NASM stílusú assemblyben

.data

section .data

str: .ascii "Hello, world!\n"

str:     db 'Hello world!', 0Ah

str_len = . - str

str_len: equ $ - str

.text

section .text

.globl _start

global _start

_start:

_start:

    movl $4, %eax
    movl $1, %ebx
    movl $str, %ecx
    movl $str_len, %edx

    mov    eax, 4
    mov    ebx, 1
    mov    ecx, str
    mov    edx, str_len

    int $0x80

    int 80h

    movl $1, %eax
    movl $0, %ebx
    int $0x80

    mov    eax, 1
    mov    ebx, 0
    int    80h

Megjegyzés az NASM-hez:

; Ez a program 32 bites védett módban fut.
;  build: nasm -f elf -F stabs name.asm
;  link:  ld -o name name.o
;
; 64 bites long módban használhatsz 64 bites regisztereket (pl. rax az eax helyett, rbx az ebx helyett stb.)
; A build parancsban a "-f elf" paramétert "-f elf64"-re kell cserélni.
; 64 bites long módban a "lea rcx, str" lenne az üzenet címe, jegyezd meg a 64 bites rcx regisztert.

"Hello, world!" program Linuxhoz NASM stílusú assemblyben a C szabványos könyvtár használatával

Lásd még: Szabványos C-könyvtár

;
;  This program runs in 32-bit protected mode.
;  gcc links the standard-C library by default

;  build: nasm -f elf -F stabs name.asm
;  link:  gcc -o name name.o
;
; In 64-bit long mode you can use 64-bit registers (e.g. rax instead of eax, rbx instead of ebx, etc..)
; Also change "-f elf " for "-f elf64" in build command.
;
        global  main                            ; ‘main’ must be defined, as it being compiled
                                                ; against the C Standard Library
        extern  printf                          ; declares the use of external symbol, as printf
                                                ; printf is declared in a different object-module.
                                                ; The linker resolves this symbol later.

segment .data                                   ; section for initialized data
    string db 'Hello world!', 0Ah, 0            ; message string ending with a newline char (10
                                                ; decimal) and the zero byte ‘NUL’ terminator
                                                ; ‘string’ now refers to the starting address
                                                ; at which 'Hello, World' is stored.

segment .text
main:
        push    string                          ; Push the address of ‘string’ onto the stack.
                                                ; This reduces esp by 4 bytes before storing
                                                ; the 4-byte address ‘string’ into memory at
                                                ; the new esp, the new bottom of the stack.
                                                ; This will be an argument to printf()

        call    printf                          ; calls the C printf() function.
        add     esp, 4                          ; Increases the stack-pointer by 4 to put it back
                                                ; to where it was before the ‘push’, which
                                                ; reduced it by 4 bytes.
        ret                                     ; Return to our caller.

Mivel a C futtatókörnyezetet használjuk, a main() függvényt a C futtatókörnyezet elvárásai szerint definiáljuk. Az exit meghívása helyett egyszerűen visszatérünk a main függvényből, hogy a futtatókörnyezet elvégezze a tisztítást.

"Hello, world!" program 64 bites módban futó Linuxhoz NASM stílusú assemblyben

Ez a példa modern 64 bites módban van.

;  build: nasm -f elf64 -F dwarf hello.asm
;  link:  ld -o hello hello.o

DEFAULT REL                ; use RIP-relative addressing modes by default, so [foo] = [rel foo]

SECTION .rodata            ; read-only data should go in the .rodata section on GNU/Linux, like .rdata on Windows
Hello:        db "Hello world!", 10   ; Ending with a byte 10 = newline (ASCII LF)
len_Hello:    equ $-Hello             ; Get NASM to calculate the length as an assembly-time constant
                                    ; the ‘$’ symbol means ‘here’. write() takes a length so that
                                    ; a zero-terminated C-style string isn't needed.
                                    ; It would be for C puts()

SECTION .text

global _start
_start:
    mov eax, 1                ; __NR_write syscall number from Linux asm/unistd_64.h (x86_64)
    mov edi, 1                ; int fd = STDOUT_FILENO
    lea rsi, [rel Hello]            ; x86-64 uses RIP-relative LEA to put static addresses into regs
    mov rdx, len_Hello        ; size_t count = len_Hello
    syscall                    ; write(1, Hello, len_Hello);  call into the kernel to actually do the system call
     ;; return value in RAX.  RCX and R11 are also overwritten by syscall

    mov eax, 60                ; __NR_exit call number (x86_64) is stored in register eax.
    xor edi, edi            ; This zeros edi and also rdi.
                            ; This xor-self trick is the preferred common idiom for zeroing
                            ; a register, and is always by far the fastest method.
                            ; When a 32-bit value is stored into eg edx, the high bits 63:32 are
                            ; automatically zeroed too in every case. This saves you having to set
                            ; the bits with an extra instruction, as this is a case very commonly
                            ; needed, for an entire 64-bit register to be filled with a 32-bit value.
                            ; This sets our routine’s exit status = 0 (exit normally)
    syscall                    ; _exit(0)

Az strace alatt futtatva ellenőrizhető, hogy a folyamat nem hajt végre extra rendszerhívásokat. A printf verzió sokkal több rendszerhívást kezdeményezne a libc inicializálásához és a dinamikus linkeléshez(wd). De ez egy statikus futtatható fájl, mivel az ld kapcsolóval linkeltünk -pie vagy megosztott könyvtárak nélkül; a felhasználói térben csak a megadott utasítások futnak.

$ strace ./hello > /dev/null                    # without a redirect, your program's stdout is mixed with strace's logging on stderr.  Which is normally fine
execve("./hello", ["./hello"], 0x7ffc8b0b3570 /* 51 vars */) = 0
write(1, "Hello world!\n", 13)          = 13
exit(0)                                 = ?
+++ exited with 0 +++

A flags regiszter használata

Az x86 architektúrában a flageket széles körben használják összehasonlításokhoz. Amikor két adat összehasonlításra kerül, a CPU beállítja a vonatkozó flaget vagy flageket. Ezt követően feltételes ugrási utasításokkal ellenőrizhetők a flagek, és elágazhatnak a futtatandó kódhoz, pl.:

    cmp    eax, ebx
    jne    do_something
    ; ...
do_something:
    ; do something here

Az összehasonlítási utasításokon kívül számos aritmetikai és egyéb utasítás létezik, amelyek biteket állítanak be a flags regiszterben. További példák a sub, test és add utasítások, és még sok más. Az olyan gyakori kombinációk, mint a cmp + feltételes ugrás, belsőleg "összeolvadnak" („makrofúzió”) egyetlen mikroutasítássá(wd) (μ-op), és gyorsak, feltéve, hogy a processzor kitalálja, merre fog menni a feltételes ugrás, jump vs. continue.

A flags regisztert az x86 architektúrában bizonyos funkciók vagy végrehajtási módok be- és kikapcsolására is használják. Például az összes maszkolható megszakítás letiltásához használhatja a következő utasítást:

    cli

A flags regiszter közvetlenül is elérhető. A flags regiszter alsó 8 bitje betölthető az ah-ba a lahf utasítással. A teljes flags regiszter a pushfd/pushfq, popfd/popfq, int (beleértve az into utasítást is) és iret utasításokkal is áthelyezhető a verembe és a veremből.

Az x87 lebegőpontos matematikai alrendszernek saját független „flags” típusú regisztere is van, az fp állapotszó. Az 1990-es években nehézkes és lassú eljárás volt a regiszterben található flag bitek elérése, de a modern processzorokon léteznek „két lebegőpontos érték összehasonlítása” utasítások, amelyek közvetlenül használhatók a normál feltételes ugrás/elágazás utasításokkal, bármilyen közbeeső lépés nélkül.

Az utasításmutató regiszter használata

Az utasításmutatót 16 bites módban ip-nek, 32 bites módban eip-nek, 64 bites módban pedig rip-nek nevezik. Az utasításmutató regiszter a processzor által végrehajtandó következő utasítás címére mutat. 16 bites vagy 32 bites módban nem érhető el közvetlenül, de az alábbihoz hasonló sorozat írható a next_line címének az eax regiszterbe való beillesztésére (32 bites kód):

    call    next_line
next_line:
    pop    eax

Az utasításmutatóba (programszámlálóba) írás egyszerű – egy jmp utasítás a megadott célcímet az utasításmutatóba tárolja, így például egy olyan sorozat, mint a következő, a rax tartalmát a rip-be (64 bites kód) helyezi:

    jmp    rax

64 bites módban az utasítások az utasításmutatóhoz képest relatív adatokra hivatkozhatnak, így kevésbé van szükség az utasításmutató értékének egy másik regiszterbe másolására.