title: Understanding how memory allocation works (LLVM)
body: <p>I'm making progress on a toy compiler (first time), and trying to understand how to allocate/construct an LLVM struct type.
  The Kaleidoscope tutorial doesn't include or even mention this and I don't know what I'm looking for in the LLVM source/tests to find possible examples.</p>
  
  <p>So I've written a simply C++ example, dumped the IR with clang in an effort to try to understand what it produces but to be honest I don't follow it all. The things obvious to me are the function definition/declarations and some function calls and a <code>memset</code> call so I get pieces of it but it doesn't all come together for me yet. (P.S my interpretation of the alloca instruction docs is that it anything created from that gets freed on return so I can't use that right, it's essentially only for local variables?)</p>
  
  <p>What I've done is:</p>
  
  <p><code>alloc.cpp</code></p>
  
  <pre><code>struct Alloc {
    int age;
  };
  
  //Alloc allocCpy() {
  //  return *new Alloc();
  //}
  
  Alloc *allocPtr() {
    return new Alloc();
  }
  
  int main() {
    Alloc *ptr = allocPtr();
  //  ptr-&gt;name = "Courtney";
  //  Alloc cpy = allocCpy();
  //  cpy.name = "Robinson";
  //  std::cout &lt;&lt; ptr-&gt;name &lt;&lt; std::endl;
  //  std::cout &lt;&lt; cpy.name &lt;&lt; std::endl;
    return 0;
  }
  </code></pre>
  
  <p>Then run <code>clang -S -emit-llvm alloc.cpp</code> to produce <code>alloc.ll</code></p>
  
  <pre><code>; ModuleID = 'alloc.cpp'
  target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
  target triple = "x86_64-apple-macosx10.11.0"
  
  %struct.Alloc = type { i32 }
  
  ; Function Attrs: ssp uwtable
  define %struct.Alloc* @_Z8allocPtrv() #0 {
  entry:
    %call = call noalias i8* @_Znwm(i64 4) #3
    %0 = bitcast i8* %call to %struct.Alloc*
    %1 = bitcast %struct.Alloc* %0 to i8*
    call void @llvm.memset.p0i8.i64(i8* %1, i8 0, i64 4, i32 4, i1 false)
    ret %struct.Alloc* %0
  }
  
  ; Function Attrs: nobuiltin
  declare noalias i8* @_Znwm(i64) #1
  
  ; Function Attrs: nounwind
  declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) #2
  
  ; Function Attrs: ssp uwtable
  define i32 @main() #0 {
  entry:
    %retval = alloca i32, align 4
    %ptr = alloca %struct.Alloc*, align 8
    store i32 0, i32* %retval
    %call = call %struct.Alloc* @_Z8allocPtrv()
    store %struct.Alloc* %call, %struct.Alloc** %ptr, align 8
    ret i32 0
  }
  
  attributes #0 = { ssp uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="core2" "target-features"="+cx16,+sse,+sse2,+sse3,+ssse3" "unsafe-fp-math"="false" "use-soft-float"="false" }
  attributes #1 = { nobuiltin "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="core2" "target-features"="+cx16,+sse,+sse2,+sse3,+ssse3" "unsafe-fp-math"="false" "use-soft-float"="false" }
  attributes #2 = { nounwind }
  attributes #3 = { builtin }
  
  !llvm.module.flags = !{!0}
  !llvm.ident = !{!1}
  
  !0 = !{i32 1, !"PIC Level", i32 2}
  !1 = !{!"clang version 3.7.0 (tags/RELEASE_370/final)"}
  </code></pre>
  
  <p>Can someone explain what's happening in this IR and how it maps back to the C++? Or ignoring this specific example how one would/should go about allocating heap memory for an LLVM StructType that out lives the function within which it was created (and if you're feeling generous, how to later release the memory).</p>
  
  <p>The bits I've commented out are from my original example but being a total novice the IR from that was even less insightful...</p>