runtime initialization

[zetah11]

Currently, only top-level functions are supported. Several things need to be implemented to support top-level values too:

• [x] Implementing values in the backend
• [ ] Differentiating between functions and function pointers in the code generator
• [x] Handle relocations properly (no longer relevant: C backend)
• [x] Mutable variables vs. constants (no longer relevnat: C backend)
• [ ] Initialization code (necessary if e.g. --no-eval is used)

[zetah11]

Constant values are more-or-less implemented, though I'm not really happy with how they work currently. For the moment, we just drop the bytes straight into the code and use labels provided by iced-x86, which gives us rip-relative addressing. This is fine, I guess, but I'd prefer to generate the data segment separately (and put it in its own section in emit). That's what the bespoke x64 backend did, but it didn't do RIP-relative addressing.

Basically, the current problem is that iced doesn't really play all that nicely with relocations. In order to get the address of a relocation we need to

• set a label at the instruction with the relocation
• get the ip of that label with label_ip
• get the instruction index by iterating through new_instruction_offsets until we get to this ip
• use that index to find the immediate offset through constant_offsets, from which we can compute the actual offset

As such, I'm adding a "handle relocations properly" task.

[zetah11]

I think all of this kind of gets put on hold by #8

[zetah11]

With the C backend, this will presumably be easier ("just create an init func"), though I want to redo the architecture a bit. I'm thinking that top-level values should really be a (Name, SimpleValue) pair, where SimpleValue is just an int, byte string or uninitialized, and when lowering from the MIR to this representation, anything that doesn't fit into that gets an uninitialized SimpleValue with some initialization code in that init func.

There's also the question of mutually recursive values. If not handled carefully, they can let us read uninitialized memory with this setup:

let x: 10 = y
let y: 10 = x
fun main (?: 1) = y

becomes something like

static char x;
static char y;
void init(void) {
  x = y;
  y = x;
}
// etc.

I think if pointers are involved (as in, if one of the values takes the address of the other), then this should be fine.

[zetah11]

Basically closed by 372df3255d857fc9eea16eec1dce3576ff3d9656 which took the approach described in the previous comment (though named StaticValue instead of SimpleValue. There's still some care needed wrt pointer and non-pointer values, but I think that's a more general issue that may be the focus later.