This is an old revision of the document!
În acest laborator vom introduce noțiunea de structură din limbajul assembly și vom lucra cu operații specializate pe șiruri.
Structurile sunt folosite pentru a grupa date care au tipuri diferite, dar care pot fi folosite împreună pentru a crea un tip compus.
În continuare vom trece prin pașii necesari pentru a folosi o structură: declararea, instanțierea și accesarea câmpurilor unei structuri.
În NASM, o structură se declară folosind construcția struc <nume structura>
, urmată de o listă de câmpuri și încheiată cu endstruc
.
Fiecare câmp al structurii este definit prin următoarele: o etichetă (folosită pentru a putea accesa membrii), specificatorul de tip și numărul de elemente.
Exemplu:
struc mystruct a: resw 1 ; a va referi un singur element de dimensiune un cuvânt b: resd 1 ; b va referi un singur element de dimensiune un dublu cuvânt c: resb 1 ; c va referi un singur element de dimensiune un octet d: resd 1 ; d va referi un singur element de dimensiune un dublu cuvânt e: resb 6 ; e va referi 6 elemente de dimensiune un octet endstruc
res
pentru a defini tipul de date și numărul de elemente pentru fiecare dintre câmpurile structurii. Pentru mai multe detalii despre sintaxa res
urmați acest link:
http://www.nasm.us/doc/nasmdoc3.html#section-3.2.2
Fiecare etichetă ce definește un câmp reprezintă offset-ul câmpului în cadrul structurii. De exemplu, b
va avea valoarea 2, deoarece sunt 2 octeți de la începutul structurii până la câmpul b
(primii 2 octeți sunt ocupați de cuvântul a
).
.
(dot) astfel:
struc mystruct1 .a: resw 1 .b: resd 1 endstruc struc mystruct2 .a: resd 16 .b: resw 1 endstruc
Folosiți contrucția mystruct2.b
pentru aflarea valorii offset-ului lui 'b' din cadrul structurii mystruct2.
O primă variantă pentru a avea o structură în memorie este de a declara-o static în secțiunea .data
. Sintaxa folosește macro-urile NASM istruc
și iend
și keyword-ul at
.
În exemplul următor este prezentată instanțierea statică a structurii declarate mai sus, unde struct_var
este adresa din memorie de unde încep datele.
struct_var: istruc mystruct at a, dw -1 at b, dd 0x12345678 at c, db ' ' at d, dd 23 at e, db 'Gary', 0 iend
Pentru a accesa și/sau modifica un anumit membru al structurii instanțiate trebuie să îi cunoaștem adresa. Această adresă se poate obține calculând suma dintre adresa de început a structurii și offset-ul din cadrul structurii al membrului dorit .
Următoarea secvență de cod prezintă punerea unei valori în câmpul b
al structurii și, ulterior, afișarea valorii acestui câmp.
mov eax, 12345 mov dword [struct + b], eax ; adresa câmpului b este adresa de bază a structurii instanțiate static + offset-ul câmpului (dat de eticheta 'b') mov ebx, dword [struct + b] ; punerea valorii din câmpul b în registrul ebx pentru afișare PRINT_DEC 4, ebx NEWLINE
Putem considera un vector ca o înșiruire de elemente de același tip, plasate contiguu în memorie. Ați observat ceva similar în laboratoarele trecute când declaram static șiruri de caractere în secțiunea .data
.
În general, datele statice declarate pot fi inițializate sau neinițializate. Diferențierea se face atât prin faptul că la datele inițializate oferim o valoare inițială, dar și prin sintaxa NASM folosită.
De exemplu, pentru a declara un vector de 100 de cuvinte inițializate cu valoarea 42, vom folosi construcția:
section .data myVect: times 100 dw 42
Pe de altă parte, dacă dorim declararea unui vector de 20 de elemente dublu cuvinte neinițializate, folosim instrucțiuni din familia res
astfel:
section .bss myVect: resd 20
Deoarece operațiile pe vectori sunt des întâlnite în programe, au fost implementate instrucțiuni speciale care facilitează: transferul de date între doi vectori, compararea a doi vectori, găsirea unui element într-un vector, parcurgerea unui vector etc.
O instrucțiune pe vectori poate avea un operand sursă, unul destinație, sau pe amândoi. Convențional, șirul sursă se află poziționat în segmentul DS, iar șirul destinație în ES. Mai mult, registrul SI este utilizat ca offset pentru adresa elementului curent din șirul sursă, iar DI este offset pentru șirul destinație. În programele voastre, gruparea DS:SI se referă la registrul esi
, iar gruparea ES:DI la registrul edi
.
Deși fiecare dintre aceste instrucțiuni care vor fi prezentate în continuare pot fi folosite independent, există o construcție specială pentru a crea bucle, prin prefixarea instrucțiunii de operare pe șiruri cu una dintre următoarele mnemonici:
rep
- repetă cât timp ECX != 0repe
/repz
- repeat while »equal« (ex: repetă până găsim un element diferit în vector) și cât timp ECX != 0repne
/repnz
- repeat while »not equal« (ex: repetă până găsim un element comun în vector) și cât timp ECX != 0
Utilizarea unuia dintre aceste prefixe are ca efect repetarea instrucțiunii prin hardware, fapt care duce la o îmbunătățire a performanței (și chiar a memoriei, datorită eliminării surplusului de instrucțiuni ca jmp
și cmp
). Aceste bucle se numesc și bucle hardware.
Pe lângă registrele ESI și EDI, instrucțiunile din familia rep
mai folosesc următoarele resurse:
repz
și repnz
Valoarea direction flag-ului se poate seta folosind instrucțiunile următoare:
cld
- Clear Direction Flag - va seta DF = 0std
- Set Direction Flag - va seta DF = 1În continuare vor fi prezentate în detaliu instrucțiunile folosite pentru lucrul cu vectori.
Se transferă un element (octet/cuvânt/dublu cuvânt) de la sursă (DS:SI) la destinație (ES:DI) și se actualizează ESI și EDI pentru a face referire la următorul element din șir.
Utilizată împreună cu prefixul rep
, realizează un transfer de bloc memorie-memorie.
Dacă instructiunea conține numele operanzilor, asamblorul poate infera tipul șirului; dacă nu, trebuie specificat în mod explicit tipul operației: pe byte, word sau double word. Astfel, prototipurile posibile pentru această instrucțiune sunt:
movs <sir_dest>, <sir_src> movsb, movsw, movsd
Instrucțiunea realizează comparația dintre valoarea aflată la EDI și cea aflată la ESI (în această ordine, deci invers față de un CMP normal), și actualizează în mod corespunzător registrul de indicatori.
Împreună cu prefixul repe
/repz
, instrucțiunea determină prima pereche de elemente diferite din cele două șiruri.
Formele in care poate apărea această instrucțiune sunt similare cu instrucțiunea movs
:
cmps <sir_dest>, <sir_src> cmpsb, cmpsw, cmpsd
Această instrucțiune realizează o comparație între elementul curent al sirului destinație (ES:DI) și acumulator (AL/AX/EAX), și actualizează flag-urile. Apoi actualizează registrul ES:DI.
Mnemonici posibile:
scas <sir_dest> scasb, scasw, scasd
De exemplu, dacă vrem să căutăm prima apariție a caracterului 'a
' în șirul string
vom folosi o construcție de forma:
cld ; setăm DF = 0 mov al, 'a' ; char-ul pe care vrem să îl căutăm mov edi, string ; zona de memorie în care căutăm repne scasb ; parcurgem cu edi șirul cât timp caracterul la care pointează șirul este diferit de al ; edi acum pointează la următorul caracter după primul caracter 'a' sub edi, string ; aflăm diferența dintre apariția char-ului 'a' și începutul șirului dec edi PRINT_UDEC 4, edi
Instrucțiunea transferă elementul situat la adresa DS:SI în acumulator (AL/AX/EAX), și actualizează SI.
Nu are sens ca această instructiune să fie însoțită de prefixul de repetare, deoarece în acumulator ar rămâne numai ultimul element transferat. Din acest motiv, instrucțiunea se folosește numai în bucle soft.
lods <sir_src> lodsb, lodsw, lodsd
Instrucțiunea transferă un element din acumulator (AL/AX/EAX) în șirul destinație (adresat de ES:DI), actualizând DI pentru a indica la următorul element. Dacă e folosit împreună cu prefixul de repetare, putem inițializa un șir cu o constantă.
stos <sir_dest> stosb, stosw, stosd
Adesea vom avea nevoie de vectori care să conțină elemente de dimensiuni mai mari decât cea a unui cuvânt dublu. Pentru a obține acest lucru vom combina cele două concepte prezentate anterior și vom folosi vectori de structuri. Bineînțeles, instrucțiunile de operare pe șiruri nu vor funcționa, deci vom fi nevoiți să ne întoarcem la metoda clasică de accesare a elementelor: cea prin adresarea explicită a memoriei.
Pentru exemplul din această secțiune, creăm o structură ce reprezintă un punct într-un spațiu 2D.
struc point .x: resd 1 .y: resd 1 endstruc
Deoarece NASM nu suportă niciun mecanism pentru a declara explicit un vector de structuri, va trebui să declarăm efectiv o zonă de date în care să încapă vectorul nostru.
Considerând că ne dorim un vector zeroizat de 100 de elemente de tipul structurii point
(care este de dimensiune 8 octeți), trebuie să alocăm 100 * 8 (= 800) octeți.
Obținem:
section .data pointArray: times 800 db 0
În plus, NASM oferă o alternativă la calculul “de mână” al dimensiunii unei structuri, generând automat macro-ul <nume structura>_size
. Astfel, exemplul anterior poate deveni:
section .data pointArray: times point_size * 100 db 0
Cum am mai spus, pentru accesarea câmpului unui element dintr-un vector trebuie să folosim adresarea normală (în particular adresarea “based-indexed with scale”). Formula pentru aflarea adresei elementului este baza_vector + i * dimensiune_struct
.
Presupunând că avem în registrul ebx
adresa de început a vectorului și în eax
indicele elementului pe care dorim să îl accesăm, exemplul următor prezintă afișarea valorii câmpului y
a acestui element.
mov ebx, pointArray ; mutăm în ebx adresa de început a șirului mov eax, 13 ; să zicem că vrem al 13-lea element mov edx, [ebx + point_size * eax + point.y] ; se calculeaza adresa campului dorit intre [] ; si apoi se transfera valoarea de la acea adresa ; in registrul edx PRINT_UDEC 4, edx NEWLINE
Parcurgem vectorul, având la fiecare iterație indicele curent în registrul eax. Putem să afișăm valorile din ambele câmpuri ale fiecărui element din vector cu următorul program:
%include "io.inc" struc point .x: resd 1 .y: resd 1 endstruc section .data pointArray: times point_size * 100 db 0 section .text global CMAIN CMAIN: push ebp mov ebp, esp xor edx, edx xor eax, eax label: mov edx, [pointArray + point_size * eax + point.x] ; accesăm membrul x PRINT_UDEC 4, edx PRINT_CHAR ',' mov edx, [pointArray + point_size * eax + point.y] ; accesăm membrul y PRINT_UDEC 4, edx NEWLINE inc eax ; incrementarea indicelui de iterare cmp eax, 100 jl label leave ret
În cadrul exercițiilor vom folosi arhiva de laborator.
Pornind de la fișierul fibo_sum.asm
, implementați un program care calculează suma primelor N numere din șirul fibonacci utilizând instrucțiunea loop
.
Suma primelor 9 este 54.
Pornind de la fișierul memset.asm
, implementați un program care initializeaza primii n bytes ai unui sir
cu un caracter specificat in zona .data.
Folosiți instrucțiunea stosb
pentru a realiza stocarea caracterului în șir.
Output-ul programului după o rezolvare corectă este:
aaaaaaaaaaaaaaaaaaaamaximus, dictum nunc in, ultricies dui
Urmariti comentariile marcate cu TODO.
Pornind de la fișierul 2-3-strings/strings.asm
, implementati calcularea lungimii unui sir astfel încât la rularea programului să se afișeze:
strlen: 27
În implementare trebuie să folosiți instrucțiunea scasb
pentru a compara fiecare caracter cu terminatorul de șir.
Urmariti comentariile marcate cu TODO1.
Completați programul de mai sus adaugand implementarea functionalitatii de a calcula numarul de aparitii al unui caracter intr-un sir.
Folosiți instrucțiunea scasb
setând mai întâi ecx la lungimea șirului astfel încât repne
să se opreasca atunci când ecx = 0
și ZF = 1
.
Urmariti comentariile marcate cu TODO2.
În programul print_structure.asm
sunt afișate câmpurile unei structuri.
Urmăriți codul, observați construcțiile și modurile de adresare a memoriei. Rulați codul.
Scrieți cod în cadrul funcției main
astfel încât să modificați câmpurile structurii sample_student
pentru ca
1993
22
323CA
TODO
codul pentru modificarea structurii.
.data
, este vorba să folosiți cod pentru a modifca structura.
group
(adică octetul/caracterul cu indexul 2
).
Actualizați programul process-structure.asm
, astfel încât câmpul id
să fie inițializat la primele 3 litere din prenume, urmate de primele trei litere din nume, urmate de semnul -
(minus) și urmate de numele grupei. Adică pentru intrarea definită în fișier, afișarea va însemna mesajul AndVoi-321CA.
rep movsb
pentru a completa câmpul id
cu secvențele de subșiruri din prenume, nume și grupă.
id
trebuie să fie NULL
-terminat. Pentru aceasta va trebui să scrieți NULL
-terminatorul (adică 0
sau caracterul '\0'
pe ultima poziție a șirului.
Pentru a scrie un caracter pe o poziție a șirului (de exemplu caracterul -
sau NULL
-terminatorul) folosiți o construcție de forma
mov byte [sample_student + id + <index>], <character>
unde <index>
este index-ul unde vrem să scriem în cadrul șirului, iar <character>
este caracterul pe ca vrem să îl scriem.
Găsiți toate aparițiile subșirului substring
în șirul source_text
din fișierul find_substring.asm
.
Afișați rezultatele sub forma:
Substring found at index: <N>
cmps
.