{"id":5,"date":"2024-10-01T06:28:32","date_gmt":"2024-10-01T06:28:32","guid":{"rendered":"https:\/\/blogs.oregonstate.edu\/gevkob\/?p=5"},"modified":"2024-10-01T06:37:38","modified_gmt":"2024-10-01T06:37:38","slug":"how-cpus-understand-0s-and-1s","status":"publish","type":"post","link":"https:\/\/blogs.oregonstate.edu\/gevkob\/2024\/10\/01\/how-cpus-understand-0s-and-1s\/","title":{"rendered":"How CPUs Understand 0s and 1s"},"content":{"rendered":"\n

I recently started an exciting project: building an NES emulator in C++. An emulator allows a computer to mimic the behavior of other hardware\u2014in my case, the Nintendo Entertainment System. It works by loading a copy of an NES game’s memory, and executing the program in a similar way a real NES would. This means replicating the behavior of the CPU, the PPU (Picture Processing Unit), and the APU (Audio Processing Unit). <\/p>\n\n\n\n

I chose to start with the brain of the system, the CPU. The NES used a variant of the MOS Technology 6502 CPU, a legendary 8-bit microprocessor found in other tech of the time, like the Commodore 64, Atari 5200, and the Apple II computer just to name a few. So, I sought out to learn how a CPU works.<\/p>\n\n\n\n

Instruction Execution<\/h2>\n\n\n\n

CPUs execute instructions. The “8-bit” part means that data is processed in 8-bit chunks. The 6502 registers\u2014small, high-speed memory areas used to hold temporary variables\u2014are 8 bits wide, which means instructions typically manipulate 8-bit numbers.<\/p>\n\n\n\n

What is an Instruction?<\/h3>\n\n\n\n

An instruction is a directive telling the CPU to do something like moving data around, perform a calculation, or jump to another section of the program. Here’s a snippet of 6502 assembly code to illustrate:<\/p>\n\n\n\n

LDA #$01 ;Load the value 01 into the accumulator register\nTAX      ;Transfer value from accumulator to the X register\nINX      ;Increment the X register by one\nBRK      ;Break, or stop the program<\/code><\/pre>\n\n\n\n
We load a value into register A, transfer it into X, and then increment X. In a higher level language, the operation might look like:<\/p>\n\n\n\n
int A = 1;\nint X = A;\nX = X + 1;\n\/\/ End program<\/code><\/pre>\n\n\n\n
Assembly vs. Machine Code<\/h3>\n\n\n\n
To make the CPU understand any given instruction, we have to decode or “disassemble” the instruction into machine code. Figuring out how to assemble and disassemble instructions sounds like a great weekend, but it’s not required for the CPU emulation. <\/p>\n\n\n\n
Executing Machine Code<\/h3>\n\n\n\n
Looking back at the first line of the assembly snippet, LDA #$01<\/code> can be written as 0xA9 0x01<\/code>. You may have guessed it, but 0xA9<\/code> maps to LDA<\/code> and 0x01<\/code> to 01<\/code> respectively. <\/p>\n\n\n\n
To understand how, let’s load the above program into memory, starting at the address 0x0000<\/code>:<\/p>\n\n\n\n
\n
0x0000\n0x0001\n0x0002\n0x0003\n0x0004<\/code><\/pre>\n\n\n\n
0xA9      ;LDA #$01\n0x01\n0xBA      ;TAX\n0xE8      ;INX\n0x00      ;BRK<\/code><\/pre>\n<\/div>\n\n\n\n
Let’s briefly talk about how the CPU would execute this code.<\/p>\n\n\n\n