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?