1 / 44

Operatori Operatorii aritmetici unari: +, - (deci stabilesc semnul unei expresii),

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

howe
Télécharger la présentation

Operatori Operatorii aritmetici unari: +, - (deci stabilesc semnul unei expresii),

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. 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 >

  2. Operatori de deplasare < expresie > SHR < expr_contor > SHL • Operatori relaţionali Aceşti operatori compară două expresii, rezultatul fiind o valoare logică (true = ffH, sau false = 00H): 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 >

  3. 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 0abcdh 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

  4. 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 data1, data2

  5. data1 segment . . . . . . data1 ends data2 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 data2 ends mov bx, offset val ; offset în segment mov bx, offset dgrup:val ; offset în grup

  6. 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 - ffffH; far - fffeH; 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

  7. 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. n1 db 50 dup (?); n2 dw 150 dup (0, 1, ?); n3 dd 200 dup (10, 20, 15 dup (?)); mes db 'Exemplu de mesaj'; length n1 = 50; length n2 = 150; length n3 = 200; length mes = 1;

  8. 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 n1 = 50; size n2 = 300; size n3 = 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 >

  9. 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:

  10. 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 0abcH, 12abH ab db 0aH, 12H 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, data1: word ptr 3000H; ref. cuv. de la offset ; 3000H din segmentul data1: mov bx, data1:[3000]

  11. 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 8B1Eh, care este codul operaţiei mov bx, memorie. Simbolul contor de locaţii ‘$’ este echivalent cu: this near

  12. 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 000 = 0f00H mov cl, width D ; (CL) = 5, dimensiunea câmpului D mov cl, C ; (CL) = 8, poziţia câmpului C

  13. 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.

  14. 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

  15. Directiva EQU Permite asignarea unei valori, la asamblare, la un simbol. <nume> EQU <expresie> unde expresia poate fi: - constantă: val1 equ 1 valc equ 5*5 - orice expresie corectă în limbaj de asamblare: inreg record A:5, B:5, C:5 v321 equ inreg < 3, 2, 1 > e1 equ (mask a) or (0f0h and mask b) - simbol definit anterior: unu equ val1 - ş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: rdsbp8 equ ds:[bp + 8]

  16. - 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’, 0DH, 0AH, ‘$’> ; sau sir_car equ ’mesaj’, 0DH, 0AH, ‘$’ 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

  17. 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, 0aah 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 >

  18. org 100h ; ce urmează în continuare va fi depus în ; segmentul respectiv de la adresa relativă 100h 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 100h va genera o eroare. În schimb putem proceda astfel: org 100h 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

  19. 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 ale 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

  20. 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 0b800H start_buffer label byte RAM_graph ends mov ax, RAM_graph mov es, ax; assume es:RAM_graph

  21. tip_utilizare - atribut mod de utilizare, pentru procesoarele de la 386 în sus, ce poate lua valorile: USE16, USE32 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 word common 'data' ....... Bseg ends

  22. cseg segment para stack 'stack' ....... cseg ends dseg segment at 0B800H ...... . dseg ends end start Modul 2 aseg segment byte public 'code' ...... . aseg ends

  23. bseg segment word common 'data' ..... . bseg ends end • 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ă.

  24. Segmente imbricate Segmentele nu sunt niciodată fizic imbricate (incluse unul într-altul), 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. code1 segment assume cs:code1, ds:data1 ....... data1 segment ....... data1 ends ....... code1 ends

  25. În schimb aceste segmente nu se pot intersecta: data3 segment ....... data4 segment ....... data3 ends ....... data4 ends

  26. 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 (64K) small - LP < 1 seg (64K), LD + LS < 1 seg. medium - LP > 1 seg (64K), LD + LS < 1 seg. compact - LP < 1 seg (64K), LD + LS > 1 seg. large - LP > 1 seg (64K), 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.

  27. .model small, C .model large, Pascal (echivalentă cu modelul TPascal) .STACK [dimensiune] .CODE [nume] .DATA .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 GROUP _DATA, CONST, _BSS, STACK iar pentru modelele ‘small’ şi ‘compact’, linia sursă pentru directiva: ASSUME CS:nume_TEXT, DS:DGROUP, SS:DGROUP

  28. 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

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

  30. date segment word public 'data' mesaj db 'exemplu program 1a$' 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 21h ; a unui text, cu adresa dată în DX mov ax, 4c00h ; revenire în DOS int 21h cod ends

  31. stiva segment word stack 'stack' dw 10 dup (?) ; rezervare memorie pentru stivă stiva ends end start .model small .stack 10 .data mesaj db 'exemplu program 1b$' .code start: mov ax, @data ; iniţializare reg 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 21h ; a unui text, cu adresa dată în DX

  32. mov ax, 4c00h ; revenire în DOS int 21h end start Asocierea segmentelor cu registrele Pseudoinstrucţiunea ASSUME 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.

  33. data1 segment alfa db 5 beta dw 25 data1 ends data2 segment var1 dw 0 var2 dw 100 data2 ends cod segment assume cs:cod, ds:data1, es:data2 start: mov ax, data1 mov ds, ax mov ax, data2 mov es, ax

  34. ; referiri la date mov bx, beta ; se va utiliza DS, beta  data1  DS mov alfa, al ; alfa  data1  din ASSUME  DS add var1, bx ; var1  data2  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

  35. 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ă).

  36. 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.

  37. 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 val1 mov ds, ax mov ax, data_cs add ax, ds: val1 ; utilizare explicită a lui DS mov es: rez, ax ; utilizare explicită a lui ES

  38. 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

  39. seg_date segment d1 dw 3 dup (3) d2 db 5 dup (5) seg_date ends cod segment assume cs:cod, ds:seg_date start: ...... mov bx, offset d2 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, d1[2] ; utilizare explicită a registrului DS mov ds:[bp+si], ax ; explicit DS mov si, offset d1 mov [si], dx ; utilizare implicită a registrului DS ........ cod ends end start

  40. 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> <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:var1 ; offsetul în grup dd dgrup:var2 ; adresa în cadrul grupului

  41. cod1 segment public extrn proc1: near cod1 ends cod2 segment public extrn proc2: near cod2 ends data1 segment extrn d1: byte data1 ends data2 segment extrn d2: word data2 ends dgrup group data1, data2 cgrup group cod1, cod2, code

  42. code segment public assume cs:cgrup, ds:dgrup start: mov ax, dgrup mov ds, ax ..... mov al, d1 ..... mov d2, ax ..... call proc2 ..... code ends end start

More Related