Operatori Operatorii aritmetici unari deci stabilesc semnul unei

Operatori • Operatorii aritmetici unari: +, - (deci stabilesc semnul unei expresii), binari: +, -, *, /, MOD (cu doi operanzi); MOD - reprezintă restul împărţirii întregi. / - este operator pentru împărţire întreagă. • Operatorul index depl [bx][di] echivalent cu: depl + (bx) + (di) alfa [4] , alfa + 4 • Operatori logici NOT < expresie > < expresie 1 > AND < expresie 2 > < expresie 1 > OR < expresie 2 > < expresie 1 > XOR < expresie 2 >

• Operatori de deplasare < expresie > SHR < expr_contor > SHL • Operatori relaţionali Aceşti operatori compară două expresii, rezultatul fiind o valoare logică (true = ff. H, sau false = 00 H): EQ - pentru egalitate; NE - pentru inegalitate; GT - pentru mai mare; GE - mai mare sau egal; LT - mai mic; LE - mai mic sau egal; Sintaxa pentru utilizarea acestor operatori este: < expresie 1 > [operator] < expresie 2 >

• Operatori de tip şi de conversie Aceşti operatori specifică/analizează tipul operanzilor din memorie sau alte expresii, sau pot realiza conversie de tip. HIGH, LOW < expresie > data_16 equ 0 abcdh mov ah, high data_16 mov al, low data_16 SEG < expresie > Furnizează adresa de segment a unei adrese exprimată printr-o expresie: variabilă, operand memorie, etichetă, numele unui segment sau numele unui grup de segmente. Exemplu: beta dw. . . mov bx, seg beta mov ds, bx

• OFFSET < expresie > expresie: variabilă (simplă sau structurată), operand memorie, etichetă. Valoarea este cunoscută în momentul editării de legături, când se face alinierea finală a segmentului, deoarece offseturile de la asamblare se pot modifica, la locatare, dacă segmentul este combinat cu părţi ale aceluiaşi segment, definite în alte module sau dacă nu este aliniat la un paragraf. sir dw. . . . mov bx, offset sir ; adresa de început a şirului mov si, 0 ; se iniţializează indexul. . . add ax, [bx] [si] ; se însumează elementele Dacă se utilizează directiva group operatorul OFFSET nu va returna offsetul variabilei din grup, ci offsetul variabilei din segmentul său. Pentru a returna offsetul variabilei din grupul respectiv trebuie utilizat prefixul grupului respectiv. dgrup group data 1, data 2

data 1 segment. . . data 1 ends data 2 segment. . . val db. . dw val ; offsetul în cadrul segmentului ; furnizat de asamblor dw dgrup: val ; offsetul în grup dd val ; offset în segment + adresa segment dd drgup: val ; offset în grup + adresa segment data 2 ends mov bx, offset val ; offset în segment mov bx, offset dgrup: val ; offset în grup

TYPE < expresie > Furnizează un număr întreg ce reprezintă tipul expresiei; pt. variabilă - numărul de octeţi pe care se reprezintă componentele byte- 1; word- 2; dword- 4; qword- 8; pword- 6; fword- 6; tbyte- 10; structură - numărul de octeţi ai structurii; Se utilizează, de obicei, în calcule asupra vectorilor sau structurilor, pentru a determina adresa următorului element. Dacă argumentul este de tip etichetă: near - ffff. H; far - fffe. H; Exemple: var dw. . . mov bx, type var ; (BX) = 2 vector dd 10 dup (? ) mov si, type vector ; (SI) = 4 num_BCD dt 13245768, . . . mov bx, type num_BCD; (BX) = 10

LENGTH < expresie > Furnizează o valoare întreagă ce reprezintă numărul de elemente ale unei variabile (declarată utilizând operatorul DUP). Dacă variabila a fost declarată prin utilizarea operatorului DUP imbricat, atunci va returna o valoare asociată operatorului exterior. Dacă variabila nu a fost declarată utilizând operatorul DUP, atunci operatorul LENGTH va returna valoarea 1. n 1 db 50 dup (? ); n 2 dw 150 dup (0, 1, ? ); n 3 dd 200 dup (10, 20, 15 dup (? )); mes db 'Exemplu de mesaj'; length n 1 = 50; length n 2 = 150; length n 3 = 200; length mes = 1;

