K

@kissa.bsky.social

@kissa.bsky.social

86 Followers 646 Following

Tomfoolery, nincompoopery, programming

Tweet by @heydonworks that sparked some controversy in 2019: What do you like to do when you're not coding? Vue-based developer: I am fond of cooking, getting stuck into a good graphic novel and— React-based developer: WEIGHTS. BROING DOWN. MORE WEIGHTS. TRUMP. WEIGHTS. GUNS. THE FREE MARKET.
List of test instructions that ChatGPT wrote me. export const opcodes: { [key: number]: string } = { 0b00000000: "add", // add <op1> <op2> <op3> - op1 <- op2 + op3 0b00000001: "sub", // sub <op1> <op2> <op3> - op1 <- op2 - op3 0b00000010: "mul", // mul <op1> <op2> <op3> - op1 <- op2 * op3 // etc, ending with 0b00001100: "mov" 0b00010000: "adda", // add <op1> <op2> - op1 <- op1 + op2 0b00010001: "suba", // sub <op1> <op2> - op1 <- op1 - op2 0b00010010: "mula", // mul <op1> <op2> - op1 <- op1 * op2 // etc, ending with 0b00011100: "nop" 0b11110000: "hlt", // hlt <?> <?> <?> - halt program execution 0b11110001: "hcf", // hcf <?> <?> <?> - halt and catch fire }
Previous picture, plus new stuff (8-bit immediate instructions) // If bit 6 (immediate mode) is set, bit 7 sets "byte mode" // // Instruction names are postfixed with "b" for immediate. // Arithmetic instructions with 8-bit immediate operand (96-111): // // addb op1, op2, imm8 ; op1 <- op2 + imm8 01100000 // subb // mulb // divb // modb // andb // orb // xorb // shlb // shrb // add1b // sub1b // movb // // // Arithmetic instructions with 8-bit immediate operand, augmented assignment // (112-127): // // addab op1, imm8 ; op1 <- op2 + imm8 01110000 // subab // mulab // divab // modab // andab // orab // xorab // shlab // shrab // incab // decab // nopab
Immediate instructions with 16-bit operand (32-47), plus augmented ones (48-63) (Details omitted due to space constraints) addi op1, op2, imm16 ; op1 <- op2 + imm16 00100000 subi muli divi modi andi ori xori shli shri add1i sub1i movi addai op1, imm16 ; op1 <- op2 + imm16 00110000 subai mulai divai modai andai orai xorai shlai shrai incai decai nopai
// // Augmented arithmetic instructions (16-31) // // adda op1, op2 ; op1 <- op2 + op3 00010000 // suba op1, op2 ; op1 <- op2 - op3 00010001 // mula op1, op2 ; op1 <- op2 * op3 00010010 // diva op1, op2 ; op1 <- op2 / op3 00010011 // moda op1, op2 ; op1 <- op2 % op3 00010100 // anda op1, op2 ; op1 <- op2 & op3 00010101 // ora op1, op2 ; op1 <- op2 | op3 00010110 // xora op1, op2 ; op1 <- op2 ^ op3 00010111 // shla op1, op2 ; op1 <- op2 << op3 00011000 // shra op1, op2 ; op1 <- op2 >> op3 00011001 // inc op1 ; op1 <- op2 + 1 00011010 - Note name // dec op1 ; op1 <- op2 - 1 00011011 - Note name // nop ; (do nothing) 00011100 - Note zero operands // // Augmented add1 is called inc. Augmented sub1 is called dec. Augmented mov // is called nop and takes 0 parameters. //
Instructions Arithmetic instructions (0-15) add op1, op2, op3 ; op1 <- op2 + op3 00000000 sub op1, op2, op3 ; op1 <- op2 - op3 00000001 mul op1, op2, op3 ; op1 <- op2 * op3 00000010 div op1, op2, op3 ; op1 <- op2 / op3 00000011 mod op1, op2, op3 ; op1 <- op2 % op3 00000100 and op1, op2, op3 ; op1 <- op2 & op3 00000101 or op1, op2, op3 ; op1 <- op2 | op3 00000110 xor op1, op2, op3 ; op1 <- op2 ^ op3 00000111 shl op1, op2, op3 ; op1 <- op2 << op3 00001000 shr op1, op2, op3 ; op1 <- op2 >> op3 00001001 add1 op1, op2 ; op1 <- op2 + 1 00001010 sub1 op1, op2 ; op1 <- op2 - 1 00001011 mov op1, op2 ; op1 <- op2 00001100 Arithmetic instructions ending in 1101, 1110, 1111 are reserved. Some candidates: abs op1, op2 ; op1 <- abs(op2) sgn op1, op2 ; op1 <- sign(op2) neg op1, op2 ; op1 <- -op2 add2 op1, op2 ; op1 <- op2 + 2 sub2 op1, op2 ; op1 <- op2 - 2
export const opcodes: { [key: number]: string } = { 0b00000000: "add", // add <dst> <src1> <src2> - dst <- src1 + src2 0b00000001: "sub", // sub <dst> <src1> <src2> - dst <- src1 - src2 0b11110000: "hlt", // hlt <?> <?> <?> - halt program execution 0b11110001: "hcf", // hcf <?> <?> <?> - halt and catch fire }
// Write 8-bit unsigned byte `byte` to memory address `addr`, or `more` after // that if provided export function write8(addr: number, byte: number, ...more: Array<number>) { if (byte < 0 || byte >= 256) { error(`write8: byte doesn't fit ${byte}`) } if (addr < 0 || addr >= MEM_SIZE) { error(`write8: invalid address ${addr}`) } mem[addr] = byte if (more.length) { for (let i = 0; i < more.length; i++) { mem[addr + i + 1] = more[i] } } }
Code diff where "instructions." has been changed to "instr.", and registers like "A" to "op.a" when used as operand, but to "addr.a" when used as absolute address
export function step(): boolean { let pc: number = registers.pc log(`step: pc ${print(pc)}`) let opcode: number = read8(pc++) let instr: string = opcodes[opcode] ?? "nop" let op1: number = read8(pc++) let op2: number = read8(pc++) let op3: number = read8(pc++) registers.pc = pc let op2value = readOperand(op2) let op3value = readOperand(op3) log( `step: instr ${instr} ${print(opcode)} ${print(op1)} ${print(op2)} ${print( op3, )}`, ) if (instr === "add") { let result = op2value + op3value writeOperand(op1, result) return true } if (instr === "hlt") { return false } if (instr === "hcf") { error("Machine caught fire") } return true }
function readOperand(op: number) { let lowest6bits = op & 0b0011_1111 if (op & 0b0100_0000) { return read8s(lowest6bits) } else { return read(lowest6bits) } } function writeOperand(op: number, value: number) { let lowest6bits = op & 0b0011_1111 if (op & 0b0100_0000) { write8(lowest6bits, value) } else { write(lowest6bits, value) } }
export function hi(op: number): number { return op | 0b0100_0000 } export function lo(op: number): number { return (op + 1) | 0b0100_0000 }
test("writing bytes", () => { // add a.lo, b, c write8(0x100, instructions.add) write8(0x101, hi(A)) write8(0x102, B) write8(0x103, C) // add a.hi, d, x write8(0x104, instructions.add) write8(0x105, lo(A)) write8(0x106, D) write8(0x107, X) write8(0x108, instructions.hlt) // Set initial values to registers and point PC to start write(PC, 0x100) // Clear registers write(A, 0) write(B, 0x12) // 12 write(C, 0x34) // + 34 -> 0x46__ write(D, 0x56) // 56 write(X, 0x78) // + 78 -> 0x__ce run() expect(read(A)).toBe(0x46ce) })
✓ jump relative with add [0.03ms] step: pc 0x0100 step: instr add (0x0000) step: pc 0x0104 step: instr hlt (0x00f0) ✓ program with byte addressing [0.08ms]
Autumn
Operand format: Direct addressing (word), values 0..63: 00mmmmmm: [M], where M is number 0-63 Direct addressing (byte), values 64..127: 01mmmmmm: [M].b, where M is number 0-63 Indirect addressing with immediate offset (word), values 128..175: 10ooooaa: [<rega> + O], where <rega> is selected with bits 'aa' and O is the range 0b0000-0b1011, represented by bits 'oooo', mapped to values -6 to 5 Indirect addressing with index register (word), values 176..191: 1011iiaa: [<rega> + <regi>], where <rega> is selected with bits 'aa' and <regi> is selected with bits 'ii' Indirect addressing with immediate offset (byte), values 192..239: 11ooooaa: [<rega> + O].b, where <rega> is selected with bits 'aa' and O is range 0b0000-0b1011 mapped to values -6 to 5 Indirect addressing with index register (byte), values 240..255: 1111iiaa: [<rega> + <regi>].b, where <rega> is selected with bits 'aa' and <regi> is selected with bits 'ii'
Syntax [M] means the word at memory address M. [M].b means the byte at memory address M. When read, it is sign-extended to a word. <reg> is equivalent to [addressof <reg>], where <reg> is one of registers (a, b, c, d, x, y, i, j, p, q, sp, pc), and addressof <reg> is the memory address of the register according to the table below. <reg>.hi is equivalent to [address of <reg>].b <reg>.lo is equivalent to [address of <reg> + 1].b Table of registers and their addresses: a: 0x0 a.hi: 0x0 a.lo: 0x1 b: 0x2 b.hi: 0x2 b.lo: 0x3 c: 0x4 c.hi: 0x4 c.lo: 0x5 d: 0x6 d.hi: 0x6 d.lo: 0x7 x: 0x8 x.hi: 0x8 x.lo: 0x9 y: 0xa y.hi: 0xa y.lo: 0xb i: 0xc i.hi: 0xc i.lo: 0xd j: 0xe j.hi: 0xe j.lo: 0xf p: 0x10 p.hi: 0x10 p.lo: 0x11 q: 0x12 q.hi: 0x12 q.lo: 0x13 sp: 0x14 sp.hi: 0x14 sp.lo: 0x15 pc: 0x16 pc.hi: 0x16 pc.lo: 0x17 Finally: <regi> is one of x, y, i, j <rega> is one of p, q, sp, pc
test("jump relative with add", () => { // Load program "add pc, pc, a" to memory address 0x100 write8(0x100, instructions.add) write8(0x101, PC) write8(0x102, PC) write8(0x103, A) // Load program "hlt" to memory address 0x200 write8(0x200, instructions.hlt) write(PC, 0x100) // Offset that should jump to 0x200 write(A, 0x100 - 4) let cont = step() expect(read(PC)).toBe(0x200) expect(cont).toBe(true) cont = step() expect(read(PC)).toBe(0x204) expect(cont).toBe(false) })
test("simple program", () => { // Load program "add a, b, c; hlt" to memory address 0x100 write8(0x100, instructions.add) write8(0x101, A) write8(0x102, B) write8(0x103, C) write8(0x104, instructions.hlt) // hlt also has pseudo-operands; this will change write8(0x105, 0) write8(0x106, 0) write8(0x107, 0) // Set initial values to registers and point PC to start write(PC, 0x100) write(B, 0x1234) write(C, 0x5432) let cont = step() expect(read(PC)).toBe(0x104) expect(read(A)).toBe(0x6666) step() expect(read(PC)).toBe(0x108) }) test("halt and catch fire", () => { write8(0x100, instructions.hcf) write(PC, 0x100) expect(() => step()).toThrow("Machine caught fire") })
export const opcodes: { [key: number]: string } = { 0b00000000: "add", // add <dst> <src1> <src2> - dst <- src1 + src2 0b11110000: "hlt", // hlt <?> <?> <?> - halt program execution 0b11110001: "hcf", // hcf <?> <?> <?> - halt and catch fire } // Reverse mapping of opcodes (to make it easier to write programs) export const instructions: { [opcode: string]: number } = {} for (let opcode in opcodes) { instructions[opcodes[opcode]] = Number(opcode) } // Read and execute one instruction at pc. Returns false if machine halted export function step(): boolean { let pc: number = registers.pc let opcode: number = read8(pc++) let instr: string = opcodes[opcode] ?? "nop" let op1: number = read8(pc++) let op2: number = read8(pc++) let op3: number = read8(pc++) registers.pc = pc if (instr === "add") { write(op1, read(op2) + read(op3)) return true } if (instr === "hlt") { return false } if (instr === "hcf") { error("Machine caught fire") } return true }
// Write 16-bit big endian signed word `word` to memory address `addr` export function write(addr: number, word: number) { if (word < -32768 || word > 32767) { // Alternatively, we might just do `& 0xffff` and be done with it error(`write: word doesn't fit ${word}`) } let hi = (word & 0xff00) >> 8 let lo = word & 0x00ff if (addr < 0 || addr >= MEM_SIZE - 1) { if (addr === MEM_SIZE - 1) { mem[addr] = hi mem[0] = lo } else { error(`write: invalid address ${addr}`) } } mem[addr] = hi mem[addr + 1] = lo } // Write 8-bit unsigned byte `byte` to memory address `addr` export function write8(addr: number, byte: number) { if (byte < 0 || byte >= 256) { error(`write8: byte doesn't fit ${byte}`) } if (addr < 0 || addr >= MEM_SIZE) { error(`write8: invalid address ${addr}`) } mem[addr] = byte }
// Register layout: // Memory address: | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | a | b | c | d | e | f | // Register: | a | b | c | d | x | y | i | j | // // Memory address: | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 1a | 1b | 1c | 1d | 1e | 1f | // Register: | p | q | sp | pc | <reserved> | // const A = 0x00 const B = 0x02 const C = 0x04 const D = 0x06 const X = 0x08 const Y = 0xa const I = 0xc const J = 0xe const P = 0x10 const Q = 0x12 const SP = 0x14 const PC = 0x16 const registers = { get pc() { return read(PC) }, set pc(val: number) { write(PC, val) }, // TODO other registers } export function step() { let pc = registers.pc let opcode = read8(pc++) let op1 = read8(pc++) let op2 = read8(pc++) let op3 = read8(pc++) registers.pc = pc // TODO decode and execute instruction }
export function write(addr: number, num: number) { if (num < -32768 || num > 32767) { // Alternatively, we might just do `& 0xffff` and be done with it error(`write: number doesn't fit ${num}`) } let hi = (num & 0xff00) >> 8 let lo = num & 0x00ff if (addr < 0 || addr >= MEM_SIZE - 1) { if (addr === MEM_SIZE - 1) { mem[addr] = hi mem[0] = lo } else { error(`write: invalid address ${addr}`) } } mem[addr] = hi mem[addr + 1] = lo }
export function read(addr: number) { let data if (addr < 0 || addr >= MEM_SIZE - 1) { if (addr === MEM_SIZE - 1) { data = (mem[addr] << 8) + mem[0] } else { error(`read: invalid address ${addr}`) } } else { data = (mem[addr] << 8) + mem[addr + 1] } if ((data & 0x8000) > 0) { return data - 0x10000 } else { return data } }
test("read negative word", () => { mem[0] = 0xff mem[1] = 0xff expect(read(0)).toBe(-1) }) test("boundary between negative and positive", () => { mem[0] = 0x7f mem[1] = 0xff mem[2] = 0x80 mem[3] = 0x00 expect(read(0)).toBe(32767) expect(read(2)).toBe(-32768) })
index.test.ts: ✓ read word from memory [0.06ms] 12 | 13 | test("read at memory boundary", () => { 14 | mem[MEM_SIZE - 1] = 0x98 15 | mem[0] = 0x76 16 | 17 | expect(read(MEM_SIZE - 1)).toBe(0x9876) ^ error: expect(received).toBe(expected) Expected: 39030 Received: NaN
const MEM_SIZE = 256 * 256 const mem = new Uint8Array(MEM_SIZE) function error(msg: string) { throw new Error(msg) } function read(addr: number) { if (addr < 0 || addr >= MEM_SIZE) { error(`read: invalid address ${addr}`) } return (mem[addr] << 8) + mem[addr + 1] } function test() { mem[0] = 0x12 mem[1] = 0x34 console.log(`0x${read(0).toString(16)}`) // => 0x1234 } test()