WRITE (2) Linux Programmer’s Manual WRITE (2)
NAME
write – write to a file descriptor
Synopsis

#include <unistd.h>;
ssize_t write (int fd, const void *buf, size_t count);

Prvý zádrhel, píšeme v assembleri, ale manuálová stránka nám dáva prototyp systémového volania write v jazyku C. Ak nepoznáte jazyk C, bude sa vám prototyp čítať horšie, to však neznamená, že nebudete môcť vylúštiť, čo kam uložiť. V assembleri môžeme do registra zapísať buď priamo hodnotu alebo adresu. Myslím, že môžeme prijať zjednodušenie, že všetky parametre odovzdávame hodnotou, okrem parametrov označených hviezdičkou (to je ukazovateľ).
Funkcia write vyžaduje tri parametre, podobne ako v DOSe: identifikačné číslo súboru (handle), ukazovateľ (adresa) na dala, ktoré sa majú uložiť (vidíte, je tam napísané *buf), a počet bajtov, ktoré chceme zapísať. Výstupom funkcie je počet skutočne zapísaných byte alebo chyba. Poruchový stav rozpoznáme od zapísaných bajtov tak, že vždy ide o záporné číslo.
Zdrojový program preložíme překladačom NASM do objektového súboru, ktorý zostavíme zostavovacím programom ld. Získame tak spustiteľný súbor, ktorý na obrazovku vypíše Hello, World!

Pre preklad použijeme verziu prekladače NASM pre Linux. Objektový súbor typu elf vytvoríme prepínačom -f elf.
Program Id bude potrebovať adresu prvej inštrukcie, ktorá sa bude vykonávať po zavedení programu do pamäti. V zdrojovom programe označíme miesto prvej inštrukcie špeciálnym globálnom návestím _start.
Rovnako ako v OS DOS musíme program rozložiť do programových sekcií.
Program Hello, World! by mohol vyzerať takto:

SECTION .text 
global _start; aby linker vedel, kde je začiatok nášho programu, musíme definovať globálne symbol, _start 
_start: 
mov eax, 4; prvý parameter, čislo systémového volania 
mov EBX, 1; vieme, že konštanta STDOUT má hodnotu 1 
mov ecx, hello ; prekladač sem doplní adresu reťazca hello 
mov edx, 012 ; počet znakov reťazca Hello World! vrátane odradkovania
int 0x80 ; zavoláme jadro 
; pripojíme aj kód potrebný pre ukončenie programu 
mov eax, 1; číslo volania jadra - exit 
mov EBX, 0 ; návratový kód 0 
int 0x80 ; zavoláme jadro a tak ukončíme náš proces (program) 
 
SECTION .data 
hello db "Hello, world!", 0xa; náš reťazec vrátane nového riadku 
len equ $ - hello ;  symbolu len bude priradená dĺžka reťazca

Program preložíme ľahko:

nasm -f elf hello.asm

A zostavíme linker ld.

ld -s -o hello hello.o

Parameter -o udáva meno výsledného spustiteľného súboru. Parametrom -s chceme odstrániť všetky nepotrebné (symbolické) informácie.
Výsledný program môžeme spustiť príkazom:

./ Hello
Hello World!

Navrhovaný program má vytvoriť dialógové okno a skončiť. Dialógové okno vytvoríme volaním API funkcie MessageBox a o ukončenie programu sa postaráme funkciou rozhrania API nazývanou ExitProcess.
V dokumentácii k MessageBox sa dočítame:

int MessageBox ( 
IFWND hWnd, // handle of owner window 
LPCTSTR lpText, // address of text in message box 
LPCTSTR lpCaption, // address of title of message box 
UINT Utype // style of message box 
);

Prvým parametrom bude popisovač vlastného okna. Žiadny nemáme, preto predáme nulu. Druhým parametrom je ukazovateľ na text, ktorý sa v dialógovom okne zobrazí (klasický reťazec zakončený nulovým byte), tretím ukazovateľom je text titulku okna. Posledný parameter určuje typ dialógového okna (použijeme symbolickú konštantu MB_OK – z include súboru, viď ďalej).
Druhé volanie API funkcie ExitProcess, rovnako ako v DOSe, svojím jediným parametrom určuje chybový kód ukončeného programu. Po jeho zavolaní program skončí.
Aby bol život programátora v assembleri jednoduchší, bol vytvorený “include súbor” win32n.inc, v ktorom sú definované všetky typy parametrov API (napr. HWND aj LPCTSTR zodpovedajú v assembleri obyčajnému dvojslovu – dword) i hodnoty symbolických konštánt. Do programu tento súbor vložíme direktívou include:

%include "win32n.inc"; vložíme súbor win32n.inc

Použité API funkcie uložené v dynamických knižniciach nesmieme zabudnúť sprístupniť nášmu programu. Stačí použiť direktívy EXTERN a IMPORT:

EXTERN MessageBox ; symbol MessageBox je definovaný inde
IMPORT MessageBox user32.dll ; konkrétne v user32.dll
EXTERN ExitProcess ; symbol ExitProcess je definovaný inde
IMPORT ExitProcess kernel32.dll ; konkrétne v kernel32.dll

Zostáva vyriešil jediný problém: Ako odovzdať API funkciám jednotlivé parametre. Zoznámime sa tu len stručne s odovzdávacími konvenciiami parametrov rozhrania Win32 API.
Predávaciia konvencia sa volá STDCALL. Parametre sa odovzdávajú cez zásobník sprava doľava (ako v jazyku C), vymazanie zásobníka vykonáva volaný (ako v jazyku Pascal).
Na zásobník uložíme parametre inštrukciami PUSH, požadovanú funkciu zavoláme nepriamo inštrukciou CALL, o vymazanie zásobníka sa nemusíme starať. Celý program bude vyzerať nasledovne (pro prekladac NASM):

% include "win32n.inc" ; vložíme súbor win32n.inc 
EXTERN MessageBox ; symbol MessageBox je definovaný inde
IMPORT MessageBox user32.dll ; konkrétne v user32.dll 
EXTERN ExitProcess  ; symbol ExitProcess je definovaný inde 
IMPORT ExitProcess kernel32.dll ; konkrétne v kernel32.dll 
 
SECTION CODE USE32 CLASS = CODE ; začiatok kódovej sekcie 
.start: ; špeciálne návestie pre linker, ktoré označuje vstupný bod programu z (entrypointu) 
push UINT MB OK ; na zásobník uložíme posledný parameter, dialógové okno bude mať len tlačidlo OK 
push LPCTSTR titulok ; na zásobník vložíme adresu reťazca ukončeného nulovým byte, ktorý sa zobrazí ako titulok okna 
push LPCTSTR napis ; na zásobník vložíme adresu reťazca ukončeného nulovým byte, ktorý sa zobrazí ako text okna 
push HWND NULL ; na zásobník uložíme nulu, žiadne nadradené okno nemáme 
call [MessageBox] ; zavoláme API - vytvoríme dialógové okno návrat až po stlačení tlačidla OK
 
push  UINT NULL                                     ;vrátime  rodičovi  nulový  chybový  kód
call   [ExitProcess]                                  ;ukončíme proces
 
SECTION  DATA  USE32   CLASS=DATA
 
napis  db   'Hello  world',OxD,OxA,0 ;reťazec Hello,   World! vrátane odriadkovania 
titulek  db   'Hello", 0                                  ;titulok okna  bude  hello

Sečtěte dve 32bitová čísla uložené v premenných cislo1 a číslo2, výsledok uložíme do premennej vysledok (tiež 32-bitová premenná).

Riešenie príkladu musíme rozložiť do troch častí. V prvej naplníme vybrané registre požadovanými hodnotami, v druhej je sčítame, a v tretej časti zapíšeme výsledok. Výber registrov riadime veľkosťou použitých dát.

mov eax, [cislo1] ; pamätáte si? hranaté zátvorky znamenajú prístup do pamäte 
mov ebx, [cislo2]; do registra EBX načítame obsah druhej "premennej" 
add eax, ebx; EAX = EAX + EBX 
mov [vysledok], eax ; výsledok uložíme do "premennej" vysledok 
...
cislo1 dd 08; tu sme definovali "premennú" cislo1 a zároveň sme do nej vložili čislo 8 
cislo2 dd 2; do premennej "cislo2" sme vložili čislo 2 
vysledok dd 0; vysledok bude 8 + 2 = 010

Môžeme ušetriť register EBX, ak program prepíšeme takto:

mov eax, [cislo1]; nahraj hodnotu "premennej" cislo1 do registra EAX 
add eax, [cislo2] ; sčítaj register EAX a "premennu" číslo2 
mov [vysledok], eax ; výsledok ulož na adresu určenú symbolom vysledok
 
cislo1 dd 08 ; tu sme definovali "premennú" cislo1 a zároveň sme do nej vložili číslo 8
cislo2 dd 2  ; do premennej "cislo2" sme vložili číslo 2
vysledok dd 0 ; výsledok bude 8 + 2 = 010

Určenie či je číslo párne alebo nepárne

Príklad: Určite, či je v registri AX uložené číslo párne alebo nepárne!
Každé nepárne číslo má najnižší bit nastavený na 1. Inštrukciou SHR môžeme tento bit presunúť do príznaku prenosu CF (carry) a vykonať podmienený skok podľa príznaku prenosu inštrukciou JC.

push ax; nechceme stratiť hodnotu v registri AX, uložíme ju na zásobník 
shr ax, 1    ; najnižší bit sa presunul do príznaku CF 
pop ax      ; do registra AX vrátime pôvodnú hodnotu, register príznakov inštrukcie POP nemení. 
jc neparne ; ak jepríznak nastavený, číslo je nepárne 
sude:      ; tu môže nasledovať nejaká akcia, ak je párne 
neparne:  ; tu bude program pokračovať, ak je v AX číslo nepárne.