SIZE < expresie > Furnizează o valoare ce reprezintă numărul de octeţi ocupaţi de o variabilă, şi este în relaţie cu LENGTH şi TYPE prin identitatea: SIZE = LENGTH * TYPE Dacă o variabilă a fost declarată utilizând operatorul DUP imbricat, SIZE furnizează, conform relaţiei anterioare, numai valoarea operatorului DUP exterior. Pentru declaraţiile anterioare acest operator va furniza următoarele valori: size n 1 = 50; size n 2 = 300; size n 3 = 800; size mes = 1; PTR < expresie > Acest operator realizează conversia de tip pentru o variabilă, operand memorie sau etichetă fie pentru a specifica tipul adresării, fie pentru a permite adresarea unor date cu un alt tip decât cel cu care au fost declarate. Sintaxa acestui operator este: tip PTR < expresie >

unde 'tip' poate fi: BYTE, WORD, DWORD, QWORD, PWORD, FWORD, TBYTE sau nume de structură pentru operanzi din memorie şi variabile, sau NEAR, FAR, PROC sau unknown pentru etichete de instrucţiuni, nume de proceduri. De fapt acest operator asociază următoarele atribute expresiei:

a) Explicitarea referinţei la memorie, pentru referinţe anonime: inc byte ptr [bx]; inc word ptr [si] mov byte ptr [bx], 99; and word ptr [bp], 100 b) Specificarea tipului de salt (intersegment sau intrasegment): jmp dword ptr [bx] jmp near ptr etich ; pentru 'etich' în alt modul, c) Referirea unor variabile cu un alt tip decât cel iniţial: aw dw 0 abc. H, 12 ab. H ab db 0 a. H, 12 H mov al, byte ptr aw mov ax, word ptr ab d) Crearea unei variabile anonime la un offset dat dintr-un segment: mov al, ds: byte ptr 5; referă octetul de la ds: 5, mov al, ds: [5] mov bx, data 1: word ptr 3000 H; ref. cuv. de la offset ; 3000 H din segmentul data 1: mov bx, data 1: [3000]

Operatorul THIS Operatorul creează un operand cu adresa de segment şi offset egale cu cele ale locaţiei curente. Tipul sau ‘distanţa’ sunt specificate de operator: this tip unde 'tip': BYTE, WORD, DWORD, QWORD sau TBYTE pentru operanzi din memorie şi variabile, sau NEAR, FAR, PROC pentru etichete. El poate fi utilizat, de obicei, cu directivele EQU sau semnul =. Exemplul următor defineşte eticheta param: param equ this byte echivalent cu: param label byte Alt exemplu, instrucţiunea: mov bx, this word va încărca în registrul BX valoarea 8 B 1 Eh, care este codul operaţiei mov bx, memorie. Simbolul contor de locaţii ‘$’ este echivalent cu: this near

SHORT <expresie> Operator acceptă un argument de tip etichetă (un offset adresabil prin registrul segment CS). Se utilizează în instrucţiuni de salt condiţionat, necondiţionat şi în instrucţiuni de apel de procedură, când codul ţintă are un deplasament autorelativ de un octet cu semn (adică ţinta saltului este în intervalul -128 ÷ 127 faţă de instrucţiunea de salt): jmp short etich Pentru referinţe externe (adică pentru etichete definite în alte module, de tipul near) va genera un deplasament pe 16 biţi. WIDTH, MASK Aceşti operatori sunt folosiţi pentru a returna numărul de biţi sau o mască de biţi pentru o înregistrare (date structurate). model record A: 3, B: 1, C: 4, D: 5, E: 3 mov cx, mask C ; (CX) = 000 0 1111 00000 = 0 f 00 H mov cl, width D ; (CL) = 5, dimensiunea câmpului D mov cl, C ; (CL) = 8, poziţia câmpului C

