API tools faq
paste
Advertisement
Guest User

EasyASM Log 21 Febrero 2017

a guest
Feb 21st, 2017
89
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
ASM (NASM) 4.28 KB | None | 0 0
raw download clone embed print report
  1. [ideras@localhost EasyASM (master)]$ ./EasyASM --x86
  2. --- EasyASM x86 mode (little endian) ----
  3.  
  4. Global base address = 0x10000000
  5. Stack pointer address = 0x7fffeffc
  6. Global memory size = 256 dwords
  7. Stack size         = 256 dwords
  8.  
  9. ASM> mov eax, 0x11223344
  10. eax = 0x11223344 287454020 287454020
  11. ASM> push eax
  12. dword [0x7FFFEFF8] = 0x11223344 287454020 287454020
  13. ASM> #show esp hex
  14. esp = 7FFFEFF8
  15. ASM> pop ebx
  16. ebx = 0x11223344 287454020 287454020
  17. ASM> #show esp hex
  18. esp = 7FFFEFFC
  19. ASM> pop ebx
  20. Line 1: Runtime exception: fetch address out of limit 0x7fffeffc
  21. Line 1: Invalid address '0x7FFFEFFC'.
  22. ASM> pushad
  23. Line 2: Syntax error. Unexpected end of input
  24. ASM> mov eax, 10
  25. eax = 0xA 10 10
  26. ASM> mov ebx, 20
  27. ebx = 0x14 20 20
  28. ASM> add eax, ebx
  29. eax = 0x1E 30 30
  30. ASM> add eax, 30
  31. eax = 0x3C 60 60
  32. ASM> add eax, dword [0x10000000]
  33. eax = 0x3C 60 60
  34. ASM> add eax, -30
  35. eax = 0x1E 30 30
  36. ASM> mov eax, 10
  37. eax = 0xA 10 10
  38. ASM> mov ebx, 20
  39. ebx = 0x14 20 20
  40. ASM> mul ebx
  41. eax = 0xC8 200 200
  42. ASM> #show edx hex
  43. edx = 00000000
  44. ASM> mul eax
  45. eax = 0x9C40 40000 40000
  46. ASM> #show edx hex
  47. edx = 00000000
  48. ASM> mul eax
  49. eax = 0x5F5E1000 1600000000 1600000000
  50. ASM> #show edx hex
  51. edx = 00000000
  52. ASM> mul eax
  53. eax = 0xC1000000 -1056964608 3238002688
  54. ASM> #show edx hex
  55. edx = 2386F26F
  56. ASM> mul 10
  57. Line 1: Invalid arguments '10' in Mul instruction
  58. ASM> mul dword [0x10000000]
  59. eax = 0x0 0 0
  60. ASM> mul byte [0x10000000]    
  61. ax = 0x0 0 0
  62. ASM> mov al, 10
  63. al = 0xA 10 10
  64. ASM> mov bl, 20
  65. bl = 0x14 20 20
  66. ASM> mul bl
  67. ax = 0xC8 200 200
  68. ASM> mov bx, 20
  69. bx = 0x14 20 20
  70. ASM> mov ax, 10
  71. ax = 0xA 10 10
  72. ASM> mul bx
  73. ax = 0xC8 200 200
  74. ASM> #show eax hex
  75. eax = 000000C8
  76. ASM> #show eax decimal
  77. eax = 200
  78. ASM> mov ax, 100
  79. ax = 0x64 100 100
  80. ASM> mov bx, 200
  81. bx = 0xC8 200 200
  82. ASM> mul bx
  83. ax = 0x4E20 20000 20000
  84. ASM> mul bx
  85. ax = 0x900 2304 2304
  86. ASM> #show eax decimal
  87. eax = 2304
  88. ASM> #show ax decimal  
  89. ax = 2304
  90. ASM> #show dx decimal
  91. dx = 61
  92. ASM> imul eax, eax, ebx
  93. Line 1: IMUL instruction with three argument  not supported.
  94. ASM> imul eax, ebx    
  95. eax = 0x70800 460800 460800
  96. ASM> mov eax, 10
  97. eax = 0xA 10 10
  98. ASM> mov edx, 0
  99. edx = 0x0 0 0
  100. ASM> mov ebx, 2
  101. ebx = 0x2 2 2
  102. ASM> div ebx
  103. eax = 0x5 5 5
  104. ASM> mov eax, 100
  105. eax = 0x64 100 100
  106. ASM> mov ebx, 3
  107. ebx = 0x3 3 3
  108. ASM> div ebx
  109. eax = 0x21 33 33
  110. ASM> #show edx
  111. edx = 1
  112. ASM> mov ebx, 0
  113. ebx = 0x0 0 0
  114. ASM> div ebx
  115. Line 1: Divide error in Div instruction, divide by zero not supported.
  116. ASM> lea eax, ebx
  117. Line 1: Second argument of instruction 'lea' should be a memory reference.
  118. ASM> lea eax, [ebx]
  119. eax = 0x0 0 0
  120. ASM> lea eax, [ebx+8]
  121. eax = 0x8 8 8
  122. ASM> lea eax, [ebx+4*ecx]
  123. eax = 0x0 0 0
  124. ASM> lea eax, [ebx+4*ecx+9]
  125. eax = 0x9 9 9
  126. ASM> lea eax, [ebx+7*ecx+9]
  127. Line 1: Invalid scalar multiplier 7 in address expression '7*ecx'. Valid values are 1, 2, 4, 8.ASM>
  128. ASM> lea eax, [ebx+8*ecx-ecx]
  129. Line 1: Invalid expression 'ebx+8*ecx-ecx' in memory reference.
  130. ASM> lea eax, [ebx+4*ecx]
  131. eax = 0x0 0 0
  132. ASM> lea eax, [2*ebx+4*ecx]
  133. Line 1: Invalid expression '2*ebx+4*ecx' in memory reference.
  134. ASM> lea eax, [ebx+4*ecx+ecx]
  135. Line 1: Invalid expression 'ebx+4*ecx+ecx' in memory reference.
  136. ASM> lea eax, [ebx+4*ecx+10]
  137. eax = 0xA 10 10
  138. ASM> lea eax, [4*ecx]    
  139. eax = 0x0 0 0
  140. ASM> lea eax, [ebx+4+ecx+10]
  141. Line 1: Syntax error. Unexpected operator '+'
  142. ASM> lea eax, [ebx+4+ecx]
  143. Line 1: Invalid expression 'ebx+4+ecx' in memory reference.
  144. ASM> lea eax, [ebx+4+1*ecx]
  145. eax = 0x4 4 4
  146. ASM> mov ebx, [0x10000000]
  147. ebx = 0x0 0 0
  148. ASM> lea eax, [ebx+ecx+4]
  149. Line 1: Invalid expression 'ebx+ecx+4' in memory reference.
  150. ASM> lea eax, [ebx+1*ecx+4]
  151. eax = 0x4 4 4
  152. ASM>
  153. ASM>
  154. ASM> mov eax, 0x10000000
  155. eax = 0x10000000 268435456 268435456
  156. ASM> mov ebx, 0x10000000
  157. ebx = 0x10000000 268435456 268435456
  158. ASM> mov eax, 0
  159. eax = 0x0 0 0
  160. ASM> mov ecx, 10
  161. ecx = 0xA 10 10
  162. ASM> mov dword [ebx+4*eax], ecx
  163. dword [0x10000000] = 0xA 10 10
  164. ASM> inc eax
  165. eax = 0x1 1 1
  166. ASM> mov ecx, 20
  167. ecx = 0x14 20 20
  168. ASM> mov dword [ebx+4*eax], ecx
  169. dword [0x10000004] = 0x14 20 20
  170. ASM> #show dword [ebx][2] decimal
  171. dword [0x10000000] = 10
  172. dword [0x10000004] = 20
  173. ASM> inc eax
  174. eax = 0x2 2 2
  175. ASM> mov dword [ebx+4*eax], 30
  176. dword [0x10000008] = 0x1E 30 30
  177. ASM> #show dword [ebx][3] decimal
  178. dword [0x10000000] = 10
  179. dword [0x10000004] = 20
  180. dword [0x10000008] = 30
  181. ASM>
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!