Limbajul de asamblare al unui calculator este un limbaj de programare in care setul de baz_ al instruc_iunilor coincide cu opera_iile ma_inii _i ale c_rui structuri de date coincid cu structurile primare de date ale ma_inii.

Limbajul ma_in_ al unui SC este format din totalitatea instruc_iunilor ma_in_ puse la dispozi_ie de procesorul SC. Acestea se reprezint_ sub forma unor _iruri de bi_i cu semnifica_ie prestabilit_. In 1.1.5.6. am prezentat formatul instruc_iunilor ma_in_ pentru 8086.

In ultim_ instan__ deci, orice program apare in calculator ca un _ir (mare!) de bi_i. A manipula aceste structuri sub un astfel de format este extrem de dificil. Limbajul de asamblare vine s_ u_ureze aceast_ sarcin_. Astfel, codurile instruc_iunilor ma_in_ se rescriu sub forma unor cuvinte simbol, numite mnemonice, suficient de sugestive pentru a indica semantica instruc_iunii respective. Adresele de memorie frecvent folosite sunt notate _i ele prin ni_te cuvinte simbol, numite etichete.

Procesul de translatare in cod ma_in_ a unui program scris in limbaj de asamblare se nume_te asamblare _i este realizat de un program de conversie numit asamblor. In afar_ de inlocuirea instruc_iunilor simbolice ale programului surs_ prin cod ma_in_, asamblorul asigur_ _i prelucrarea adreselor simbolice, astfel incat fiecare adres_ simbolic_ este inlocuit_ prin adresa fizic_ corespunz_toare.

Elementele cu care lucreaz_ un asamblor sunt:

* etichete - nume scrise de utilizator, cu ajutorul c_rora acesta se poate referi la anumite date sau zone de memorie.

* instruc_iuni - scrise sub forma unor mnemonice care sugerea-z_ ac_iunea, fiecare instruc_iune a limbajului de asamblare corespunzand unei instruc_iuni ma_in_. Asamblorul genereaz_ octe_ii care codific_ instruc_iunea respectiv_.

* directive - sunt indica_ii date asamblorului in diverse sco-puri cum ar fi: rela_ii intre modulele obiect, definirea unor segmente, indica_ii de asamblare condi_ionat_, machete de macrogenerare, controlul listingului, etc. Directivele care indic_ asamblorului s_ incarce o zon_ de memorie cu un con_inut dorit de programator sau care cer rezervarea unui num_r de octe_i in vederea folosirii ulterioare se mai numesc _i pseudoinstruc_iuni. v6t18td

* contor de loca_ii - este un num_r intreg gestionat de asamblor. In fiecare moment, valoarea contorului coincide cu num_rul de octe_i genera_i corespunz_tor instruc_iunilor _i directivelor deja intalnite. Programatorul poate utiliza aceast_ valoare prin simbolul '$'.

Principalele servicii oferite de c_tre un asamblor (_i in consecin__ _i de c_tre asamblorul 8086) constau in:

- traducerea din scrierea cu mnemonice in cod binar
- generarea de octe_i folosind pseudoinstruc_iuni
- calculul unor adrese de salt (deplasamente) folosind opera_ii cu etichete
- evaluarea in timpul translat_rii a unor expresii aritmetice simple
- posibilitatea asambl_rii condi_ionate
- posibilitatea definirii _i utiliz_rii de macroinstruc_iuni
- detectarea erorilor de sintax_

2.1. FORMATUL UNEI LINII SURS_

Formatul unei linii surs_ in limbajul de asamblare 8086 este urm_torul:

aetichet_i amnemonic_i aoperanzii a;comentariui

Caracterele din care poate fi constituit_ o etichet_ sunt urm_toarele:

A - Z a - z _ @ $ ? 0 - 9

Cifrele 0-9 nu pot fi folosite ca prim caracter, iar simbolurile $ _i ? folosite singure au un in_eles special, ele neputand fi deci utilizate drept nume de simbol al utilizatorului.

La definirea lor in cadrul programelor, etichetele ce prefixeaz_ instruc_iuni trebuie s_ fie urmate de caracterul ':'. Fiecare etichet_ trebuie s_ fie definit_ o singur_ dat_ (cu alte cuvinte, etichetele trebuie s_ fie unice). Ca operand, o aceea_i etichet_ poate s_ apar_ ins_ de oricate ori in cadrul unui program. Valoarea unei etichete este un num_r intreg reprezentand adresa instruc_iunii sau directivei ce urmeaz_ etichetei.

Exist_ dou_ tipuri de mnemonice: mnemonice de instruc_iuni _i nume de directive. Directivele dirijeaz_ asamblorul. Ele specific_ modul in care asamblorul va genera codul obiect. Instruc_iunile dirijeaz_ procesorul. In momentul asambl_rii ele sunt transformate in cod obiect.

Operanzii sunt parametri care definesc valorile ce vor fi prelucrate de instruc_iuni sau de directive. Ei pot fi regi_tri, constante, etichete, expresii, cuvinte cheie sau alte simboluri. Semnifica_ia operanzilor depinde de mnemonica instruc_iunii sau directivei asociate.

Comentariile sunt folosite numai de c_tre utilizator pentru documentarea programului, fiind ignorate de c_tre asamblor. Orice text aflat dup_ punct _i virgul_ este considerat comentariu.

Parantezele drepte precizeaz_ c_ prezen_a elementului respectiv este op_ional_. A_adar, putem avea linii cu toate cele patru elemente prezente, dup_ cum putem avea _i linii f_r_ nici un element (linii vide) sau linii formate cu doar unul dintre cele patru elemente.

2.2. EXPRESII

O expresie const_ din mai mul_i operanzi care sunt combina_i pentru a descrie o valoare sau o loca_ie de memorie. Operatorii indic_ modul de combinare a operanzilor in scopul form_rii expresiei.

Expresiile sunt evaluate in momentul asambl_rii (adic_, valorile lor sunt determinabile la momentul asambl_rii, cu excep_ia acelor p_r_i care desemneaz_ con_inuturi de regi_tri _i care vor fi determinate la execu_ie).

2.2.1. Moduri de adresare

Operanzii instruc_iunilor pot fi specifica_i in diferite forme, numite moduri de adresare. Modurile de adresare indic_ procesorului modalitatea de a ob_ine valoarea real_ a unui operand in momentul execu_iei.

Relativ la modurile de adresare, cele trei tipuri de operanzi sunt operanzi imedia_i, operanzi registru _i operanzi in memorie. Valoarea operanzilor este calculat_ in momentul asambl_rii pentru operanzii imedia_i, in momentul inc_rc_rii programului pentru adresarea direct_ _i in momentul execu_iei pentru operanzii registru _i cei adresa_i indirect (vezi 1.1.5.8.).

Instruc_iunile care au doi sau mai mul_i operanzi opereaz_ intotdeauna de la dreapta spre stanga. Operandul din dreapta este operandul surs_. El specific_ datele care vor fi folosite in opera_ie, dar nu _i modificate. Operandul din stanga este operandul destina_ie. El specific_ datele care vor fi folosite _i, probabil, modificate de c_tre instruc_iune.

2.2.1.1. Utilizarea operanzilor imedia_i

Operanzii imedia_i sunt forma_i din date numerice constante cunoscute sau calculabile la momentul asambl_rii.

Constantele sunt utilizate ca operanzi in expresii. Limbajul de asamblare recunoa_te patru tipuri de valori constante: intregi, _iruri, numere reale _i constante impachetate codificate binar zecimal.

Constantele intregi reprezint_ valori intregi. Ele pot fi utilizate in declara_ii sau ca operanzi imedia_i.

Constantele intregi se specific_ prin valori binare, octale, zecimale sau hexazecimale. Baza de numera_ie se d_ printr-un specificator al bazei de numera_ie dup_ ultima cifr_ a num_rului, astfel: pentru numere binare specificatorul B, pentru cele octale -Q sau O, pentru numere zecimale - D _i pentru hexazecimale specificatorul H.

Pentru a nu fi tratate la asamblare drept simboluri, numerele hexazecimale trebuie s_ inceap_ intotdeauna cu o cifr_ hexazecimal_ cuprins_ intre 0 _i 9. De exemplu, OABCH este interpretat ca num_r hexazecimal, dar ABCH este interpretat ca simbol. Cifrele hexazecimale de la A la F precum _i specificatorii bazei de numera_ie pot fi atat litere mari cat _i mici. Exemple: 123d (echivalent cu 123), 94fah, 63701o, 01101011b, 0FAB2h, etc.