Prioritatea operatorilor 1. length, size, width, mask, (), [ ], < >, oper. câmp de structura. ; 2. seg, offset, type, ptr, prefix segment : ; 3. high, low; 4. +, - (operatorii unari); 5. *, /, mod, shl, shr; 6. +, - (operatori binari); 7. eq, ne, gt, lt, ge, le (operatori relaţionali); 8. not; 9. and; 10. or, xor; 11. short.

Definirea şi iniţializarea etichetelor Etichetele identifică locaţii de memorie ale instrucţiunilor, operanzilor sau (apeluri) de proceduri. Ele au trei atribute: segment, deplasament (offset) şi 'distanţa' (near sau far) pentru etichete de instrucţiune şi nume de proceduri, sau tip (byte, word etc. ) pentru etichete de operanzi. etich_near: mov ax, bx proc_alfa label near calcul proc near beta proc far etich_far label far Această directivă nu avansează contorul de program ($). stiva segment dw 100 dup (? ) varf_stiva label word stiva ends

Directiva EQU Permite asignarea unei valori, la asamblare, la un simbol. <nume> EQU <expresie> unde expresia poate fi: - constantă: val 1 equ 1 valc equ 5*5 - orice expresie corectă în limbaj de asamblare: inreg record A: 5, B: 5, C: 5 v 321 equ inreg < 3, 2, 1 > e 1 equ (mask a) or (0 f 0 h and mask b) - simbol definit anterior: unu equ val 1 - şir de caractere, cu diferite semnificaţii: referinţă indexată: rbp equ [bp + 8] ; folosit astfel: mov ax, rbp. camp - operator prefix segment şi operanzii săi: rdsbp 8 equ ds: [bp + 8]

- nume de instrucţiuni: IDAI equ AAD - şir de caractere: octet equ <db> ; se poate folosi în loc de db numele octet; sir_car equ <’mesaj’, 0 DH, 0 AH, ‘$’> ; sau sir_car equ ’mesaj’, 0 DH, 0 AH, ‘$’ Observaţie: parantezele unghiulare trebuie utilizate, neapărat, la redefinirea pseudoinstrucţiunilor, pentru a le delimita precis. Asemănător, pentru valori numerice, se poate folosi şi operatorul = cu sintaxa: <nume> = <expresie> Diferenţa dintre cei doi operatori este că numele simbolice ce folosesc operatorul EQU nu îşi pot modifica valoarea pe durata asamblării programului, pe când identificatorii definiţi cu operatorul = îşi pot modifica valoarea: n=0 şi apoi se poate redefini: n=n+1

Simbolul contor program $ (contor locaţii) Simbolul $ reprezintă adresa curentă a contorului program, adică adresa relativă în cadrul segmentului curent a instrucţiunii sau datelor de asamblat. La începutul fiecărui segment contorul de locaţii este iniţializat la zero şi este actualizat de asamblor pe măsura asamblării programului. lista dw 11, 22, 33, 0 aah lung_lista equ ($ - lista)/2 mesaj db ' mesaj $ ' lung_mesaj equ $ - mesaj În ambele exemple s-a determinat numărul de elemente, respectiv de cuvinte/octeţi, din cele două declaraţii utilizând acest simbol. Directiva ORG Contorul de locaţii poate fi iniţializat cu o anumită valoare, pozitivă, cu această directivă, astfel: ORG < expresie >

org 100 h ; ce urmează în continuare va fi depus în ; segmentul respectiv de la adresa relativă 100 h org offset $ + 100 ; se rezervă, de la ultimul octet ; asamblat, 100 octeţi neiniţializaţi Directiva nu poate fi asignată la o etichetă; o declaraţie de forma start: org 100 h va genera o eroare. În schimb putem proceda astfel: org 100 h start: . . sau pentru date: date label byte org $ + 100 şi în acest fel se rezervă 100 de octeţi de la adresa specificată. org offset $ - 100 ; declaraţie fără sens

