Renaming folders

Renaming folders to keep the correct order of the tasks.

Signed-off-by: Andreia Ocanoaia <[email protected]>

laborator/content/interactiune-c-assembly/README.md

@@ -83,7 +83,7 @@ Pentru mai multe detalii, consultați [linkul](https://www.codeproject.com/Artic
 > **IMPORTANT:** În cadrul laboratoarelor vom folosi repository-ul de git al materiei IOCLA - [https://github.com/systems-cs-pub-ro/iocla](https://github.com/systems-cs-pub-ro/iocla). Repository-ul este clonat pe desktop-ul mașinii virtuale. Pentru a îl actualiza, folosiți comanda `git pull origin master` din interiorul directorului în care se află repository-ul (`~/Desktop/iocla`). Recomandarea este să îl actualizați cât mai frecvent, înainte să începeți lucrul, pentru a vă asigura că aveți versiunea cea mai recentă. Dacă doriți să descărcați repository-ul în altă locație, folosiți comanda `git clone https://github.com/systems-cs-pub-ro/iocla ${target}`.Pentru mai multe informații despre folosirea utilitarului `git`, urmați ghidul de la [Git Immersion](https://gitimmersion.com/).
 
 ### 1. Tutorial: Buclă for în inline assembly
-În subdirectorul `1-inline-for/` din arhiva de sarcini a laboratorului aveți o implementare a unei bucle for folosind inline assembly.
+În subdirectorul `01-inline-for/` din arhiva de sarcini a laboratorului aveți o implementare a unei bucle for folosind inline assembly.
 
 Urmăriți codul și compilați-l și rulați-l într-un terminal. Pentru a-l compila rulați comanda
 ```bash
@@ -118,7 +118,7 @@ Urmăriți în cod partea de inline assembly din blockul ce începe cu `asm`. Î
 
 ### 2. Rotație în inline assembly
 În limbajul C avem suport pentru operații de shiftare pe biți dar nu avem suport pentru operații de rotație pe biți. Acest lucru în ciuda prezenței operațiilor de rotație pe biți la nivelul procesorului.
-În subdirectorul `2-inline-rotate/` găsiți un schelet de cod pe care să îl folosiți pentru a implementa, folosind mnemonicile `rol` și respectiv `ror`, rotații pe biți. O descriere scurtă a acestor instrucțiuni găsiți [aici](https://en.wikibooks.org/wiki/X86_Assembly/Shift_and_Rotate#Rotate_Instructions).
+În subdirectorul `02-inline-rotate/` găsiți un schelet de cod pe care să îl folosiți pentru a implementa, folosind mnemonicile `rol` și respectiv `ror`, rotații pe biți. O descriere scurtă a acestor instrucțiuni găsiți [aici](https://en.wikibooks.org/wiki/X86_Assembly/Shift_and_Rotate#Rotate_Instructions).
 Pentru compilare folosiți comanda `make`.
 > **TIP:**
 > La o implementare corectă a rotației cu 8 biți la stânga și dreapta, în urma rulării executabilului `./inline_rotate`, veți obține un rezultat de forma:
@@ -129,15 +129,15 @@ Pentru compilare folosiți comanda `make`.
 
 ### 3. RTDSCP în inline assembly
 La nivelul procesoarelor moderne există o instrucțiune simplă, accesibilă doar din limbaj de asamblare, care oferă informații despre registrul TSC (Time Stamp Counter) numită `rtdscp`.
-În subdirectorul `3-inline-rtdscp/` găsiți un schelet de cod pe care să îl folosiți pentru obținerea valorii registrului TSC folosind instrucțiunea `rtdscp`. Completați scheletul și faceți programul să afișeze informațiile dorite.
+În subdirectorul `03-inline-rtdscp/` găsiți un schelet de cod pe care să îl folosiți pentru obținerea valorii registrului TSC folosind instrucțiunea `rtdscp`. Completați scheletul și faceți programul să afișeze informațiile dorite.
 Pentru compilare folosiți comanda `make`.
 > **TIP:**
 > Pentru informații despre instrucțiunea `rtdscp` consultați și aceste link-uri:
 > - https://www.felixcloutier.com/x86/rdtscp
 > - https://en.wikipedia.org/wiki/Time_Stamp_Counter
 
-### 1. Tutorial: Calcul maxim în assembly cu apel din C
-În subdirectorul `01-2-max-c-calls/` din arhiva de sarcini a laboratorului găsiți o implementare de calcul a maximului unui număr în care funcția `main()` este definită în C de unde se apelează funcția `get_max()` definită în limbaj de asamblare.
+### 4. Tutorial: Calcul maxim în assembly cu apel din C
+În subdirectorul `04-5-max-c-calls/` din arhiva de sarcini a laboratorului găsiți o implementare de calcul a maximului unui număr în care funcția `main()` este definită în C de unde se apelează funcția `get_max()` definită în limbaj de asamblare.
 
 Urmăriți codul din cele două fișiere și modul în care se transmit argumentele funcției și valoarea de retur.
 
@@ -155,7 +155,7 @@ make
 > **IMPORTANT:**
 > Valoarea de retur a unei funcții este plasată în registrul `eax`.
 
-### 2. Extindere calcul maxim în assembly cu apel din C
+### 5. Extindere calcul maxim în assembly cu apel din C
 Extindeți programul de la exercițiul anterior (în limbaj de asamblare și C) astfel încât funcția `get_max()` să aibă acum semnătura `unsigned int get_max(unsigned int *arr, unsigned int len, unsigned int *pos)`. Al treilea argument al funcției este adresa în care se va reține poziția din vector pe care se găsește maximul.
 
 La afișare se va afișa și poziția din vector pe care se găsește maximul.
@@ -169,8 +169,8 @@ La afișare se va afișa și poziția din vector pe care se găsește maximul.
 > max = get_max(arr, 10, &pos);
 >  ```
 
-### 3. Depanare stack frame corupt
-În subdirectorul `03-stack-frame/` din arhiva de sarcini a laboratorului găsiți un program C care implementează afișarea stringului `Hello world!` printr-un apel al funcției `print_hello()` definită în assembly pentru prima parte a mesajului, urmat de două apeluri ale funcției `printf()` direct din codul C.
+### 6. Depanare stack frame corupt
+În subdirectorul `06-stack-frame/` din arhiva de sarcini a laboratorului găsiți un program C care implementează afișarea stringului `Hello world!` printr-un apel al funcției `print_hello()` definită în assembly pentru prima parte a mesajului, urmat de două apeluri ale funcției `printf()` direct din codul C.
 
 Compilați și rulați programul. Ce observați? Mesajul printat nu este cel așteptat deoarece din codul assembly lipsește o instrucțiune.
 
@@ -181,16 +181,16 @@ Găsiți instrucțiunea lipsă și rerulați executabilul.
 > **TIP:**
 > Pentru a putea restaura stiva la starea sa de la începutul funcției curente, instrucțiunea `leave` se bazează pe faptul că frame pointerul funcției a fost setat.
 
-### 4. Tutorial: Calcul maxim în C cu apel din assembly
-În subdirectorul `04-5-max-assembly-calls/` din arhiva de sarcini a laboratorului găsiți o implementare de calcul a maximului unui număr în care funcția `main()` este definită în limbaj de asamblare de unde se apelează funcția `get_max()` definită în C.
+### 7. Tutorial: Calcul maxim în C cu apel din assembly
+În subdirectorul `07-8-max-assembly-calls/` din arhiva de sarcini a laboratorului găsiți o implementare de calcul a maximului unui număr în care funcția `main()` este definită în limbaj de asamblare de unde se apelează funcția `get_max()` definită în C.
 
 Urmăriți codul din cele două fișiere și modul în care se transmit argumentele funcției și valoarea de retur.
 
 Compilați și rulați programul.
 > **IMPORTANT:**
 > Acordați atenție înțelegerii codului înainte de a trece la exercițiul următor.
 
-### 5. Extindere calcul maxim în C cu apel din assembly
+### 8. Extindere calcul maxim în C cu apel din assembly
 Extindeți programul de la exercițiul anterior (în limbaj de asamblare și C) astfel încât funcția `get_max()` să aibă acum semnătura `unsigned int get_max(unsigned int *arr, unsigned int len, unsigned int *pos)`. Al treilea argument al funcției este adresa în care se va reține poziția din vector pe care se găsește maximul.
 
 La afișare se va afișa și poziția din vector pe care se găsește maximul.
@@ -203,39 +203,39 @@ La afișare se va afișa și poziția din vector pe care se găsește maximul.
 >
 >  Pentru afișare modificați șirul `print_format` și apelul `printf` în fișierul assembly (`main.asm`) ca să permită afișare a două valori: maximul și poziția.
 
-### 6. Tutorial: Conservare registre
-În subdirectorul `06-7-regs-preserve/` din arhiva de sarcini a laboratorului găsiți funcția `print_reverse_array()` implementată printr-un simplu loop ce face apeluri repetate ale funcției `printf()`.
+### 9. Tutorial: Conservare registre
+În subdirectorul `09-10-regs-preserve/` din arhiva de sarcini a laboratorului găsiți funcția `print_reverse_array()` implementată printr-un simplu loop ce face apeluri repetate ale funcției `printf()`.
 
 Urmăriți codul din fișierul `main.asm`, compilați și rulați programul. Ce s-a întâmplat? Programul rulează la infinit. Acest lucru se întămplă deoarece funcția `printf()` nu conservă valoarea din registrul `ECX`, folosit aici ca și contor.
 
 Decomentați liniile marcate cu `TODO1` și rerulați programul.
 
-### 7. Depanare SEGFAULT
+### 10. Depanare SEGFAULT
 Decomentați liniile marcate cu `TODO2` în fișierul assembly de la exercițiul anterior. Secvența de cod realizează un apel al funcției `double_array()`, implementată în C, chiar înainte de afișarea vectorului folosind funcția văzută anterior.
 
 Compilați și rulați programul. Pentru depanarea segfault-ului puteți folosi utilitarul `objdump` pentru a urmări codul în limbaj de asamblare corespunzător funcției `double_array()`. Observați care din registrele folosite înainte și după apel sunt modificate de această funcție.
 
 Adăugați în fișierul assembly instrucțiunile pentru conservarea și restaurarea registrelor necesare.
 
-### 8. Warning (nu eroare)
+### 11. Warning (nu eroare)
 
-Accesați directorul `08-include-fix/`.
+Accesați directorul `11-include-fix/`.
 Rulați comanda `make`.
 Veți primi un warning.
 Este de la compilare sau de la linkare?
 Rezolvați acest warning prin editarea fișierului `hello.c`.
 
 Rezolvați warningul fără folosirea directivei `#include`.
 
-### 9. Reparare probleme de export
+### 12. Reparare probleme de export
 
-Accesați directorul `09-export-fix/`.
+Accesați directorul `12-export-fix/`.
 Fiecare subdirector (`a-func/`, `b-var/`, `c-var-2/`) conține o problemă legată de exportarea unor simboluri (funcții sau variabile).
 În fiecare subdirector, rulați comanda `make`, identificați problema și editați fișierele necesare pentru rezolvarea problemei.
 
-### 10. Tutorial: Linkare C și C++
+### 13. Tutorial: Linkare C și C++
 
-Accesăm directorul `10-cpp-obs/`.
+Accesăm directorul `13-cpp-obs/`.
 Vrem să urmărim cum se realizează linkarea din surse mixte: C și C++.
 
 În subdirectorul `errors/` avem două directoare `c-calls-cpp/` și `cpp-calls-c/` în care se combinăm surse mixte C și C++.
@@ -259,8 +259,8 @@ Pentru a rezolva acest lucru, trebuie ca simbolurile definite C și importate î
 Acest lucru este realizat în subdirectorul `correct/`. In acest subdirector sunt reparate erorile din subdirrectorul `errors/`. Comparati fisierele `ops.h` din ambele subdirectoare.
 Detalii despre directiva `extern "C"` găsiți [aici](https://stackoverflow.com/a/1041880/4804196).
 
-### 11. Bonus: Calcul maxim în assembly cu apel din C pe 64 de biți
-Intrați în subdirectorul `11-max-c-calls-x64/` și faceți implementarea calculului maximului în limbaj de asamblare pe un sistem pe 64 de biți. Porniți de la programul de la exercițiile 4 și 5 în așa fel încât să îl rulați folosind un sistem pe 64 de biți.
+### 14. Bonus: Calcul maxim în assembly cu apel din C pe 64 de biți
+Intrați în subdirectorul `14-max-c-calls-x64/` și faceți implementarea calculului maximului în limbaj de asamblare pe un sistem pe 64 de biți. Porniți de la programul de la exercițiile 4 și 5 în așa fel încât să îl rulați folosind un sistem pe 64 de biți.
 
 > **TIP:**
 > https://en.wikipedia.org/wiki/X86_calling_conventions.
@@ -271,6 +271,6 @@ Intrați în subdirectorul `11-max-c-calls-x64/` și faceți implementarea calcu
 >
 >  Convenția de apel necesită ca, pentru funcțiile cu număr variabil de argumente, `RAX` să fie setat la numărul de registre vector folosiți pentru a pasa argumentele. `printf` este o funcție cu număr variabil de argumente, și dacă nu folosiți alte registre decât cele menționate în paragraful anterior pentru trimiterea argumentelor, trebuie să setați `RAX = 0` înainte de apel. Citiți mai multe [aici](https://stackoverflow.com/questions/38335212/calling-printf-in-x86-64-using-gnu-assembler).
 
-### 12. Bonus: Calcul maxim în C cu apel din assembly pe 64 de biți
-Intrați în subdirectorul `12-max-assembly-calls` și faceți implementarea calculului maximului în C cu apel din limbaj de asamblare pe un sistem pe 64 de biți. Porniți de la programul de la exercițiile 6 și 7 în așa fel încât să îl rulați folosind un sistem pe 64 de biți. Urmați indicațiile de la exercițiul anterior și aveți grijă la ordinea parametrilor.
+### 15. Bonus: Calcul maxim în C cu apel din assembly pe 64 de biți
+Intrați în subdirectorul `15-max-assembly-calls` și faceți implementarea calculului maximului în C cu apel din limbaj de asamblare pe un sistem pe 64 de biți. Porniți de la programul de la exercițiile 6 și 7 în așa fel încât să îl rulați folosind un sistem pe 64 de biți. Urmați indicațiile de la exercițiul anterior și aveți grijă la ordinea parametrilor.