Dac_ nu se folose_te nici un specificator asamblorul interpreteaz_
intregul folosind baza de numera_ie implicit_. Ini_ial, baza de numera_ie implicit_ este cea zecimal_. Ea poate fi modificat_ cu ajutorul directivei RADIX, care are urm_toarea sintax_:

.RADIX expresie

unde expresie trebuie s_ fie unul din numerele 2, 8, 10 sau 16.

O constant_ de tip _ir este format_ din unul sau mai multe caractere ASCII delimitate de ghilimele sau de apostrofuri. Dac_ printre aceste caractere ASCII trebuie s_ apar_ caracterul delimitator, acesta trebuie dublat. Exemple: 'a', "a", "Acesta este un mesaj", 'Ia vino ''ncoa', "Ia vino 'ncoa", "Acest ""maestru"" este un farseur", 'Acest "maestru" este un farseur' etc.

Pentru unele instruc_iuni exist_ o limit_ maxim_ in ceea ce prive_te dimensiunea de reprezentare a valorilor imediate (de obicei 8, 16 sau 32 bi_i). Constantele _ir mai lungi de dou_ caractere (patru caractere la procesoarele 80386) nu pot fi date imediate. Ele trebuie s_ fie stocate in memorie inainte de a fi prelucrate de instruc_iuni.

Datele imediate nu sunt admise ca operand destina_ie (a_a cum nici 2:=N nu este o instruc_iune valid_ in nici un limbaj de programare de nivel inalt!).

Constantele intregi impachetate zecimal constituie un tip special de constante ce pot fi utilizate numai pentru ini_ializarea variabilelor codificate binar zecimal (BCD). Cu numere reale se poate opera numai in prezen_a unui coprocesor matematic. Am_nunte despre utilizarea acestor ultime dou_ genuri de valori sunt prezentate in a1i _i a2i.

2.2.1.2. Utilizarea operanzilor registru

Regi_trii sunt probabil cei mai des folosi_i operanzi in cadrul instruc_iunilor limbajului de asamblare. Ei pot servi ca operanzi surs_ sau ca operanzi destina_ie, putand con_ine _i adrese de salt pentru instruc_iunile rezervate acestui scop. In plus, exist_ unele instruc_iuni care pot fi folosite numai cu operanzi regi_tri _i instruc_iuni care pot fi folosite numai cu anumi_i regi_tri. Deseori, instruc_iunile au coduri mai scurte (_i opera_iile sunt mai rapide) dac_ este specificat registrul acumulator (AX sau AL). Regi_trii microprocesorului 8086 au fost prezenta_i in primul capitol, iar instruc_iunile care ii vor utiliza ca operanzi vor fi prezentate in capitolul 3.

Operanzii registru sunt forma_i din datele memorate in regi_tri. Modul de adresare direct_ in cazul regi_trilor inseamn_ folosirea valorii reale din interiorul registrului in momentul execu_iei instruc_iunii. De asemenea, regi_trii pot fi folosi_i indirect pentru a indica loca_iile de memorie, a_a cum va fi prezentat in 2.2.1.4.

2.2.1.3. Utilizarea operanzilor din memorie

Operanzii din memorie (termen care include _i no_iunea clasic_ de variabil_ cunoscut_ din limbajele de nivel inalt) se impart in dou_ grupuri: operanzi cu adresare direct_ _i operanzi cu adresare indirect_.

Cand se d_ un operand in memorie, procesorul calculeaz_ adresa datelor care vor fi prelucrate. Aceast_ adres_ se nume_te adres_ efectiv_. A_a cum se va vedea in continuare calcularea adresei efective depinde de modalitatea in care este specificat operandul.

Observa_ie. Dup_ cum rezult_ _i din 1.1.5.6., nu sunt admise opera_iile pentru care atat sursa cat _i destina_ia sunt operanzi din memorie.

Operandul cu adresare direct_ este o constant_ sau un simbol care reprezint_ adresa (segment _i deplasament) unei instruc_iuni sau a unor date. Ace_ti operanzi pot fi etichete, nume de proceduri sau valoarea contorului de loca_ii. Deplasamentul unui operand cu adresare direct_ este calculat in momentul asambl_rii. Adresa fiec_rui operand raportat_ la structura programului executabil (mai precis stabilirea segmentelor la care se raporteaz_ deplasamentele calculate) este calculat_ in momentul edit_rii de leg_turi. Adresa fizic_ efectiv_ este calculat_ in momentul inc_rc_rii programului pentru execu_ie.

Adresa efectiv_ este intotdeauna raportat_ la un registru de segment. Registrul de segment implicit pentru adresarea direct_ a datelor este cel specificat in directiva ASSUME corespunz_toare (a se vedea in acest sens _i 2.3.1.). Segmentul implicit poate fi inlocuit cu ajutorul operatorului de prefixare segment (notat ":" _i care se mai nume_te, 'operatorul de specificare a segmentului' - vom reveni in 2.2.2.6.).

Observa_ie.
Dac_ este omis_ eticheta din adresarea direct_ folosit_ cu un index constant (de exemplu omiterea etichetei table din exprimarea tablea100hi), este necesar_ atunci specificarea unui segment. Deplasamentul operandului este considerat drept punctul de inceput al segmentului specificat (care trebuie s_ aib_ aceea_i valoare cu deplasamentul etichetei table in cazul nostru) plus deplasamentul indexat. De exemplu, ds:a100hi reprezint_ valoarea de la adresa 100h din segmentul referit de DS, exprimare echivalent_ cu ds:100h.

Dac_ se omite specificarea segmentului, este folosit_ valoarea constant_ (imediat_) a operandului _i nu valoarea pe care o indic_. De exemplu, a100hi desemneaz_ chiar valoarea 100h, _i nu valoarea de la adresa 100h.

2.2.1.4. Operanzi cu adresare indirect_

Operanzii cu adresare indirect_ (vezi 1.1.5.7.) utilizeaz_ regi_tri pentru a indica adrese din memorie. Deoarece valorile din regi_tri se pot modifica la momentul execu_iei, adresarea indirect_ este indicat_ pentru a opera in mod dinamic asupra datelor.

In cazul microprocesoarelor 8086 numai patru regi_tri pot fi folosi_i in adresarea indirect_: BX, BP (regi_tri de baz_), DI _i SI (regi_tri index). Orice tentativ_ de a folosi al_i regi_tri, diferi_i de cei patru de mai sus, intr o instruc_iune care acceseaz_ memoria indirect, va produce o eroare.

Regi_trii de baz_ sau index pot fi folosi_i separat sau impreun_, cu sau far_ specificarea unui deplasament. Forma general_ pentru accesarea indirect_ a unui operand de memorie este

(1) aregistru_de_baz_ + registru_index + deplasamenti

unde toate cele trei componente sunt op_ionale, ins_ trebuie s_ existe intotdeauna m_car o component_.

Deplasament este o expresie a c_rei valoare este determinabil_ la momentul asambl_rii. De exemplu, abx + di + table + 6i desemneaz_ un operand prin adresare indirect_, unde atat table cat _i 6 sunt deplasamente. Asamblorul calculeaz_ deplasamentul real adunand table _i 6, pentru a ob_ine deplasamentul total.

Operanzii registru_de_baz_ _i registru_index sunt folosi_i de obicei pentru a indica o adres_ de memorie referitoare la un tablou.

Dac_ BX este folosit ca registru de baz_ sau dac_ nu este specificat nici un registru de baz_, la calculul adresei efective a unui operand cu adresare indirect_, procesorul utilizeaz_ DS ca registru de segment implicit. Dac_ BP este folosit oriunde in operand, registrul de segment implicit este SS. Segmentul implicit poate fi inlocuit prin operatorul de prefixare segment (:), a_a cum se prezint_ in 2.2.2.6.

Pe lang_ forma standard dat_ mai sus, diverse asambloare sau moduri de asamblare permit _i alte modalit__i de a specifica operanzi cu adresare indirect_. Orice operator care indic_ adunarea (+,ai,.) poate fi folosit pentru a combina deplasamentul cu regi_tri de baz_ sau index. De exemplu, urm_toarele moduri de specificare sunt toate echivalente:

table abxi adii + 6 abx+6iadii + table
6 + table abx+dii table adii abxi
atable+bx+dii + 6 bx + di + tablea6i
abxiadii.table + 6 di + table + bxa6i

Cand se utilizeaz_ modurile de adresare baz_-index, unul dintre regi_tri trebuie s_ fie registru de baz_, iar cel_lalt trebuie s_ fie registru index. Urm_toarele instruc_iuni sunt incorecte:

mov ax,table abxi abpi ;ilegal dou_ registre de baz_ ! mov ax,table adii asii ;ilegal dou_ registre index !

Deci, s_ re_inem c_ pentru adresarea indirect_, esen_ial_ este specificarea intre paranteze drepte a cel pu_in unuia dintre elementele componente ale formei (1).

2.2.2. Utilizarea operatorilor

Limbajul de asamblare ofer_ o gam_ variat_ de operatori pentru combinarea, compararea, modificarea _i analiza operanzilor. Unii operatori lucreaz_ cu constante intregi, al_ii cu valori intregi memorate, iar al_ii cu ambele tipuri de operanzi.

Este important_ in_elegerea diferen_ei dintre operatori _i instruc_iuni. Operatorii efectueaz_ calcule cu valori constante determinabile la momentul asambl_rii. Instruc_iunile efectueaz_ calcule cu valori ce pot fi necunoscute pan_ in momentul execu_iei. De exemplu, operatorul de adunare (+) efectueaz_ adunarea in momentul asambl_rii, in timp ce instruc_iunea ADD efectueaz_ adunarea in timpul execu_iei.

Expresiile sunt evaluate conform urm_toarelor reguli:

Opera_iile cu prioritatea cea mai mare sunt efectuate primele.

Opera_iile cu accea_i prioritate se execut_ de la stanga la dreapta.
Ordinea de prioritate poate fi modificat_ prin folosirea pa- rantezelor. Opera_iile din paranteze se efectueaz_ intotdeauna inaintea oric_ror opera_ii adiacente.

In tabelul de mai jos sunt prezenta_i in ordinea priorit__ii operatorii ce pot fi folosi_i in cadrul expresiilor limbajului de asamblare 8086. Operatorii de pe aceea_i linie au prioritate egal_.

maxim_
1
2
3
4
5
6
7
8
9
10
11
12
13 minim_
(), ai, <>, LENGTH, SIZE, WIDTH, MASK
.(selector pentru membru al unei structuri)
HIGH,LOW
+, (unar)
: (precizarea explicit_ a segmentului)
PTR, OFFSET, SEG, TYPE, THIS
*, /, MOD, SHL, SHR
+, (binar)
EQ, NE, LT, LE, GT, GE
NOT
AND
OR, XOR SHORT, .TYPE, SMALL, LARGE

In continuare vom descrie unii dintre cei mai utiliza_i operatori in cadrul instruc_iunilor limbajului de asamblare 8086 _i vom da exemple de expresii formate cu ace_ti operatori.

2.2.2.1 Operatori aritmetici

Limbajul de asamblare dispune de o gam_ variat_ de operatori aritmetici pentru opera_iile matematice uzuale. Ei sunt prezenta_i in tabelul de mai jos.

Pentru to_i operatorii aritmetici, cu excep_ia operatorului de adunare (+) _i a celui de sc_dere ( ), expresiile asupra c_rora se efectueaz_ opera_iile trebuie s_ fie constante intregi. Operatorii de adunare si sc_dere pot fi folosi_i pentru efectuarea opera_iilor de adunare _i sc_dere intre o constant_ intreag_ _i un operand in memorie. Rezultatul poate fi folosit ca operand in memorie. Operatorul de sc_dere poate fi de asemenea folosit pentru a efectua sc_derea intre doi operanzi in memorie, dar numai in cazul in care operanzii adreseaz_ loca_ii din interiorul aceluia_i segment. In acest caz rezultatul va fi o constant_, reprezentand num_rul de octe_i dintre cele dou_ loca_ii desemnate.

OPERATOR
SINTAXA SEMNIFICA_IE
+ + expresie pozitiv (unar)
- - expresie negativ (unar)
* expresie1 * expresie2 inmul_ire
/ expresie1 / expresie2 imp_r_ire intreag_
MOD expr1 MOD expr2 rest (modulo)
+ expresie1 + expresie2 adunare
- expresie1 - expresie2 sc_dere

De exemplu, fie A _i B dou_ etichete definite intr-un acela_i segment. Presupunem c_ A are valoarea 100h (deplasamentul ei in cadrul segmentului este 100h), iar B are valoarea 150h. Atunci, expresia A+5 are valoarea 105h, A-7 are valoarea 0F9h. Atat A+5 cat _i A-7 pot fi folosi_i ca operanzi in memorie. Expresia B-A are valoarea 50h _i poate fi folosit_ ca _i o constant_ intreag_.

2.2.2.2. Operatorul de indexare

Operatorul de indexare (ai) indic_ o adunare. El este similar cu operatorul de adunare (+). Sintaxa lui este

aexpresie_1i aexpresie_2i

Ca efect, se adun_ expresie_1 cu expresie_2. Restric_iile privind adunarea operanzilor p_stra_i in memorie ce se aplic_ la operatorul de adunare sunt valabile _i pentru operatorul de indexare. De exemplu, nu se pot aduna doi operanzi in memorie adresa_i in mod direct. Expresia eticheta_1 aeticheta_2i nu este admis_ dac_ ambii sunt operanzi in memorie.

Operatorul de indexare are o utilizare larg_ in specificarea operanzilor din memorie adresa_i indirect. Paragraful 2.2.1 a clarificat rolul operatorului ai in adresarea indirect_.

2.2.2.3. Operatori de deplasare de bi_i

Operatorii SHR (SHift Right) _i SHL (SHift Left) realizeaz_ deplas_ri ale expresiei operand (la dreapta pentru SHR _i respectiv la stanga pentru SHL) cu un num_r de bi_i egal cu valoarea celui de-al doilea operand. Bi_ii din dreapta (pentru SHL) _i cei din stanga (pentru SHR) sunt completa_i cu zerouri cand con_inuturile lor sunt deplasate in afara pozi_iilor limitrofe. Sintaxa instruc_iunilor este:

expresie SHR cu_cat _i expresie SHL cu_cat

expresie este deplasat_ la dreapta sau la stanga cu un num_r cu_cat de bi_i. Bi_ii deplasa_i dincolo de un cap_t sau de cel_lalt al reprezent_rii expresiei sunt pierdu_i. In cazul in care cu_cat este mai mare sau egal cu 16 (32 pe 80386), rezultatul este 0. O valoare negativ_ pentru cu_cat cauzeaz_ deplasarea valorii expresiei in direc_ie opus_. Exemple (presupunem c_ expresia se reprezint_ pe un octet):

01110111b SHL 3 ; desemneaz_ valoarea 10111000b
01110111b SHR 3 ; desemneaz_ valoarea 00001110b

Operatorii SHR _i SHL nu trebuie confunda_i cu instruc_iunile omonime ale procesorului (care vor fi tratate in capitolul urm_tor). Operatorii ac_ioneaz_ asupra constantelor intregi numai la momentul asambl_rii. Instruc_iunile procesorului ac_ioneaz_ asupra valorilor p_strate in regi_tri sau in memorie la momentul execu_iei. Asamblorul deosebe_te din context instruc_iunile SHR _i SHL de operatorii SHR _i respectiv SHL.

2.2.2.4. Operatori logici pe bi_i

Operatorii pe bi_i efectueaz_ opera_ii logice la nivelul fiec_rui bit al operandului (operanzilor) unei expresii. Expresiile au ca rezultat valori constante. Tabelul urm_tor con_ine lista operatorilor logici _i semnifica_ia acestora.

OPERATOR
SINTAXA SEMNIFICA_IE
NOT NOT expresie complementare bi_i
AND expr1 AND expr2 _I bit cu bit
OR expr1 OR expr2 SAU bit cu bit
XOR expr1 XOR expr2 SAU exclusiv bit cu bit

Exemple (presupunem c_ expresia se reprezint_ pe un octet):