Ako už býva zvykom, program môžeme zapísať aj oveľa jednoduchšie:

test al, 1 ; najnižší bit bitovej masky bude jedna, vykonáme inštrukciu TEST 
jz je_parne ; príznak nuly ZF (zero flag) bude nastavený, ak bude najnižší bit nula, číslo bude párne 
neparne: 
....
je_parne: ; program bude pokračovať tu, ak bude číslo v AX párne.

Všimnime si, že sme testovali len register AL, nie celý AX. Vyššie bity registra AX sú pre nás nezaujímavé, a preto sme mohli testovať len register AL.

Inštrukcie CALL a RET používame na implementáciu podprogramov. Inštrukcia CALL má jeden, zvyčajne priamy operand (ako u inštrukcii skoku sa pripúšťa operand v registri alebo v pamäti), ktorým je adresa miesta v pamäti, kam sa odovzdá riadenie. Na rozdiel od inštrukcie JMP sa do zásobníka uloží hodnota registra IP (EIP) nasledujúcej inštrukcie po inštrukcii CALL.
Parameter typ volania je podobný ako u inštrukcie JMP, ak nie je uvedený, bude sa predpokladať typ volania near, a preto sa bude ukladať a meniť iba register IP (EIP). Pri typu volania far sa na zásobník okrem registra IP (EIP) uloží aj hodnota segmentového registra CS (adresa volania sa lak bude pozostávať z hodnoty pre register IP (EIP) a hodnoty pre register CS).
Návrat z podprogramu zabezpečuje inštrukcia RET, ktorá zo zásobníka vyberie hodnotu z vrcholu a tu uloží do registra IP (EIP), čím sa začnú vykonávať inštrukcie uložené za volajúcou inštrukciou CALL. Pre návrat z podprogramu, ktorý bol privolaný inštrukciou CALL far musíme obnoviť aj pôvodnú hodnotu registra CS, čo môžeme zabezpečiť použitím inštrukcie RETF, ktorá zo zásobníka najprv vyberie hodnotu a uloží ju do registra IP, a potom vyberie ešte jednu, ktorú uloží do registra CS.
Situáciu môžeme ešte trochu skomplikovať.
Inštrukcie RET alebo RETF môžu mať ako priamy operand počet položiek, ktoré sa majú zo zásobníka vybrať po naplnení registra IP (EIP) (alebo aj SK). Tento špeciálny tvar inštrukcie RET využijeme až neskôr, kde si povieme o možnostiach prepojenia vyšších programovacích jazykov a assembleru.

Ukážme si použitie inštrukcií CALL a RET na príklade:
Pomocou podprogramu sčítame dve čísla uložené v registroch EAX a EBX, výsledok súčtu uložíme v registri ECX (ignoruje pretečenie). Hodnoty uložené v registroch EAX a EBX musia byť zachované aj po návrate z podprogramu.
Vytvoríme podprogram sčítaj. Najskôr musíme vyriešiť odovzdávanie parametrov podprogramu. Vo vyšších programovacích jazykoch sa pre odovzdanie parametra používa zásobník, my si zatiaľ vystačíme s dohodnutými registrami. Akonáhle vykonáme inštrukciu pre sčítanie ADD, bude jedna hodnota operanda prepísaná výsledkom. Využijeme zásobník a hodnotu uloženú v danom registri si uložíme a neskôr opäť obnovíme.

scitaj:
push eax; uložíme hodnotu registra EAX na zásobník 
add eax, EBX; sčítame EAX a EBX, výsledok bude v EAX 
mov ecx, eax; výsledok z EAX uložíme do ECX 
pop eax; obnovíme pôvodnú hodnotu v registri EAX 
ret ; návrat z podprogramu.

Podprogram scitaj vyskúšame s hodnotami 4 a 8.

mov eax, 4; do EAX uložíme 4 
mov EBX, 8; EBX = 8 
call scitaj ; zavoláme podprogram scitaj 
;Výsledok bude uložený v registri ECX a bude JIRRA. 
; hodnota ECX = OxOOOOOOOC

Čo by sa stalo keby sme vynechali inštrukciu POP eax? Inštrukcia RET by tak predala riadenie na adresu, ktorá bola pôvodne uložená v registri EAX, čo by viedlo k pádu programu a v horšom prípade pádu systému. Podobne opomenutie inštrukcie RET by viedlo k vykonávanie inštrukcií dávno nepatria nášmu podprogramu, čo tiež ľahko (a celkom určite) vedie k pádu programu (to sa veľmi často využíva crackarmi a hackermi).
Podprogram scitaj možno v našom jednoduchom prípade zjednodušiť tak, že sa zaobídeme bez inštrukcií PUSH a POP:

scitaj: 
mov ecx, eax ; hodnotu registra EAX (prvý parameter) prekopírujete do registra ECX 
add ecx, EBX ; a sčítame s druhým parametrom v registri EBX, 
; výsledok bude v požadovanom registri ECX 
ret ; návrat z podprogramu.

Pomocou inštrukcie PUSH môžeme na zásobník uložiť ľubovoľný 16-bitový alebo 32-bitový register alebo obsah pamäťového miesta (nepoužíva sa príliš často).

push eax; na zásobník uložíme register EAX

Inštrukciu push môžeme rozpísať inštrukciami:

sub esp, 4; zníž ESP o 4 
mov [ss: esp], eax; zapíš do zásobníka hodnotu registra EAX

alebo všeobecnejšie (pomocou operátora sizeof, požičaného z vyšších prog. jazykov):

push ol

môžeme zapísať ako

(E) SP = (E) SP-sizeof (ol)
ol -> SS: [(E) SP]

Inštrukcia POP presunie do operanda hodnotu (obsah) z vrcholu zásobníka a vrcholom zásobníka sa stane hodnota uložená na vyššej adrese. Inštrukcia POP môže mať rovnaký typ operandov ako inštrukcia PUSH.

Opäť možno inštrukciu POP prepísať pomocou inštrukcií MOV a ADD:

mov eax, [ss: esp]; načítaj z vrcholu zásobníka do registra EAX 
add esp, 4; "smaž" najvyššie dvojslovo zo zásobníka

Uveďme si niekoľko príkladov.

push eax; na zásobník ulož hodnotu uloženú v registri EAX 
push esi; na zásobník ulož hodnotu registra ESI 
pop eax; zo zásobníka vyber hodnotu a ulož ju v registri EAX 
pop esi; zo zásobníka vyber hodnotu a ulož ju v registri ESI

Pripomeňme si, že na zásobník nie je možné pomocou inštrukcie PUSH uložiť 8-bitové registre a ani nemožno priamo uložiť obsah registra IP (EIP) (instruction pointer, ukazovateľ na ďalšiu inštrukciu). Inštrukcie PUSH / POP ip alebo PUSH / POP EIP neexistujú (možno ich ale nahradiť inak, viď ďalej).

Instrukcie PUSHA/POPA a PUSHAD/POPAD

Syntax:
PUSHA
POPA

Niekedy potrebujeme uložiť všetky univerzálne registre na zásobník. Na tento účel je mikroprocesor vybavený inštrukciami PUSH a POPA, ktoré na zásobník uloží (PUSHA) alebo zo zásobníka obnoví (POPA) hodnoty všetkých univerzálnych 16-bitových registrov. Inštrukcie PUSH a POPA nemajú žiadny voliteľný operand.

Inštrukcie PUSH / POPA boli zavedené v predchodcovi procesoru 80386, a preto neukladá 32-bitové registre (nemôže, pretože neexistovali). Ak ich cheme uložiť alebo vybrať, tak musíme použiť “nové” inštrukcie PUSHAD a POP AD.

Poradie ukladaných registrov na zásobníka od vrcholu nadol je:
(E)AX, (E)CX, (E)DX, (E)BX, pôvodné (E)SP, (E)BP, (E)SI, (E)DI

pusha; uložíme na zásobník obsah všetkých univerzálnych registrov
; urobíme veľké zmeny (napríklad komplikovaný výpočet,; ktorý zmení väčšinu hodnôt univerzálnych registrov) 
popa; zase všetky registre obnovíme

for_start: 
mov ecx, 0 ; naplníme register ECX nulou 
for_cyklus: ; na toto návestie sa budeme vracať 
... ; tu budeme vykonávať príkazy v FOR-cykle 
inc ecx ; ECX zvýšime o 1 
cmp ecx, 10 ; porovnáme ECX s 10 
jnz for_cyklus ; ak nie je 10, skočíme na for_cyklus 
for_skonci: ; ak už je 10, potom skončíme

Ukážme si aj variant s premennou I umiestnenou v pamäti.

for_start:
mov  dword   [i] , 0
for_cyklus: ; na toto návestie sa budeme vracať 
... ; tu budeme vykonávať príkazy vo FOR-cykle 
inc dword [i] ; ECX zvýšime o 1 
cmp dword [i], 10 ; srovnárne ECX s 10 
jnz for_cyklus ; ak nie 10, skočíme na for_cyklus 
for_skonci: ; ak už je 10, tak skončíme

Inštrukcia LOOP

Syntax: LOOP navestie_cyklu

Inštrukcia LOOP má dva operandy, podobne ako inštrukcia MUL. Prvý operand je pevne daný a je ním register CX (alebo ECX). Druhý, voliteľný operand je adresa návestia, kam sa bude odovzdávať konanie v prípade splnenej podmienky. Inštrukcia LOOP najskôr odpočíta jedničku od registra CX (ECX), a ak výsledok nie je nula, tak odovzdá riadenie programu na miesto určené svojim voliteľným operandom (cieľ skoku musí ležať v intervale + (alebo -) 128 bytov).

