fix: record extern LLVM fnptr in constants

[jimbxb]

The test case exits with this on the a previous master build

Error detected during translating: 
llc: error: llc: /tmp/wybe-40074fe12aabd129/tmpMain.ll:8:78: error: use of undefined value '@unary_higher_order#.#anon#1<1>'
@"unary_higher_order#constant#0" = private unnamed_addr constant {ptr} { ptr @"unary_higher_order#.#anon#1<1>" }, align 8

I have also made the "env" param of closure procs explicit. This enabled further lowering of HO->FO calls, in some situations.

[pschachte]

One small change, and a question.

[pschachte]

Please document this

[jimbxb]

Done

[pschachte]

Why is there an extra environment argument in this case?

[pschachte]

I think I understand: you're making this explicit so you can optimise it. Is that the idea?

[jimbxb]

Yeah. It makes it mildly easier to align the arguments when optimising LPVM.

[jimbxb]

Okay. I want to do a bit more work on this.

I want to add explicit instructions to un-pack the closed values from the env as well. At the moment, there is still the assymetry of the env being present (and passed), but the free variables are not.

In order to do that, I need a special lpvm instruction. I'm calling it unmarshall for now. All it will do is take is the env param and the "index" of the free param of the closed variable in the non-closure variant of the proc, and return the closed value itself.

I can't use an existing instruction is because the unmarshall instructions are special. They won't have a fixed offset to read from, as some free params may be unused in the non-closure proc.

unmarshall could only be allowed in the pre-amble of a closure-proc when it comes to LLVM generation. We could also only inline a closure proc if the env is known, too, which I believe would always be the case (we only get to the point we directly call the closure proc if we inline a HO call to a FO call!)

The procs would look something like this:

def closure(#env, in, ?out) {
    foreign lpvm unmarshall(#env, 0, ?closed)
    non_closure(closed, in, ?out)
}

def non_closure(closed, in, ?out) {
    # body
}

[jimbxb]

Actually, I dont know if this is possible. We still need some of the information contained inside those "Free" params. We do still get that if the proc is a closure of some anonymous proc, but not when it is a closure like `+`(10) :(

I think I'll need to have both the explicit env and free params. I do still need to figure out how to factor in the unmarshall bit though. Let's see

[jimbxb]

Should be right now :) No need for unmarshall

[pschachte]

This is awesome, but I don't understand why unary_higher_order.#anon#1<0> didn't get inlined here, when it's marked for inlining?

[jimbxb]

I think it's because we only do one expansion/inlining pass. The call to fetch_number is expanded, and that lowers the HO call to a FO call, but we dont get the chance to inline the FO call

[jimbxb]

More merge conflicts 😭