Differences

This shows you the differences between two versions of the page.

--- laboratoare:laborator-07 [2015/11/24 16:10]
catalin.vasile3004 [Exerciții]
+++ laboratoare:laborator-07 [2015/11/27 18:38]
razvan.deaconescu [Sign bit. Left padding.]
@@ Line 109: / Line 109: @@
     ; loop code:
 for:
-    mov eax, byte [A + ecx*4] ; get a digit from A
+    mov eax, dword [A + ecx*4] ; get a digit from A
-    adc eax, byte [B + ecx*4] ; AL = A + B + Carry
+    adc eax, dword [B + ecx*4] ; AL = A + B + Carry
     mov [result + ecx*4], eax ; store result
     inc ecx
@@ Line 128: / Line 128: @@
 ===== Sign bit. Left padding. =====
 După cum ştiţi, la numerele reprezentate în formă zecimală, se poate face padding în faţa numărului cu un set de cifre infinite de zero (de exemplu: 0000343 este fi acelaşi număr cu 343). Este perfect valabil şi la numerele reprezentate în binar, pot fi prefixate de oricâte cifre de zero (0010000100 este fix acelaşi număr ca 10000100).\\
-Apare în schimb o situaţie dubioasă la numerele negative datorită felului în care sunt reprezentate în binar. Dacă vă mai aduceţi aminte, acestea se reprezintă în complet faţă de 2.\\
+Apare în schimb o situaţie dubioasă la numerele negative datorită felului în care sunt reprezentate în binar. Dacă vă mai aduceţi aminte, acestea se reprezintă în complement faţă de 2.\\
 Înainte să vă zic un fact concret, haideţi să vedem cum evoluează reprezentarea numerelor negative la stânga, cu cât se apropie mai mult de zero:\\
 {{:laboratoare:nr_negative.png|}}\\