NOT 11110000b ; desemneaz_ valoarea 00001111b
01010101b AND 11110000b ; are ca rezultat valoarea 01010000b
01010101b OR 11110000b ; are ca rezultat valoarea 11110101b
01010101b XOR 11110000b ; are ca rezultat valoarea 10100101b

2.2.2.5. Operatori rela_ionali

Un operator rela_ional compar_ (cu semn!) dou_ expresii _i intoarce valoarea adev_rat ( 1) cand condi_ia specificat_ de operator este indeplinit_, sau valoarea fals (0) cand nu este indeplinit_. Indiferent de dimensiunea de reprezentare, valoarea -1 se reprezint_ in cod complementar ca un _ir de bi_i, avand to_i valoarea 1. Expresiile evaluate au ca rezultat valori constante. Numele _i semantica acestor operatori sunt similare celor din FORTRAN. Ei sunt: EQ (EQual), NE (Not Equal), LT (Less Than), LE (Less or Equal), GT (Greater Than) _i GE (Greater or Equal). Exemple:

4 EQ 3 ; fals (0) - 4 LT 3 ; adev_rat (-1)
4 NE 3 ; adev_rat ( 1) - 4 GT 3 ; fals (0)

2.2.2.6. Operatorul de specificare a segmentului

Operatorul de specificare a segmentului (:) comand_ calcularea adresei FAR a unei variabile sau etichete in func_ie de un anumit segment. Sintaxa este:

segment:expresie

unde segment poate fi specificat in mai multe moduri. El poate fi unul dintre regi_tri de segment: CS, DS, SS, sau ES (sau FS sau GS pe 80386). El poate fi de asemenea un nume de segment. In acest caz, numele trebuie s_ fie definit in prealabil cu o directiv_ SEGMENT (pe care o vom prezenta in 2.3.1.) _i eventual asociat unui registru de segment cu o directiv_ ASSUME (o vom prezenta tot in 2.3.1.). Expresie poate fi o constant_, o expresie sau o expresie SEG (vezi in continuare 2.2.2.7.). Exemple:

ss:abx+4i ; deplasamentul e relativ la SS es:082h ; deplasamentul e relativ la ES date:var ; adresa de segment este adresa de inceput a
; segmentului cu numele date, iar offsetul
; este valoarea etichetei var.

2.2.2.7. Operatori de tip

In acest paragraf sunt descri_i operatorii limbajului de asamblare care specific_ sau analizeaz_ tipurile unor expresii _i a unor operanzi p_stra_i in memorie.

Operatorul PTR

Operatorul PTR specific_ tipul (in_eles in sensul dimensiunii de reprezentare) pentru o variabil_ sau o etichet_ de cod. Sintaxa este

tip PTR expresie

Operatorul for_eaz_ ca expresie s_ fie tratat_ ca avand dimensiunea de reprezentare tip. Pentru operanzii p_stra_i in memorie, tip poate fi BYTE, WORD, DWORD, QWORD sau TBYTE, avand dimensiunile de reprezentare 1, 2, 4, 8 _i respectiv 10 bi_i. Pentru etichetele de cod el poate fi NEAR (adres_ pe 2 octe_i) sau FAR (adres_ pe 4 octe_i).

Operatorul PTR este folosit pentru a da posibilitatea instruc_iunilor s_-_i "vad_" operanzii ca fiind de tipul indicat in cazul in care ace_tia au alt tip. De exemplu, operatorul PTR poate fi folosit pentru a accesa octetul cel mai semnificativ al unei variabile de dimensiune WORD. Deasemenea, indiferent de semnifica_ia lui A, expresia byte ptr A va indica doar primul octet de la adresa indicat_ de A. Analog, dword ptr A indic_ dublucuvantul ce incepe la adresa A.

Operatorul THIS

Operatorul THIS creeaz_ un operand ale c_rui valori de deplasament _i segment sunt egale cu valoarea curent_ a contorului de loca_ii _i al c_rui tip este specificat de operator. Sintaxa lui este:

THIS tip

Pentru operanzii p_stra_i in memorie, tip poate fi BYTE, WORD, DWORD, QWORD sau TBYTE. Pentru etichete, tip poate fi NEAR sau FAR. Operatorul THIS se folose_te de obicei cu directivele EQU sau = pentru crearea unor etichete sau variabile. Rezultatul este similar cu cel ob_inut prin utilizarea directivei LABEL (despre directive vom vorbi in 2.3).

Reiese deci c_ forma THIS tip este echivalent_ cu tip PTR $.

Operatorii HIGH si LOW

Operatorii HIGH _i LOW intorc octetul cel mai semnificativ, respectiv cel mai pu_in semnificativ, al unei expresii constante reprezentat_ pe cuvant. Sintaxa lor este:

HIGH expresie _i LOW expresie

Operatorul HIGH intoarce cei mai semnificativi opt bi_i din expresie; operatorul LOW intoarce cei mai pu_in semnificativi opt bi_i. Expresia are ca rezultat o constant_ octet.

Operatorii SEG _i OFFSET

Sintaxele acestor doi operatori sunt:

SEG expresie _i OFFSET expresie

unde expresie adreseaz_ direct o loca_ie de memorie.

Operatorul SEG intoarce adresa de segment a loca_iei de memorie referite. Valoarea intoars_ de operatorul OFFSET este o constant_ reprezentand num_rul de octe_i dintre inceputul segmentului _i loca_ia de memorie referit_. Valorile intoarse de ace_ti doi operatori sunt determinate la momentul inc_rc_rii programului, ele r_manand neschimbate pe parcursul execu_iei. Ca exemplu, s_ consider_m eticheta V, a c_rei adres_ far este 5AFDh:0003. Atunci SEG (V+5) va avea valoarea 5AFDh iar OFFSET (V+5) va avea valoarea 0008.

2.3. DIRECTIVE

Directivele indic_ modul in care sunt generate codul _i datele in momentul asambl_rii. Majoritatea directivelor au ca operanzi constante _ir sau numerice _i simboluri sau expresii care sunt evaluate la astfel de constante.

Tipul operandului difer_ de la o directiv_ la alta, dar operandul este evaluat intotdeauna la o valoare cunoscut_ cel tarziu in momentul inc_rc_rii. Prin acest aspect directivele difer_ de instruc_iuni, ai c_ror operanzi pot fi necunoscu_i in momentul asambl_rii _i pot varia in timpul execu_iei.

2.3.1. Directive standard pentru definirea segmentelor

La un moment dat microprocesorul poate s_ aib_ acces la patru segmente logice: segmentul de cod curent, segmentul de date curent, segmentul de stiv_ _i segmentul de date suplimentar. Aceste segmente logice pot s_ corespund_ la patru segmente fizice distincte, dar pot s_ existe _i suprapuneri.

Exist_ dou_ tipuri de directive segment: directive segment standard (SEGMENT, ENDS, ASSUME _i GROUP - pe care le vom discuta in cele ce urmeaz_) _i directive segment simplificate (a c_ror prezentare complet_ cititorul interesat o poate g_si in a1i).

2.3.1.1. Directiva SEGMENT

Inceputul unui segment de program este definit cu directiva SEGMENT, iar sfar_itul segmentului este definit cu directiva ENDS.
Sintaxa unei definiri de segment este urm_toarea:

nume SEGMENT aalinierei acombinarei autilizarei a'clasa'i

ainstruc_iunii nume ENDS

Numele segmentului este definit de eticheta nume. Acestui nume i se asociaz_ ca valoare adresa de segment (16 bi_i) corespunz_toare pozi_iei segmentului in memorie in faza de execu_ie. Fiind o etichet_, numele trebuie s_ fie unic in cadrul modulului surs_. Un nume de segment poate fi utilizat de mai multe ori intr un fi_ier surs_ numai dac_ fiecare defini_ie de segment ce utilizeaz_ acel nume va avea fie exact acelea_i atribute, fie atribute care concord_.

Argumentele op_ionale aliniere, combinare, utilizare _i 'clasa' dau editorului de leg_turi _i asamblorului indica_ii referitoare la modul de inc_rcare _i combinare a segmentelor. In absen_a unor argumente vor fi utilizate valori implicite.

Argumentul op_ional aliniere specific_ multiplul num_rului de octe_i la care trebuie s_ inceap_ segmentul respectiv. Alinierile posibile sunt urm_toarele:

- BYTE - multiplu de 1 (adres_ de octet)
- WORD - multiplu de 2 (adres_ de cuvant)
- DWORD - multiplu de 4 (adres_ de dublu cuvant)
- PARA - multiplu de 16 (adres_ de paragraf)
- PAGE - multiplu de 256 (adres_ de pagin_)

Dac_ argumentul aliniere lipse_te, atunci se consider_ implicit c_ este vorba despre o aliniere tip PARA.

Argumentul op_ional combinare controleaz_ modul in care segmente cu acela_i nume din cadrul altor module vor fi combinate cu segmentul in cauz_ la momentul edit_rii de leg_turi. Valorile posibile sunt:

- PUBLIC - indic_ editorului de leg_turi s_ concateneze acest segment cu alte eventuale segmente cu acela_i nume, ob_inandu-se un unic segment a c_rei lungime este suma lungimilor segmentelor componente.

- COMMON - specific_ faptul c_ inceputul acestui segment trebuie s_ se suprapun_ peste inceputul tuturor segmentelor ce au acela_i nume. Se ob_ine un segment avand dimensiunea egal_ cu cea a celui mai mare segment avand acela_i nume.

- AT <expresie> - impune ca segmentul s_ fie inc_rcat in memo- rie la adresa reprezentat_ de valoarea expresiei.

- STACK - segmentele cu acela_i nume vor fi concatenate.

In faza de execu_ie segmentul rezultat va fi segmentul stiv_.

- MEMORY - segmentele cu acest atribut vor fi a_ezate in me- morie in spa_iul disponibil r_mas dup_ inc_rcarea in memorie a segmentelor de argument combinare diferit de MEMORY.

Dac_ nu se d_ nici un tip de combinare, segmentele cu acela_i nume nu vor fi combinate, fiecare primind o zon_ de memorie separat_.

Observa_ii.
1. Pentru programele care se inten_ioneaz_ a deveni programe .COM (vezi 4.5.2) nu trebuie specificat_ alinierea.

2. In mod normal, intr un program se va furniza minimum un segment de stiv_ (cu ajutorul tipului de combinare STACK). Dac_ nu este declarat nici un segment de stiv_, atunci editorul de leg_turi va considera spa_iu pentru stiv_ in continuarea unuia dintre segmentele existente.

Argumentul utilizare se folose_te numai in cazul microprocesoarelor 80386 _i celor ulterioare pentru specificarea m_rimii cuvantului.
Argumentul 'clasa' are rolul de a permite stabilirea ordinii in care editorul de leg_turi plaseaz_ segmentele in memorie. Toate segmentele avand aceea_i clas_ vor fi plasate intr-un bloc contiguu de memorie indiferent de ordinea lor in cadrul codului surs_. Numele claselor se vor da cu litere mari. Numele 'STACK' este rezervat pentru segment de stiv_.

Directiva GROUP este utilizat_ pentru a combina dou_ sau mai multe segmente intr-o singur_ entitate logic_, astfel incat toate segmentele componente s_ poat_ fi adresate relativ la un singur registru segment.

2.3.1.2. Directiva ASSUME _i gestiunea segmentelor

Directiva ASSUME are sintaxa general_

ASSUME CS:nume1, SS:nume2, DS:nume3, ES:nume4

unde ordinea specific_rilor de dup_ ASSUME nu este important_, oricare _i oricate dintre acestea putand s_ lipseasc_. Fiecare dintre nume1, nume2, nume3 _i nume4 este un nume de segment sau cuvantul rezervat NOTHING.

Rolul directivei ASSUME este de a preciza asamblorului regi_trii de segment ce trebuie utiliza_i pentru calculul adreselor efective ale etichetelor _i ale variabilelor folosite in program. Existen_a acestei directive este necesar_, deoarece un program poate fi alc_tuit din mai multe segmente _i este necesar ca asamblorul s_ cunoasc_ in fiecare moment care sunt segmentele active.

Prefixarea explicit_ a etichetelor _i variabilelor cu numele registrului de segment corespunz_tor (deci utilizarea operatorului de specificare a segmentului) furnizeaz_ in mod imediat aceast_ informa_ie, avand prioritate in cazul respectiv fa__ de asocierea declarat_ prin directiva ASSUME.

Facem de la inceput precizarea c_ prezen_a acestei directive nu este necesar_ (avand doar caracter de documentare) in cazul in care programul nu acceseaz_ etichete _i variabile (astfel de programe sunt ins_ extrem de rare). Deasemenea, dac_ operanzii in cadrul acces_rilor indirecte nu fac referiri la etichete (de exemplu abx+2i sau abp+dii) atunci se folose_te ca registru de segment SS dac_ apare BP _i respectiv DS in celelalte cazuri. Aceste asocieri se fac automat, independent de ASSUME.

Este foarte important de re_inut faptul c_ rolul acestei directive nu este _i de a inc_rca regi_trii segment cu adresele corespunz_toare !

Valoarea din CS (adresa de segment a segmentului de cod curent) este gestionat_ automat in timpul execu_iei, programatorul avand acces doar in citire asupra acestei valori. Pentru accesarea etichetelor din cadrul unui segment de cod este necesar_ specificarea numelui segmentului printr-o directiv_ ASSUME. Consider_m urm_torul exemplu, in care folosim instruc_iunea JMP (salt necondi_ionat la eticheta specificat_), instruc_iune pe care o vom prezenta in capitolul 3:

ASSUME CS:c ;asociaz_ registrul segment CS
;cu segmentul de cod c c segment start: jmp far ptr etd ;salt far necondi_ionat la eticheta ;etd din cadrul segmentului de cod d etc: jmp x ;salt near necondi_ionat la eticheta local_ x x: . . . c ends

ASSUME CS:d
;realizeaz_ o nou_ asociere a registrului segment CS,
;de ast_ dat_ cu segmentul d. Vechea asociere este anulat_, cea ;curent_ r_manand valabil_ pan_ la o nou_ directiv_ ASSUME sau pan_ ;la sfar_itul textului surs_.

d segment etd: jmp y ;salt near necondi_ionat la eticheta local_ y y: jmp far ptr etc ;salt far necondi_ionat la eticheta etc ;din cadrul segmentului de cod c d ends end start

Observa_ie. Dac_ segmentul de cod nu con_ine referiri la etichete locale, prezen_a unei directive ASSUME nu mai este obligatorie. Astfel, exemplul de mai jos con_ine dou_ segmente de cod, fiecare con_inand doar o instruc_iune: salt far necondi_ionat in cel_lalt segment. Se observ_ c_ spre deosebire de exemplul anterior aici nu apare nici o directiv_ ASSUME:

c segment start: jmp far ptr etd ;salt far necondi_ionat la eticheta etd etc : . . . ;din cadrul segmentului de cod d c ends

d segment etd: jmp far ptr etc ;salt far necondi_ionat la eticheta etc . . . ;din cadrul segmentului de cod c d ends end start

Dup_ cum am mai afirmat, pentru un program scris in limbaj de asamblare este normal ca programatorul s_ furnizeze minimum un segment de stiv_.

Sunt foarte rare cazurile cand elementele din stiv_ se acceseaz_ prin etichete. De obicei, opera_iile la nivel de stiv_ se rezum_ la introducerea sau scoaterea de cuvinte in _i respectiv din varful stivei.

Directiva ASSUME pentru SS este necesar_ numai in cazul in care se define_te un segment de stiv_ _i numai dac_ exist_ acces_ri de elemente ale stivei prin intermediul unor etichete definite in acest segment. De exemplu:

s segment stack 'STACK'
. . . v db . . .
. . . s ends

ASSUME SS:s c segment start:
. . . ; se poate accesa v din stiv_ c ends end start

In ceea ce prive_te accesarea datelor, un program poate avea la un moment dat 0, 1 sau 2 segmente active de date. Dac_ o dat_ este accesat_ prin eticheta ei, atunci segmentul in care este definit_ trebuie s_ fac_ obiectul unei asocieri prin directiva ASSUME cu registrul segment DS sau ES. Dac_ se dore_te accesarea simultan_ a datelor din dou_ segmente, unul dintre ele va fi asociat registrului DS (va fi segment principal de date) iar cel_lalt se va asocia cu ES (segment suplimentar de date). Dac_ nume3 sau nume4 este NOTHING atunci asocierea respectiv_ este anulat_. Se intampl_ frecvent ca DS _i ES s_ fie asocia_i la acela_i segment de date.

