the-assembled-loci-a-systems-story ================================== Prologue – The Shattered Console -------------------------------- Kai pressed Enter one last time. The build had failed, again. The screen flickered and spat a line of red text he had never seen before: FATAL: Instruction Set Boundary Collapse. All architectures merging. Then the screen went black. The desk beneath Kai’s hands dissolved, and he fell through a tunnel of light, code scrolling past him like a waterfall. push rbp mov rbp, rsp sub rsp, 32 … He landed on cool stone, a single golden ticket clutched in his hand. The ticket read: Admit one to the Kingdom of Instructions. All gates open. In the distance, four citadels rose against a grey sky. A voice, warm and precise, spoke behind him. “You’re awake. Good. I am the Architect. The realms are fracturing. To save them, and your world, you must walk each kingdom and learn their true nature. Only then will the Console be restored.” Kai looked at the ticket, then at the distant spires. “Where do I start?” The Architect pointed to the leftmost citadel, a tower of blue glass and shifting reflections. “Where else? The Glass Tower.” PART ONE – THE FOUR KINGDOMS OF INSTRUCTION =========================================== Chapter 1 – The Glass Tower of x86-64 ------------------------------------- The Glass Tower had no visible doors, only a revolving gate shaped like a zero split into two rings. Kai stepped through and found himself in a marble lobby lit by eight enormous sculptures, each one a living machine that hummed with power. A plaque beside the first read: RAX – The Golden Axe. The sculpture was a colossal axe buried in marble, and as Kai watched, it stirred. The axe-head split open, revealing a smaller eagle-emblazoned blade. The eagle folded its wings, and a still smaller hatchet emerged, then a tiny top hat and an alligator tooth, all nested one inside the other, each a piece of the 64-bit whole. The Architect’s voice echoed: “RAX is the accumulator, the return value, and the volatile heart of computation. When you give it a value, it carries that value through a function and brings it back.” Kai touched the axe. A spell appeared in his mind: mov rax, 42 He whispered it, and the axe glowed with the number 42. The handle felt warm. Nearby, a heavy safe of red brick was chained to the floor. RBX – The Brick Box. Kai opened it and found a smaller ebony box, then a bronze box, then a black hinge and a blue latch. “Callee-saved,” the Architect said. “Whatever you place inside will survive a function call. The chain never breaks.” A grandfather clock RCX – The Clock Counter ticked with the rhythm of a loop. Its pendulum was a 32-tooth gear, the hands split into cobalt and copper. Kai knew this clock drove the looping spells. A spinning vinyl record RDX – The Data Disc held the third argument and partnered the axe in mighty multiplications. Then a crystal fountain RSI – The Source Spring and a dartboard RDI – The Destination Dartboard stood facing each other, ready to pour bytes from one to the other. RBP – The Base Plate, a massive hydraulic press, could anchor a function’s stack frame, while RSP – The Stack of Plates towered high, plates clinking as they grew downward, each etched with a return address. Kai glanced at two telephone booths in the corner: one red, one blue. The Architect explained: “The red booth, System V, passes arguments in RDI, RSI, RDX, RCX, R8, R9, then the stack. The blue booth, Microsoft, uses RCX, RDX, R8, R9, with a shadow space of 32 bytes. They are the calling conventions, the agreements that let functions speak.” A glass elevator carried Kai to floors 1 through 8. Each held a robot. R8 had eight tentacles, R9 had nine eyes, up to R15 with fifteen antennae. All wore loose parts, signifying they were volatile, free to use but not preserved across calls. At the very top, the RFLAGS Attic held a stained-glass ceiling. The panes lit one by one as Kai watched: Carry (a golden chain), Zero (a zebra in ice), Sign (a silver serpent), Overflow (an orange fountain), and others. “Flags change after almost every arithmetic or logic spell,” the Architect said. “Conditional jumps read them.” Kai descended into the Basement of Instructions, a cavern filled with dioramas. First, Data Movement: a moving truck MOV that never goes memory-to-memory directly; a waiter PUSH pushing plates onto the stack; POP removing them; and a leaf blower LEA that computes an address without touching memory, a spell of pure arithmetic. lea rax, [rbx + rcx4 + 8] Kai felt the address form in his mind, a bull (base), an iguana (index), a scale (1,2,4,8), and a disco ball (displacement). Next, Arithmetic: an adder snake ADD, a submarine torpedo SUB, elevators INC/DEC that never touch the carry flag, a mushroom cloud MUL that splits its result across RDX:RAX, and a dividing dragon DIV that burns those who forget to zero RDX. Comparison: a chimpanzee CMP that subtracts and discards, only updating the flag windows. TEST ANDs without storing. Control Flow: a jaguar JMP leaping unconditionally; a gallery of juggling judges for each conditional jump (JE with equal stripes, JNE with a neon sign, JG with a golden goblet, etc.); a telephone booth CALL that pushes the return address; a retriever dog RET that fetches it back; and a looping lasso LOOP that decrements RCX. Finally, the red interrupt button SYSCALL. Kai spoke the spell: mov rax, 1 ; write mov rdi, 1 ; stdout mov rsi, msg ; buffer mov rdx, len ; count syscall The kernel heard. The words appeared in the air. The Architect placed a small gem in Kai’s hand: The Opcode of x86-64. “One kingdom understood. Three remain.” Chapter 2 – The Legacy Castle of x86 32-Bit ------------------------------------------- Kai crossed a cobblestone bridge to a medieval fortress. A weather-beaten banner read IA‑32. Here, everything was 32-bit, and the “E” prefix reigned. In the courtyard stood eight knights in armour. Each was a 32-bit echo of the Glass Tower’s sculptures, but broader, grounded. EAX – Eagle Axe Knight held an axe with an eagle’s crest. Under his helmet were AX, AH, AL. EBX – Ebony Box Knight carried a callee-saved safe. ECX – Endless Clock Knight ticked loops. EDX – Extra Data Knight held a data disk. ESI – Eternal Spring Knight and EDI – Eternal Dart Knight partnered in string operations. EBP – Base Pole Knight anchored frames, and ESP – Stone Pillar Knight balanced on a crumbling pillar, the stack pointer. Segment registers lurked as watchdogs: CS (a falcon), DS (a dragon scale), SS (a snake spiral), ES (an emerald shield), FS (a fox fur), GS (a golden sash). The Architect said, “In protected mode, they are mostly flat, but FS and GS still serve thread-local secrets.” In the throne room, three rulers embodied the calling conventions. cdecl, the queen of chaos, piled arguments right-to-left on the stack and demanded the caller clean up. stdcall, a strict king, insisted the callee clean with ret 8. fastcall, a swift prince, passed the first two arguments in ECX and EDX. A jester reminded Kai: “EBX, EBP, ESI, EDI are callee-saved in all but the direst circumstances.” The tower held the EFLAGS window and EIP, a giant pointing finger that advanced instruction by instruction. In the dungeon, Kai saw the same instructions as the Glass Tower, but now in stone-walled dioramas. The moving truck was a horse-drawn cart. PUSHAD and POPAD were cannons firing all eight registers onto the stack at once. The system call trapdoor was guarded by a moat dragon: mov eax, 4 ; syswrite mov ebx, 1 ; fd mov ecx, msg ; buf mov edx, len ; count int 0x80 The dragon nodded, and the kernel stirred. Kai earned The Opcode of x86 32-bit, a weathered silver coin. The two gems glowed in his palm. The Architect motioned toward a garden gate. “Now, to the RISC Manor.” Chapter 3 – The RISC Manor of ARM --------------------------------- The manor was a symmetrically perfect Georgian house, the word RISC carved into the keystone. Inside, a long corridor stretched, sixteen doors on either side. r0 held a round table with a king clutching a result trophy. r1 had one armchair; r2, two; r3, three jesters. r4 to r11 were vaults guarded by animals: ram, rhino, rabbit, raven, raccoon, reindeer, rattlesnake, rhinoceros. All callee-saved treasures that must survive function calls. r12 was a room of floating IP documents, the scratch register, a lawyer shuffling papers. r13 (SP) was a spiral staircase, full descending. r14 (LR) was a lion’s den; the lion held a card with a return address. r15 (PC) was a conveyor belt of punch cards feeding a mechanical counter. You could read and write it. A spell from the manor’s library: mov pc, lr Was a valid return. Kai felt the elegance. In the central hall hung the CPSR Chandelier: Negative, Zero, Carry, Overflow, GE bits, and mode bulbs (User, FIQ, IRQ, Supervisor…). A butler announced: “Almost every instruction can be conditional on these flags. Append a suffix and add S to update.” The Instruction Wing opened into four galleries. Gallery 1: Data Processing. A laboratory of alchemical apparatus. Instructions followed op{cond}{S} Rd, Rn, Operand2. Operand2 could be a register, a shifted register, or a rotated immediate. Kai saw the moving man MOV, the negative photo MVN, the adder snake ADD, the submarine SUB, the reverse submarine RSB, the puzzle gate AND, the roaring ORR, the oracle serpent EOR, the bicycle BIC that cleared bits. A rack of sixteen condition pennants stood ready: EQ (green), NE (red), CS (copper), CC (white), MI (black), PL (yellow), VS (violet), VC (clear), HI, LS, GE, LT, GT, LE, AL. Kai clipped the GT pennant onto a spell: mov r0, 5 add r1, r0, 3 ; r1 = 8 cmp r1, 10 movgt r2, 1 ; if r1 > 10, r2 = 1 Gallery 2: Memory Access. A warehouse with a crane LDR and forklift STR. Variations: LDRB (a tiny bread crumb), LDRH (half-eaten hamburger), LDRSB (signed byte), LDRSH. Multiple loads/stores: storks LDM and elephants STM. Addressing modes: immediate offset, register offset, scaled, pre-indexed ([Rn, offset]!), post-indexed ([Rn], offset). Kai spoke: ldr r0, [r1, 4]! ; r1 += 4, then r0 = [new r1] str r2, [r3], 8 ; store r2 at [r3], then r3 += 8 Gallery 3: Branches. A hedge maze where bumblebees B, BL, BX, BLX flew, trailing link chains or switching between ARM and Thumb if the least significant bit was set. Gallery 4: System. A swan in a vest SWI/SVC raised supervisor calls. MRS/MSR mannequins moved values between general registers and the CPSR. A dusty marshmallow coprocessor lingered for old floating-point. The butler of AAPCS declared: arguments in r0–r3, then stack; return in r0 (and r1 for 64-bit); callee-saved r4–r11, SP, LR; stack 8-byte aligned. Kai received The Opcode of ARM, a crystalline prism that split light into condition codes. Now three gems warmed his hand. Chapter 4 – The Open Villa of RISC‑V ------------------------------------ Kai passed through a pergola into a sun-drenched villa, its walls open to the sky. The Architect said, “This is the realm of freedom. Modular, extensible, and growing. Here, the registers are many, and the base is RV32I.” The entrance hall held 32 guardians. x0 was a fountain, always dry, the zero register, writes to it vanish. x1, a raven with a return address. x2, a stack of plates growing downward. x3, a globe pointer. x4, a thread pointer (a knotted needle). x5–x7 were temporaries: thermometer, tea cup, tooth. x8 (s0/fp) was Safe 0, often the frame pointer. x9 (s1) a comfortable chair-safe. x10–x17 (a0–a7) were argument posters. x18–x27 (s2–s11) were park safes guarded by a swan, skis, a saurier, a star, a sun, a sieve, an S-Bahn train, a nine, a tape measure, and a football safe. x28–x31 (t3–t6) were winter-garden temporaries: fir tree, door, table, cups. In the Instruction Format Atrium, six crystal statues stood: R-type (Roman soldier), I-type (ice cream cone), S-type (snake), B-type (bee), U-type (U magnet), J-type (juggler). Each statue’s body was divided into bit fields, etched in light. Kai entered the Kitchen where immediates were ingredients. ADDI added a pinch of salt; SLTI tested with a lemon; ANDI/ORI/XORI mixed with jars; SLLI/SRLI/SRAI shifted shelves. Loads fetched from the pantry: LB (biscuit), LH (half-cake), LW (whole cake), with unsigned wraps. addi a0, zero, 5 ; a0 = 5 lw a1, 0(sp) ; load from stack JALR, a jack-in-the-box, jumped and linked. ECALL was a telephone to the supervisor; EBREAK, a glass break for debuggers. The Living Room held two armchairs (rs1, rs2). They performed ADD, SUB, SLL, SLT, SLTU, XOR, SRL, SRA, OR, AND. Funct3 pendants distinguished them: ADD had funct3=000, funct7=0000000; SUB had funct7=0100000. add a0, a1, a2 sub t0, t1, t2 The Garage stored values with SB, SH, SW, a forklift with a split immediate sign. The Maze Garden was alive with branch bees: BEQ (equal sign), BNE (crossed equal), BLT (lemon tart), BGE (ginger gem), BLTU (U-shaped lemon), BGEU (U-shaped gem). Each buzzed a 12-bit offset. beq a0, a1, label The U-Shaped Hall lifted upper immediates: LUI placed a 20-bit plate into the upper bits, AUIPC added it to the PC for PC-relative magic. lui a0, %hi(myvar) addi a0, a0, %lo(myvar) auipc a1, %pcrelhi(symbol) The Juggler’s Tent held JAL, storing PC+4 in rd (usually ra) and leaping. jal ra, myfunction ; call ... ret ; pseudo: jalr zero, ra, 0 The Privileged Tower held CSR maids (CSRRS, CSRRC), mermaids (MRET), sirens (SRET), and fences for memory ordering. Extension wings opened to M (multiply/divide mules), F/D (flamingo registers for floats), and C (a cat curling 32-bit instructions into 16-bit compressed forms). In the Open-Air Theatre, actors played the calling convention: arguments a0–a7 took the stage, the raven returned with values, safes remained locked, temporaries were wiped clean, and a stage manager kept the stack 16-byte aligned. Kai received the final gem: The Opcode of RISC‑V, warm and multifaceted. Interlude – The Console Reborn ------------------------------ With four gems glowing in his hand, the Opcodes of x86-64, x86 32-bit, ARM, and RISC‑V, Kai returned to the centre of the grey plain where the four citadels stood. The Architect was waiting. “You have walked the Glass Tower and learned the nesting registers, the flag windows, the moving trucks and leaf blowers, the red and blue booths. You have marched through the Legacy Castle and bowed to the three thrones of cdecl, stdcall, and fastcall. You have wandered the RISC Manor with its condition pennants and barrel shifters. And you have tasted the open air of the RISC‑V Villa, where immediates are spices and formats are crystal statues.” “Now, place the gems on the Console.” Kai saw a stone altar rise from the ground, with four sockets corresponding to the kingdoms. He placed each gem into its slot. Light shot from the altar, and the citadels began to glow. Suddenly, the stained-glass flags of x86-64 merged with the ARM chandelier; the stack of plates from RISC‑V touched the stone pillar of x86 32-bit; the robots R8–R15 exchanged tools with the vault guardians of ARM. The four architectures did not collapse. They harmonized. A code spell wrote itself in the air, mixing elements from all realms: ; x86-64 call mov rax, 10 call compute ; x86 32-bit idea push eax pop ebx ; ARM condition cmp r0, 5 addgt r1, r2, r3 ; RISC‑V link jal ra, helper The Architect smiled. “In your world, programs do not need to be confined to one kingdom. They speak across conventions, through system calls, over networks. You now understand that every push is a plate on a stack, every bl is a lion remembering home, every auipc is a magnet lifting an address. The museums within you are the real Console.” Kai felt the ground solidify under his feet. The grey plain became his desk; the citadels, the books on his shelf. The golden ticket dissolved, and the screen before him flickered back to life. BUILD SUCCESSFUL But before Kai could move, the floor rippled. PART TWO – THE DEEPER LAYERS ============================ Chapter 5 – The Descent into the Underworld ------------------------------------------- The desk dissolved again, but this time Kai did not fall. Instead, the world rearranged around him, and he found himself in a vast hall beneath the grey plain. The Architect stood beside a stairwell leading downward, its walls lined with ancient circuitry that pulsed like veins. “You know the kingdoms of instruction,” the Architect said. “But the castles and villas are only the surface. Beneath every kingdom lies the Underworld, the true machinery that breathes life into the instructions. And there is trouble there. Corrupted opcodes, speculative ghosts, memory creatures. The Build succeeded, but the deeper layers are unstable. If the Underworld fractures, all the realms above will collapse.” Kai looked at the staircase. “What’s down there?” “Pipelines. Branch predictors. Reorder buffers. The shadow realm of speculative execution. And beyond the Underworld, two other powers: the Compiler Mages, who forge the spells you carry, and the Memory Hierarchies, from the swiftest cache‑libraries to the slow, deep archive‑catacombs of the Disk. You must walk them all. And you will face real enemies this time.” A new ticket appeared in Kai’s hand, silver and inscribed with a single word: Microarchitecture. The Architect gestured downward. “The Underworld first. Then the Mages, then the Memory City. Hurry.” Kai descended. The staircase opened into a cavern that stretched endlessly, lit by a strange, orderly flow. An enormous assembly line ran through the centre, the Pipeline. Instructions moved along it in stages, each undergoing a transformation. A sign read: IF – ID – EX – MEM – WB Kai watched a simple instruction, add rax, rbx, enter the first station: Instruction Fetch. A librarian grabbed it from a shelf. Next, Instruction Decode, where a scholar unrolled its meaning. Then Execute, where a smith hammered the addition on an anvil. Then Memory Access, where if needed, a courier ran to the side‑vaults. Finally Write Back, where the result was placed into the golden axe. But the line was not smooth. Gaps appeared. Instructions stalled. Further ahead, Kai saw a creature made of tangled NOP sleds and broken jumps, a Pipeline Hazard. The Architect’s voice echoed: “Data hazards, control hazards, structural hazards. The pipeline must be kept flowing. That is the job of the Hazard‑Wardens.” A group of engineers rushed forward with forwarding paths (like bypass tunnels) and stall bubbles (soft cushions). The hazard dissolved. Next, Kai reached a strange crossroads where paths split and merged. A cloaked figure stood there, eyes closed, murmuring. “The Branch Predictor,” the Architect whispered. “An oracle that guesses where a branch will go before the condition is known. Its prophecies speed the pipeline, but if it is wrong, the wrong path must be flushed. Those discarded instructions are ghosts.” As if summoned, shadows flickered at the edges of the cavern: half‑executed instructions, speculatively loaded data, results that never reached write‑back. Speculative Ghosts. They whispered of the future that never was. Kai felt a chill. One ghost lunged at him, a memory access that should never have occurred, and a Spectre of leaked data brushed his mind. The Architect pulled him back. “Speculative execution is powerful, but these ghosts are vulnerabilities. Side‑channels. They can read secrets from the very walls. You must help contain them.” Kai saw a large chamber nearby where instructions, after execution, were kept in a Reorder Buffer, an archive where they waited to be retired in the correct program order. “Out‑of‑order execution,” the Architect said. “The processor reorders work for speed, but must commit in order. The buffer is the final arbiter of truth.” At the heart of the Underworld, Kai confronted a creature born of corrupted micro‑ops: Undefined Behavior. It had no fixed shape. Sometimes a division by zero dragon, sometimes a use‑after‑free wraith. It could bypass the buffer, poison the pipeline, and cause the world above to crash. Kai realized: this was the true enemy that threatened the realms. To defeat it, Kai had to understand the Underworld fully. He spent what felt like days walking the pipeline, learning the timing, the hazards, the predictors. He saw reservation stations where operands waited, register renaming that gave each instruction its own private copy to avoid false dependencies. He watched the load/store queue managing memory access. He saw how a cache miss could stall the pipeline and how the TLB (Translation Lookaside Buffer) sped up virtual address translation. With each new piece of knowledge, the Undefined Behavior creature weakened. Finally, Kai approached the Reorder Buffer and spoke a fence instruction, a barrier that ordered memory. The ghost screamed and dissolved. The Underworld hummed in stable rhythm. The Architect handed him a dark iron key. “The Underworld is secure, for now. But the source of the corruption lies higher, in the spells themselves. You must visit the Compiler Mages.” Chapter 6 – The Forge of the Compiler Mages ------------------------------------------- Kai emerged through a rune‑carved door into a great hall filled with robed figures. They were the Compiler Mages, the guild that transformed high‑level spells into the instruction sequences he carried. Here, C‑words were spoken, and they became mov, add, call. The head mage, an ancient woman with eyes like lexer scanners, greeted him. “We know why you’ve come. The Undefined Behavior beast is born when we translate wrongly, when we optimize too aggressively, when we ignore the strict aliasing or violate sequence points. We must reforge the spells.” She led Kai through the Frontend Forge, where spells were tokenized, parsed into an abstract syntax tree, then lowered into intermediate representation. Then the Optimization Crucible, where spells were transformed: dead code was stripped, loops unrolled, constants propagated. Kai saw a spell being vectorized, turned into SIMD incantations that could operate on many data at once. But there, in a dark corner, a mage had used an unsafe charm. A buffer overflow creature slithered out: too much data crammed into a small array, overwriting the return address. The creature looked like a serpent made of memory addresses, and it laughed. “Stack smashing!” it hissed. Kai realized this was another face of Undefined Behavior, a concrete exploit. The head mage cried, “Use stack canaries! Insert a guard value before the return address.” The mages wove a spell, and a canary (a small glowing bird) perched before the return address. The serpent struck, the canary died, and the program aborted safely, no execution of corrupted return addresses. Kai helped the mages rewrite vulnerable spells, adding bounds checks, using safe libraries, turning on compiler warnings. The buffer overflow creatures shrank. But the head mage warned: “The spells ultimately touch memory. Even if we forge perfect instructions, the memory itself can be corrupted. You must descend to the Memory Hierarchies.” She gave Kai a map of the memory landscape: the swift L1 cache library, the larger L2 hall, the L3 shared cathedral, the sprawling RAM city, and the deep Disk catacombs. Chapter 7 – The Memory City and the Deep Catacombs -------------------------------------------------- Kai stepped through a portal into a bustling Cache Library. L1, a small, brilliantly lit room where the most‑used data sat on shelves within single‑cycle reach. A librarian nodded: “I am the fastest. I hold 32 KiB, 8‑way set associative. If I have what you need, the instruction does not wait. If not, you must go to L2.” He moved to the larger L2 hall, still fast but a few cycles slower. Then the shared L3 cathedral, where all cores could meet. The architecture reminded him of a memory palace. Each level larger and slower, but still orders of magnitude faster than RAM City. He entered the city of RAM. Buildings stretched to the horizon, each address a dwelling. The streets were DRAM buses, and data took tens of nanoseconds to travel. Here, a page fault tremor shook the ground. A program had touched a virtual address not mapped to physical memory. A sky‑high page table walked the translation, and the operating system’s pagedaemon fetched the missing page from Swap, a gloomy Disk archive. Kai descended into the Disk catacombs. Here, data slept in magnetic tombs, accessible only by slow mechanical arms. In the darkest corner, a Segmentation Fault Beast growled, a ferocious guardian that attacked when a program tried to read or write memory it did not own. Kai faced it, remembering the rules: no out‑of‑bounds access, no use‑after‑free. He tamed it by presenting a properly mapped pointer. But the true enemy lurked deeper: the Memory Corruption Worm, a cousin of the buffer overflow serpent. It thrived in uninitialized memory, dangling pointers, double frees. To defeat it, Kai had to walk the memory hierarchy from cache to disk, ensuring every allocation was matched, every pointer valid, every boundary respected. The Architect appeared beside him. “This is the final piece. The memory is the canvas on which the instructions paint. When the canvas is torn, the painting is lost.” Kai stood at the intersection of the Compiler Mages’ forge, the Memory City, and the Underworld. He understood now: a program was a living thing, born in the mages’ spells, flowing through the pipeline’s veins, breathing in the memory hierarchies. Antagonists like Undefined Behavior, Spectre ghosts, and buffer overflow serpents were the diseases of carelessness. Finale – The System Architect ----------------------------- Kai returned to the grey plain where the four citadels stood. The Architect was there, holding a new gem, clear as diamond. “The Opcode of Understanding. You have not only learned the kingdoms of assembly, but the deeper layers that give them life. The Console is now fully stable. The Build will never fail.” Kai placed the final gem on the altar. The Underworld, the Mages’ Hall, and the Memory City shone through the ground like a root system. The four citadels stood tall, their foundations secure. The Architect smiled. “You are no longer an apprentice. You are a System Architect. Go back to your world. Write code that respects the pipeline, trusts the compiler, and loves the cache. And should you ever encounter a new mystery, there are always deeper layers to explore.” Kai awoke at his desk. The screen showed his editor, the last commit message reading: Fix: understand the whole stack. He smiled and began typing again, his fingers moving not just with syntax but with the full, layered reality of the machine beneath. End