For-cyklus od 10 do 1 (vrátane) vytvorený inštrukciou LOOP by vyzeral takto:

for_start:
mov cx, 10  ; naplníme register CX 10 
for_cyklus:  ; na toto návestie sa budeme vracať 
...              ; tu budeme vykonávať príkazy v FOR-cykle 
loop for_cyklus ; ak CX nie je 0, skočíme na for_cyklus 
for_skonci: ; ak už je 0, potom skončíme

Inštrukcie LOOPZ a LOOPZN

Syntax:
LOOPZ navestie_cyklu
LOOPNZ navestie_cyklu

Inštrukcia LOOPZ rozširuje podmienku uskutočnenia skoku. Skok na návestie uvedené v inštrukcii sa uskutoční práve vtedy, keď hodnota v registri CX (ECX) nie je rovná nule a zároveň je nastavený príznak ZF (zero flag) na 1. Synonymum inštrukcie je LOOPE.

Inštrukciou LOOPZ ľahko vytvoríme cyklus s dodatočnou podmienkou. Rozšírme podmienku jedného priechodu cyklu z predchádzajúceho príkladu o test registra BX na číslo 3. Cyklus sa vykoná najviac desaťkrát, ale za podmienky, že hodnota v registri BX = 3. Inak sa predčasne ukončí.

for_start: 
mov cx, 10   ; naplníme register ECX 10 
for_cyklus: ; na toto návestie sa budeme vracať 
... ; tu budeme vykonávať príkazy v FOR-cykle 
... ; možná zmena registra BX 
cmp bx, 3 ; je BX = 3?
loopz for_cyklus ; ak CX neni 0 a BX = 3, skočíme na for_cyklus 
for_skonci: ; ak už je 0 alebo BX nie je 3, tak skončíme

Inštrukcia LOOPNZ funguje analogicky, ale druhá podmienka je negovaná. Skok sa uskutoční, ak nie je register CX (ECX) rovný nule a zároveň nie je nastavený príznak ZF (zero flag je nula). Jej synonymum je LOOPNE.

Porovnanie dvoch operandov vykonávajú inštrukcie CMP a TEST. Ako operandy môžeme použiť registre alebo operand uložený v pamäti v známych veľkostiach 8, 16 a 32 bitov.
Názov inštrukcie CMP je odvodený z anglického slova compare (porovnaj). Inštrukcia je implementovaná podobne ako inštrukcia SUB. Operand o2 sa odpočíta od operanda ol. Výsledok sa nikam neuloží, zmenia sa len príznaky v registri príznakov. Inštrukciu CMP môžeme použiť na porovnanie celých čísel bez znamienka aj so znamienkom.
Inštrukcia TEST pracuje podobne, miesto rozdielu operandov sa vykoná ich bitový súčin (AND). Výsledkom sú novo nastavené príznaky v registri príznakov. Inštrukciu TEST používame pre testovanie hodnôt jednotlivých bitov v bitovom poli.

Ukážme si niekoľko príkladov:

cmp ax, 4       ; porovná register AX s hodnotou 4
cmp dl, ah             ; porovná register DL s registrom AH
cmp [prumerl], ax   ; porovná obsah "premennej" prumer s registrom AX
cmp ax, [prumerl]   ; porovná register AX s obsahom "premennej" prumer
cmp eax, ecx         ; porovná registre EAX a ECX
test ax, 00000100b ; testujeme bit 2 (tretia) bit, ak je nastavený

Inštrukcie nepodmieného skoku JMP

Prvým spôsobom, ako zmeniť sekvenčné vykonávanie inštrukcií v programe, je použitie inštrukcie nepodmienečného skoku. Inštrukcia prinúti procesor spracovávať inštrukcie z iného miesta v pamäti (prepíše hodnoty ukazovateľa na ďalšiu inštrukciu, register IP alebo i CS).

Syntax: JMP typ_skoku operand

