API tools faq
paste
Advertisement
Guest User

Disassembly Code (VS2012)

a guest
Dec 29th, 2014
321
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
ASM (NASM) 30.70 KB | None | 0 0
raw download clone embed print report
  1. only Visual Studio 2012:
  2. CODE 1: Debug mode -> until input with cin :
  3. --------------------------------------------
  4. int until;
  5.  
  6.     clock_t start,stop;
  7.     cout << "Until: "; cin >> until;
  8. 011550B2  push        115DC70h  
  9. 011550B7  mov         eax,dword ptr ds:[01161390h]  
  10. 011550BC  push        eax  
  11. 011550BD  call        std::operator<<<std::char_traits<char> > (011512B7h)  
  12. 011550C2  add         esp,8  
  13. 011550C5  mov         esi,esp  
  14. 011550C7  lea         eax,[until]  
  15. 011550CA  push        eax  
  16. 011550CB  mov         ecx,dword ptr ds:[116132Ch]  
  17. 011550D1  call        dword ptr ds:[1161330h]  
  18. 011550D7  cmp         esi,esp  
  19. 011550D9  call        __RTC_CheckEsp (01151334h)  
  20.  
  21.     start = clock();
  22. 011550DE  mov         esi,esp  
  23. 011550E0  call        dword ptr ds:[1161460h]  
  24. 011550E6  cmp         esi,esp  
  25. 011550E8  call        __RTC_CheckEsp (01151334h)  
  26. 011550ED  mov         dword ptr [start],eax  
  27.     for(i=0 ; i<until; i++)
  28. 011550F0  mov         dword ptr [i],0  
  29. 011550F7  jmp         main+212h (01155102h)  
  30. 011550F9  mov         eax,dword ptr [i]  
  31. 011550FC  add         eax,1  
  32. 011550FF  mov         dword ptr [i],eax  
  33. 01155102  mov         eax,dword ptr [i]  
  34. 01155105  cmp         eax,dword ptr [until]  
  35. 01155108  jge         main+279h (01155169h)  
  36.     {
  37.         ExampleArray1[1]++;
  38. 0115510A  mov         eax,4  
  39. 0115510F  shl         eax,0  
  40. 01155112  mov         ecx,dword ptr [ExampleArray1]  
  41. 01155115  mov         edx,dword ptr [ecx+eax]  
  42. 01155118  add         edx,1  
  43. 0115511B  mov         eax,4  
  44. 01155120  shl         eax,0  
  45. 01155123  mov         ecx,dword ptr [ExampleArray1]  
  46. 01155126  mov         dword ptr [ecx+eax],edx  
  47.         ExampleArray2[1]++;
  48. 01155129  mov         eax,4  
  49. 0115512E  shl         eax,0  
  50. 01155131  mov         ecx,dword ptr [ExampleArray2]  
  51. 01155134  mov         edx,dword ptr [ecx+eax]  
  52. 01155137  add         edx,1  
  53. 0115513A  mov         eax,4  
  54. 0115513F  shl         eax,0  
  55. 01155142  mov         ecx,dword ptr [ExampleArray2]  
  56. 01155145  mov         dword ptr [ecx+eax],edx  
  57.         ExampleArray3[1]++;
  58. 01155148  mov         eax,4  
  59. 0115514D  shl         eax,0  
  60. 01155150  mov         ecx,dword ptr [ExampleArray3]  
  61. 01155153  mov         edx,dword ptr [ecx+eax]  
  62. 01155156  add         edx,1  
  63. 01155159  mov         eax,4  
  64. 0115515E  shl         eax,0  
  65. 01155161  mov         ecx,dword ptr [ExampleArray3]  
  66. 01155164  mov         dword ptr [ecx+eax],edx  
  67.     }
  68. 01155167  jmp         main+209h (011550F9h)  
  69.     stop = clock();
  70. 01155169  mov         esi,esp  
  71. 0115516B  call        dword ptr ds:[1161460h]  
  72. 01155171  cmp         esi,esp  
  73. 01155173  call        __RTC_CheckEsp (01151334h)  
  74. 01155178  mov         dword ptr [stop],eax  
  75.     cout << "Time: " << static_cast<float>(stop-start)/CLOCKS_PER_SEC << " sec.\n";
  76. 0115517B  push        115DC7Ch  
  77. 01155180  mov         eax,dword ptr [stop]  
  78. 01155183  sub         eax,dword ptr [start]  
  79. 01155186  cvtsi2ss    xmm0,eax  
  80. 0115518A  divss       xmm0,dword ptr ds:[115DDA0h]  
  81. 01155192  mov         esi,esp  
  82. 01155194  push        ecx  
  83. 01155195  movss       dword ptr [esp],xmm0  
  84. 0115519A  push        115DC84h  
  85. 0115519F  mov         ecx,dword ptr ds:[1161390h]  
  86. 011551A5  push        ecx  
  87. 011551A6  call        std::operator<<<std::char_traits<char> > (011512B7h)  
  88. 011551AB  add         esp,8  
  89. 011551AE  mov         ecx,eax  
  90. 011551B0  call        dword ptr ds:[1161338h]  
  91. 011551B6  cmp         esi,esp  
  92. 011551B8  call        __RTC_CheckEsp (01151334h)  
  93. 011551BD  push        eax  
  94. 011551BE  call        std::operator<<<std::char_traits<char> > (011512B7h)  
  95. 011551C3  add         esp,8  
  96.  
  97.     start = clock();
  98. 011551C6  mov         esi,esp  
  99. 011551C8  call        dword ptr ds:[1161460h]  
  100. 011551CE  cmp         esi,esp  
  101. 011551D0  call        __RTC_CheckEsp (01151334h)  
  102. 011551D5  mov         dword ptr [start],eax  
  103.     for(i=0 ; i<until; i++)
  104. 011551D8  mov         dword ptr [i],0  
  105. 011551DF  jmp         main+2FAh (011551EAh)  
  106. 011551E1  mov         eax,dword ptr [i]  
  107.     for(i=0 ; i<until; i++)
  108. 011551E4  add         eax,1  
  109. 011551E7  mov         dword ptr [i],eax  
  110. 011551EA  mov         eax,dword ptr [i]  
  111. 011551ED  cmp         eax,dword ptr [until]  
  112. 011551F0  jge         main+361h (01155251h)  
  113.     {
  114.         ExampleArray4[1]++;
  115. 011551F2  mov         eax,4  
  116. 011551F7  shl         eax,0  
  117. 011551FA  mov         ecx,dword ptr [ExampleArray4]  
  118. 011551FD  mov         edx,dword ptr [ecx+eax]  
  119. 01155200  add         edx,1  
  120. 01155203  mov         eax,4  
  121. 01155208  shl         eax,0  
  122. 0115520B  mov         ecx,dword ptr [ExampleArray4]  
  123. 0115520E  mov         dword ptr [ecx+eax],edx  
  124.         ExampleArray5[1]++;
  125. 01155211  mov         eax,4  
  126. 01155216  shl         eax,0  
  127. 01155219  mov         ecx,dword ptr [ExampleArray5]  
  128. 0115521C  mov         edx,dword ptr [ecx+eax]  
  129. 0115521F  add         edx,1  
  130. 01155222  mov         eax,4  
  131. 01155227  shl         eax,0  
  132. 0115522A  mov         ecx,dword ptr [ExampleArray5]  
  133. 0115522D  mov         dword ptr [ecx+eax],edx  
  134.         ExampleArray6[1]++;
  135. 01155230  mov         eax,4  
  136. 01155235  shl         eax,0  
  137. 01155238  mov         ecx,dword ptr [ExampleArray6]  
  138. 0115523B  mov         edx,dword ptr [ecx+eax]  
  139. 0115523E  add         edx,1  
  140. 01155241  mov         eax,4  
  141. 01155246  shl         eax,0  
  142. 01155249  mov         ecx,dword ptr [ExampleArray6]  
  143. 0115524C  mov         dword ptr [ecx+eax],edx  
  144.     }
  145. 0115524F  jmp         main+2F1h (011551E1h)  
  146.     stop = clock();
  147. 01155251  mov         esi,esp  
  148. 01155253  call        dword ptr ds:[1161460h]  
  149. 01155259  cmp         esi,esp  
  150. 0115525B  call        __RTC_CheckEsp (01151334h)  
  151. 01155260  mov         dword ptr [stop],eax  
  152.     cout << "Time: " << static_cast<float>(stop-start)/CLOCKS_PER_SEC << " sec.\n";
  153. 01155263  push        115DC7Ch  
  154. 01155268  mov         eax,dword ptr [stop]  
  155. 0115526B  sub         eax,dword ptr [start]  
  156. 0115526E  cvtsi2ss    xmm0,eax  
  157. 01155272  divss       xmm0,dword ptr ds:[115DDA0h]  
  158. 0115527A  mov         esi,esp  
  159. 0115527C  push        ecx  
  160. 0115527D  movss       dword ptr [esp],xmm0  
  161. 01155282  push        115DC84h  
  162. 01155287  mov         ecx,dword ptr ds:[1161390h]  
  163. 0115528D  push        ecx  
  164. 0115528E  call        std::operator<<<std::char_traits<char> > (011512B7h)  
  165. 01155293  add         esp,8  
  166. 01155296  mov         ecx,eax  
  167. 01155298  call        dword ptr ds:[1161338h]  
  168. 0115529E  cmp         esi,esp  
  169. 011552A0  call        __RTC_CheckEsp (01151334h)  
  170. 011552A5  push        eax  
  171. 011552A6  call        std::operator<<<std::char_traits<char> > (011512B7h)  
  172. 011552AB  add         esp,8
  173. ---------------------------------------------------------------------------------------------------------------------------------------
  174. CODE 2: release mode (with optimization) -> until input with cin :
  175. ------------------------------------------------------------------
  176. int until;
  177.  
  178.     clock_t start,stop;
  179.     cout << "Until: "; cin >> until;
  180. 002E131B  mov         ecx,dword ptr ds:[2E3054h]  
  181. 002E1321  add         esp,4  
  182. 002E1324  mov         edx,2E31BCh  
  183. 002E1329  call        std::operator<<<std::char_traits<char> > (02E1910h)  
  184. 002E132E  mov         ecx,dword ptr ds:[2E3050h]  
  185. 002E1334  lea         eax,[esp+10h]  
  186. 002E1338  push        eax  
  187. 002E1339  call        dword ptr ds:[2E302Ch]  
  188.  
  189.     start = clock();
  190. 002E133F  call        dword ptr ds:[2E30E0h]  
  191. 002E1345  mov         edi,dword ptr [esp+14h]  
  192.     for(i=0 ; i<until; i++)
  193. 002E1349  xor         ecx,ecx  
  194. 002E134B  mov         dword ptr [esp+24h],eax  
  195. 002E134F  cmp         dword ptr [esp+10h],ecx  
  196. 002E1353  jle         main+0F5h (02E1365h)  
  197.     {
  198.         ExampleArray1[1]++;
  199. 002E1355  inc         dword ptr [esi+4]  
  200.         ExampleArray2[1]++;
  201. 002E1358  inc         dword ptr [ebx+4]  
  202.         ExampleArray3[1]++;
  203. 002E135B  inc         dword ptr [edi+4]  
  204. 002E135E  inc         ecx  
  205. 002E135F  cmp         ecx,dword ptr [esp+10h]  
  206. 002E1363  jl          main+0E5h (02E1355h)  
  207.     }
  208.     stop = clock();
  209. 002E1365  call        dword ptr ds:[2E30E0h]  
  210.     cout << "Time: " << static_cast<float>(stop-start)/CLOCKS_PER_SEC << " sec.\n";
  211. 002E136B  sub         eax,dword ptr [esp+24h]  
  212. 002E136F  mov         ecx,dword ptr ds:[2E3054h]  
  213. 002E1375  movd        xmm0,eax  
  214. 002E1379  cvtdq2ps    xmm0,xmm0  
  215. 002E137C  sub         esp,8  
  216. 002E137F  divss       xmm0,dword ptr ds:[2E327Ch]  
  217. 002E1387  mov         edx,2E31CCh  
  218. 002E138C  movss       dword ptr [esp+4],xmm0  
  219. 002E1392  call        std::operator<<<std::char_traits<char> > (02E1910h)  
  220. 002E1397  add         esp,4  
  221. 002E139A  mov         ecx,eax  
  222. 002E139C  call        dword ptr ds:[2E3034h]  
  223. 002E13A2  mov         edx,2E31C4h  
  224. 002E13A7  mov         ecx,eax  
  225. 002E13A9  call        std::operator<<<std::char_traits<char> > (02E1910h)  
  226.  
  227.     start = clock();
  228. 002E13AE  call        dword ptr ds:[2E30E0h]  
  229.     for(i=0 ; i<until; i++)
  230. 002E13B4  xor         ecx,ecx  
  231. 002E13B6  mov         dword ptr [esp+24h],eax  
  232. 002E13BA  cmp         dword ptr [esp+10h],ecx  
  233. 002E13BE  jle         main+174h (02E13E4h)  
  234.     for(i=0 ; i<until; i++)
  235. 002E13C0  mov         eax,dword ptr [esp+1Ch]  
  236. 002E13C4  mov         edx,dword ptr [esp+18h]  
  237. 002E13C8  mov         edi,dword ptr [esp+20h]  
  238. 002E13CC  lea         esp,[esp]  
  239.     {
  240.         ExampleArray4[1]++;
  241. 002E13D0  inc         dword ptr [eax+4]  
  242.         ExampleArray5[1]++;
  243. 002E13D3  inc         dword ptr [edx+4]  
  244.         ExampleArray6[1]++;
  245. 002E13D6  inc         dword ptr [edi+4]  
  246. 002E13D9  inc         ecx  
  247. 002E13DA  cmp         ecx,dword ptr [esp+10h]  
  248. 002E13DE  jl          main+160h (02E13D0h)  
  249. 002E13E0  mov         edi,dword ptr [esp+14h]  
  250.     }
  251.     stop = clock();
  252. 002E13E4  call        dword ptr ds:[2E30E0h]  
  253.     cout << "Time: " << static_cast<float>(stop-start)/CLOCKS_PER_SEC << " sec.\n";
  254. 002E13EA  sub         eax,dword ptr [esp+24h]  
  255. 002E13EE  mov         ecx,dword ptr ds:[2E3054h]  
  256. 002E13F4  movd        xmm0,eax  
  257. 002E13F8  cvtdq2ps    xmm0,xmm0  
  258. 002E13FB  sub         esp,8  
  259. 002E13FE  divss       xmm0,dword ptr ds:[2E327Ch]  
  260. 002E1406  mov         edx,2E31DCh  
  261. 002E140B  movss       dword ptr [esp+4],xmm0  
  262. 002E1411  call        std::operator<<<std::char_traits<char> > (02E1910h)  
  263. 002E1416  add         esp,4  
  264. 002E1419  mov         ecx,eax  
  265. 002E141B  call        dword ptr ds:[2E3034h]  
  266. 002E1421  mov         edx,2E31D4h  
  267. 002E1426  mov         ecx,eax  
  268. 002E1428  call        std::operator<<<std::char_traits<char> > (02E1910h)
  269. ---------------------------------------------------------------------------------------------------------------------------------------
  270. CODE 3: release mode (without optimization) -> until input with cin :
  271. ---------------------------------------------------------------------
  272. int until;
  273.  
  274.     clock_t start,stop;
  275.     cout << "Until: "; cin >> until;
  276. 008D1776  push        8D41DCh  
  277. 008D177B  mov         eax,dword ptr ds:[008D406Ch]  
  278. 008D1780  push        eax  
  279. 008D1781  call        std::operator<<<std::char_traits<char> > (08D23F0h)  
  280. 008D1786  add         esp,8  
  281. 008D1789  lea         ecx,[until]  
  282. 008D178C  push        ecx  
  283. 008D178D  mov         ecx,dword ptr ds:[8D4068h]  
  284. 008D1793  call        dword ptr ds:[8D4034h]  
  285.  
  286.     start = clock();
  287. 008D1799  call        dword ptr ds:[8D40FCh]  
  288. 008D179F  mov         dword ptr [start],eax  
  289.     for(i=0 ; i<until; i++)
  290. 008D17A2  mov         dword ptr [i],0  
  291. 008D17A9  jmp         main+1C4h (08D17B4h)  
  292. 008D17AB  mov         edx,dword ptr [i]  
  293. 008D17AE  add         edx,1  
  294. 008D17B1  mov         dword ptr [i],edx  
  295. 008D17B4  mov         eax,dword ptr [i]  
  296. 008D17B7  cmp         eax,dword ptr [until]  
  297. 008D17BA  jge         main+22Bh (08D181Bh)  
  298.     {
  299.         ExampleArray1[1]++;
  300. 008D17BC  mov         ecx,4  
  301. 008D17C1  shl         ecx,0  
  302. 008D17C4  mov         edx,dword ptr [ExampleArray1]  
  303. 008D17C7  mov         eax,dword ptr [edx+ecx]  
  304. 008D17CA  add         eax,1  
  305. 008D17CD  mov         ecx,4  
  306. 008D17D2  shl         ecx,0  
  307. 008D17D5  mov         edx,dword ptr [ExampleArray1]  
  308. 008D17D8  mov         dword ptr [edx+ecx],eax  
  309.         ExampleArray2[1]++;
  310. 008D17DB  mov         eax,4  
  311. 008D17E0  shl         eax,0  
  312. 008D17E3  mov         ecx,dword ptr [ExampleArray2]  
  313. 008D17E6  mov         edx,dword ptr [ecx+eax]  
  314. 008D17E9  add         edx,1  
  315. 008D17EC  mov         eax,4  
  316. 008D17F1  shl         eax,0  
  317. 008D17F4  mov         ecx,dword ptr [ExampleArray2]  
  318. 008D17F7  mov         dword ptr [ecx+eax],edx  
  319.         ExampleArray3[1]++;
  320. 008D17FA  mov         edx,4  
  321. 008D17FF  shl         edx,0  
  322. 008D1802  mov         eax,dword ptr [ExampleArray3]  
  323. 008D1805  mov         ecx,dword ptr [eax+edx]  
  324. 008D1808  add         ecx,1  
  325. 008D180B  mov         edx,4  
  326. 008D1810  shl         edx,0  
  327. 008D1813  mov         eax,dword ptr [ExampleArray3]  
  328. 008D1816  mov         dword ptr [eax+edx],ecx  
  329.     }
  330. 008D1819  jmp         main+1BBh (08D17ABh)  
  331.     stop = clock();
  332. 008D181B  call        dword ptr ds:[8D40FCh]  
  333. 008D1821  mov         dword ptr [stop],eax  
  334.     cout << "Time: " << static_cast<float>(stop-start)/CLOCKS_PER_SEC << " sec.\n";
  335. 008D1824  push        8D41E4h  
  336. 008D1829  mov         ecx,dword ptr [stop]  
  337. 008D182C  sub         ecx,dword ptr [start]  
  338. 008D182F  cvtsi2ss    xmm0,ecx  
  339. 008D1833  divss       xmm0,dword ptr ds:[8D429Ch]  
  340. 008D183B  push        ecx  
  341. 008D183C  movss       dword ptr [esp],xmm0  
  342. 008D1841  push        8D41ECh  
  343. 008D1846  mov         edx,dword ptr ds:[8D406Ch]  
  344. 008D184C  push        edx  
  345. 008D184D  call        std::operator<<<std::char_traits<char> > (08D23F0h)  
  346. 008D1852  add         esp,8  
  347. 008D1855  mov         ecx,eax  
  348. 008D1857  call        dword ptr ds:[8D4074h]  
  349. 008D185D  push        eax  
  350. 008D185E  call        std::operator<<<std::char_traits<char> > (08D23F0h)  
  351. 008D1863  add         esp,8  
  352.  
  353.     start = clock();
  354. 008D1866  call        dword ptr ds:[8D40FCh]  
  355. 008D186C  mov         dword ptr [start],eax  
  356.     for(i=0 ; i<until; i++)
  357. 008D186F  mov         dword ptr [i],0  
  358. 008D1876  jmp         main+291h (08D1881h)  
  359. 008D1878  mov         eax,dword ptr [i]  
  360. 008D187B  add         eax,1  
  361. 008D187E  mov         dword ptr [i],eax  
  362. 008D1881  mov         ecx,dword ptr [i]  
  363. 008D1884  cmp         ecx,dword ptr [until]  
  364. 008D1887  jge         main+2F8h (08D18E8h)  
  365.     {
  366.         ExampleArray4[1]++;
  367. 008D1889  mov         edx,4  
  368. 008D188E  shl         edx,0  
  369. 008D1891  mov         eax,dword ptr [ExampleArray4]  
  370. 008D1894  mov         ecx,dword ptr [eax+edx]  
  371. 008D1897  add         ecx,1  
  372. 008D189A  mov         edx,4  
  373. 008D189F  shl         edx,0  
  374. 008D18A2  mov         eax,dword ptr [ExampleArray4]  
  375.     {
  376.         ExampleArray4[1]++;
  377. 008D18A5  mov         dword ptr [eax+edx],ecx  
  378.         ExampleArray5[1]++;
  379. 008D18A8  mov         ecx,4  
  380. 008D18AD  shl         ecx,0  
  381. 008D18B0  mov         edx,dword ptr [ExampleArray5]  
  382. 008D18B3  mov         eax,dword ptr [edx+ecx]  
  383. 008D18B6  add         eax,1  
  384. 008D18B9  mov         ecx,4  
  385. 008D18BE  shl         ecx,0  
  386. 008D18C1  mov         edx,dword ptr [ExampleArray5]  
  387. 008D18C4  mov         dword ptr [edx+ecx],eax  
  388.         ExampleArray6[1]++;
  389. 008D18C7  mov         eax,4  
  390. 008D18CC  shl         eax,0  
  391. 008D18CF  mov         ecx,dword ptr [ExampleArray6]  
  392. 008D18D2  mov         edx,dword ptr [ecx+eax]  
  393. 008D18D5  add         edx,1  
  394. 008D18D8  mov         eax,4  
  395. 008D18DD  shl         eax,0  
  396. 008D18E0  mov         ecx,dword ptr [ExampleArray6]  
  397. 008D18E3  mov         dword ptr [ecx+eax],edx  
  398.     }
  399. 008D18E6  jmp         main+288h (08D1878h)  
  400.     stop = clock();
  401. 008D18E8  call        dword ptr ds:[8D40FCh]  
  402. 008D18EE  mov         dword ptr [stop],eax  
  403.     cout << "Time: " << static_cast<float>(stop-start)/CLOCKS_PER_SEC << " sec.\n";
  404. 008D18F1  push        8D41F4h  
  405. 008D18F6  mov         edx,dword ptr [stop]  
  406. 008D18F9  sub         edx,dword ptr [start]  
  407. 008D18FC  cvtsi2ss    xmm0,edx  
  408. 008D1900  divss       xmm0,dword ptr ds:[8D429Ch]  
  409. 008D1908  push        ecx  
  410. 008D1909  movss       dword ptr [esp],xmm0  
  411. 008D190E  push        8D41FCh  
  412. 008D1913  mov         eax,dword ptr ds:[008D406Ch]  
  413. 008D1918  push        eax  
  414. 008D1919  call        std::operator<<<std::char_traits<char> > (08D23F0h)  
  415. 008D191E  add         esp,8  
  416. 008D1921  mov         ecx,eax  
  417. 008D1923  call        dword ptr ds:[8D4074h]  
  418. 008D1929  push        eax  
  419. 008D192A  call        std::operator<<<std::char_traits<char> > (08D23F0h)  
  420. 008D192F  add         esp,8
  421. ---------------------------------------------------------------------------------------------------------------------------------------
  422. Note: the required times doesn't change if until hardcoded
  423. CODE 4: debug mode -> until hardcoded :
  424. ---------------------------------------
  425. clock_t start,stop;
  426.  
  427.     start = clock();
  428. 002750B2  mov         esi,esp  
  429. 002750B4  call        dword ptr ds:[281460h]  
  430. 002750BA  cmp         esi,esp  
  431. 002750BC  call        __RTC_CheckEsp (0271334h)  
  432. 002750C1  mov         dword ptr [start],eax  
  433.     for(i=0 ; i<1000000000; i++)
  434. 002750C4  mov         dword ptr [i],0  
  435. 002750CB  jmp         main+1E6h (02750D6h)  
  436. 002750CD  mov         eax,dword ptr [i]  
  437. 002750D0  add         eax,1  
  438. 002750D3  mov         dword ptr [i],eax  
  439. 002750D6  cmp         dword ptr [i],3B9ACA00h  
  440. 002750DD  jge         main+24Eh (027513Eh)  
  441.     {
  442.         ExampleArray1[1]++;
  443. 002750DF  mov         eax,4  
  444. 002750E4  shl         eax,0  
  445. 002750E7  mov         ecx,dword ptr [ExampleArray1]  
  446. 002750EA  mov         edx,dword ptr [ecx+eax]  
  447. 002750ED  add         edx,1  
  448. 002750F0  mov         eax,4  
  449. 002750F5  shl         eax,0  
  450. 002750F8  mov         ecx,dword ptr [ExampleArray1]  
  451. 002750FB  mov         dword ptr [ecx+eax],edx  
  452.         ExampleArray2[1]++;
  453. 002750FE  mov         eax,4  
  454. 00275103  shl         eax,0  
  455. 00275106  mov         ecx,dword ptr [ExampleArray2]  
  456. 00275109  mov         edx,dword ptr [ecx+eax]  
  457. 0027510C  add         edx,1  
  458. 0027510F  mov         eax,4  
  459. 00275114  shl         eax,0  
  460. 00275117  mov         ecx,dword ptr [ExampleArray2]  
  461. 0027511A  mov         dword ptr [ecx+eax],edx  
  462.         ExampleArray3[1]++;
  463. 0027511D  mov         eax,4  
  464. 00275122  shl         eax,0  
  465. 00275125  mov         ecx,dword ptr [ExampleArray3]  
  466. 00275128  mov         edx,dword ptr [ecx+eax]  
  467. 0027512B  add         edx,1  
  468. 0027512E  mov         eax,4  
  469. 00275133  shl         eax,0  
  470. 00275136  mov         ecx,dword ptr [ExampleArray3]  
  471. 00275139  mov         dword ptr [ecx+eax],edx  
  472.     }
  473. 0027513C  jmp         main+1DDh (02750CDh)  
  474.     stop = clock();
  475. 0027513E  mov         esi,esp  
  476. 00275140  call        dword ptr ds:[281460h]  
  477. 00275146  cmp         esi,esp  
  478. 00275148  call        __RTC_CheckEsp (0271334h)  
  479. 0027514D  mov         dword ptr [stop],eax  
  480.     cout << "Time: " << static_cast<float>(stop-start)/CLOCKS_PER_SEC << " sec.\n";
  481. 00275150  push        27DC70h  
  482. 00275155  mov         eax,dword ptr [stop]  
  483. 00275158  sub         eax,dword ptr [start]  
  484. 0027515B  cvtsi2ss    xmm0,eax  
  485. 0027515F  divss       xmm0,dword ptr ds:[27DD6Ch]  
  486. 00275167  mov         esi,esp  
  487. 00275169  push        ecx  
  488. 0027516A  movss       dword ptr [esp],xmm0  
  489. 0027516F  push        27DC7Ch  
  490. 00275174  mov         ecx,dword ptr ds:[281390h]  
  491. 0027517A  push        ecx  
  492. 0027517B  call        std::operator<<<std::char_traits<char> > (02712B7h)  
  493. 00275180  add         esp,8  
  494. 00275183  mov         ecx,eax  
  495. 00275185  call        dword ptr ds:[281338h]  
  496. 0027518B  cmp         esi,esp  
  497. 0027518D  call        __RTC_CheckEsp (0271334h)  
  498. 00275192  push        eax  
  499. 00275193  call        std::operator<<<std::char_traits<char> > (02712B7h)  
  500. 00275198  add         esp,8  
  501.  
  502.     start = clock();
  503. 0027519B  mov         esi,esp  
  504. 0027519D  call        dword ptr ds:[281460h]  
  505. 002751A3  cmp         esi,esp  
  506. 002751A5  call        __RTC_CheckEsp (0271334h)  
  507. 002751AA  mov         dword ptr [start],eax  
  508.     for(i=0 ; i<1000000000; i++)
  509. 002751AD  mov         dword ptr [i],0  
  510. 002751B4  jmp         main+2CFh (02751BFh)  
  511. 002751B6  mov         eax,dword ptr [i]  
  512. 002751B9  add         eax,1  
  513. 002751BC  mov         dword ptr [i],eax  
  514. 002751BF  cmp         dword ptr [i],3B9ACA00h  
  515. 002751C6  jge         main+337h (0275227h)  
  516.     {
  517.         ExampleArray4[1]++;
  518. 002751C8  mov         eax,4  
  519.     {
  520.         ExampleArray4[1]++;
  521. 002751CD  shl         eax,0  
  522. 002751D0  mov         ecx,dword ptr [ExampleArray4]  
  523. 002751D3  mov         edx,dword ptr [ecx+eax]  
  524. 002751D6  add         edx,1  
  525. 002751D9  mov         eax,4  
  526. 002751DE  shl         eax,0  
  527. 002751E1  mov         ecx,dword ptr [ExampleArray4]  
  528. 002751E4  mov         dword ptr [ecx+eax],edx  
  529.         ExampleArray5[1]++;
  530. 002751E7  mov         eax,4  
  531. 002751EC  shl         eax,0  
  532. 002751EF  mov         ecx,dword ptr [ExampleArray5]  
  533. 002751F2  mov         edx,dword ptr [ecx+eax]  
  534. 002751F5  add         edx,1  
  535. 002751F8  mov         eax,4  
  536. 002751FD  shl         eax,0  
  537. 00275200  mov         ecx,dword ptr [ExampleArray5]  
  538. 00275203  mov         dword ptr [ecx+eax],edx  
  539.         ExampleArray6[1]++;
  540. 00275206  mov         eax,4  
  541. 0027520B  shl         eax,0  
  542. 0027520E  mov         ecx,dword ptr [ExampleArray6]  
  543. 00275211  mov         edx,dword ptr [ecx+eax]  
  544. 00275214  add         edx,1  
  545. 00275217  mov         eax,4  
  546. 0027521C  shl         eax,0  
  547. 0027521F  mov         ecx,dword ptr [ExampleArray6]  
  548. 00275222  mov         dword ptr [ecx+eax],edx  
  549.     }
  550. 00275225  jmp         main+2C6h (02751B6h)  
  551.     stop = clock();
  552. 00275227  mov         esi,esp  
  553. 00275229  call        dword ptr ds:[281460h]  
  554. 0027522F  cmp         esi,esp  
  555. 00275231  call        __RTC_CheckEsp (0271334h)  
  556. 00275236  mov         dword ptr [stop],eax  
  557.     cout << "Time: " << static_cast<float>(stop-start)/CLOCKS_PER_SEC << " sec.\n";
  558. 00275239  push        27DC70h  
  559. 0027523E  mov         eax,dword ptr [stop]  
  560. 00275241  sub         eax,dword ptr [start]  
  561. 00275244  cvtsi2ss    xmm0,eax  
  562. 00275248  divss       xmm0,dword ptr ds:[27DD6Ch]  
  563. 00275250  mov         esi,esp  
  564. 00275252  push        ecx  
  565. 00275253  movss       dword ptr [esp],xmm0  
  566. 00275258  push        27DC7Ch  
  567. 0027525D  mov         ecx,dword ptr ds:[281390h]  
  568. 00275263  push        ecx  
  569. 00275264  call        std::operator<<<std::char_traits<char> > (02712B7h)  
  570. 00275269  add         esp,8  
  571. 0027526C  mov         ecx,eax  
  572. 0027526E  call        dword ptr ds:[281338h]  
  573. 00275274  cmp         esi,esp  
  574. 00275276  call        __RTC_CheckEsp (0271334h)  
  575. 0027527B  push        eax  
  576. 0027527C  call        std::operator<<<std::char_traits<char> > (02712B7h)  
  577. 00275281  add         esp,8
  578. ---------------------------------------------------------------------------------------------------------------------------------------
  579. CODE 5: release mode (with optimization) -> until hardcoded:
  580. Note: in this disassembly is "start = clock()" twice. If I set the breakpoint in the second loop the second is missing !?
  581. ------------------------------------------------------------
  582. clock_t start,stop;
  583.  
  584.     start = clock();
  585. 00DD131E  call        dword ptr ds:[0DD30D8h]  
  586. 00DD1324  mov         edi,dword ptr [esp+10h]  
  587. 00DD1328  mov         dword ptr [esp+1Ch],eax  
  588. 00DD132C  mov         ecx,3B9ACA00h  
  589.     for(i=0 ; i<1000000000; i++)
  590.     {
  591.         ExampleArray1[1]++;
  592. 00DD1331  inc         dword ptr [esi+4]  
  593.         ExampleArray2[1]++;
  594. 00DD1334  inc         dword ptr [ebx+4]  
  595.         ExampleArray3[1]++;
  596. 00DD1337  inc         dword ptr [edi+4]  
  597. 00DD133A  dec         ecx  
  598. 00DD133B  jne         main+0C1h (0DD1331h)  
  599.     }
  600.     stop = clock();
  601. 00DD133D  mov         edi,dword ptr ds:[0DD30D8h]  
  602. 00DD1343  call        edi  
  603.     cout << "Time: " << static_cast<float>(stop-start)/CLOCKS_PER_SEC << " sec.\n";
  604. 00DD1345  sub         eax,dword ptr [esp+1Ch]  
  605. 00DD1349  mov         ecx,dword ptr ds:[0DD3048h]  
  606. 00DD134F  movd        xmm0,eax  
  607. 00DD1353  cvtdq2ps    xmm0,xmm0  
  608. 00DD1356  sub         esp,8  
  609. 00DD1359  divss       xmm0,dword ptr ds:[0DD3274h]  
  610. 00DD1361  mov         edx,0DD31C4h  
  611. 00DD1366  movss       dword ptr [esp+4],xmm0  
  612. 00DD136C  call        std::operator<<<std::char_traits<char> > (0DD18D0h)  
  613. 00DD1371  add         esp,4  
  614. 00DD1374  mov         ecx,eax  
  615. 00DD1376  call        dword ptr ds:[0DD302Ch]  
  616. 00DD137C  mov         edx,0DD31BCh  
  617. 00DD1381  mov         ecx,eax  
  618. 00DD1383  call        std::operator<<<std::char_traits<char> > (0DD18D0h)  
  619.  
  620.     start = clock();
  621. 00DD1388  call        edi  
  622. 00DD138A  mov         edx,dword ptr [esp+0Ch]  
  623. 00DD138E  mov         edi,dword ptr [esp+18h]  
  624. 00DD1392  mov         dword ptr [esp+1Ch],eax  
  625. 00DD1396  mov         eax,dword ptr [esp+14h]  
  626.  
  627.     start = clock();
  628. 00DD139A  mov         ecx,3B9ACA00h  
  629. 00DD139F  nop  
  630.     for(i=0 ; i<1000000000; i++)
  631.     {
  632.         ExampleArray4[1]++;
  633. 00DD13A0  inc         dword ptr [eax+4]  
  634.         ExampleArray5[1]++;
  635. 00DD13A3  inc         dword ptr [edx+4]  
  636.         ExampleArray6[1]++;
  637. 00DD13A6  inc         dword ptr [edi+4]  
  638. 00DD13A9  dec         ecx  
  639. 00DD13AA  jne         main+130h (0DD13A0h)  
  640.     }
  641.     stop = clock();
  642. 00DD13AC  call        dword ptr ds:[0DD30D8h]  
  643.     cout << "Time: " << static_cast<float>(stop-start)/CLOCKS_PER_SEC << " sec.\n";
  644. 00DD13B2  sub         eax,dword ptr [esp+1Ch]  
  645. 00DD13B6  mov         ecx,dword ptr ds:[0DD3048h]  
  646. 00DD13BC  movd        xmm0,eax  
  647. 00DD13C0  cvtdq2ps    xmm0,xmm0  
  648. 00DD13C3  sub         esp,8  
  649. 00DD13C6  divss       xmm0,dword ptr ds:[0DD3274h]  
  650. 00DD13CE  mov         edx,0DD31D4h  
  651. 00DD13D3  movss       dword ptr [esp+4],xmm0  
  652. 00DD13D9  call        std::operator<<<std::char_traits<char> > (0DD18D0h)  
  653. 00DD13DE  add         esp,4  
  654. 00DD13E1  mov         ecx,eax  
  655. 00DD13E3  call        dword ptr ds:[0DD302Ch]  
  656. 00DD13E9  mov         edx,0DD31CCh  
  657. 00DD13EE  mov         ecx,eax  
  658. 00DD13F0  call        std::operator<<<std::char_traits<char> > (0DD18D0h)
  659. ---------------------------------------------------------------------------------------------------------------------------------------
  660. CODE 6: release mode (without optimization) -> until hardcoded:
  661. ---------------------------------------------------------------
  662. clock_t start,stop;
  663.  
  664.     start = clock();
  665. 00051776  call        dword ptr ds:[540F4h]  
  666. 0005177C  mov         dword ptr [start],eax  
  667.     for(i=0 ; i<1000000000; i++)
  668. 0005177F  mov         dword ptr [i],0  
  669. 00051786  jmp         main+1A1h (051791h)  
  670. 00051788  mov         eax,dword ptr [i]  
  671. 0005178B  add         eax,1  
  672. 0005178E  mov         dword ptr [i],eax  
  673. 00051791  cmp         dword ptr [i],3B9ACA00h  
  674. 00051798  jge         main+209h (0517F9h)  
  675.     {
  676.         ExampleArray1[1]++;
  677. 0005179A  mov         ecx,4  
  678. 0005179F  shl         ecx,0  
  679. 000517A2  mov         edx,dword ptr [ExampleArray1]  
  680. 000517A5  mov         eax,dword ptr [edx+ecx]  
  681. 000517A8  add         eax,1  
  682. 000517AB  mov         ecx,4  
  683. 000517B0  shl         ecx,0  
  684. 000517B3  mov         edx,dword ptr [ExampleArray1]  
  685. 000517B6  mov         dword ptr [edx+ecx],eax  
  686.         ExampleArray2[1]++;
  687. 000517B9  mov         eax,4  
  688. 000517BE  shl         eax,0  
  689. 000517C1  mov         ecx,dword ptr [ExampleArray2]  
  690. 000517C4  mov         edx,dword ptr [ecx+eax]  
  691. 000517C7  add         edx,1  
  692. 000517CA  mov         eax,4  
  693. 000517CF  shl         eax,0  
  694. 000517D2  mov         ecx,dword ptr [ExampleArray2]  
  695. 000517D5  mov         dword ptr [ecx+eax],edx  
  696.         ExampleArray3[1]++;
  697. 000517D8  mov         edx,4  
  698. 000517DD  shl         edx,0  
  699. 000517E0  mov         eax,dword ptr [ExampleArray3]  
  700. 000517E3  mov         ecx,dword ptr [eax+edx]  
  701. 000517E6  add         ecx,1  
  702. 000517E9  mov         edx,4  
  703. 000517EE  shl         edx,0  
  704. 000517F1  mov         eax,dword ptr [ExampleArray3]  
  705. 000517F4  mov         dword ptr [eax+edx],ecx  
  706.     }
  707. 000517F7  jmp         main+198h (051788h)  
  708.     stop = clock();
  709. 000517F9  call        dword ptr ds:[540F4h]  
  710. 000517FF  mov         dword ptr [stop],eax  
  711.     cout << "Time: " << static_cast<float>(stop-start)/CLOCKS_PER_SEC << " sec.\n";
  712. 00051802  push        541DCh  
  713. 00051807  mov         ecx,dword ptr [stop]  
  714. 0005180A  sub         ecx,dword ptr [start]  
  715. 0005180D  cvtsi2ss    xmm0,ecx  
  716. 00051811  divss       xmm0,dword ptr ds:[54294h]  
  717. 00051819  push        ecx  
  718. 0005181A  movss       dword ptr [esp],xmm0  
  719. 0005181F  push        541E4h  
  720. 00051824  mov         edx,dword ptr ds:[54064h]  
  721. 0005182A  push        edx  
  722. 0005182B  call        std::operator<<<std::char_traits<char> > (0523D0h)  
  723. 00051830  add         esp,8  
  724. 00051833  mov         ecx,eax  
  725. 00051835  call        dword ptr ds:[54034h]  
  726. 0005183B  push        eax  
  727. 0005183C  call        std::operator<<<std::char_traits<char> > (0523D0h)  
  728. 00051841  add         esp,8  
  729.  
  730.     start = clock();
  731. 00051844  call        dword ptr ds:[540F4h]  
  732. 0005184A  mov         dword ptr [start],eax  
  733.     for(i=0 ; i<1000000000; i++)
  734. 0005184D  mov         dword ptr [i],0  
  735. 00051854  jmp         main+26Fh (05185Fh)  
  736. 00051856  mov         eax,dword ptr [i]  
  737. 00051859  add         eax,1  
  738. 0005185C  mov         dword ptr [i],eax  
  739. 0005185F  cmp         dword ptr [i],3B9ACA00h  
  740. 00051866  jge         main+2D7h (0518C7h)  
  741.     {
  742.         ExampleArray4[1]++;
  743. 00051868  mov         ecx,4  
  744. 0005186D  shl         ecx,0  
  745. 00051870  mov         edx,dword ptr [ExampleArray4]  
  746. 00051873  mov         eax,dword ptr [edx+ecx]  
  747. 00051876  add         eax,1  
  748. 00051879  mov         ecx,4  
  749. 0005187E  shl         ecx,0  
  750. 00051881  mov         edx,dword ptr [ExampleArray4]  
  751. 00051884  mov         dword ptr [edx+ecx],eax  
  752.         ExampleArray5[1]++;
  753. 00051887  mov         eax,4  
  754.         ExampleArray5[1]++;
  755. 0005188C  shl         eax,0  
  756. 0005188F  mov         ecx,dword ptr [ExampleArray5]  
  757. 00051892  mov         edx,dword ptr [ecx+eax]  
  758. 00051895  add         edx,1  
  759. 00051898  mov         eax,4  
  760. 0005189D  shl         eax,0  
  761. 000518A0  mov         ecx,dword ptr [ExampleArray5]  
  762. 000518A3  mov         dword ptr [ecx+eax],edx  
  763.         ExampleArray6[1]++;
  764. 000518A6  mov         edx,4  
  765. 000518AB  shl         edx,0  
  766. 000518AE  mov         eax,dword ptr [ExampleArray6]  
  767. 000518B1  mov         ecx,dword ptr [eax+edx]  
  768. 000518B4  add         ecx,1  
  769. 000518B7  mov         edx,4  
  770. 000518BC  shl         edx,0  
  771. 000518BF  mov         eax,dword ptr [ExampleArray6]  
  772. 000518C2  mov         dword ptr [eax+edx],ecx  
  773.     }
  774. 000518C5  jmp         main+266h (051856h)  
  775.     stop = clock();
  776. 000518C7  call        dword ptr ds:[540F4h]  
  777. 000518CD  mov         dword ptr [stop],eax  
  778.     cout << "Time: " << static_cast<float>(stop-start)/CLOCKS_PER_SEC << " sec.\n";
  779. 000518D0  push        541ECh  
  780. 000518D5  mov         ecx,dword ptr [stop]  
  781. 000518D8  sub         ecx,dword ptr [start]  
  782. 000518DB  cvtsi2ss    xmm0,ecx  
  783. 000518DF  divss       xmm0,dword ptr ds:[54294h]  
  784. 000518E7  push        ecx  
  785. 000518E8  movss       dword ptr [esp],xmm0  
  786. 000518ED  push        541F4h  
  787. 000518F2  mov         edx,dword ptr ds:[54064h]  
  788. 000518F8  push        edx  
  789. 000518F9  call        std::operator<<<std::char_traits<char> > (0523D0h)  
  790. 000518FE  add         esp,8  
  791. 00051901  mov         ecx,eax  
  792. 00051903  call        dword ptr ds:[54034h]  
  793. 00051909  push        eax  
  794. 0005190A  call        std::operator<<<std::char_traits<char> > (0523D0h)  
  795. 0005190F  add         esp,8
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!