Alloca not freeing?

[Git-i]

I've been looking at this project recently and trying to understand it and potentially use it for an embeddable scripting language. however I got confused when it got to return values, I've been mostly exploring the language via c2m and wanted to see how it handled compund(non primitive) return types, so I have the following c code

struct lmao
{
    int a;
    float b;
};
struct lmao fn(){
    struct lmao l;
    l.a = 10;
    l.b = 20.0;
    return l;
}
int main()
{
    struct lmao a = fn();
    return (int)(a.a + a.b);
}

the corresponding generated mir is

M0:     module
        import  memcpy
memcpy_p:       proto   i64, i64:dest, i64:src, i64:n
proto0: proto   i64, ...
fn:     func    i64
        local   i64:fp, f:f_0, i64:I_1

# 0 args, 3 locals, 0 globals
        alloca  fp, 16
        mov     i32:(fp):i, 10
        d2f     f_0, 2.00000000000000000000000000000000000000000000000000000e+01
        fmov    f:4(fp):f, f_0
        mov     I_1, i64:(fp)
        ret     I_1
        endfunc
        export  fn
main:   func    i32
        local   i64:fp, i64:I_0, i64:I_1, i64:I_2, f:f_3, f:f_4, i64:i_5

# 0 args, 7 locals, 0 globals
        alloca  fp, 32
        add     I_1, fp, 16
        call    proto0, fn, I_0
        mov     i64:(I_1), I_0
        call    memcpy_p, memcpy, I_2, fp, I_1, 8
        i2f     f_3, i32:(fp):i
        fadd    f_4, f_3, f:4(fp):f
        f2i     i_5, f_4
        ret     i_5
        endfunc
        export  main
        endmodule

I have a few questions

• What is the f:4(fp):f and i32:(fp):i doing exactly, I'm guessing dereferencing and casting, but I'm not exactly sure
• Why not use p instead of i64 for pointers(gotten from alloca)
• Is the alloca memory not freed once outside the function, from what i see the pointer to the memory is returned, when if not at the end of a function is alloca memory freed?

[sgraham]

I believe what's happening here is that the return value from fn is only i64-sized, so the alloca is being used to allocate 8 bytes, then the int/float are stored into that memory, then the i64 is returned (by value) from fn, not address of the alloca. (The address of the alloca is fp, but it's loading an i64 from fp into I_1 to return.

If you create a larger than 8 bytes struct, it switches to using rblk which I haven't looked at yet, but that seems to be for returning chunks of memory in this case where they don't fit into register-sizes.

(I am just starting to learn about MIR through c2m too, so this may be wrong.)