In ceea ce prive_te inc_rcarea regi_trilor de segment, preciz_m urm_toarele:

- registrul CS este inc_rcat automat
- registrul SS este deasemenea inc_rcat automat. Dac_ programatorul dore_te s_ schimbe segmentul de stiv_, atunci el trebuie s_ incarce noua valoare in SS (d_m mai jos un exemplu)
- regi_trii DS _i ES, in cadrul programelor .EXE (vezi 4.5.3) trebuie inc_rca_i de c_tre programator.

Anticipand instruc_iunea MOV (care va fi prezentat_ in 3.1.1) d_m mai jos un exemplu de accesare a datelor din dou_ segmente de date. S_ facem precizarea c_ regi_trii de segment nu pot fi inc_rca_i direct, ci numai printr-un intermediar (registru sau stiv_). In cazul nostru, intermediar este registrul AX:

d1 segment
. . . a1 . . . ;definire a1
. . . d1 ends

d2 segment
. . . a2 . . . ;definire a2
. . . d2 ends

ASSUME CS:c, DS:d1, ES:d2

c segment

start: mov ax,d1 ;inc_rcarea registrului segmentului mov ds,ax ;principal de date

mov ax,d2 ;inc_rcarea registrului segmentului mov es,ax ;de date suplimentar

mov al,a1 ;accesare etichet_ a1 relativ la DS mov ah,a2 ;accesare etichet_ a2 relativ la ES

c ends end start

In final d_m un exemplu in care se lucreaz_ alternativ cu dou_ stive. Stiva ini_ial_ este segmentul VS, stiva alternativ_ este segmentul NS, iar segmentul de date este D:

d segment vsp . . . ;definire vsp vss . . . ;definire vss d ends

ns segment
. . . ;rezervare spa_iu stiv_ ns ends

vs segment stack 'STACK'
. . . ;rezervare spa_iu stiv_ vs ends

c segment

assume ds:d, ss:vs

start: mov ax,d mov ds,ax
; este activ_ stiva veche mov vsp,sp mov ax,ss mov vss,ax mov ax,ns mov ss,ax mov sp,200h 2
; este activ_ stiva noua mov ax,vss mov ss,ax mov sp,vsp
; este activ_ stiva veche c ends end start

Directive ASSUME pot fi inserate in textul surs_ oricand este considerat necesar de c_tre programator. Pentru a indica faptul c_ unul sau mai mul_i regi_tri segment nu pointeaz_ spre nici un segment se folose_te cuvantul rezervat NOTHING.

Orice program scris in limbaj de asamblare trebuie s_ con_in_ directiva END pentru marcarea sfar_itului codului surs_ al programului. Eventualele linii de program ce urmeaz_ directivei END sunt ignorate de c_tre asamblor. Sintaxa ei este

END aadresa_starti

unde adresa_start este o expresie sau un simbol op_ional indicand adresa din program de unde va incepe execu_ia. Intr-un program care const_ dintr-un singur modul (fi_ier surs_) specificarea adresei de start in cadrul directivei END este obligatorie. _i pentru un program constituit din mai multe module fiecare modul are in final o directiv_ END. Ins_ numai directiva END a modulului ce con_ine instruc_iunea de la care programul trebuie s_-_i inceap_ execu_ia va con_ine specificarea adresei de start. Semnifica_ia acestor reguli este clar_ _i natural_ - fiecare program trebuie s_ aib_ neap_rat un inceput, _i numai unul, indiferent de num_rul modulelor ce il compun. Eventualele excep_ii de la aceste reguli pot apare la nivelul leg_rii cu module scrise in alte limbaje de programare. Preciz_rile necesare in acest sens se vor aduce in capitolul 7.

2.3.2. Directive pentru definirea datelor

Definirea unei date inseamn_ specificarea atributelor acesteia _i alocarea spa_iului de memorie necesar.

Directivele de definire a datelor permit alocarea de memorie pentru date. In acela_i timp, pentru datele alocate se pot specifica valorile ini_iale. Datele pot fi specificate ca numere, _iruri de caractere sau expresii evaluate ca fiind constante. Asamblorul transform_ aceste valori constante in octe_i, cuvinte sau alte unit__i de date. Datele codificate sunt scrise in fi_ierul obiect in momentul asambl_rii.

Forma general_ a unei linii surs_ in cazul unei declara_ii de date este:

anumei tip_data lista_expresii a;comentariui sau
anumei tip_data factor DUP (lista_expresii) a;comentariui

unde nume este o etichet_ prin care va fi referit_ data. Acest nume are asociat un tip _i o valoare. Tipul rezult_ din tipul datei iar valoarea este adresa la care se va g_si in memorie primul octet rezervat pentru data etichetat_ cu numele respectiv.

Elementul lista_expresii reprezint_ lista unor expresii cu ale c_ror valori se vor ini_ializa zonele de date rezervate prin declara_ia respectiv_. Dac_ apare numai caracterul '?' atunci zona de date corespunz_toare va fi numai rezervat_, nu _i ini_ializat_.

factor este un num_r care indic_ de cate ori se repet_ lista de expresii care urmeaz_ in parantez_.

Tip_data este o directiv_ de definire a datelor, una din urm_toare-le:
DB - date de tip octet (BYTE)
DW - date de tip cuvant (WORD)
DD - date de tip dublucuvant (pointer - DWORD)
DQ - date de tip 8 octe_i (QWORD)
(utilizate pentru memorarea constantelor reale)
DT - date de tip 10 octe_i (TWORD)
(utilizate pentru memorarea constantelor BCD)

(de la microprocesorul 80386 incepand exist_ in plus dou_ directive - DF _i DP - ce definesc pointeri far pe 6 octe_i).

De exemplu, secven_a de mai jos define_te _i ini_ializeaz_ cinci variabile de memorie:

data segment varb DB 'd' ;1 octet varw DW 101b ;2 octe_i vard DD 2bfh ;4 octe_i varq DQ 307o ;8 octe_i (1 quadword) vart DT 100 ;10 octe_i data ends

Dup_ o directiv_ de definire a datelor pot s_ apar_ mai multe valori, permi_andu-se astfel declararea _i ini_ializarea de tablouri. De exemplu, declara_ia

Tablou DW 1,2,3,4,5

creaz_ un tablou de 5 intregi reprezenta_i pe cuvinte avand valorile respectiv 1,2,3,4,5. Dac_ valorile de dup_ directiv_ nu incap pe o singur_ linie se pot ad_uga oricate linii este necesar, linii ce vor con_ine numai directiva _i valorile dorite. Exemplu:

Tabpatrate DD 0, 1, 4, 9, 16, 25, 36
DD 49, 64, 81
DD 100, 121, 144, 169

Operatorul DUP se folose_te pentru definirea unor blocuri de memorie ini_ializate cu o anumit_ valoare. De exemplu

Tabzero DW 100h DUP (0)

rezerv_ 256 de cuvinte pentru tabloul Tabzero ini_ializandu-le cu 0, iar
Tabchar DB 80 DUP ('a')

creaz_ un tablou de 80 de octe_i ini_ializa_i fiecare cu codul ASCII al caracterului 'a'.

Dac_ se dore_te doar rezervarea de spa_iu de memorie pentru tablouri, f_r_ ini_ializarea acestora cu anumite valori se va folosi caracterul '?'. Intr-o astfel de situa_ie declara_iile de mai sus ar deveni

Tabzero DW 100h DUP (?)
Tabchar DB 80 DUP (?)

Dac_ dorim definirea de _iruri de caractere este suficient s_ _inem cont c_ ele sunt de fapt ca reprezentare intern_ _iruri de octe_i, asamblorul considerand echivalente declara_ii ca:

sirchar DB 'a','b','c','d' sirchar DB 'abcd'

Valoarea de ini_ializare poate fi _i o expresie, ca de exemplu in

vartest DW (1002/4+1)

Valoarea curent_ a contorului de loca_ii poate s_ fie referit_ cu ajutorul simbolului $ sau al expresiei this <tip>. Ca urmare, putem avea urm_toarele secven_e echivalente