@@ Line 193: / Line 194: @@
 {{http://truestorieswithgill.com/wp-content/uploads/2013/09/20130915-190532.jpg?200|}}\\
 că ați putea folosi, de exemplu, registrele DX concatenat cu AX (DX:AX) pentru a împărți un număr de 32 de biți la 16 biți (sau, de ce nu, să împărțiți EDX:EAX la un operand de 32 de biți).\\
-Să zicem ca am vrea să reprezentăm numărul 444123 în DX:AX și că vrem să-l împărțim la 10 (care merge reprezentat și pe 16 biți).
+Să zicem ca am vrea să reprezentăm numărul 4444123 în DX:AX și că vrem să-l împărțim la 10 (care merge reprezentat și pe 16 biți).
-Ne-ar returna corect restul (=3), DAR ne-ar rămâne câtul 444123 care nu poate fi reprezentat, pentru că eventualul cât se depozitează în AX, care poate reține o valoare maximă de 65 536, AX fiind un registru de 16 biți.\\
+Ne-ar returna corect restul (=3), DAR ne-ar rămâne câtul 444412 care nu poate fi reprezentat, pentru că eventualul cât se depozitează în AX, care poate reține o valoare maximă de 65 536, AX fiind un registru de 16 biți.\\
 Acestă reprezentare de la **div** ne ajută, dar pe post de "reverse" "Carry" de la înmulțire. Dacă ar fi fost să faceți împărțirea ca în clasele primare a operației menționate anterior, probabil ați fi făcut-o cam așa:\\
 {{http://elf.cs.pub.ro/asm/wiki-old/_media/tut/impartire.png}}\\
@@ Line 244: / Line 245: @@
 Recomandarea ar fi să folosiţi operanzi de tip dword (32 biţi) când nu vi se menţionează explicit, în exerciţiu, tipul acestora.
 </note>
-. Implementaţi împărţirea unui număr cu puteri ale lui 2 fără a folosi instrucţiunea **div**. Datele de input ale programului vor fi: numărul deîmpărţit şi puterea la care se ridică 2.\\
+==== [2p] 1. Împărţiri cu puteri ale lui 2 ====
-. Următorul cod îşi propune să incrementeze un byte dintr-un număr, cât timp acesta nu se resetează la 0, folosind instrucţiuni pe operanzi de 8 biţi. După o rulare se poate observa însă ca programul nu se execută cu ne-am aştepta, mai exact rămâne în buclă infinită. **Fără a modifica tipul operanzilor**, corectaţi linia din loop care face incrementarea astfel încât programul să se termine şi la finalizarea lui să se afişeze **512**.
+Implementaţi împărţirea unui număr cu puteri ale lui 2 fără a folosi instrucţiunea **div**. Datele de input ale programului vor fi: numărul deîmpărţit şi puterea la care se ridică 2.
+<note tip>Instrucţiunile **shl** şi **shr** pot folosi registrul **CL** pentru a specifica numărul de shiftări.</note>
+==== [2p] 2. Increment flags ====
+Următorul cod îşi propune să incrementeze un byte dintr-un număr, cât timp acesta nu se resetează la 0, folosind instrucţiuni pe operanzi de 8 biţi. După o rulare se poate observa însă ca programul nu se execută cu ne-am aştepta, mai exact rămâne în buclă infinită. **Fără a modifica tipul operanzilor**, corectaţi linia din loop care face incrementarea astfel încât programul să se termine şi la finalizarea lui să se afişeze **512**.
 <file asm inc.asm>
 %include "io.inc"
@@ Line 268: / Line 272: @@
 Uitaţi-vă ce FLAG-uri activeză instrucţiunea **[[http://www.jegerlehner.ch/intel/IntelCodeTable.pdf|inc]]**.
 </note>
-. Implementaţi înmulţirea unui număr cu 2, fără a folosi instrucţiunea **mul**.
+==== [2p] 3. Înmulţirea corectă a 2 numere de lungimi diferite ====
-<note important>
+Scrieţi o secvenţă de cod astfel încât să înmulţiţi **nr1** cu **nr2** şi să depuneţi rezultat în variabila **result**. **Trebuie** să folosiţi registre de 8 biţi.
-Numărul **trebuie** să aibă cel puţin 5 bytes în alcătuirea sa.
+<file asm mul.asm>
-</note>
-. Pornind de la scheletul de cod următor, implementaţi suma elementelor ale unui vector folosind **registre de 8 biţi (obligatoriu)**:
-<file asm sum.asm>
 %include "io.inc"
 section .data
-    v: dB 12, 56, 93, 44, 55, 23, 44, 71, 43
+    nr1: dB 0x90, 0x02 ; =656
-    len: dd $-v
+    nr2: dB 0x04
-    sum: dW 0
+    result: dw 0
 section .text
 global CMAIN
 CMAIN:
-    ; TODO sum vector of BYTE elements into "sum" WORD variable
+    ; TODO multiply nr1 by nr2 using only 8bit registers
+    ;      store the result in the "result" variable
-    PRINT_UDEC 2, sum ; should be 441 if result is correct
+    PRINT_UDEC 2, result ; should be 2624
     xor eax, eax
     ret
 </file>
-. Scrieţi o secvenţă de cod astfel încât să înmulţiţi **nr1** cu **nr2** şi să depuneţi rezultat în variabila **result**. **Trebuie** să folosiţi registre de 8 biţi.
+==== [2p] 4. Suma elementelor (fără semn) ale unui vector ====
-<file asm mul.asm>
+Pornind de la scheletul de cod următor, implementaţi suma elementelor ale unui vector folosind **registre de 8 biţi (obligatoriu)**:
+<file asm sum.asm>
 %include "io.inc"
 section .data
-    nr1: dB 0x90, 0x02 ; =656
+    v: dB 12, 56, 93, 44, 55, 23, 44, 71, 43
-    nr2: dB 0x04
+    len: dd $-v
-    result: dw 0
+    sum: dW 0
 section .text
 global CMAIN
 CMAIN:
-    ; TODO multiply nr1 by nr2 using only 8bit registers
+    ; TODO sum vector of BYTE elements into "sum" WORD variable
-    ;      store the result in the "result" variable
-    PRINT_UDEC 2, result ; should be 2624
+    PRINT_UDEC 2, sum ; should be 441 if result is correct
     xor eax, eax
     ret
 </file>
+==== [2p] 5. Înmulţirea cu 2 a unui număr mare/lung ====
+Implementaţi înmulţirea unui număr cu 2, fără a folosi instrucţiunea **mul**.
+<note important>
+  - Numărul **trebuie** să aibă cel puţin 5 bytes în alcătuirea sa.
+  - Trebuie să folosiţi instrucţiunea OR.
+</note>
-. BONUS: Pornind de la scheletul de cod următor, implementaţi suma elementelor (**cu semn**) ale unui vector folosind **registre de 8 biţi (obligatoriu)**:
+==== [1p] 6. BONUS: Suma elementelor (cu semn) ale unui vector ====
-<file asm signed_sum>
+Pornind de la scheletul de cod următor, implementaţi suma elementelor (**cu semn**) ale unui vector folosind **registre de 8 biţi (obligatoriu)**:
+<file asm signed_sum.asm>
 %include "io.inc"
 section .data
@@ Line 325: / Line 334: @@
     ret
 </file>
-. BONUS: Realizaţi împărţirea corectă a lui **nr1** la **nr2** folosind **registre de maxim 16 biţi**:
+==== [1p] 7. BONUS: Împărţirea a 2 numere de lungimi diferite ====
+Realizaţi împărţirea corectă a lui **nr1** la **nr2** folosind **registre de maxim 16 biţi**:
 <file asm div.asm>
 %include "io.inc"
@@ Line 344: / Line 354: @@
     ret
 </file>
+==== [1p] 8. BONUS: Îmbunătăţire înmulţiri cu 2 ====
+[[http://www.jegerlehner.ch/intel/IntelCodeTable.pdf|Observaţi]] şi utilizaţi instrucţiunile de rotire cu Carry, în locul celor de tip AND si OR, pentru a rezolva exerciţiului 5.
+==== [1p] 9. BONUS: Generalizare înmulţiri cu puteri ale lui 2 ====
+Modificaţi exerciţiul 5 astfel încât numărul să se poată înmulţi cu o variaţie mai mare de puteri ale lui 2 (cu aceleaşi limitări ca la 5).

Introducere în organizarea calculatorului și limbaj de asamblare

User Tools

Site Tools

Differences

Page Tools