Nepodmienený skok známy z vyšších programovacích jazykov pod názvom GOTO v Assembleru predstavuje inštrukcia JMP. Názov vznikol z anglického slova jump (skoč). Inštrukcia vyžaduje jediný priamy operand, ktorým je adresa miesta v pamäti, kam sa má skočiť (ako operand možno použiť aj univerzálny register naplnený adresou skoku, čo by som začiatočníkom neodporúčal). V Assembleri sú rovnako ako vo vyšších programovacích jazykoch adresy skokov reprezentované návestiami (label).
Podľa “vzdialenosti” skoku v programe rozlišujeme tri druhy skokov: short, near a far. (Krátky, blízky a vzdialený).
Maximálna “dĺžka” skoku (maximálny absolútny rozdiel adries, ktorý možeme skokom zmeniť) typu short je obmedzená. V druhom byte inštrukcie je uložená len 8-bitová hodnota sa znamienkom, preto adresa cieľa skoku smie ležať iba v rozmedzí -128 až 127 byte. Skok sa vykoná tak, že sa 8-bitová hodnota znamienkovo rozšíri a pripočíta sa k súčasnej hodnote registra (E)IP.
Inštrukcia skoku typu near už obsahuje vo svojej strojovej reprezentácii novú hodnotu registra (E)IP, dĺžka skoku je obmedzená iba módom procesora. V reálnom režime procesora meníme inštrukciou jmp near register IP, preto sa smieme pohybovať len v rozmedzí jedného segmentu (64 KB), v chránenom režime používame register EIP a tak cieľ skoku môže ležať kdekoľvek v 4 GB adresového priestoru.
Skok far mení aj hodnotu segmentového registra CS, ktorý sa podieľa na výpočte adresy inštrukcie v pamäti. Súčasťou adresy skoku musí byť aj nová hodnota pre register CS.
Ak nie je typ skoku uvedený, predpokladá sa typ near.
Teraz trochu vo výklade “preskočíme” a povieme si, ako vyzerá návestie v Assembleri. Ide v podstate o identifikátor zakončený dvojbodkou, ktorému bola pri preklade pridelená adresa podľa miesta výskytu v programe. Ukážme si časť programu, kde je použité návestie:

mov ax, 4       ; do AX vlož hodnotu 4 
novy_cyklus:   ; návestie novy_cyklus 
mov bx, ax      ; do BX okopírujte AX

Ak chceme vykonať nepodmienený skok na návestie novy_cyklus, napíšeme inštrukciu:

jmp novy_cyklus; skok na novy_cyklus

Po jej prevedení sa program začne vykonávať od návestia novy_cyklus.
Nič nám nebráni najprv vykonať skok a neskôr v programe uviesť návestie. Prekladač pracuje “na viacerých priechodoch”, a preto aj také skoky dopredu vie spracovať. Časť programu používajúca dopredné skoky by mohla vyzerať nasledovne:

jmp start; skok na štart 
ciel:        ; návestie ciel 
...
...         ; ďalšie inštrukcie 
start:    ; návestie štart 
jmp ciel   ; skok na ciel

Vráťme sa ešte krátko k typom skokov, ktoré budeme síce ako začiatočníci využívať veľmi zriedka. Skok typu short použijeme všade tam, kde návestie “leží” do 128 B. Tak ušetríme 1B programového kódu, pretože preložená inštrukcia jmp short zaberá len dva byte (inštrukcia JMP alebo JMP near 3 alebo 5 byte). Možno vás desí predstava, ako odhadnúť vzdialenosť návestí v nepreloženom programe. Nemusíte sa báť, jednoducho to vyskúšajte, prekladač v prípade neúspechu zahlási chybu.

blizke_navestie:              ; návestie blizke_navestie 
....                              ; Nejaké dalšie inštrukcie 
jmp short blizke_navestie  ; urobíme skok na blizke_navestie

Inštrukcie podmienených skokov Jx

Syntax: Jx návestie_ciela_skoku

Ďalším spôsobom, ako zmeniť sekvenčné vykonávanie inštrukcií v programe, je použitie inštrukcie podmieneného skoku.
Inšturkcií podmieneného skoku existuje celá rada. Navzájom sa odlišujú rozhodovaciu podmienkou, ktorá riadi vykonanie skoku. V závislosti od vyhodnotenia podmienky sa vykonávanie programu buď presunie na iné miesto, alebo program pokračuje na nasledujúcu adresu za inštrukciou skoku. Rozhodovaciou podmienkou sú stavy príznakov (niekoľkých alebo len jedného) príznakového registra procesora.
Ukážme si najpoužívanejšie inštrukcie, ktoré skočia na návestie splnené, ak bude podmienka splnená.

jz splnene   ; skočí, ak je príznak ZF (zero flag, príznak nuly) nastavený na 1 
jc splnene  ; skočí, ak je príznak CF (carry flag, príznak prenosu) nastavený na 1 
js splnene  ; skočí, ak je nastavený príznak znamienka SF (signum flag) 
jo splnene  ; skočí, ak je nastavený príznak pretečenia

Všetky podmienky môžeme obrátiť (negovať).

jnz splnene; skočí, ak nie je príznak ZF (zero flag, príznak nuly) nastavený (je nula)

Podobne aj ostatné JNC, JNS a JNO.

Teraz môžeme s našimi znalosťami príslušných inštrukcií Assembleru podmienku IF naprogramovať. Ukážme si jednoduchý príklad, v ktorom budeme chcieť odovzdať riadenie programu (skočiť) na návestie je_tri, ak je hodnota v registri AX rovná trom.
V prvom kroku porovnáme hodnotu v registri AX s číslom 3, čo urobíme inštrukciou CMP.