tabcuv DW 50 DUP (?) tabcuv DW 50 DUP (?) lungtab DW $ - tabcuv lungtab DW this word - tabcuv
Mai d_m in continuare un exemplu care con_ine declara_ii _i ini_ializ_ri de date _i care este edificator in ceea ce prive_te posibilit__ile de combinare a facilit__ilor de declarare descrise pan_ aici:

data segment a1 DB 0,1,2,'xyz'

DB 2 SHL 4, "F"+3 a2 DB 3 DUP (44h) a3 DB 10 DUP (5 DUP (3), 11) a4 DW a2+1, 'bc'
DW 0ffddh, 0800h SHR 2 a5 DW 4 DUP ('13') a6 DD a4
. . . data ends

Declara_ia pentru a1 ini_ializeaz_ 6 octe_i cu valorile 0, 1, 2 _i codurile ASCII corespunz_toare caracterelor x, y _i z. Urmeaz_ doi octe_i ini_ializa_i cu valori rezultate in urma evalu_rii de c_tre asamblor a expresiilor respective. Pentru ace_ti octe_i nu a fost specificat un nume, ei putand fi ins_ referi_i relativ la a1. Valorile lor sunt: primul octet va con_ine num_rul 32 (2*2^4), iar al doilea codul ASCII al caracterului 'I' (al treilea de dup_ 'F'). Declara_ia pentru a2 ini_ializeaz_ 3 octe_i cu valoarea 44h. Declara_ia pentru a3 rezerv_ 60 de octe_i ini_ializa_i in ordine cu valorile 3,3,3,3,3,11,3,3,3,3,3,11,...Pentru a4 se vor rezerva 4 octe_i: 2 pentru valoarea rezultat_ prin incrementarea adresei a2 _i inc_ 2 pentru caracterele b _i c. Urmeaz_ 4 octe_i (din nou f_r_ nume ins_ putand fi referi_i relativ la a4) ini_ializa_i cu valorile rezultate in urma evalu_rii expresiilor corespunz_toare. Pentru a5 se vor rezerva 8 octe_i (4 cuvinte) ini_ializa_i in ordine cu 1,3,1,3,1,3,1,3. Pentru a6 se vor rezerva 4 octe_i con_inand adresa (segment:deplasament) variabilei a4.

2.3.3. Directivele LABEL, EQU, =

Directiva LABEL permite numirea unei loca_ii f_r_ alocarea de spa_iu de memorie sau generare de octe_i, precum _i accesul la o dat_ utilizand alt tip decat cel cu care a fost definit_ data respectiv_. Sintaxa este

nume LABEL tip

unde nume este un simbol ce nu a fost definit anterior in textul surs_, iar tip descrie dimensiunea de interpretare a simbolului _i dac_ acesta se va referi la cod sau la date.

Numele prime_te ca valoare contorul de loca_ii. Tip poate s_ fie una din urm_toarele:

BYTE NEAR FAR
WORD QWORD PROC
DWORD TBYTE UNKNOWN

Tipurile BYTE, WORD, DWORD, QWORD _i TBYTE eticheteaz_ respectiv date de 1, 2, 4, 8 _i 10 octe_i. Iat_ un exemplu de ini_ializare a unei variabile de memorie ca pereche de octe_i ins_ accesat_ ca _i cuvant:

data segment cod segment
. . . . . . varcuv LABEL WORD mov ax,varcuv
DB 1,2
. . . . . . data ends

Tipul PROC (existent numai in varianta TASM) va furniza un tip NEAR sau FAR (deci efectul acestui tip este similar cu cel al ultimelor dou_ tipuri prezentate) in func_ie de modelul de memorie folosit in cazul utiliz_rii directivelor segment simplificate (vezi capitolul 7 pentru am_nunte).

Tipul UNKNOWN declar_ un tip necunoscut _i este folosit atunci cand se dore_te s_ existe posibilitatea acces_rii unei variabile de memorie in mai multe moduri (se aseam_n_ cu tipul void din limbajul C). De exemplu, accesarea variabilei tempvar din secven_a de mai jos uneori ca octet _i alteori ca _i cuvant poate fi realizat_ prin declararea ei ca etichet_ de tip UNKNOWN:

data segment cod segment tempvar LABEL UNKNOWN . . .
DB ?,? mov tempvar,ax
. . . . . . data ends add dl,tempvar
. . .

Reamintim c_ o alt_ solu_ie pentru adresarea unei date cu un alt tip decat cel cu care a fost declarat_ este utilizarea operatorului de conversie PTR, prezentat in 2.2.2.7.

Directiva EQU permite atribuirea, in faza de asamblare, unei valori numerice sau _ir de caractere unei etichete. Sintaxa directivei EQU este nume EQU expresie

unde numelui ii este atribuit_ valoarea numeric_ a expresiei. Simbolul nume trebuie s_ fie un simbol neutilizat anterior sau utilizat anterior tot intr-o directiv_ EQU. Dac_ simbolul a fost utilizat anterior, el trebuie s_ fi avut ca rezultat al evalu_rii expresiei un _ir de caractere. Cu alte cuvinte nu se admit redefiniri de etichete decat in cazul echival_rii lor ini_iale cu _iruri de caractere. Exemple:

END_OF_DATA EQU '!'
BUFFER_SIZE EQU 1000h
INDEX_START EQU (1000/4 + 2)
VAR_CICLARE EQU i

Prin utilizarea de astfel de echival_ri textul surs_ poate deveni mai lizibil.

Se observ_ asem_narea etichetelor echivalate prin directiva EQU cu constantele din limbajele de programare de nivel inalt.

Expresia pentru echivalarea unei etichete definite prin directiva EQU poate con_ine la randul ei etichete definite prin EQU:

TABLE_OFFSET EQU 1000h
INDEX_START EQU (TABLE_OFFSET + 2)
DICTIONAR_STAR EQU (TABLE_OFFSET + 100h)

Directiva = este echivalent_ directivei EQU cu excep_ia urm_toare-lor aspecte:

- etichetele definite cu EQU nu pot fi redefinite in timp ce acelea definite cu = pot.

- operanzii expresiei directivei = trebuie s_ furnizeze in fi- nal o valoare numeric_, nefiind permis_ asignarea de _iruri de caractere etichetelor.

2.3.4. Directiva PROC

No_iunea de subrutin_ este cunoscut_ din studiul limbajelor de programare de nivel inalt. Ea ofer_ posibilitatea dezvolt_rii modulare a programelor, permi_and concentrarea aten_iei asupra punctelor esen_iale ale unui program, ignorandu-se in acele locuri detaliile de implementare. Deasemenea, prezen_a subrutinelor aduce avantajul reutiliz_rii codului (deci ob_inerea in final a unui cod cat mai compact), o subrutin_ fiind scris_ o singur_ dat_, putand fi ins_ apelat_ de oricate ori _i in orice punct al programului cu valori diferite ale eventualilor parametri.

In limbajul de asamblare 8086 definirea unei subrutine incepe cu o directiv_ PROC:

<nume_procedur_> PROC atip_apeli

unde nume_procedur_ este o etichet_ reprezentand numele procedurii, iar tip_apel este NEAR sau FAR. Dac_ lipse_te, atunci se consider_ implicit NEAR. Procedura va fi NEAR dac_ va fi apelat_ numai de c_tre segmentul de cod in care este definit_. Procedura va fi FAR dac_ va fi apelat_ _i din alte segmente de cod.

Directiva ENDP marcheaz_ sfar_itul unei subrutine ce incepe cu PROC. Sintaxa ei este

<nume_procedur_> ENDP

Intre cele dou_ directive se vor scrie instruc_iunile _i directivele corpului procedurii.

2.3.5. Blocuri repetitive

Un bloc repetitiv este o construc_ie prin care i se cere asamblorului s_ genereze in mod repetat o configura_ie de octe_i. Prezent_m in continuare trei tipuri de blocuri repetitive: REPT, IRP _i IRPC.

Un bloc repetitiv delimitat de directivele REPT _i ENDM are urm_toarea sintax_ de definire:

REPT contor secven__
ENDM

cu semnifica_ia c_ secven_a va fi asamblat_ de contor ori. De exemplu secven_ele

dw 0
REPT 5 dw 0 dw 0 _i dw 0
ENDM dw 0 dw 0 genereaz_ acela_i cod, lucru se poate realiza binein_eles _i cu

dw 5 DUP (0)