Definirea şi utilizarea segmentelor Un segment este definit ca o colecţie de instrucţiuni sau date, ale căror adrese sunt relative faţă de începutul segmentului (faţă de registrul segment corespunzător). Specificarea segmentelor se poate face în două moduri: - definire simplificată a segmentelor; - definire completă a segmentelor. Cele patru registre segment la care procesorul are acces în orice moment, CS, DS, ES şi SS pot corespunde la patru segmente fizice distincte sau pot exista suprapuneri parţiale sau totale acestor segmente. Forma completă de definire a segmentelor nume_seg SEGMENT [tip_alin][tip_comb][tip_utiliz][clasa_seg]. . . . < corpul segmentului >; instrucţiuni sau date nume_seg ENDS

mov ax, <nume_seg> mov ds, ax ; în mod asemănător pentru ES sau SS tip_aliniere, este o informaţie referitoare la adresa fizica, de început, la care este depus segmentul în memorie, divizibilă cu 1, 2, 4, 16 sau 256, acest tip poate fi: byte, word, dword, para, page; tip_combinare, sau tip segment constituie o informaţie pentru editorul de legaturi, care specifică raportul dintre acest segment şi alte segmente definite în alte module obiect. Dacă tipul de combinare nu este specificat se va genera în mod implicit tipul de combinare private. Parametrul tip de combinare poate fi: public, common, at <adresă>, memory, stack, none RAM_graph segment at 0 b 800 H start_buffer label byte RAM_graph ends mov ax, RAM_graph mov es, ax; assume es: RAM_graph

tip_utilizare - atribut mod de utilizare, pentru procesoarele de la 386 în sus, ce poate lua valorile: USE 16, USE 32 sau FLAT; Ca tip_utilizare se mai pot utiliza şi atribute de tipul readonly, pentru ca asamblorul să genereze mesaje de eroare la încercarea (doar la asamblare) de a scrie în acel segment. Cu toate acestea, la execuţia programului, acesta poate să scrie într-un astfel de segment. Modul 1: aseg segment byte public 'code' start: . . . . aseg ends bseg segment . . . . Bseg ends word common 'data'

cseg segment para stack 'stack' . . . . cseg ends dseg segment. ends at 0 B 800 H segment. byte public 'code' . . . dseg end start Modul 2 aseg. . . asegends

bseg segment. . . bseg ends end word common 'data' • Segmentele se dispun în mem. în ordinea în care au fost declarate. • Segmentul de stivă, declarat complet, şi se utilizează directiva dosseg, este dispus, întotdeauna, după celelalte segmente. Dacă are clasa 'stack', SP va fi iniţializat automat cu dimensiunea stivei. În cazul utilizării directivei DOSSEG, care poate fi utilizată pentru directivele complete/ simplificate, segmentele vor fi dispuse în ordinea logică: cod, date, stivă.

Segmente imbricate Segmentele nu sunt niciodată fizic imbricate (incluse unul întraltul), totuşi este permis să se codifice o porţiune de segment, să se înceapă un alt segment şi să se termine, după care să se termine codul început primul. code 1 segment assumecs: code 1, ds: data 1. . . . data 1 segment. . . . data 1 ends. . . . code 1 ends

În schimb aceste segmente nu se pot intersecta: data 3. . . . data 4. . . . data 3. . . . data 4 segment ends

Directive simplificate de segmentare. MODEL tip_model Prin această directivă se specifică dimensiunea şi modul de dispunere a segmentelor în memoria RAM: tiny LP + LD + LS < 1 segment (64 K) small LP < 1 seg (64 K), LD + LS < 1 seg. medium - LP > 1 seg (64 K), LD + LS < 1 seg. compact - LP < 1 seg (64 K), LD + LS > 1 seg. large LP > 1 seg (64 K), LD + LS > 1 seg. huge - la fel cu modelul anterior, cu diferenţa că referinţele sunt normalizate. LP, LD, LS - lungime program, date, stivă. Aceste abrevieri pot reprezenta şi număr de segmente de cod / date (LP), (LD); pentru modelul small sunt doar câte un segment pentru cod şi unul pentru date, în timp ce pentru modelul large sunt definite mai mult de câte un segment atât pentru cod cât şi pentru date.

