RSS Feed

Probleme asm pe “release”

January 19th, 2008
Posted in Programare(Visual C++) | 1 Comment

Problema de fata apare in versiunele 2005+ ale Visual Studio in modul de compilare "Release". Sa luam exemplul urmator:

PLAIN TEXT
C++:
  1. int functie(int)
  2. {
  3.    _asm
  4.          {
  5.            mov eax,[ebp+8]
  6.           }
  7. }
  8.  
  9.  
  10. int main()
  11. {
  12. int a=10,b;
  13. b=functie(a);
  14. printf("%d ",b);
  15. return 0;
  16. }

In mod normal, functia returneaza valoarea primita ca parametru . Prin urmare, b=functie(a) va lua valoarea lui a, adica 10. Pana acum toate bune si frumoase. Sa compilam acum pe "Release mode" . De data aceasta, b va lua valoarea ...0 :) . Ciudat ? Nicidecum. Daca vom modifica antetul functiei main in felul urmator:

PLAIN TEXT
C++:
  1. int main(int)

b va lua valoarea ... 1 :) ... acum sa rulam programul cu 5 parametri ... si da, intr-adevar , b va lua valoarea 5 ... hmmm...Situatia nu e atat de hazlie pe cat pare. Sa zicem ca avem o functie care primeste ca parametru adresa unei variabile ... daca in loc de adresa noi primim 0, 1 sau alte tampenii, cu siguranta ca programul nostru va functiona razna iar noi ne vom pune nervii la incercare pentru mult timp, cu debugger-ul etc., negasind eroarea.

Eroarea provine din cauza optimizarilor de cod pe care le efectueaza Visual Studio . Sa luam acelasi caz de mai sus. Ce inseamna optimizare ? Compilatorul "vede" ca functia de mai sus nu mai apeleaza alte functii si este apelata doar din main . Asa ca , literal, ia tot codul functiei si il pune in locul apelului din functia main . Ceea ce echivaleaza perfect cu :

PLAIN TEXT
C++:
  1. int main()
  2. {
  3. int a=10,b;
  4.    _asm
  5.          {
  6.            mov eax,[ebp+8]
  7.            mov b,eax
  8.           }
  9. printf("%d ",b);
  10. return 0;
  11. }

Astfel, nu se mai face saltul la codul functiei, codul e "performant", dar intelesul sau deja se schimba...
In mod logic, problema se rezolva in 2 moduri :