cmp ax, 3; register AX porovnaj s hodnotou 3

Pri porovnaní na rovnosť použijeme inštrukciu JZ.

jz je_tri; skočí na návestie je_tri, ak bude hodnota AX = 3

Všimnime si, že pri porovnávaní rovnosti čísiel nezáleží na tom, či práve číslo chápeme ako číslo so znamienkom alebo bez.
Inštrukcia JZ vykoná skok na návestie je_tri, ak bude hodnota v registri AX rovná trom, inak bude program pokračovať inštrukciou nasledujúcou po JZ.

V ďalšom príklade budeme chcieť porovnať bez znamienka hodnoty v registri CL a AI .. Do registra BL zapísať jedničku, keď sú si hodnoty rovnaké, dvojku, ak je AL väčší ako CL, a trojku, ak je v registri AL menšie ako v CL

Porovnáme registre AL a CL, výsledok porovnania sa uloží do príznakového registra procesora a použitím rôznych inštrukcií skoku zabezpečíme výber správnej alternatívy a tým aj riešenie problému.

cmp al, cl  ; porovnaj hodnoty uložené v AL a CL 
jz zapis_l   ; skoč na návestie zapis_l, ak AL = CL 
cmp al, cl  ; porovnaj hodnoty uložené v AL a CL 
ja zapis_2 ; skoč na návestie zapis_2, ak AL> CL 
mov bl, 3  ; do BL zapíš 3 
koniec_if:  ; tu je koniec nášho programu 
zapis_1:    ; návestie zapis_1 
mov bl, 1   ; do BL zapíš 1 
jmp koniec_if; skok na koniec nášho programu 
zapis_2:    ; návestie zapis_2 
mov bl, 2   ; do BL zapíš 2 
jmp koniec_if; skok na koniec nášho programu

Museli sme dokonca použiť nepodmienený skok, aby sme vrátili riadenie programu na pôvodné miesto. Riešenie možno ešte výrazne vylepšiť:

mov bl, 1     ; do BL zapíš 1 
cmp al, cl    ; porovnaj AL a CL 
je koniec_if  ; skoč na koniec programu, ak AL = CL 
mov bl, 2    ; do BL zapíš 2 
cmp al, cl   ; porovnaj AL a CL 
ja koniec_if ; skoč na koniec programu, ak AL > CL 
mov bl, 3   ; do BL zapíš 3 
koniec_if:   ; koniec programu

DX: AX / (r/ml6) -> AX, zvyšok v DX

V 32-bitovej variante je voliteľný operand ľubovoľným 32-bitovým registrom alebo miestom v pamäti, pevný operand sa predpokladá v registrovej dvojici EDX: EAX, výsledok delenia sa ukladá do registra EAX, zvyšok po delení do registra EDX.

EDX:EAX / (r/m32) -> EAX, zvyšok v EDX

Inštrukciu IDIV použijeme pri delení čísel so znamienkom, operandy inštrukcie sú rovnaké ako u inštrukcie DIV.
Uveďme si opäť niekoľko príkladov.

Príklad: Celočíselne vydeľte číslo 13 dvoma, výsledok uložte do registra BL a zvyšok do registra BH.

mov ax, 13  ; do AX vložíme 13 
mov cl, 2 ; do CL 2
div cl ; vydelíme CL 
mov bx, ax ; výsledok očakávame v BX, stačí prekopírovať

Inštrukcie ADD a SUB

Začneme ako v prvej triede s inštrukciou ADD (sčítaj). Inštrukcia ADD má dva operandy, podobne ako inštrukcia MOV.

Syntax: ADD ol, o2

ADD sčíta obidva operandy a výsledok uloží do operanda ol, jeho predchádzajúca hodnota je stratená.

Inštrukcia pre odčítanie je označovaná SUB (z anglického substract) a jej syntax je podobná.

Syntax: SUB ol, o2

Výsledok ol – o2 sa uloží do ol; jeho pôvodná hodnota je opäť stratená. Ukážme si niekoľko príkladov:
Př.: Sčítajme čísla 8 a 6 (uložené v registri AX a CX), výsledok uložme do DX:

mov ax, 8   ; do registra AX vložíme 8 
mov cx, 6   ; do registra CX zase 6 
mov dx, cx  ; CX okopíruje do DX takže DX = 6 
add dx, ax  ; sčítame DX = DX + AX

Pretože sme chceli uchrániť register AX aj CX pred zničením (prepísaním výsledkom), prekopírovali sme hodnotu uloženú v registri CX do DX a spočítali register DX s AX. Inštrukcia ADD výsledok súčtu DX + AX uložila do DX.

Ukážme si ďalšie príklady, ako použiť inštrukcie ADD a SUB.