. model small, C. model large, Pascal (echivalentă cu modelul TPascal). STACK [dimensiune]. CODE [nume]. DATA? - pentru date neiniţializate, referinţe de tip NEAR; . FARDATA [nume] - date iniţializate sau nu, ref. de tip FAR; . FARDATA? [nume] - date neiniţializate, referinţe de tip FAR; . CONST - segment cu date de tip "citeşte numai" (constante), care pot rezida şi în ROM; Segmentele definite cu directivele: . data, . const, . data? , . stack -> ‘DGROUP’ DGROUP _DATA, CONST, _BSS, STACK iar pentru modelele ‘small’ şi ‘compact’, linia sursă pentru directiva: ASSUME CS: nume_TEXT, DS: DGROUP, SS: DGROUP

Simboluri predefinite: @CODE - numele segmentului de cod; @DATA? , @DATA - numele segmentului de date (ne)iniţializate; @FARDATA - numele segmentului de date iniţializate, de tip FAR; @FARDATA? - numele segmentului de date neiniţializate, FAR; @CURSEG - numele segmentului curent executat; forma: @curseg ends conduce la închiderea segmentului curent; Aceste simboluri pot fi utilizate în directivele ASSUME, şi la iniţializarea registrelor segment: assume cs: @code, ds: @data mov ax, @data mov ds, ax Alte simboluri predefinite: @FILENAME; @CODESIZE; @DATASIZE

COMMENT această directivă permite comentarii pe mai multe linii: COMMENT delimitator [comentarii] [comnetarii. . . ] delimitator [comentarii] COMMENT $ acesta este un comentariu pe mai multe $ linii

date segment word public 'data' mesaj db 'exemplu program 1 a$' date ends cod segment word public 'code' assume cs: cod, ds: date, ss: stiva start: mov ax, date ; iniţializare registru segment mov ds, ax ; pentru date DS mov dx, offset mesaj ; iniţializare adresă mesaj în DX mov ah, 9 ; apel funcţia 9 - DOS, de tipărire int 21 h ; a unui text, cu adresa dată în DX mov ax, 4 c 00 h ; revenire în DOS int 21 h cod ends

stiva segment dw 10 stiva ends end start. model small. stack 10. data mesaj. code start: mov mov int db word stack 'stack' dup (? ) ; rezervare memorie pentru stivă 'exemplu program 1 b$' ax, @data ; iniţializare reg segment ds, ax ; pentru date DS dx, offset mesaj ; iniţializare adresă mesaj în DX ah, 9 ; apel funcţia 9 - DOS, de tipărire 21 h ; a unui text, cu adresa dată în DX

end mov int start ax, 4 c 00 h 21 h ; revenire în DOS Asocierea segmentelor cu registrele Pseudoinstrucţiunea ASSUME <reg_segment>: <segment> unde <segment> este numele unui segment sau grup de segmente, sau operatorul SEG, urmat de numele unei variabile sau numele unei etichete, din segmentul respectiv: assume cs: code, ds: dgrup, es: SEG var_a, ss: SEG varf_stiva assume <reg_seg> : NOTHING ; anulează asocierea assume NOTHING ; care anulează toate asocierile făcute. • ASSUME este o pseudoinstrucţiune pentru care nu se generează cod, rolul său fiind numai de a informa asamblorul care este intenţia programatorului.

data 1 segment alfa db 5 beta dw 25 data 1 ends data 2 segment var 1 dw 0 var 2 dw 100 data 2 ends cod segment assume cs: cod, ds: data 1, es: data 2 start: mov ax, data 1 mov ds, ax mov ax, data 2 mov es, ax

; referiri la date mov bx, beta ; se va utiliza DS, beta data 1 DS mov alfa, al ; alfa data 1 din ASSUME DS add var 1, bx ; var 1 data 2 ES ; modificăm conţinutul lui DS mov ax, cs mov ds, ax assume ds: cod mov data_cs, bx ; se va utiliza DS mov cs: data_cs, cx ; utilizare explicită a lui CS. . . . data_cs dw 1000 cod ends end start