1. Spunem compilatorului sa nu mai optimizeze nimic ( foarte usor : Project Properties -> Configuration Properties -> C/C++ -> Optimization -> Optimization -> Disabled .
2. Spunem compilatorului sa nu optimizeze functia noastra ... va urma

Visual Studio 2008 … interesant

January 9th, 2008
Posted in Programare(Visual C++) | No Comments

Hmm .. eram obisnuit sa setez release, si dau f5 , sa astept sa termina de incarcat aberatiile respective si sa am executabilul ... vremuri bune . Pe Visual Studio mai vechi poti face acest lucru pentru un program de tip console application. Se pare ca, mai nou, acest lucru nu mai este disponibil direct in Visual Studio 2008 . Daca dati simplu release si dati altcuiva programul, sunt sanse mari ca acesta sa nu-i mearga ( logica spune asa : daca eu sunt singurul tampit care foloseste Visual Studio 2008 cu .net 3.5, iar ceilalti folosesc altceva, e clar ca nu va merge ) . Problema se rezolva foarte simplu. Mergeti la Properties->Configurations Properties-> C/C++ ->Code Generation->Runtime Library-> Multi-threaded (/MT)... atata tot ... acum dati prietenilor programul vostru si virusati-i :d

Naiv Sort - C++/ASM

January 1st, 2008
Posted in Programare(Visual C++) | No Comments

Ah ... 2008 ... un nou an ... Dupa sampanie si cozonac ( meniu special de revelion ) , dupa artificii ( pe faleza Dunarii ) ...
Ma bucur cel putin ca acum folosesc un soft de anu asta ( Visual Studio 2008 ) , sunt trist ca in curand vin examenele, sunt bucuros ca in scurta vacanta de Craciun am reusit sa invat ASM ( un limbaj imposibil pentru mine la inceput - cu ocazia asta, tin sa-i multumesc lui AndreiASM .. de la el am invatat o buna parte a limbajului dar si profului ... printre cei mai de treaba de la FII ) ...
Si ca sa incep anul cu dreptul, m-am gandit in seara asta sa schimb algoritmul de anul trecut ( bubble sort ) , cu unul de "anul asta" ( naiv sort ) ... am implementat atat in C++ cat si in ASM ...

PLAIN TEXT
C++:
  1. #include <stdio.h>
  2.  
  3. int v[5];
  4. /*
  5. void interschimba(int &a,int &b)
  6. {
  7.     int c;
  8.     c=a;
  9.     a=b;
  10.     b=c;
  11. }
  14. void Naiv_Sort(int v[],int n)
  15. {
  16.     int i,poz,min,j;
  17.     for(i=0;i<n;i++)
  18.     {
  19.         min=v[i];
  20.         poz=i;
  21.        
  22.         for(j=i+1;j<n;j++)
  23.             if(v[j]<min)
  24.             {
  25.                 min=v[j];
  26.                 poz=j;
  27.             }
  29.         interschimba(v[i],v[poz]);
  30.     }
  31. }*/
  32.  
  33. void Naiv_Sort(int*,int)
  34. {
  35.     _asm
  36.     {
  37.         mov ebx,0
  38. for_mare:
  39.         mov ecx,[ebp+12]
  40.         dec ecx
  41.         cmp ebx,ecx
  42.         je gata
  43.         mov esi,[ebp+8]
  44.         //ajungem pe pozitia curenta
  45.         mov eax,ebx
  46.         shl eax,2
  47.         add esi,eax
  48.         //in esi avem pozitia curenta
  49.         //in eax avem minimul, in edx avem pozitia minimului
  50.         mov eax,[esi]
  51.         mov edx,ebx
  52.         //ecx va fi contorul celui de-al doilea for
  53.         mov ecx,ebx
  54.         inc ecx
  55.         add esi,4
  56. for_mic:
  57.         cmp ecx,[ebp+12]
  58.         je stop
  59.         mov edi,[esi]
  60.         cmp edi,eax
  61.         jb schimba
  62.         jmp continua
  63. schimba:
  64.         mov eax,[esi]
  65.         mov edx,ecx
  66.         jmp continua
  67. continua:
  68.         add esi,4
  69.         inc ecx
  70.         jmp for_mic
  71. stop:
  72.         mov esi,[ebp+8]
  73.         mov eax,ebx
  74.         shl eax,2
  75.         add esi,eax
  76.         mov edi,[ebp+8]
  77.         mov eax,edx
  78.         shl eax,2
  79.         add edi,eax
  80.         //in esi si edi am cele 2 adrese ale elementelor ce trebuie schimbate
  81.        
  82.         push dword ptr [esi]
  83.         push dword ptr [edi]
  84.         pop dword ptr [esi]
  85.         pop dword ptr [edi]
  86.  
  87.         inc ebx
  88.         jmp for_mare
  89. gata:
  90.  
  91.     }
  92. }
  93.  
  94.  
  95. int main()
  96. {
  97.     int n,i;
  98.     n=5;
  99.     v[0]=10;v[1]=2;v[2]=1;v[3]=5;v[4]=6;
  100.     Naiv_Sort(v,n);
  101.     for(i=0;i<n;i++) printf("%d ",v[i]);
  102.     getchar();
  103.     return 0;
  104. }

Sa utilizam bubble sort …

December 29th, 2007
Posted in Programare(Visual C++) | No Comments

M-am gandit sa ma mai joc putin cu bubble sort-ul, sa-l folosesc in cadrul unei anumite probleme. Problema care mi-a venit in minte este urmatoarea : Sa se scrie o functie care primeste ca parametru un numar natural si care returneaza cel mai mare numar care se poate forma cu cifrele sale . Algoritmul banal cu care se rezolva aceasta problema este urmatorul:

-retinem cifrele numarului intr-un vector
-le ordonam
-compunem noul numar

Am implementat totul in ASM desigur. Pentru a nu mai recurge la fel de fel de artificii, am organizat vectorul in felul urmator:
v[0] - numarul de cifre
v[1] ... v[v[0] - cifrele numarului

Bineinteles, am modificat usor bubble-sort-ul ( cel scris de mine avea nevoie de 2 variabile , un pointer catre primul element al vectorului, v[0] , si numarul de elemente ... cateva modificari minore si a fost gata. O alta problema care mi-a atras atentia la bubble sort a fost urmatoarea : ce se intampla daca exista un singur element in vector ? Am vrut sa merg la f**** masa si sa-l las asa, dar atunci cand compara v[i] cu v[i+1], sare la o adresa la care nu se gaseste nimic ... eroare :) ... am prevazut acest caz in functia maxim() . Este cel mai lung programel scris de mine in ASM ( vreo 90 linii de cod ) ... Sper sa nu mai am placerea sa scriu programe atat de lungi in ASM, e foarte dificil sa caut erori, chiar si cu ajutorul debugger-ului ... Iata codul...

PLAIN TEXT
C++:
  1. #include <iostream>
  2. using namespace std;
  3.  
  4. void bubble_sort(int*)
  5. {
  6.     _asm
  7.     {
  8. bucla_mare:
  9.         mov ecx,0
  10.         mov eax,[ebp+8]
  11.         mov ebx,[eax]
  12.         add eax,4
  13. bucla_mica:
  14.         mov edx,eax
  15.         add edx,4
  16.         mov esi,[eax]
  17.         cmp esi,[edx]
  18.         ja interschimbare
  19.         jmp continua
  20. interschimbare:
  21.         push dword ptr [edx]
  22.         push dword ptr [eax]
  23.         pop dword ptr [edx]
  24.         pop dword ptr [eax]
  25.         mov ecx,1
  26.         jmp continua
  27. continua:
  28.         add eax,4
  29.         dec ebx
  30.         cmp ebx,1
  31.         jne bucla_mica
  32.         cmp ecx,1
  33.         je bucla_mare
  34.     }
  35. }
  36.  
  37. int maxim(int)
  38. {
  39.     int v[12];
  40.     _asm
  41.     {
  42.         mov eax,[ebp+8]
  43.         cmp eax,10
  44.         jb exceptie
  45.         jmp continua
  46. exceptie:
  47.         mov ecx,eax
  48.         jmp stop2
  49. continua:
  50.         mov ebx,10
  51.         mov ecx,0
  52.         lea esi,v
  53.         add esi,4
  54. bucla1:
  55.         mov edx,0
  56.         cmp eax,0
  57.         je stop1
  58.         div ebx
  59.         inc ecx
  60.         mov [esi],edx
  61.         add esi,4
  62.         jmp bucla1
  63. stop1:
  64.         lea eax,v
  65.         mov [eax],ecx
  66.         push eax
  67.         call bubble_sort
  68.         add esp,4
  69.  
  70.         mov ecx,0
  71.         mov eax,1
  72.         lea esi,v
  73.         mov ebx,[esi]
  74.         add esi,4
  75. bucla2:
  76.         cmp ebx,0
  77.         je stop2
  78.         push ecx
  79.         mov ecx,[esi]
  80.         mov edx,0
  81.         push eax
  82.         mov edi,eax
  83.         mov eax,1
  84.         mul edi
  85.         mul ecx
  86.         pop edx
  87.         pop ecx
  88.         push edx
  89.         add ecx,eax
  90.         pop eax
  91.         mov edi,10
  92.         mul edi
  93.         dec ebx
  94.         add esi,4
  95.         jmp bucla2
  96. stop2:
  97.         mov eax,ecx
  98.     }
  99. }
  100.  
  101. int main()
  102. {
  103.     int x;
  104.     cin>>x;
  105.     cout<<maxim(x)<<endl;
  106.     system("pause");
  107.     return 0;
  108. }

O mica problema in ASM … de Craciun

December 26th, 2007
Posted in Programare(Visual C++) | No Comments

Pentru ca tot era Craciunul si nu aveam ce face, m-am apucat de o mica problema in ASM ... am apelat la un coleg de facultate,Alex D., care mi-a dat urmatoarea problema : Sa se ordoneze un vector de numere naturale dupa numarul de biti necesari pentru a le scrie in baza 2 ... aveam deja bubble sort-ul implementat in asm ... Am procedat in felul urmator: stiam ca bubble sort compara, la un moment dat cate 2 elemente si verifica daca unul e mai mare ca celalalt. In loc de aceasta condiitie, eu trebuia sa aflu daca numarul de biti al primului e mai mare ca numarul de biti al celui de-al doilea... ca sa evit o seara "plina", am scris o alta functie, tot in asm , care imi returneaza numarul de biti pentru un numar. De aici totul a fost simplu ... ba nu ! Am stat o ora intreaga, uitandu-ma dupa pop-uri, push-uri, unele adrese se pierdeau, o adevarata dezordine... noroc cu prietenul meu AndreiASM ( numele spune tot :) ), care m-a ajutat cu diverse chestii tehnice pe care nu aveam de unde sa le cunosc ( apelarea unei functii cu parametri, etc. ) . In cele din urma, a rezultat codul de mai jos, care "merge", dar nu am absolut niciun chef sa ma mai bag pe el in caz ca gasesc vreo eroare...

PLAIN TEXT
C++:
  1. #include <stdio.h>
  2. #include <iostream>
  3. using namespace std;
  4.  
  5.  
  6. int nr_biti(int)
  7. {
  8.     _asm
  9.     {
  10.         mov eax,[ebp+8]
  11.         cmp eax,0
  12.         je final
  13.         mov ebx,0
  14. bucla:
  15.         cmp eax,0
  16.         je stop
  17.         inc ebx
  18.         shr eax,1
  19.         jmp bucla
  20. stop:
  21.         mov eax,ebx
  22.         jmp stop2
  23. final:
  24.         mov ebx,1
  25.         jmp stop
  26. stop2:
  27.        
  28.     }
  29. }
  30.  
  31. void bubble_sort(int*,int)
  32. {
  33.     _asm
  34.     {
  35. bucla_mare:
  36.         mov ecx,0
  37.         mov eax,[ebp+8]
  38.         mov ebx,[ebp+12]
  39. bucla_mica:
  40.         mov edx,eax
  41.         add edx,4
  42.        
  43.         push dword ptr[eax]
  44.         push dword ptr[edx]
  45.  
  46.         push eax
  47.  
  48.         mov edi,eax
  49.  
  50.         push dword ptr[edx]
  51.         call nr_biti
  52.         mov  [edx],eax
  53.         add esp,4
  54.  
  55.         push dword ptr[edi]
  56.         call nr_biti
  57.         mov [edi],eax
  58.         add esp,4
  59.  
  60.         pop eax
  61.         push ecx
  62.         mov ecx,[edi]
  63.         mov [eax],ecx
  64.         pop ecx
  65.         mov esi,[eax]
  66.         cmp esi,[edx]
  67.         ja interschimbare
  68.         cmp esi,[edx]
  69.         jle nu_e
  70.        
  71. interschimbare:
  72.         pop dword ptr[edx]
  73.         pop dword ptr[eax]
  74.         push dword ptr [edx]
  75.         push dword ptr [eax]
  76.         pop dword ptr [edx]
  77.         pop dword ptr [eax]
  78.         mov ecx,1
  79.         jmp continua
  80. nu_e:   pop dword ptr[edx]
  81.         pop dword ptr[eax]
  82.         jmp continua
  83.  
  84. continua:
  85.  
  86.         add eax,4
  87.         dec ebx
  88.         cmp ebx,1
  89.         jne bucla_mica
  90.         cmp ecx,1
  91.         je bucla_mare
  92.     }
  93. }
  94.  
  95. int main()
  96. {
  97.     int v[100],n,i;
  98.     cin>>n;
  99.     for(i=0;i<n;i++) cin>>v[i];
  100.     bubble_sort(v,n);
  101.     for(i=0;i<n;i++) cout<<v[i]<<' ';
  102.     system("pause");
  103.     return 0;
  104. }

Use the stack , Luke !

December 23rd, 2007
Posted in Programare(Visual C++) | No Comments

Lucrez de foarte putin timp timp in ASM si , cum imi sta mie mai bine, imi place sa ma complic al naibii de tare cand rezolv o problema... de exemplu, azi m-am gandit la urmatoarea problema in ASM : se da un vector de numere intregi. Sa se scrie o functie in ASM care inverseaza elementele vectorului .
Ok . Bag in registrul eax adresa elementului curent, calculez cati bytes trebuie sa sar ca sa ajung la ultimul element, fac o bucla, sar la elementul al doilea, calculez cati bytes am nevoie sa sar la penultimul ... etc., nervi, pana la urma adaug un sub edx,ecx ... minune, merge. De ce? Nu ma mai intereseaza... Merge si atat. Iata minunatul cod:

PLAIN TEXT
C++:
  1. void inversare(int*,int)
  2. {
  3.     _asm
  4.     {
  5.         mov ecx,0
  6.         mov ebx,[ebp+12]
  7.         shr ebx,1
  8.         dec ebx
  9. bucla:
  10.         mov eax,[ebp+8]
  11.        
  12.         push ecx
  13.         shl ecx,2
  14.         add eax,ecx
  15.         pop ecx
  16.        
  17.         mov edx,[ebp+12]
  18.         dec edx
  19.         sub edx,ecx
  20.         sub edx,ecx
  21.         shl edx,2
  22.  
  23.         push eax
  24.         add eax,edx
  25.         mov edx,eax
  26.         pop eax
  27.  
  28.         push dword ptr [eax]
  29.         push dword ptr [edx]
  30.         pop dword ptr [eax]
  31.         pop dword ptr [edx]
  32.    
  33.         cmp ecx,ebx
  34.         jne continua
  35.         cmp ecx,ebx
  36.         je stop
  37. continua:
  38.          inc ecx
  39.          jmp bucla
  40. stop:
  41.     }
  42. }

Ok... , ma minunam si eu de cat de frumos e codul asta ... ma simteam mandru... USE THE STACK LUKE... mi-am adus aminte de Star Wars ... si de o mica chestie numite STIVA... care avea interesenta proprietate ca ultimul intrat era primul iesit . Sa vezi si sa nu crezi ... exact ce-mi trebuia mie . :)) Mi-am tras o palma peste cap, am pornit alt proiect, am scris repede codul, a rezultat cel de mai jos. Elegant, simplu, fara shiftari de biti sau alte magarii ...

