POV: You are a compiler targeting arm64, and you want some code to reference this global variable from the same library. The classic way to do this is to emit an instruction that loads “the address of X”, which will be determined at run time by the dynamic loader. But that’s not super efficient! For one thing, addresses are 64 bits long, and instructions are only 32 bits, so you can either break it up into multiple instructions, or load the address from some other location. But more importantly, the global variable is in the same library. The dynamic loader isn’t going to break it up from this code, and if we knew how far away it was we could reference it that way.
That’s what the
adrp instruction’s for.
A few weeks ago I got sucked into designing a toy 8-bit CPU, ROSE-8, and got as far as writing an emulator for the machine that you could manually feed instructions to. At the end, I listed some future projects, the first of which was
- An assembler/interpreter, i.e. running from a text file (and outputting to a binary file, I guess). Writing arrays of instructions by hand (as shown above) isn’t so bad except for manually computing addresses and offsets, so I still want to get to this at some point.
or, “How I put too much time into making an 8-bit ISA and accompanying virtual machine”
It all started with my colleague Cassie having fun designing a toy 8-bit ISA (“instruction set architecture”). I love encoding tables (I helped out a little with the one for Swift’s
String struct representation), and I did assignments in college involving simplified CPUs. So I started thinking about what it would be like to write a program in Cassie’s ISA…and decided its four registers were too limited for me. How could I get up to 8 registers while still keeping most of the instructions in a single byte?