Iniţializarea registrelor segment Registrele CS: IP sunt iniţializate de SO (Sistemul de Operare) la încărcarea programului executabil în memorie, pentru execuţie, astfel încât ele să conţină adresa primei instrucţiuni ce trebuie executată din program. Această instrucţiune este etichetată şi se specifică cu directiva END: END [adresa_de_start] Registre SS: SP iniţializarea va fi făcută de utilizator, dacă se utilizează directive complete de segmentare şi nu se specifică tipul şi clasa segmentului de stivă. Dacă, însă, se utilizează directive simplificate, sau directive complete, cu precizarea tipului şi clasei 'stack', atunci cele două registre vor fi iniţializate automat (SP va fi iniţializat cu dimensiunea segmentului de stivă, declarată în directiva. stack, sau rezervată în declararea completă a segmentului de stivă).

stiva segment dw 100 dup (? ) ; se rezervă 100 cuvinte pt. stivă varf_stiva label word stiva ends assume cs: seg_cod, ds: seg_date, ss: stiva. . . mov ax, seg_date ; iniţializare DS mov ds, ax mov ax, stiva ; iniţializare SS mov ss, ax mov sp, offset varf_stiva ; iniţializare SP Registrele segment (DS, ES etc. ) trebuie iniţializate explicit şi întotdeauna de programator, conform directivei ASSUME.

Prefix segment reg_seg : instrucţiune (referinţă) Cu toate că această construcţie are avantajul că nu necesită directiva ASSUME, ea are două dezavantaje: - este valabilă doar pentru o instrucţiune; - este mult mai uşor de greşit. exemplu segment assume cs: exemplu data_cs dw 1000 start: mov ax, seg rez ; iniţializare registre segment mov es, ax ; ES şi DS cu segmentele respective mov ax, seg val 1 mov ds, ax mov ax, data_cs add ax, ds: val 1 ; utilizare explicită a lui DS mov es: rez, ax ; utilizare explicită a lui ES

Referinţe anonime [bx] , [bp] , word ptr [si] , byte ptr [di] , [bx]. camp, Reguli pentru determinarea registrului segment implicit - pentru registrele de bază: SS pentru BP, DS pentru BX; - pentru registrele index: DS pentru ambele registre index (DI, SI). • ori de câte ori se utilizează registrul de bază BP, fără nume de variabilă sau prefix segment, se va utiliza pentru adresare segmentul referit de SS, altfel se va utiliza cel referit de DS

seg_date segment d 1 dw 3 dup (3) d 2 db 5 dup (5) seg_date ends cod segment assume cs: cod, ds: seg_date start: . . . mov bx, offset d 2 mov al, [bx] ; utilizare implicită a registrului DS mov bp, sp mov dx, [bp] ; utilizare implicită a registrului SS mov ax, es: [bp] ; utilizare explicită a registrului ES mov ax, d 1[2] ; utilizare explicită a registrului DS mov ds: [bp+si], ax ; explicit DS mov si, offset d 1 mov [si], dx ; utilizare implicită a registrului DS. . . . cod ends

Definirea şi utilizarea grupurilor de segmente. Directiva GROUP Se poate utiliza directiva GROUP, pentru a specifica că anumite segmente se află în acelaşi segment fizic de memorie: <nume_grup> GROUP <lista_nume_segmente> - conţine nume de segmente, sau expresii: SEG nume_variabilă sau SEG nume_etichetă Numele grupului poate fi utilizat: - pentru a iniţializa un RS; - într-o pseudoinstrucţiune ASSUME: assume ds: dgrup mov ax, dgrup mov ds, ax - ca prefix operand: mov ax, offset dgrup: var 1 ; offsetul în grup dd dgrup: var 2 ; adresa în cadrul grupului

cod 1 extrn cod 1 cod 2 extrn cod 2 data 1 extrn data 1 data 2 extrn data 2 segment proc 1: near ends segment proc 2: near ends segment d 1: byte ends segment d 2: word ends public dgrup cgrup group data 1, data 2 group cod 1, cod 2, code public

code segment public assume cs: cgrup, ds: dgrup start: mov ax, dgrup mov ds, ax. . . mov al, d 1. . . mov d 2, ax. . . call proc 2. . . code ends end start