PLAIN TEXT
C++:
  1. void inverseaza2(int*,int)
  2. {
  3.     _asm
  4.     {
  5.         mov eax,[ebp+8]
  6.         mov ecx,[ebp+12]
  7.         mov edx,0
  8. bucla:
  9.         cmp edx,ecx
  10.         je final
  11.         push dword ptr [eax]
  12.         add eax,4
  13.         inc edx
  14.         jmp bucla
  15. final:
  16.         mov eax,[ebp+8]
  17.         mov edx,0
  18. bucla2:
  19.         cmp edx,ecx
  20.         je final2
  21.         pop dword ptr [eax]
  22.         add eax,4
  23.         inc edx
  24.         jmp bucla2
  25. final2:
  26.     }
  27. }

De acum incolo voi folosi stiva !
De acum incolo voi folosi stiva !
De acum incolo voi folosi stiva !
De acum incolo voi folosi stiva !
De acum incolo voi folosi stiva !
De acum incolo voi folosi stiva !

Bubble Sort - ASM

December 20th, 2007
Posted in Programare(Visual C++) | 1 Comment

Astazi am reusit , cu ajutor ce-i drept ( din partea prof. meu de arhitectura ), sa implementez ultra-performantul, ultra-schimbistul si nemaipomenitul Bubble Sort . Il pun aici, in speranta ca mai exista cineva care este interesat de ASM ...

PLAIN TEXT
C++:
  1. void bubble_sort(int*,int)
  2. {
  3.     _asm
  4.     {
  5. bucla_mare:
  6.         mov ecx,0
  7.         mov eax,[ebp+8]
  8.         mov ebx,[ebp+12]
  9. bucla_mica:
  10.         mov edx,eax
  11.         add edx,4
  12.         mov esi,[eax]
  13.         cmp esi,[edx]
  14.         ja interschimbare
  15.         jmp continua
  16. interschimbare:
  17.         push dword ptr [edx]
  18.         push dword ptr [eax]
  19.         pop dword ptr [edx]
  20.         pop dword ptr [eax]
  21.         mov ecx,1
  22.         jmp continua
  23. continua:
  24.         add eax,4
  25.         dec ebx
  26.         cmp ebx,1
  27.         jne bucla_mica