Exemplul urm_tor ins_ nu are un echivalent atat de simplu. El genereaz_ 5 loca_ii de memorie consecutive con_inand valorile de la 0 la 4. Folosim in acest scop _i directiva = :

Intval = 0 care va genera dw 0
REPT 10 dw 1 dw Intval dw 2
Intval = Intval + 1 dw 3
ENDM dw 4

De asemenea, blocurile repetitive pot fi imbricate. Secven_a

REPT 5
REPT 2 secven__
ENDM
ENDM

genereaz_ de 10 ori secven_a specificat_.

Directiva IRP are sintaxa

IRP parametru, <arg1 a,arg2i...> secven__
ENDM

Se efectueaz_ repetat asamblarea secven_ei, cate o dat_ pentru fiecare argument prev_zut in lista de argumente, prin inlocuirea textual_ in secven__ a fiec_rei apari_ii a parametrului cu argumentul curent. Argumentele pot fi _iruri de caractere, simboluri, valori numerice. De exemplu,

IRP param,<0,1,4,9,16,25> db 0 db param db 1
ENDM db 4 genereaz_ secven_a db 9 db 16 db 25 iar IRP reg,<ax,bx,cx,dx> mov ax,di mov reg,di mov bx,di
ENDM mov cx,di genereaz_ secven_a mov dx,di


Directiva IRPC are un efect similar, ea realizand ins_ inlocuirea textual_ a parametrului, pe rand, cu fiecare caracter dintr-un _ir de caractere dat. Sintaxa ei este

IRPC parametru,string secven__
ENDM

De exemplu IRPC nr,1375 db nr
ENDM

creaz_ 4 octe_i avand respectiv valorile 1, 3, 7 _i 5.

2.3.6. Directiva INCLUDE

Directiva INCLUDE are sintaxa

INCLUDE numefisier

Efectul ei (similar de exemplu cu cel al directivei #include a preprocesorului C) este de a insera textual fi_ierul numefisier in textul surs_ curent. Inserarea se face in locul in care apare directiva INCLUDE respectiv_. numefisier este specificarea unui nume de fi_ier DOS, putand a_adar s_ con_in_ specific_ri de unitate de disc, directoare, nume de fi_ier _i tip. In lipsa specific_rii unui tip se consider_ implicit .ASM. De exemplu, dac_ fi_ierul prog.asm con_ine codul

cod segment mov ax,1
INCLUDE INSTR2.ASM push ax
. . .

iar fi_ierul instr2.asm con_ine codul

mov bx,3 add ax,bx dec bx

rezultatul asambl_rii fi_ierului prog.asm va fi echivalent cu cel al asambl_rii codului

cod segment mov ax,1 mov bx,3 add ax,bx dec bx push ax
. . .

Fi_ierele incluse pot con_ine la randul lor alte directive INCLUDE, _.a.m.d. pan_ la orice nivel, instruc_iunile respective fiind inse-rate corespunz_tor pentru crearea in final a unui singur cod surs_.
2.3.7. Macrouri

Un macro este un text parametrizat c_ruia i se atribuie un nume. La fiecare intalnire a numelui, asamblorul pune in codul surs_ textul cu parametrii actualiza_i. Opera_ia este cunoscut_ _i sub numele de expandarea macroului. Se poate face o analogie cu directiva INCLUDE prezentat_ anterior. Fa__ de fi_ierele incluse, macrourile prezint_ un grad sporit de flexibilitate permi_and transmiterea de parametri _i existen_a de etichete locale.

Un macro este delimitat de directivele MACRO _i ENDM conform urm_toarei sintaxe:

nume MACRO aparametru a,parametrui...i corp instruc_iuni
ENDM

De exemplu, pentru interschimbarea valorilor a dou_ variabile cuvant putem defini urm_torul macro:

swap MACRO a,b mov ax,a mov a,b mov b,ax
ENDM

Pentru a cre_te consisten_a exemplelor de mai jos vom utiliza _i instruc_iuni care vor fi prezentate abia in urm_torul capitol. Oricum, in contextul acestei sec_iuni nu este esen_ial_ semnifica_ia lor precis_. Dorim doar promovarea unei baze de discu_ie asupra structurii programelor pentru a putea scoate in eviden__ semnifica_ia elementelor prezentate aici.

Pentru inmul_irea cu 4 a valorii unei variabile (rezultatul depunandu-se in DX:AX) se poate scrie urm_torul macro:

inmcu4 MACRO a mov ax,a sub dx,dx shl ax,1 rcl dx,1 shl ax,1 rcl dx,1
ENDM

O utilizare a sa sub forma inmcu4 varm va genera secven_a

mov ax,varm sub dx,dx shl ax,1 rcl dx,1 shl ax,1 rcl dx,1

Macrourile pot con_ine blocuri repetitive. In acest sens putem lua ca exemplu chiar macroul inmcu4 de mai sus, care se poate rescrie astfel: inmcu4 MACRO a mov ax,a sub dx,dx
REPT 2 shl ax,1 rcl dx,1
ENDM
ENDM

O posibil_ problem_ ce apare se refer_ la definirea unei etichete intr-un macro. S_ presupunem c_ intr-un macro se define_te o etichet_ _i in program exist_ mai mult de un apel al acelui macro. Eticheta definit_ va ap_rea la fiecare expandare a macroului in codul programului, cauzand o eroare de "redefinire de etichet_". Exemplu: scade MACRO jcxz Etich dec cx
Etich:
ENDM
. . . scade ;apare eticheta Etich
. . . scade ;_i aici apare Etich!
. . .

Solu_ia unei astfel de probleme este oferit_ de c_tre directiva LOCAL, care, la apari_ia ei in cadrul unui macro for_eaz_ ca domeniul de vizibilitate al etichetelor specificate ca argumente s_ fie numai acel macro. Solu_ia pentru exemplul de mai sus este: scade MACRO
LOCAL Etich jcxz Etich dec cx
Etich:
ENDM cele dou_ apeluri consecutive de mai sus fiind translatate in
. . . jcxz ??0000 dec cx
??0000:
. . . jcxz ??0001 dec cx
??0001:
. . .

Utilizarea directivei LOCAL trebuie s_ urmeze imediat directivei MACRO. Num_rul argumentelor nu este limitat.

S_ mai preciz_m deasemenea c_ nu sunt permise pentru macrouri referin_ele anticipate (forward references), macrourile trebuind s_ fie definite intotdeauna inaintea invoc_rii. Deasemenea, macrourile pot fi imbricate.

O alt_ problem_ poate s_ apar_ atunci cand parametrii formali sunt amesteca_i cu alt text. De exemplu, s_ presupunem c_ dorim s_ scriem un macro care s_ realizeze depunerea in stiv_ a con_inutului unuia din cei patru regi_tri generali (AX, BX, CX sau DX) in func_ie de valoarea parametrului rlitera care va fi a, b, c sau d respectiv ('x' fiind partea comun_ tuturor variantelor). Dac_ scriem: push_reg MACRO rlitera push rliterax
ENDM

asamblorul nu va putea determina faptul c_ o parte din _irul operand al lui push este de fapt parametrul formal al macroului _i va considera c_ este vorba de operandul rliterax.

Solu_ia este oferit_ de asamblor, care permite incadrarea in cadrul corpului macroului numelui parametrului formal intr-o pereche de caractere & (ampersand, numit operatorul de substitu_ie). La intalnirea textului cuprins intre cele dou_ &, asamblorul substituie acel text cu valoarea solicitat_ la apel. De exemplu

push_reg MACRO rlitera push &rlitera&x
ENDM
. . . push_reg b
. . .

se va asambla in push bx. S_ facem precizarea c_ operatorul de substitu_ie & poate fi utilizat _i in cadrul directivelor IRP sau IRPC. De exemplu:

IRP rlitera,<a,b,c,d> push ax push &rlitera&x push bx
ENDM genereaz_ push cx push dx

Dup_ cum am v_zut, macrourile pot con_ine blocuri repetitive. De asemenea macrourile pot invoca la randul lor alte macrouri. In exemplul push_reg MACRO registru push registru
ENDM
. . . push_toate_reg MACRO
IRP reg,<ax,bx,cx,dx,si,di,bp,sp> push_reg reg
ENDM
ENDM
. . .

macroul push_toate_reg con_ine un bloc repetitiv, care la randul lui con_ine o invocare a macroului push_reg.