add eax, 8 ; k registru EAX pripočítame 8
sub ecx, EBP ; registr ECX = ECX - EBP
add byte [cislo], 4 ; k hodnote "premennej" cislo prirátame štyri
  ;(napovedáme rozsah 1 byte 0-256)
sub word [cislo], 4 ; od hodnoty "premennej" cislo odčítame 4
  ;(napovedáme rozsah 2 byte 0-65 535)
add dword [cislo], 4 ;k hodnote "premennej" cislo pripočítame 4
sub byte [cislo], al ;od hodnoty "premennej" cislo odčítame register AL
sub ah, al ; od registra AH odrátame AL a výsledok a uložíme do AH

Inštrukcie INC a DEC

Syntax: 
INC ol  ; ol = ol + 1;
DEC ol ; ol = ol - 1

Ich názvy sú opäť odvodené z angličtiny a znamenajú increment (zvýšiť) a Decre-ment (znížiť).
Inštrukcia zvyšuje (INC) alebo znižuje (DEC) jediný operand o jedničku. Jeho typ je rovnaký ako inštrukcií ADD a SUB. Ak použijeme operand ležiaci v pamäti, musíme prekladaču opäť napovedať požadovaný rozsah operanda. POZOR! Tieto pokyny upravujú príznak prenosu!

Přiklad: pripočítame k registru AI jedničku.

add al, l ; je správne, avšak vďaka inštrukcii INC môžeme požiadavku 
inc al    ; splniť aj takto.

Príklad: Zvýšte hodnotu šestnásťbitové “premennej” cislo o 1.

inc word [cislo]; pripočítali sme jedničku, napovedali sme rozsah 
  ; 0-65535, tj 16 bitov.

Inštrukcia MOV

Jej názov je odvodený z anglického slova move-presun. Inštrukcia MOV vyžaduje dva operandy, prvý cieľový a druhý zdrojový.
Syntax: MOV cieľ, zdroj
Inštrukcia slúži, ako už názov napovedá, k presunu, presnejšie povedané ku kopírovaniu zdrojového operanda do cieľového. Možné operandy inštrukcie sme si tiež už predstavili, ukážme si preto niekoľko príkladov:

mov ax, [cislo] ; do  registra AX uložíme hodnotu   "premenné"  cislo.
mov  [cislo], bx ; do  "premenne"  cislo  ulož  hodnotu,   ktorú  obsahuje registr BX
mov bx, cx ; do  registra  BX  ulož  hodnotu z registra  CX
mov  al,1 ; do  registra AL ulož  konštantu   1
mov  dh,cl ; do  registra  DH  ulož   to  čo  je  v  registri  CL
mov esi,edi ; prekopíruj   hodnotu z  registra EDI  do registra ESI
mov word [cislo],1 ; do "premenné"  cislo ulož  šestnásťbitovú konštantu   1

Architektúra mikroprocesorov x86 a kompatibilných dovoľuje uviesť najviac jeden operand inštrukcie ako nepriamy operand – ležiace v pamäti. Ak budeme chcieť prekopírovať obsah jednej “premennej” (cislojedna) do druhej (cislo_dva), nemôžeme použiť nasledujúcu inštrukciu MOV.

mov [cislo_dva], [cislo_jedna]; T0 JE ZLE!!!

(prekladač takú inštrukciu ani nepřeloží)

Musíme použiť register ako sprostredkovateľa.

mov ax, [cislo_jedna]; do AX vložíme šestnásťbitovú hodnotu
 ; "premmennej" cislo_jedna
mov [cislo_dva], ax  ; ktorú nakopírujeme do "premennej" cislo_dva

Všetky operandy inštrukcie MOV musia mať rovnakú veľkosť:

mov ax, bl ; ZLE - Nerovnaké veľkosti operandov

Ak by sme z nejakého dôvodu potrebovali hodnotu z registra BL dostať do AX (rozšíriť rozsah), musíme do AX prekopírovať celý register BX a register AH vynulovať.

mov ax, bx; do AX ulož BX
mov ah, 0 ; vynuluj hornú časť registra AX

Pripomeňme si, že register AH predstavuje horných 8 bitov registra AX. Po vykonaní inštrukcie MOV ax.bx je horných osem bitov registra AX nastavených podľa hodnoty v registri BH. Nemôžeme sa spoliehať, že v registri BH bola uložená nula, a preto druhú inštrukcií MOV ah, 0 register AH vynulujeme. Tak rozšírime pôvodnú osembitovú hodnotu uloženú v registri BL na šestnásťbitové hodnotu uloženú v registri AX (uvažujeme stále čísla bez znamienka).
Rovnaký výsledok docielime aj kódom:

mov ax, 0 ; vynulujeme register AX - AH aj AL budú nula
mov al, bl ; do registra AL nahráme obsah BL

Podobný postup môžeme uplatniť kedykoľvek budeme potrebovať prekopírovať 16-bitovú hodnotu do 32-bitového registra.