Guest User

task-2

a guest
May 25th, 2026
72
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 9.89 KB | Software | 0 0
  1. ## 6502 Emulation — Step by Step
  2.  
  3. ### Initial State
  4. ```
  5. A=$00 X=$00 Y=$00 SP=$FD PC=$0600
  6. N=0 V=0 B=0 I=0 Z=0 C=0 → NV-BDIZC = 00000000
  7. ```
  8.  
  9. ### Program Bytes (loaded at $0600)
  10. ```
  11. $0600: A2 01 LDX #$01
  12. $0602: A0 00 LDY #$00
  13. $0604: 8A TXA ← label "loop"
  14. $0605: 99 00 02 STA $0200,Y
  15. $0608: E8 INX
  16. $0609: C8 INY
  17. $060A: E0 0B CPX #$0B
  18. $060C: D0 F6 BNE loop
  19. $060E: 00 BRK
  20. ```
  21.  
  22. ---
  23.  
  24. ### Execution Trace
  25.  
  26. **Instruction 1: LDX #$01**
  27. ```
  28. [$0600] A2 01 → LDX #$01
  29. X ← $01; N=0, Z=0; PC ← $0602
  30. ```
  31. > `[$0600] LDX #$01 → A=$00 X=$01 Y=$00 SP=$FD | NV-BDIZC=00000000 | PC=$0602`
  32.  
  33. **Instruction 2: LDY #$00**
  34. ```
  35. [$0602] A0 00 → LDY #$00
  36. Y ← $00; N=0, Z=1 (zero); PC ← $0604
  37. ```
  38. > `[$0602] LDY #$00 → A=$00 X=$01 Y=$00 SP=$FD | NV-BDIZC=01000000 | PC=$0604`
  39.  
  40. ---
  41.  
  42. #### Iteration 1: X=1
  43.  
  44. **Instruction 3: TXA**
  45. ```
  46. [$0604] 8A → TXA
  47. A ← X = $01; N=0, Z=0; PC ← $0605
  48. ```
  49. > `[$0604] TXA → A=$01 X=$01 Y=$00 SP=$FD | NV-BDIZC=00000000 | PC=$0605`
  50.  
  51. **Instruction 4: STA $0200,Y**
  52. ```
  53. [$0605] 99 00 02 → STA $0200,Y
  54. Address = $0200 + Y = $0200 + $00 = $0200
  55. mem[$0200] ← $01; PC ← $0608
  56. ```
  57. > `[$0605] STA $0200,Y → A=$01 X=$01 Y=$00 SP=$FD | NV-BDIZC=00000000 | PC=$0608`
  58.  
  59. **Instruction 5: INX**
  60. ```
  61. [$0608] E8 → INX
  62. X ← X + 1 = $01 + 1 = $02; N=0, Z=0; PC ← $0609
  63. ```
  64. > `[$0608] INX → A=$01 X=$02 Y=$00 SP=$FD | NV-BDIZC=00000000 | PC=$0609`
  65.  
  66. **Instruction 6: INY**
  67. ```
  68. [$0609] C8 → INY
  69. Y ← Y + 1 = $00 + 1 = $01; N=0, Z=0; PC ← $060A
  70. ```
  71. > `[$0609] INY → A=$01 X=$02 Y=$01 SP=$FD | NV-BDIZC=00000000 | PC=$060A`
  72.  
  73. **Instruction 7: CPX #$0B**
  74. ```
  75. [$060A] E0 0B → CPX #$0B
  76. Compute X - operand = $02 - $0B = $02 - $0B
  77. $02 - $0B = -9 (signed); as unsigned borrow occurs
  78. C=0 (X < $0B), Z=0 ($02 != $0B)
  79. N: bit7 of ($02 - $0B & $FF). $02 - $0B = $F7, bit7=1 → N=1
  80. PC ← $060C
  81. ```
  82. > `[$060A] CPX #$0B → A=$01 X=$02 Y=$01 SP=$FD | NV-BDIZC=10001000 | PC=$060C`
  83.  
  84. **Instruction 8: BNE loop (F6 = unsigned 246, signed -10)**
  85. ```
  86. [$060C] D0 F6 → BNE loop
  87. Z=0, so branch taken.
  88. PC = $060C + (0xF6 - $100) = $060C + (-10) = $060C - $0A = $0602...
  89. Wait: $060C = 1548 decimal. 1548 - 10 = 1538. 1538 in hex: 1538/16 = 96 r 2 → $0602.
  90.  
  91. That's wrong — loop should go to $0604 (the TXA). Let me recalculate:
  92. $060C = 0x060C. offset = F6 = -10.
  93. $060C - 10 = $0602. But loop is at $0604...
  94.  
  95. Let me recount: $0600(A2), $0601(01), $0602(A0), $0603(00), $0604(8A), $0605(99), $0606(00), $0607(02), $0608(E8), $0609(C8), $060A(E0), $060B(0B), $060C(D0), $060D(F6), $060E(00)
  96.  
  97. BNE is at $060C. After fetching BNE opcode at $060C and operand F6 at $060D, PC = $060E.
  98. PC = $060E + (-10) = $060E - A = $0604. ✓
  99. ```
  100. > `[$060C] BNE loop → A=$01 X=$02 Y=$01 SP=$FD | NV-BDIZC=10001000 | PC=$0604`
  101.  
  102. ---
  103.  
  104. #### Iteration 2: X=2
  105.  
  106. **Instruction 9: TXA**
  107. ```
  108. [$0604] 8A → TXA
  109. A ← $02; PC ← $0605
  110. ```
  111. > `[$0604] TXA → A=$02 X=$02 Y=$01 SP=$FD | NV-BDIZC=00000000 | PC=$0605`
  112.  
  113. **Instruction 10: STA $0200,Y**
  114. ```
  115. [$0605] 99 00 02 → STA $0200,Y
  116. mem[$0200+$01] = mem[$0201] ← $02; PC ← $0608
  117. ```
  118. > `[$0605] STA $0200,Y → A=$02 X=$02 Y=$01 SP=$FD | NV-BDIZC=00000000 | PC=$0608`
  119.  
  120. **Instruction 11: INX**
  121. ```
  122. [$0608] E8 → INX
  123. X ← $03; PC ← $0609
  124. ```
  125. > `[$0608] INX → A=$02 X=$03 Y=$01 SP=$FD | NV-BDIZC=00000000 | PC=$0609`
  126.  
  127. **Instruction 12: INY**
  128. ```
  129. [$0609] C8 → INY
  130. Y ← $02; PC ← $060A
  131. ```
  132. > `[$0609] INY → A=$02 X=$03 Y=$02 SP=$FD | NV-BDIZC=00000000 | PC=$060A`
  133.  
  134. **Instruction 13: CPX #$0B**
  135. ```
  136. [$060A] E0 0B → CPX #$0B
  137. X=$03, $03 < $0B: C=0, Z=0, result=$F8, N=1; PC ← $060C
  138. ```
  139. > `[$060A] CPX #$0B → A=$02 X=$03 Y=$02 SP=$FD | NV-BDIZC=10001000 | PC=$060C`
  140.  
  141. **Instruction 14: BNE loop**
  142. ```
  143. [$060C] D0 F6 → BNE
  144. Z=0, branch taken. PC = $060E + (-10) = $0604
  145. ```
  146. > `[$060C] BNE loop → A=$02 X=$03 Y=$02 SP=$FD | NV-BDIZC=10001000 | PC=$0604`
  147.  
  148. ---
  149.  
  150. #### Iteration 3: X=3
  151.  
  152. **Instruction 15: TXA**
  153. > `[$0604] TXA → A=$03 X=$03 Y=$02 SP=$FD | NV-BDIZC=00000000 | PC=$0605`
  154.  
  155. **Instruction 16: STA $0200,Y**
  156. > `[$0605] STA $0200,Y → A=$03 X=$03 Y=$02 SP=$FD | NV-BDIZC=00000000 | PC=$0608` (mem[$0202]=$03)
  157.  
  158. **Instruction 17: INX**
  159. > `[$0608] INX → A=$03 X=$04 Y=$02 SP=$FD | NV-BDIZC=00000000 | PC=$0609`
  160.  
  161. **Instruction 18: INY**
  162. > `[$0609] INY → A=$03 X=$04 Y=$03 SP=$FD | NV-BDIZC=00000000 | PC=$060A`
  163.  
  164. **Instruction 19: CPX #$0B**
  165. > `[$060A] CPX #$0B → A=$03 X=$04 Y=$03 SP=$FD | NV-BDIZC=10001000 | PC=$060C`
  166.  
  167. **Instruction 20: BNE loop**
  168. > `[$060C] BNE loop → A=$03 X=$04 Y=$03 SP=$FD | NV-BDIZC=10001000 | PC=$0604`
  169.  
  170. ---
  171.  
  172. #### Iteration 4: X=4
  173.  
  174. **Instruction 21: TXA**
  175. > `[$0604] TXA → A=$04 X=$04 Y=$03 SP=$FD | NV-BDIZC=00000000 | PC=$0605`
  176.  
  177. **Instruction 22: STA $0200,Y**
  178. > `[$0605] STA $0200,Y → A=$04 X=$04 Y=$03 SP=$FD | PC=$0608` (mem[$0203]=$04)
  179.  
  180. **Instruction 23: INX → X=$05**
  181. > `[$0608] INX → A=$04 X=$05 Y=$03 SP=$FD | PC=$0609`
  182.  
  183. **Instruction 24: INY → Y=$04**
  184. > `[$0609] INY → A=$04 X=$05 Y=$04 SP=$FD | PC=$060A`
  185.  
  186. **Instruction 25: CPX #$0B** (X=$05 < $0B)
  187. > `[$060A] CPX #$0B → A=$04 X=$05 Y=$04 SP=$FD | NV-BDIZC=10001000 | PC=$060C`
  188.  
  189. **Instruction 26: BNE loop**
  190. > `[$060C] BNE → A=$04 X=$05 Y=$04 SP=$FD | PC=$0604`
  191.  
  192. ---
  193.  
  194. #### Iteration 5: X=5
  195.  
  196. **Instruction 27: TXA → A=$05**
  197. > `[$0604] TXA → A=$05 X=$05 Y=$04 SP=$FD | PC=$0605`
  198.  
  199. **Instruction 28: STA $0200,Y** (mem[$0204]=$05)
  200. > `[$0605] STA $0200,Y → A=$05 X=$05 Y=$04 SP=$FD | PC=$0608`
  201.  
  202. **Instruction 29: INX → X=$06**
  203. > `[$0608] INX → A=$05 X=$06 Y=$04 SP=$FD | PC=$0609`
  204.  
  205. **Instruction 30: INY → Y=$05**
  206. > `[$0609] INY → A=$05 X=$06 Y=$05 SP=$FD | PC=$060A`
  207.  
  208. **Instruction 31: CPX #$0B**
  209. > `[$060A] CPX #$0B → A=$05 X=$06 Y=$05 SP=$FD | NV-BDIZC=10001000 | PC=$060C`
  210.  
  211. **Instruction 32: BNE loop**
  212. > `[$060C] BNE → A=$05 X=$06 Y=$05 SP=$FD | PC=$0604`
  213.  
  214. ---
  215.  
  216. #### Iteration 6: X=6
  217.  
  218. **Instruction 33: TXA → A=$06**
  219. > `[$0604] TXA → A=$06 X=$06 Y=$05 SP=$FD | PC=$0605`
  220.  
  221. **Instruction 34: STA $0200,Y** (mem[$0205]=$06)
  222. > `[$0605] STA $0200,Y → A=$06 X=$06 Y=$05 SP=$FD | PC=$0608`
  223.  
  224. **Instruction 35: INX → X=$07**
  225. > `[$0608] INX → A=$06 X=$07 Y=$05 SP=$FD | PC=$0609`
  226.  
  227. **Instruction 36: INY → Y=$06**
  228. > `[$0609] INY → A=$06 X=$07 Y=$06 SP=$FD | PC=$060A`
  229.  
  230. **Instruction 37: CPX #$0B**
  231. > `[$060A] CPX #$0B → A=$06 X=$07 Y=$06 SP=$FD | PC=$060C`
  232.  
  233. **Instruction 38: BNE loop**
  234. > `[$060C] BNE → A=$06 X=$07 Y=$06 SP=$FD | PC=$0604`
  235.  
  236. ---
  237.  
  238. #### Iteration 7: X=7
  239.  
  240. **Instruction 39: TXA → A=$07**
  241. > `[$0604] TXA → A=$07 X=$07 Y=$06 SP=$FD | PC=$0605`
  242.  
  243. **Instruction 40: STA $0200,Y** (mem[$0206]=$07)
  244. > `[$0605] STA $0200,Y → A=$07 X=$07 Y=$06 SP=$FD | PC=$0608`
  245.  
  246. **Instruction 41: INX → X=$08**
  247. > `[$0608] INX → A=$07 X=$08 Y=$06 SP=$FD | PC=$0609`
  248.  
  249. **Instruction 42: INY → Y=$07**
  250. > `[$0609] INY → A=$07 X=$08 Y=$07 SP=$FD | PC=$060A`
  251.  
  252. **Instruction 43: CPX #$0B** (X=$08 < $0B)
  253. > `[$060A] CPX #$0B → A=$07 X=$08 Y=$07 SP=$FD | PC=$060C`
  254.  
  255. **Instruction 44: BNE loop**
  256. > `[$060C] BNE → A=$07 X=$08 Y=$07 SP=$FD | PC=$0604`
  257.  
  258. ---
  259.  
  260. #### Iteration 8: X=8
  261.  
  262. **Instruction 45: TXA → A=$08**
  263. > `[$0604] TXA → A=$08 X=$08 Y=$07 SP=$FD | PC=$0605`
  264.  
  265. **Instruction 46: STA $0200,Y** (mem[$0207]=$08)
  266. > `[$0605] STA $0200,Y → A=$08 X=$08 Y=$07 SP=$FD | PC=$0608`
  267.  
  268. **Instruction 47: INX → X=$09**
  269. > `[$0608] INX → A=$08 X=$09 Y=$07 SP=$FD | PC=$0609`
  270.  
  271. **Instruction 48: INY → Y=$08**
  272. > `[$0609] INY → A=$08 X=$09 Y=$08 SP=$FD | PC=$060A`
  273.  
  274. **Instruction 49: CPX #$0B** (X=$09 < $0B)
  275. > `[$060A] CPX #$0B → A=$08 X=$09 Y=$08 SP=$FD | PC=$060C`
  276.  
  277. **Instruction 50: BNE loop**
  278. > `[$060C] BNE → A=$08 X=$09 Y=$08 SP=$FD | PC=$0604`
  279.  
  280. ---
  281.  
  282. #### Iteration 9: X=9
  283.  
  284. **Instruction 51: TXA → A=$09**
  285. > `[$0604] TXA → A=$09 X=$09 Y=$08 SP=$FD | PC=$0605`
  286.  
  287. **Instruction 52: STA $0200,Y** (mem[$0208]=$09)
  288. > `[$0605] STA $0200,Y → A=$09 X=$09 Y=$08 SP=$FD | PC=$0608`
  289.  
  290. **Instruction 53: INX → X=$0A**
  291. > `[$0608] INX → A=$09 X=$0A Y=$08 SP=$FD | PC=$0609`
  292.  
  293. **Instruction 54: INY → Y=$09**
  294. > `[$0609] INY → A=$09 X=$0A Y=$09 SP=$FD | PC=$060A`
  295.  
  296. **Instruction 55: CPX #$0B** (X=$0A < $0B)
  297. > `[$060A] CPX #$0B → A=$09 X=$0A Y=$09 SP=$FD | PC=$060C`
  298.  
  299. **Instruction 56: BNE loop**
  300. > `[$060C] BNE → A=$09 X=$0A Y=$09 SP=$FD | PC=$0604`
  301.  
  302. ---
  303.  
  304. #### Iteration 10: X=$0A (10)
  305.  
  306. **Instruction 57: TXA → A=$0A**
  307. > `[$0604] TXA → A=$0A X=$0A Y=$09 SP=$FD | PC=$0605`
  308.  
  309. **Instruction 58: STA $0200,Y** (mem[$0209]=$0A)
  310. > `[$0605] STA $0200,Y → A=$0A X=$0A Y=$09 SP=$FD | PC=$0608`
  311.  
  312. **Instruction 59: INX → X=$0B**
  313. > `[$0608] INX → A=$0A X=$0B Y=$09 SP=$FD | PC=$0609`
  314.  
  315. **Instruction 60: INY → Y=$0A**
  316. > `[$0609] INY → A=$0A X=$0B Y=$0A SP=$FD | PC=$060A`
  317.  
  318. **Instruction 61: CPX #$0B**
  319. ```
  320. X=$0B, operand=$0B
  321. X - $0B = 0
  322. Z=1 (equal), C=1 (X >= $0B), N=0
  323. ```
  324. > `[$060A] CPX #$0B → A=$0A X=$0B Y=$0A SP=$FD | NV-BDIZC=01001100 | PC=$060C`
  325.  
  326. **Instruction 62: BNE loop**
  327. ```
  328. Z=1, branch NOT taken. PC stays at $060E
  329. ```
  330. > `[$060C] BNE loop → A=$0A X=$0B Y=$0A SP=$FD | NV-BDIZC=01001100 | PC=$060E`
  331.  
  332. ---
  333.  
  334. #### Halt
  335.  
  336. **Instruction 63: BRK**
  337. ```
  338. [$060E] 00 → BRK
  339. Halt execution.
  340. ```
  341. > `[$060E] BRK → A=$0A X=$0B Y=$0A SP=$FD | PC=$060E`
  342.  
  343. ---
  344.  
  345. ## Final Results
  346.  
  347. ### Output Memory ($0200–$02FF)
  348. ```
  349. $0200: $01 (1) 'SOH'
  350. $0201: $02 (2) 'STX'
  351. $0202: $03 (3) 'ETX'
  352. $0203: $04 (4) 'EOT'
  353. $0204: $05 (5) 'ENQ'
  354. $0205: $06 (6) 'ACK'
  355. $0206: $07 (7) 'BEL'
  356. $0207: $08 (8) 'BS'
  357. $0208: $09 (9) 'TAB'
  358. $0209: $0A (10) 'LF'
  359. ```
  360.  
  361. ### Final CPU State
  362. ```
  363. A=$0A X=$0B Y=$0A SP=$FD PC=$060E
  364. NV-BDIZC = 00001100
  365. ```
  366.  
  367. ### Summary
  368. - **Instructions executed:** 63
  369. - **Errors:** None
  370. - **Result:** `$0200–$0209` contain `01 02 03 04 05 06 07 08 09 0A` (values 1 through 10) ✓ (matches expected output)
Add Comment
Please, Sign In to add comment