diff options
Diffstat (limited to 'README.md')
| -rw-r--r-- | README.md | 100 |
1 files changed, 86 insertions, 14 deletions
@@ -3,7 +3,7 @@ Compilers nowadays are written in languages like C, which themselves need to be compiled. But then, you need a C compiler to compile your C compiler! Of course, the very first C compiler was not written in C (because how would it be -compiled?). Instead, it was built up over time, starting from a very basic +compiled?). Instead, it was built up over time, starting from a basic assembler, eventually reaching a full-scale compiler. In this repository, we'll explore how that's done. Each directory represents a new "stage" in the process. The first one, `00`, is a hand-written @@ -37,9 +37,9 @@ want to know before starting. You don't need to understand everything about each of these, just get a general idea: +- the basics of programming - what a system call is - what memory is -- what a programming language is - what a compiler is - what an executable file is - number bases -- if a number is preceded by 0x, 0o, or 0b in this series, that @@ -55,19 +55,9 @@ decimal. - ASCII, null-terminated strings - how pointers work - how floating-point numbers work -- some basic Intel-style x86-64 assembly -It will help you a lot to know how to program (with any programming language), -but it's not strictly necessary. - -## instruction set - -x86-64 has a *gigantic* instruction set. The manual for it is over 2,000 pages -long! So it makes sense to select only a small subset of it to use. -The set I've chosen can be found in `instructions.txt`. -I think it achieves a pretty good balance between having few enough -instructions to be manageable and having enough instructions to be useable. -To be clear, you don't need to read that file to understand the series. +If you aren't familiar with x86-64 assembly, be sure to check out the instruction list +below. ## principles @@ -103,6 +93,88 @@ an operating system to a USB key with a circuit or something, assuming you trust your CPU... I'll leave that to someone else. +## instruction set + +x86-64 has a *gigantic* instruction set. The manual for it is over 2,000 pages +long! So it makes sense to select only a small subset of it to use. + +Here are all the instructions we'll be using. If you're not familiar with +x86-64 assembly, you might want to look over these (but you don't need to understand everything). + +In the table below, `IMM64` means a 64-bit *immediate* (a constant number). +`rdx:rax` refers to the 128-bit number you get by combining `rdx` and `rax`. + +``` +┌──────────────────────┬───────────────────┬────────────────────────────────────────┐ +│ Instruction │ Encoding │ Description │ +├──────────────────────┼───────────────────┼────────────────────────────────────────┤ +│ mov rax, IMM64 │ 48 b8 IMM64 │ set rax to the 64-bit value IMM64 │ +│ xor eax, eax │ 31 c0 │ set rax to 0 (shorter than mov rax, 0) │ +│ xor edx, edx │ 31 d2 │ set rdx to 0 │ +│ mov RDEST, RSRC │ 48 89 (DEST|SRC<<3|0xc0) │ set register DEST to current │ +│ │ │ value of register SRC │ +│ mov r8, rax │ 49 89 c0 │ set r8 to rax (only used for syscalls) │ +│ mov r9, rax │ 49 89 c1 │ set r9 to rax (only used for syscalls) │ +│ mov r10, rax │ 49 89 c2 │ set r10 to rax (only used for syscalls)│ +│ xchg rax, rbx │ 48 93 │ exchange the values of rax and rbx │ +│ mov [rbx], rax │ 48 89 03 │ store rax as 8 bytes at address rbx │ +│ mov rax, [rbx] │ 48 8b 03 │ load 8 bytes from address rbx into rax │ +│ mov [rbx], eax │ 89 03 │ store eax as 4 bytes at address rbx │ +│ mov eax, [rbx] │ 8b 03 │ load 4 bytes from address rbx into eax │ +│ mov [rbx], ax │ 66 89 03 │ store ax as 2 bytes at address rbx │ +│ mov ax, [rbx] │ 66 8b 03 │ load 2 bytes from address rbx into eax │ +│ mov [rbx], al │ 88 03 │ store al as 1 byte at address rbx │ +│ mov al, [rbx] │ 8a 03 │ load 1 byte from addrress rbx into al │ +│ mov rax, [rbp+IMM32] │ 48 8b 85 IMM32 │ load 8 bytes from address rbp+IMM32 │ +│ │ │ into rax (note: IMM32 may be negative) │ +│ lea rax, [rbp+IMM32] │ 48 8d 85 IMM32 │ set rax to rbp+IMM32 │ +│ lea rsp, [rbp+IMM32] │ 48 8d a5 IMM32 │ set rsp to rbp+IMM32 │ +│ mov [rbp+IMM32], rax │ 48 89 85 IMM32 │ store rax in 8 bytes at rbp+IMM32 │ +│ mov [rsp+IMM32], rax │ 48 89 84 24 IMM32 │ store rax in 8 bytes at rsp+IMM32 │ +│ mov [rsp], rbp │ 48 89 2c 24 │ store rbp in 8 bytes at rsp │ +│ mov rbp, [rsp] │ 48 8b 2c 24 │ load 8 bytes from rsp into rbp │ +│ neg rax │ 48 f7 d8 │ set rax to -rax │ +│ add rax, rbx │ 48 01 d8 │ add rbx to rax │ +│ sub rax, rbx │ 48 29 d8 │ subtract rbx from rax │ +│ imul rbx │ 48 f7 eb │ set rdx:rax to rax * rbx (signed) │ +│ idiv rbx │ 48 f7 fb │ divide rdx:rax by rbx (signed); put │ +│ │ │ quotient in rax, remainder in rbx │ +│ mul rbx │ 48 f7 e3 │ like imul, but unsigned │ +│ div rbx │ 48 f7 f3 │ like idiv, but with unsigned division │ +│ not rax │ 48 f7 d0 │ set rax to ~rax (bitwise not) │ +│ and rax, rbx │ 48 21 d8 │ set rax to rax & rbx (bitwise and) │ +│ or rax, rbx │ 48 09 d8 │ set rax to rax | rbx (bitwise or) │ +│ xor rax, rbx │ 48 31 d8 │ set rax to rax ^ rbx (bitwise xor) │ +│ shl rax, cl │ 48 d3 e0 │ set rax to rax << cl (left shift) │ +│ shl rax, IMM8 │ 48 c1 e0 IMM8 │ set rax to rax << IMM8 │ +│ shr rax, cl │ 48 d3 e8 │ set rax to rax >> cl (zero-extend) │ +│ shr rax, IMM8 │ 48 c1 e8 IMM8 │ set rax to rax >> IMM8 (zero-extend) │ +│ sar rax, cl │ 48 d3 f8 │ set rax to rax >> cl (sign-extend) │ +│ sar rax, IMM8 │ 48 c1 f8 IMM8 │ set rax to rax >> IMM8 (sign-extend) │ +│ sub rsp, IMM32 │ 48 81 ec IMM32 │ subtract IMM32 from rsp │ +│ add rsp, IMM32 │ 48 81 c4 IMM32 │ add IMM32 to rsp │ +│ cmp rax, rbx │ 48 39 d8 │ compare rax with rbx (see je, jl, etc.)│ +│ test rax, rax │ 48 85 c0 │ equivalent to cmp rax, 0 │ +│ jmp IMM32 │ e9 IMM32 │ jump to offset IMM32 from here │ +│ je IMM32 │ 0f 84 IMM32 │ jump to IMM32 if equal │ +│ jne IMM32 │ 0f 85 IMM32 │ jump if not equal │ +│ jl IMM32 │ 0f 8c IMM32 │ jump if less than │ +│ jg IMM32 │ 0f 8f IMM32 │ jump if greater than │ +│ jle IMM32 │ 0f 8e IMM32 │ jump if less than or equal to │ +│ jge IMM32 │ 0f 8d IMM32 │ jump if greater than or equal to │ +│ jb IMM32 │ 0f 82 IMM32 │ jump if "below" (like jl but unsigned) │ +│ ja IMM32 │ 0f 87 IMM32 │ jump if "above" (like jg but unsigned) │ +│ jbe IMM32 │ 0f 86 IMM32 │ jump if below or equal to │ +│ jae IMM32 │ 0f 83 IMM32 │ jump if above or equal to │ +│ call rax │ ff d0 │ call the function at address rax │ +│ ret │ c3 │ return from function │ +│ syscall │ 0f 05 │ execute a system call │ +│ nop │ 90 │ do nothing │ +└──────────────────────┴───────────────────┴────────────────────────────────────────┘ +``` + +More will be added in the future as needed. + ## license ``` |