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