@effekt-lang/effekt 0.2.2 → 0.4.0

package/libraries/llvm/rts.ll

@@ -1,11 +1,13 @@
 ; Run-Time System
 
+%Evidence = type i64
+
 ; Basic types
 
-%Env = type ptr
+%Environment = type ptr
 
 ; Reference counts
-%Rc = type i64
+%ReferenceCount = type i64
 
 ; Code to share (bump rc) an environment
 %Sharer = type ptr
@@ -14,21 +16,21 @@
 %Eraser = type ptr
 
 ; Every heap object starts with a header
-%Header = type {%Rc, %Eraser}
+%Header = type {%ReferenceCount, %Eraser}
 
 ; A heap object is a pointer to a header followed by payload.
 ;
-;   +--[ Header ]--+-------------+
-;   | Rc  | Eraser | Payload ... |
-;   +--------------+-------------+
-%Obj = type ptr
+;   +--[ Header ]--------------+-------------+
+;   | ReferenceCount  | Eraser | Payload ... |
+;   +-----------------+--------+-------------+
+%Object = type ptr
 
 
 ; A Frame has the following layout
 ;
-;   +-------[ FrameHeader ]-----+--------------+
-;   | RetAdr  | Sharer | Eraser | Payload ...  |
-;   +---------------------------+--------------+
+;   +-------[ FrameHeader ]------------+--------------+
+;   | ReturnAddress  | Sharer | Eraser | Payload ...  |
+;   +----------------------------------+--------------+
 
 ; A stack pointer points to the top-most frame followed by all other frames.
 ;
@@ -36,7 +38,7 @@
 ;
 ;     +--------------------+   <- Limit
 ;     :                    :
-;     :                    :   <- Sp
+;     :                    :   <- StackPointer
 ;     +--------------------+
 ;     | FrameHeader        |
 ;     |    z               |
@@ -47,14 +49,14 @@
 ;     +--------------------+
 ;     :        ...         :
 ;     +--------------------+ <- Base
-%Sp = type ptr
-%Base = type %Sp
-%Limit = type %Sp
-%RetAdr = type ptr
-%FrameHeader = type { %RetAdr, %Sharer, %Eraser }
+%StackPointer = type ptr
+%Base = type %StackPointer
+%Limit = type %StackPointer
+%ReturnAddress = type ptr
+%FrameHeader = type { %ReturnAddress, %Sharer, %Eraser }
 
 ; Pointers for a heap allocated stack
-%Mem = type { %Sp, %Base, %Limit }
+%Memory = type { %StackPointer, %Base, %Limit }
 
 ; The garbage collector differentiates three groups of types:
 ; - Values (Integer, Double)
@@ -62,63 +64,43 @@
 ; - Strings
 ; For each group we have an arena where mutable state is allocated.
 ;
-%Region = type [ 3 x %Mem ]
+%Region = type [ 3 x %Memory ]
+
+; The "meta" stack (a stack of stacks) -- a pointer to a %StackValue
+%Stack = type ptr
 
-; The "meta" stack (a stack of stacks)
-%Stk = type ptr
+; Unique tags to index into the stack.
+%Prompt = type i64
+
+; fresh prompt generation
+@lastPrompt = private global %Prompt 0
 
 ; This is used for two purposes:
 ;   - a refied first-class list of stacks (cyclic linked-list)
 ;   - as part of an intrusive linked-list of stacks (meta stack)
-%StkVal = type { %Rc, %Mem, %Region, %Stk }
-
-; Positive data types consist of a (type-local) tag and a heap object
-%Pos = type {i64, %Obj}
-%Boolean = type %Pos
-%Unit = type %Pos
-
-; Negative types (codata) consist of a vtable and a heap object
-%Neg = type {ptr, %Obj}
+%StackValue = type { %ReferenceCount, %Memory, %Region, %Prompt, %Stack }
 
-; Offset within the arena
-%Ref = type i64
 
-; Global locations
 
-@base = private global %Base null
-@limit = private global %Limit null
-@region = private global %Region zeroinitializer
-@rest = private global %Stk undef
 
+; Positive data types consist of a (type-local) tag and a heap object
+%Pos = type {i64, %Object}
 
-define %StkVal @getStk(%Sp %sp) alwaysinline {
-    %base = load %Base, ptr @base
-    %limit = load %Limit, ptr @limit
-    %region = load %Region, ptr @region
-    %rest = load %Stk, ptr @rest
+; Negative types (codata) consist of a vtable and a heap object
+%Neg = type {ptr, %Object}
 
-    %stk.0 = insertvalue %StkVal undef, %Rc 0, 0
-    %stk.1 = insertvalue %StkVal %stk.0, %Sp %sp, 1, 0
-    %stk.2 = insertvalue %StkVal %stk.1, %Base %base, 1, 1
-    %stk.3 = insertvalue %StkVal %stk.2, %Limit %limit, 1, 2
-    %stk.4 = insertvalue %StkVal %stk.3, %Region %region, 2
-    %stk.5 = insertvalue %StkVal %stk.4, %Stk %rest, 3
+; Reference into an arena (prompt -- cast to 32bit, offset 32bit)
+%Reference = type {i32, i32}
 
-    ret %StkVal %stk.5
-}
+; Builtin Types
 
-define void @setStk(%StkVal %stk) alwaysinline {
-    %base = extractvalue %StkVal %stk, 1, 1
-    %limit = extractvalue %StkVal %stk, 1, 2
-    %region = extractvalue %StkVal %stk, 2
-    %rest = extractvalue %StkVal %stk, 3
-
-    store %Base %base, ptr @base
-    store %Limit %limit, ptr @limit
-    store %Region %region, ptr @region
-    store %Stk %rest, ptr @rest
-    ret void
-}
+%Int = type i64
+%Double = type double
+%Byte = type i8
+%Char = type i64
+%Bool = type %Pos
+%Unit = type %Pos
+%String = type %Pos
 
 ; Foreign imports
 
@@ -128,37 +110,57 @@ declare ptr @realloc(ptr, i64)
 declare void @memcpy(ptr, ptr, i64)
 declare i64 @llvm.ctlz.i64 (i64 , i1)
 declare i64 @llvm.fshr.i64(i64, i64, i64)
+declare double @llvm.sqrt.f64(double)
+declare double @llvm.round.f64(double)
+declare double @llvm.ceil.f64(double)
+declare double @llvm.floor.f64(double)
 declare void @print(i64)
 declare void @exit(i64)
 
+
+; Prompts
+
+define private %Prompt @currentPrompt(%Stack %stack) {
+    %prompt_pointer = getelementptr %StackValue, ptr %stack, i64 0, i32 3
+    %prompt = load %Prompt, ptr %prompt_pointer
+    ret %Prompt %prompt
+}
+
+define private %Prompt @freshPrompt() {
+    %currentPrompt = load %Prompt, ptr @lastPrompt
+    %newPrompt = add %Prompt %currentPrompt, 1
+    store %Prompt %newPrompt, ptr @lastPrompt
+    ret %Prompt %newPrompt
+}
+
 ; Garbage collection
 
-define %Obj @newObject(%Eraser %eraser, i64 %envsize) alwaysinline {
+define private %Object @newObject(%Eraser %eraser, i64 %environmentSize) alwaysinline {
     ; This magical 16 is the size of the object header
-    %size = add i64 %envsize, 16
-    %obj = call ptr @malloc(i64 %size)
-    %objrc = getelementptr %Header, ptr %obj, i64 0, i32 0
-    %objeraser = getelementptr %Header, ptr %obj, i64 0, i32 1
-    store %Rc 0, ptr %objrc
-    store %Eraser %eraser, ptr %objeraser
-    ret %Obj %obj
+    %size = add i64 %environmentSize, 16
+    %object = call ptr @malloc(i64 %size)
+    %objectReferenceCount = getelementptr %Header, ptr %object, i64 0, i32 0
+    %objectEraser = getelementptr %Header, ptr %object, i64 0, i32 1
+    store %ReferenceCount 0, ptr %objectReferenceCount
+    store %Eraser %eraser, ptr %objectEraser
+    ret %Object %object
 }
 
-define %Env @objectEnvironment(%Obj %obj) alwaysinline {
+define private %Environment @objectEnvironment(%Object %object) alwaysinline {
     ; Environment is stored right after header
-    %env = getelementptr %Header, ptr %obj, i64 1
-    ret %Env %env
+    %environment = getelementptr %Header, ptr %object, i64 1
+    ret %Environment %environment
 }
 
-define void @shareObject(%Obj %obj) alwaysinline {
-    %isnull = icmp eq %Obj %obj, null
-    br i1 %isnull, label %done, label %next
+define private void @shareObject(%Object %object) alwaysinline {
+    %isNull = icmp eq %Object %object, null
+    br i1 %isNull, label %done, label %next
 
     next:
-    %objrc = getelementptr %Header, ptr %obj, i64 0, i32 0
-    %rc = load %Rc, ptr %objrc
-    %rc.1 = add %Rc %rc, 1
-    store %Rc %rc.1, ptr %objrc
+    %objectReferenceCount = getelementptr %Header, ptr %object, i64 0, i32 0
+    %referenceCount = load %ReferenceCount, ptr %objectReferenceCount
+    %referenceCount.1 = add %ReferenceCount %referenceCount, 1
+    store %ReferenceCount %referenceCount.1, ptr %objectReferenceCount
     br label %done
 
     done:
@@ -166,37 +168,37 @@ define void @shareObject(%Obj %obj) alwaysinline {
 }
 
 define void @sharePositive(%Pos %val) alwaysinline {
-    %obj = extractvalue %Pos %val, 1
-    tail call void @shareObject(%Obj %obj)
+    %object = extractvalue %Pos %val, 1
+    tail call void @shareObject(%Object %object)
     ret void
 }
 
 define void @shareNegative(%Neg %val) alwaysinline {
-    %obj = extractvalue %Neg %val, 1
-    tail call void @shareObject(%Obj %obj)
+    %object = extractvalue %Neg %val, 1
+    tail call void @shareObject(%Object %object)
     ret void
 }
 
-define void @eraseObject(%Obj %obj) alwaysinline {
-    %isnull = icmp eq %Obj %obj, null
-    br i1 %isnull, label %done, label %next
+define private void @eraseObject(%Object %object) alwaysinline {
+    %isNull = icmp eq %Object %object, null
+    br i1 %isNull, label %done, label %next
 
     next:
-    %objrc = getelementptr %Header, ptr %obj, i64 0, i32 0
-    %rc = load %Rc, ptr %objrc
-    switch %Rc %rc, label %decr [%Rc 0, label %free]
+    %objectReferenceCount = getelementptr %Header, ptr %object, i64 0, i32 0
+    %referenceCount = load %ReferenceCount, ptr %objectReferenceCount
+    switch %ReferenceCount %referenceCount, label %decr [%ReferenceCount 0, label %free]
 
     decr:
-    %rc.1 = sub %Rc %rc, 1
-    store %Rc %rc.1, ptr %objrc
+    %referenceCount.1 = sub %ReferenceCount %referenceCount, 1
+    store %ReferenceCount %referenceCount.1, ptr %objectReferenceCount
     ret void
 
     free:
-    %objeraser = getelementptr %Header, ptr %obj, i64 0, i32 1
-    %eraser = load %Eraser, ptr %objeraser
-    %env = call %Env @objectEnvironment(%Obj %obj)
-    call fastcc void %eraser(%Env %env)
-    call void @free(%Obj %obj)
+    %objectEraser = getelementptr %Header, ptr %object, i64 0, i32 1
+    %eraser = load %Eraser, ptr %objectEraser
+    %environment = call %Environment @objectEnvironment(%Object %object)
+    call void %eraser(%Environment %environment)
+    call void @free(%Object %object)
     br label %done
 
     done:
@@ -204,416 +206,575 @@ define void @eraseObject(%Obj %obj) alwaysinline {
 }
 
 define void @erasePositive(%Pos %val) alwaysinline {
-    %obj = extractvalue %Pos %val, 1
-    tail call void @eraseObject(%Obj %obj)
+    %object = extractvalue %Pos %val, 1
+    tail call void @eraseObject(%Object %object)
     ret void
 }
 
 define void @eraseNegative(%Neg %val) alwaysinline {
-    %obj = extractvalue %Neg %val, 1
-    tail call void @eraseObject(%Obj %obj)
+    %object = extractvalue %Neg %val, 1
+    tail call void @eraseObject(%Object %object)
     ret void
 }
 
 
 ; Arena management
-define ptr @getRegionPointer(i64 %evidence) alwaysinline {
+define private ptr @getRegionPointer(%Prompt %prompt, %Stack %stack) {
 entry:
-    switch i64 %evidence, label %loop [i64 0, label %here]
+    %prompt_pointer = getelementptr %StackValue, %Stack %stack, i64 0, i32 3
+    %currentPrompt = load %Prompt, ptr %prompt_pointer
+    %promptMatch = icmp eq %Prompt %currentPrompt, %prompt
+    br i1 %promptMatch, label %found, label %continue
 
-here:
-    ret ptr @region
+continue:
+    %nextStack_pointer = getelementptr %StackValue, %Stack %stack, i64 0, i32 4
+    %nextStack = load %Stack, ptr %nextStack_pointer
+    %region = tail call ptr @getRegionPointer(%Prompt %prompt, %Stack %nextStack)
+    ret ptr %region
+
+found:
+    %stackRegion = getelementptr %StackValue, %Stack %stack, i64 0, i32 2
+    ret ptr %stackRegion
+}
 
-loop:
-    %stkp = phi ptr [@rest, %entry], [%nextp, %loop]
-    %i = phi i64 [%evidence, %entry], [%nexti, %loop]
-    %stk = load %Stk, ptr %stkp
-    %regionp = getelementptr %StkVal, %Stk %stk, i64 0, i32 2
-    %nextp = getelementptr %StkVal, %Stk %stk, i64 0, i32 3
-    %nexti = sub i64 %i, 1
-    %cmp = icmp eq i64 %nexti, 0
+define private { ptr, %Reference } @alloc(i64 %index, %Prompt %prompt, %Stack %stack) alwaysinline {
+    %region_pointer = call ptr @getRegionPointer(%Prompt %prompt, %Stack %stack)
 
-    br i1 %cmp, label %done, label %loop
+    %stackPointer_pointer = getelementptr %Region, ptr %region_pointer, i64 0, i64 %index, i32 0
+    %base_pointer = getelementptr %Region, ptr %region_pointer, i64 0, i64 %index, i32 1
+    %limit_pointer = getelementptr %Region, ptr %region_pointer, i64 0, i64 %index, i32 2
 
-done:
-    ret ptr %regionp
+    %stackPointer = load %StackPointer, ptr %stackPointer_pointer
+    %base = load %Base, ptr %base_pointer
+    %limit = load %Limit, ptr %limit_pointer
 
+    %object = icmp ne i64 %index, 0
+    %size = select i1 %object, i64 16, i64 8
+
+    %nextStackPointer = getelementptr i8, %StackPointer %stackPointer, i64 %size
+
+    %cmp = icmp ule %StackPointer %nextStackPointer, %limit
+    br i1 %cmp, label %continue, label %realloc
+
+continue:
+    store %StackPointer %nextStackPointer, ptr %stackPointer_pointer
+    %intBase = ptrtoint %Base %base to i64
+    %intStackPointer = ptrtoint %StackPointer %stackPointer to i64
+    %offset64 = sub i64 %intStackPointer, %intBase
+
+    %prompt32 = trunc i64 %prompt to i32
+    %offset32 = trunc i64 %offset64 to i32
+
+    %ret.0 = insertvalue { ptr, %Reference } undef, %StackPointer %stackPointer, 0
+    %ref.1 = insertvalue %Reference undef, i32 %prompt32, 0
+    %ref.2 = insertvalue %Reference %ref.1, i32 %offset32, 1
+    %ret.1 = insertvalue { ptr, %Reference } %ret.0, %Reference %ref.2, 1
+    ret { ptr, %Reference } %ret.1
+
+realloc:
+    %intBase_2 = ptrtoint %Base %base to i64
+    %intLimit = ptrtoint %Limit %limit to i64
+    %arenaSize = sub i64 %intLimit, %intBase_2
+    %empty = icmp eq i64 %arenaSize, 0
+    %double = mul i64 %arenaSize, 2
+    %newArenaSize = select i1 %empty, i64 1024, i64 %double
+
+    %newBase = call ptr @realloc(ptr %base, i64 %newArenaSize)
+    %newlimit = getelementptr i8, %Base %newBase, i64 %newArenaSize
+    %newStackPointer = getelementptr i8, %Base %newBase, i64 %arenaSize
+    %newNextStackPointer = getelementptr i8, %StackPointer %newStackPointer, i64 %size
+
+    store %Base %newBase, ptr %base_pointer
+    store %Limit %newlimit, ptr %limit_pointer
+    store %StackPointer %newNextStackPointer, ptr %stackPointer_pointer
+
+    %prompt32_2 = trunc i64 %prompt to i32
+    %arenaSize32 = trunc i64 %arenaSize to i32
+
+    %ret..0 = insertvalue { ptr, %Reference } undef, %StackPointer %newStackPointer, 0
+    %ref..1 = insertvalue %Reference undef, i32 %prompt32_2, 0
+    %ref..2 = insertvalue %Reference %ref..1, i32 %arenaSize32, 1
+    %ret..1 = insertvalue { ptr, %Reference } %ret..0, %Reference %ref..2, 1
+    ret { ptr, %Reference } %ret..1
 }
 
 
+define private ptr @getPointer(%Reference %reference, i64 %index, %Stack %stack) {
+    %prompt32 = extractvalue %Reference %reference, 0
+    %offset32 = extractvalue %Reference %reference, 1
+    %prompt = zext i32 %prompt32 to i64
+    %offset = zext i32 %offset32 to i64
 
-define { ptr, %Ref } @alloc(i64 %idx, i64 %evidence) alwaysinline {
-    %regionp = call ptr @getRegionPointer(i64 %evidence)
-    %spp = getelementptr %Region, ptr %regionp, i64 0, i64 %idx, i32 0
-    %basep = getelementptr %Region, ptr %regionp, i64 0, i64 %idx, i32 1
-    %limitp = getelementptr %Region, ptr %regionp, i64 0, i64 %idx, i32 2
+    %region_pointer = call ptr @getRegionPointer(%Prompt %prompt, %Stack %stack)
+    %base_pointer = getelementptr %Region, ptr %region_pointer, i64 0, i64 %index, i32 1
+    %base = load %Base, ptr %base_pointer
+    %pointer = getelementptr i8, ptr %base, i64 %offset
+    ret ptr %pointer
+}
 
-    %sp = load %Sp, ptr %spp
-    %base = load %Base, ptr %basep
-    %limit = load %Limit, ptr %limitp
+define private %Stack @getStack(%Stack %stack, %Prompt %prompt) {
+    %promptPointer = getelementptr %StackValue, %Stack %stack, i64 0, i32 3
+    %thisPrompt = load %Prompt, ptr %promptPointer
+    %found = icmp eq %Prompt %prompt, %thisPrompt
+    br i1 %found, label %done, label %recurse
 
-    %obj = icmp ne i64 %idx, 0
-    %size = select i1 %obj, i64 16, i64 8
+done:
+    ret %Stack %stack
 
-    %nextsp = getelementptr i8, %Sp %sp, i64 %size
+recurse:
+    %nextStackPointer = getelementptr %StackValue, %Stack %stack, i64 0, i32 4
+    %nextStack = load %Stack, ptr %nextStackPointer
+    %result = call %Stack @getStack(%Stack %nextStack, %Prompt %prompt)
+    ret %Stack %result
+}
 
-    %cmp = icmp ule %Sp %nextsp, %limit
-    br i1 %cmp, label %continue, label %realloc
+define private ptr @getVarPointer(%Reference %reference, %Stack %stack) {
+    %prompt32 = extractvalue %Reference %reference, 0
+    %offset32 = extractvalue %Reference %reference, 1
+    %prompt = zext i32 %prompt32 to i64
+    %offset = zext i32 %offset32 to i64
+
+    %targetStack = call %Stack @getStack(%Stack %stack, %Prompt %prompt)
+    %basePointer = getelementptr %StackValue, %Stack %targetStack, i64 0, i32 1, i32 1
+    %base = load %Base, ptr %basePointer
+    %varPointer = getelementptr i8, %Base %base, i64 %offset
+    ret ptr %varPointer
+}
 
-continue:
-    store %Sp %nextsp, ptr %spp
-    %intb = ptrtoint %Base %base to i64
-    %intsp = ptrtoint %Sp %sp to i64
-    %offset = sub i64 %intsp, %intb
+define private %Reference @newReference(%Stack %stack) alwaysinline {
+    %stackPointerPointer = getelementptr %StackValue, %Stack %stack, i64 0, i32 1, i32 0
+    %basePointer = getelementptr %StackValue, %Stack %stack, i64 0, i32 1, i32 1
 
-    %ret.0 = insertvalue { ptr, %Ref } undef, %Sp %sp, 0
-    %ret.1 = insertvalue { ptr, %Ref } %ret.0, %Ref %offset, 1
-    ret { ptr, %Ref } %ret.1
+    %stackPointer = load %StackPointer, ptr %stackPointerPointer
+    %base = load %StackPointer, ptr %basePointer
 
-realloc:
-    %intbase = ptrtoint %Base %base to i64
-    %intlimit = ptrtoint %Limit %limit to i64
-    %arenasize = sub i64 %intlimit, %intbase
-    %empty = icmp eq i64 %arenasize, 0
-    %double = mul i64 %arenasize, 2
-    %newarenasize = select i1 %empty, i64 1024, i64 %double
+    %intStack = ptrtoint %StackPointer %stackPointer to i64
+    %intBase = ptrtoint %StackPointer %base to i64
 
-    %newbase = call ptr @realloc(ptr %base, i64 %newarenasize)
-    %newlimit = getelementptr i8, %Base %newbase, i64 %newarenasize
-    %newsp = getelementptr i8, %Base %newbase, i64 %arenasize
-    %newnextsp = getelementptr i8, %Sp %newsp, i64 %size
+    %offset = sub i64 %intStack, %intBase
+    %offset32 = trunc i64 %offset to i32
 
-    store %Base %newbase, ptr %basep
-    store %Limit %newlimit, ptr %limitp
-    store %Sp %newnextsp, ptr %spp
+    %prompt = call %Prompt @currentPrompt(%Stack %stack)
+    %prompt32 = trunc %Prompt %prompt to i32
 
-    %ret..0 = insertvalue { ptr, %Ref } undef, %Sp %newsp, 0
-    %ret..1 = insertvalue { ptr, %Ref } %ret..0, %Ref %arenasize, 1
-    ret { ptr, %Ref } %ret..1
+    %reference..1 = insertvalue %Reference undef, i32 %prompt32, 0
+    %reference = insertvalue %Reference %reference..1, i32 %offset32, 1
 
+    ret %Reference %reference
 }
 
-define ptr @getPtr(%Ref %ref, i64 %idx, i64 %evidence) alwaysinline {
-    %regionp = call ptr @getRegionPointer(i64 %evidence)
-    %basep = getelementptr %Region, ptr %regionp, i64 0, i64 %idx, i32 1
-    %base = load %Base, ptr %basep
-    %ptr = getelementptr i8, ptr %base, %Ref %ref
-    ret ptr %ptr
+; Stack management
+
+define private %StackPointer @stackAllocate(%Stack %stack, i64 %n) {
+    %stackStackPointer = getelementptr %StackValue, %Stack %stack, i64 0, i32 1, i32 0
+    %stackPointer = load %StackPointer, ptr %stackStackPointer
+
+    %stackPointer_2 = getelementptr i8, %StackPointer %stackPointer, i64 %n
+    store %StackPointer %stackPointer_2, ptr %stackStackPointer
+    ret %StackPointer %stackPointer
+}
+
+define private %StackPointer @stackDeallocate(%Stack %stack, i64 %n) {
+    %stackStackPointer = getelementptr %StackValue, %Stack %stack, i64 0, i32 1, i32 0
+    %stackPointer = load %StackPointer, ptr %stackStackPointer
+
+    %o = sub i64 0, %n
+    %stackPointer_2 = getelementptr i8, %StackPointer %stackPointer, i64 %o
+    store %StackPointer %stackPointer_2, ptr %stackStackPointer
+
+    ret %StackPointer %stackPointer_2
 }
 
 ; Meta-stack management
 
-define %Mem @newMem() alwaysinline {
-    %sp = call %Sp @malloc(i64 1024)
-    %limit = getelementptr i8, ptr %sp, i64 1024
+define private %Memory @newMemory() {
+    %stackPointer = call %StackPointer @malloc(i64 268435456)
+    %limit = getelementptr i8, ptr %stackPointer, i64 268435456
 
-    %mem.0 = insertvalue %Mem undef, %Sp %sp, 0
-    %mem.1 = insertvalue %Mem %mem.0, %Base %sp, 1
-    %mem.2 = insertvalue %Mem %mem.1, %Limit %limit, 2
+    %memory.0 = insertvalue %Memory undef, %StackPointer %stackPointer, 0
+    %memory.1 = insertvalue %Memory %memory.0, %Base %stackPointer, 1
+    %memory.2 = insertvalue %Memory %memory.1, %Limit %limit, 2
 
-    ret %Mem %mem.2
+    ret %Memory %memory.2
 }
 
-define %Stk @newStack() alwaysinline {
+define private %Stack @newStack(%Prompt %prompt) {
 
     ; TODO find actual size of stack
-    %stk = call ptr @malloc(i64 112)
+    %stack = call ptr @malloc(i64 120)
 
     ; TODO initialize to zero and grow later
-    %stackmem = call %Mem @newMem()
+    %stackMemory = call %Memory @newMemory()
 
-    %stk.0 = insertvalue %StkVal undef, %Rc 0, 0
-    %stk.1 = insertvalue %StkVal %stk.0, %Mem %stackmem, 1
-    %stk.2 = insertvalue %StkVal %stk.1, %Region zeroinitializer, 2
-    %stk.3 = insertvalue %StkVal %stk.2, %Stk %stk, 3
+    %stack.0 = insertvalue %StackValue undef, %ReferenceCount 0, 0
+    %stack.1 = insertvalue %StackValue %stack.0, %Memory %stackMemory, 1
+    %stack.2 = insertvalue %StackValue %stack.1, %Region zeroinitializer, 2
+    %stack.3 = insertvalue %StackValue %stack.2, %Prompt %prompt, 3
+    %stack.4 = insertvalue %StackValue %stack.3, %Stack zeroinitializer, 4
 
-    store %StkVal %stk.3, %Stk %stk
+    store %StackValue %stack.4, %Stack %stack
 
-    ret %Stk %stk
+    ret %Stack %stack
 }
 
-define %Sp @pushStack(%Stk %stk, %Sp %oldsp) alwaysinline {
-    %newstk = load %StkVal, %Stk %stk
+define private void @pushStack(%Stack %stack, %Stack %oldStack) {
+    %stackRest = getelementptr %StackValue, %Stack %stack, i64 0, i32 4
+    %rest = load %Stack, ptr %stackRest
+    %isNull = icmp eq %Stack %rest, null
+    br i1 %isNull, label %done, label %next
 
-    %oldstk = call %StkVal @getStk(%Sp %oldsp)
+done:
+    store %Stack %oldStack, ptr %stackRest
+    ret void
 
-    call void @setStk(%StkVal %newstk)
+next:
+    tail call void @pushStack(%Stack %rest, %Stack %oldStack)
+    ret void
+}
 
-    store %StkVal %oldstk, %Stk %stk
+define private %Stack @popStacks(%Stack %stack, %Prompt %prompt) {
+entry:
+    %prompt_pointer = getelementptr %StackValue, %Stack %stack, i64 0, i32 3
+    %currentPrompt = load %Prompt, ptr %prompt_pointer
+    %promptMatch = icmp eq %Prompt %currentPrompt, %prompt
+    br i1 %promptMatch, label %found, label %continue
 
-    %newsp = extractvalue %StkVal %newstk, 1, 0
-    ret %Sp %newsp
+continue:
+    %nextStack_pointer = getelementptr %StackValue, %Stack %stack, i64 0, i32 4
+    %nextStack = load %Stack, ptr %nextStack_pointer
+    %result = tail call %Stack @popStacks(%Stack %nextStack, %Prompt %prompt)
+    ret %Stack %result
+
+found:
+    %nextStack2_pointer = getelementptr %StackValue, %Stack %stack, i64 0, i32 4
+    %nextStack2 = load %Stack, ptr %nextStack2_pointer
+    store %Stack null, ptr %nextStack2_pointer
+    ret %Stack %nextStack2
 }
 
-; pop n+1 stacks
-define {%Stk, %Sp} @popStacks(%Sp %oldsp, i64 %n) alwaysinline {
-entry:
-    %oldstk = call %StkVal @getStk(%Sp %oldsp)
-    br label %loop
+define private void @eraseMemory(%Memory %memory) {
+    %stackPointer = extractvalue %Memory %memory, 0
+    call void @free(%StackPointer %stackPointer)
+    ret void
+}
 
-loop:
-    %stkval = phi %StkVal [%oldstk, %entry], [%newstk, %loop]
-    %i = phi i64 [%n, %entry], [%nexti, %loop]
+define private void @forEachObject(ptr %elementPointer, ptr %end, ptr %f) alwaysinline {
+    %done = icmp uge ptr %elementPointer, %end
+    br i1 %done, label %return, label %erase
 
-    %newstkp = extractvalue %StkVal %stkval, 3
-    %newstk = load %StkVal, %Stk %newstkp
+erase:
+    %element = load %Pos, ptr %elementPointer
+    call void %f(%Pos %element)
 
-    %nexti = sub i64 %i, 1
+    %nextElementPointer = getelementptr %Pos, ptr %elementPointer, i64 1
+    tail call void @forEachObject(ptr %nextElementPointer, ptr %end, ptr %f)
+    ret void
 
-    %cmp = icmp eq i64 %i, 0
-    br i1 %cmp, label %done, label %loop
+return:
+    ret void
+}
 
-done:
-    call void @setStk(%StkVal %newstk)
+define private void @eraseRegion(%Region %region) alwaysinline {
+    %valuesBase = extractvalue %Region %region, 0, 1
+    call void @free(%Base %valuesBase)
 
-    store %StkVal %oldstk, %Stk %newstkp
+    %objectsBase = extractvalue %Region %region, 1, 1
+    %objectsStackPointer = extractvalue %Region %region, 1, 0
+    call void @forEachObject(%Base %objectsBase, %StackPointer %objectsStackPointer, %Eraser @erasePositive)
+    call void @free(%Base %objectsBase)
 
-    %newsp = extractvalue %StkVal %newstk, 1, 0
-    %ret.0 = insertvalue {%Stk, %Sp} undef, %Stk %newstkp, 0
-    %ret.1 = insertvalue {%Stk, %Sp} %ret.0, %Sp %newsp, 1
+    %stringsBase = extractvalue %Region %region, 2, 1
+    %stringsStackPointer = extractvalue %Region %region, 2, 0
+    call void @forEachObject(%Base %stringsBase, %StackPointer %stringsStackPointer, %Eraser @erasePositive)
+    call void @free(%Base %stringsBase)
 
-    ret {%Stk, %Sp} %ret.1
+    ret void
 }
 
-define %Sp @underflowStack(%Sp %sp) alwaysinline {
-    %stk = load %Stk, ptr @rest
-    %newstk = load %StkVal, %Stk %stk
+define private %Stack @underflowStack(%Stack %stack) {
+    %stackMemory = getelementptr %StackValue, %Stack %stack, i64 0, i32 1
+    %stackRegion = getelementptr %StackValue, %Stack %stack, i64 0, i32 2
+    %stackRest = getelementptr %StackValue, %Stack %stack, i64 0, i32 4
 
-    %region = load %Region, ptr @region
-    call void @eraseRegion(%Region %region)
+    %memory = load %Memory, ptr %stackMemory
+    %region = load %Region, ptr %stackRegion
+    %rest = load %Stack, ptr %stackRest
 
-    call void @setStk(%StkVal %newstk)
-
-    call void @free(%Sp %sp)
-    call void @free(%Stk %stk)
+    call void @eraseMemory(%Memory %memory)
+    call void @eraseRegion(%Region %region)
+    call void @free(%Stack %stack)
 
-    %newsp = extractvalue %StkVal %newstk, 1, 0
-    ret %Sp %newsp
+    ret %Stack %rest
 }
 
-define %Mem @copyMem(%Mem %mem) alwaysinline {
-    %sp = extractvalue %Mem %mem, 0
-    %base = extractvalue %Mem %mem, 1
-    %limit = extractvalue %Mem %mem, 2
+define private %Memory @copyMemory(%Memory %memory) alwaysinline {
+    %stackPointer = extractvalue %Memory %memory, 0
+    %base = extractvalue %Memory %memory, 1
+    %limit = extractvalue %Memory %memory, 2
 
-    %intsp = ptrtoint %Sp %sp to i64
-    %intbase = ptrtoint %Base %base to i64
-    %intlimit = ptrtoint %Limit %limit to i64
-    %used = sub i64 %intsp, %intbase
-    %size = sub i64 %intlimit, %intbase
+    %intStackPointer = ptrtoint %StackPointer %stackPointer to i64
+    %intBase = ptrtoint %Base %base to i64
+    %intLimit = ptrtoint %Limit %limit to i64
+    %used = sub i64 %intStackPointer, %intBase
+    %size = sub i64 %intLimit, %intBase
 
-    %newbase = call ptr @malloc(i64 %size)
-    %intnewbase = ptrtoint %Base %newbase to i64
-    %intnewsp = add i64 %intnewbase, %used
-    %intnewlimit = add i64 %intnewbase, %size
-    %newsp = inttoptr i64 %intnewsp to %Sp
-    %newlimit = inttoptr i64 %intnewlimit to %Limit
+    %newBase = call ptr @malloc(i64 %size)
+    %intNewBase = ptrtoint %Base %newBase to i64
+    %intNewStackPointer = add i64 %intNewBase, %used
+    %intNewLimit = add i64 %intNewBase, %size
+    %newStackPointer = inttoptr i64 %intNewStackPointer to %StackPointer
+    %newLimit = inttoptr i64 %intNewLimit to %Limit
 
-    call void @memcpy(ptr %newbase, ptr %base, i64 %used)
+    call void @memcpy(ptr %newBase, ptr %base, i64 %used)
 
-    %mem.0 = insertvalue %Mem undef, %Sp %newsp, 0
-    %mem.1 = insertvalue %Mem %mem.0, %Base %newbase, 1
-    %mem.2 = insertvalue %Mem %mem.1, %Limit %newlimit, 2
+    %memory.0 = insertvalue %Memory undef, %StackPointer %newStackPointer, 0
+    %memory.1 = insertvalue %Memory %memory.0, %Base %newBase, 1
+    %memory.2 = insertvalue %Memory %memory.1, %Limit %newLimit, 2
 
-    ret %Mem %mem.2
+    ret %Memory %memory.2
 }
 
-define %Region @copyRegion(%Region %region) alwaysinline {
-    %mem.0 = extractvalue %Region %region, 0
-    %mem.1 = extractvalue %Region %region, 1
-    %mem.2 = extractvalue %Region %region, 2
+define private %Region @copyRegion(%Region %region) alwaysinline {
+    %memory.0 = extractvalue %Region %region, 0
+    %memory.1 = extractvalue %Region %region, 1
+    %memory.2 = extractvalue %Region %region, 2
 
-    %objectsbase = extractvalue %Region %region, 1, 1
-    %objectssp = extractvalue %Region %region, 1, 0
-    call void @forEachObject(%Base %objectsbase, %Sp %objectssp, %Eraser @sharePositive)
+    %objectsBase = extractvalue %Region %region, 1, 1
+    %objectsStackPointer = extractvalue %Region %region, 1, 0
+    call void @forEachObject(%Base %objectsBase, %StackPointer %objectsStackPointer, %Sharer @sharePositive)
 
-    %stringsbase = extractvalue %Region %region, 2, 1
-    %stringssp = extractvalue %Region %region, 2, 0
-    call void @forEachObject(%Base %stringsbase, %Sp %stringssp, %Eraser @c_buffer_refcount_increment)
+    %stringsBase = extractvalue %Region %region, 2, 1
+    %stringsStackPointer = extractvalue %Region %region, 2, 0
+    call void @forEachObject(%Base %stringsBase, %StackPointer %stringsStackPointer, %Sharer @sharePositive)
 
-    %newmem.0 = call %Mem @copyMem(%Mem %mem.0)
-    %newmem.1 = call %Mem @copyMem(%Mem %mem.1)
-    %newmem.2 = call %Mem @copyMem(%Mem %mem.2)
+    %newMemory.0 = call %Memory @copyMemory(%Memory %memory.0)
+    %newMemory.1 = call %Memory @copyMemory(%Memory %memory.1)
+    %newMemory.2 = call %Memory @copyMemory(%Memory %memory.2)
 
-    %region.0 = insertvalue %Region undef, %Mem %newmem.0, 0
-    %region.1 = insertvalue %Region %region.0, %Mem %newmem.1, 1
-    %region.2 = insertvalue %Region %region.1, %Mem %newmem.2, 2
+    %region.0 = insertvalue %Region undef, %Memory %newMemory.0, 0
+    %region.1 = insertvalue %Region %region.0, %Memory %newMemory.1, 1
+    %region.2 = insertvalue %Region %region.1, %Memory %newMemory.2, 2
 
     ret %Region %region.2
 }
 
-define %Stk @uniqueStack(%Stk %stk) alwaysinline {
+define private %Stack @uniqueStack(%Stack %stack) alwaysinline {
 
 entry:
-    %stkrc = getelementptr %StkVal, %Stk %stk, i64 0, i32 0
-    %rc = load %Rc, ptr %stkrc
-    switch %Rc %rc, label %copy [%Rc 0, label %done]
+    %stackReferenceCount = getelementptr %StackValue, %Stack %stack, i64 0, i32 0
+    %referenceCount = load %ReferenceCount, ptr %stackReferenceCount
+    switch %ReferenceCount %referenceCount, label %copy [%ReferenceCount 0, label %done]
 
 done:
-    ret %Stk %stk
+    ret %Stack %stack
 
 copy:
-    %newoldrc = sub %Rc %rc, 1
-    store %Rc %newoldrc, ptr %stkrc
+    %newOldReferenceCount = sub %ReferenceCount %referenceCount, 1
+    store %ReferenceCount %newOldReferenceCount, ptr %stackReferenceCount
 
-    %newhead = call ptr @malloc(i64 112)
+    %newHead = call ptr @malloc(i64 120)
     br label %loop
 
 loop:
-    %old = phi %Stk [%stk, %copy], [%rest, %next]
-    %newstk = phi %Stk [%newhead, %copy], [%nextnew, %next]
+    %old = phi %Stack [%stack, %copy], [%rest, %next]
+    %newStack = phi %Stack [%newHead, %copy], [%nextNew, %next]
 
-    %stkmem = getelementptr %StkVal, %Stk %old, i64 0, i32 1
-    %stkregion = getelementptr %StkVal, %Stk %old, i64 0, i32 2
-    %stkrest = getelementptr %StkVal, %Stk %old, i64 0, i32 3
+    %stackMemory = getelementptr %StackValue, %Stack %old, i64 0, i32 1
+    %stackRegion = getelementptr %StackValue, %Stack %old, i64 0, i32 2
+    %stackPrompt = getelementptr %StackValue, %Stack %old, i64 0, i32 3
+    %stackRest = getelementptr %StackValue, %Stack %old, i64 0, i32 4
 
-    %mem = load %Mem, ptr %stkmem
-    %region = load %Region, ptr %stkregion
-    %rest = load %Stk, ptr %stkrest
+    %memory = load %Memory, ptr %stackMemory
+    %region = load %Region, ptr %stackRegion
+    %prompt = load %Prompt, ptr %stackPrompt
+    %rest = load %Stack, ptr %stackRest
 
-    %newstkrc = getelementptr %StkVal, %Stk %newstk, i64 0, i32 0
-    %newstkmem = getelementptr %StkVal, %Stk %newstk, i64 0, i32 1
-    %newstkregion = getelementptr %StkVal, %Stk %newstk, i64 0, i32 2
-    %newstkrest = getelementptr %StkVal, %Stk %newstk, i64 0, i32 3
+    %newStackReferenceCount = getelementptr %StackValue, %Stack %newStack, i64 0, i32 0
+    %newStackMemory = getelementptr %StackValue, %Stack %newStack, i64 0, i32 1
+    %newStackRegion = getelementptr %StackValue, %Stack %newStack, i64 0, i32 2
+    %newStackPrompt = getelementptr %StackValue, %Stack %newStack, i64 0, i32 3
+    %newStackRest = getelementptr %StackValue, %Stack %newStack, i64 0, i32 4
 
-    %newmem = call %Mem @copyMem(%Mem %mem)
+    %newMemory = call %Memory @copyMemory(%Memory %memory)
 
-    %newsp = extractvalue %Mem %newmem, 0
-    call fastcc void @shareFrames(%Sp %newsp)
+    %newStackPointer = extractvalue %Memory %newMemory, 0
+    call void @shareFrames(%StackPointer %newStackPointer)
 
-    %newregion = call %Region @copyRegion(%Region %region)
+    %newRegion = call %Region @copyRegion(%Region %region)
 
-    store %Rc 0, ptr %newstkrc
-    store %Mem %newmem, ptr %newstkmem
-    store %Region %newregion, ptr %newstkregion
+    store %ReferenceCount 0, ptr %newStackReferenceCount
+    store %Memory %newMemory, ptr %newStackMemory
+    store %Region %newRegion, ptr %newStackRegion
+    store %Prompt %prompt, ptr %newStackPrompt
 
-    %last = icmp eq %Stk %rest, %stk
-    br i1 %last, label %closecycle, label %next
+    %isNull = icmp eq %Stack %rest, null
+    br i1 %isNull, label %stop, label %next
 
 next:
-    %nextnew = call ptr @malloc(i64 112)
-    store %Stk %nextnew, ptr %newstkrest
+    %nextNew = call ptr @malloc(i64 120)
+    store %Stack %nextNew, ptr %newStackRest
     br label %loop
 
-closecycle:
-    store %Stk %newhead, ptr %newstkrest
-    ret %Stk %newhead
-
+stop:
+    store %Stack null, ptr %newStackRest
+    ret %Stack %newHead
 }
 
-define void @shareStack(%Stk %stk) alwaysinline {
-    %stkrc = getelementptr %StkVal, %Stk %stk, i64 0, i32 0
-    %rc = load %Rc, ptr %stkrc
-    %rc.1 = add %Rc %rc, 1
-    store %Rc %rc.1, ptr %stkrc
+define void @shareStack(%Stack %stack) alwaysinline {
+    %stackReferenceCount = getelementptr %StackValue, %Stack %stack, i64 0, i32 0
+    %referenceCount = load %ReferenceCount, ptr %stackReferenceCount
+    %referenceCount.1 = add %ReferenceCount %referenceCount, 1
+    store %ReferenceCount %referenceCount.1, ptr %stackReferenceCount
     ret void
 }
 
-define void @eraseStack(%Stk %stk) alwaysinline {
-    %stkrc = getelementptr %StkVal, %Stk %stk, i64 0, i32 0
-    %rc = load %Rc, ptr %stkrc
-    switch %Rc %rc, label %decr [%Rc 0, label %free]
+define void @eraseStack(%Stack %stack) alwaysinline {
+    %stackReferenceCount = getelementptr %StackValue, %Stack %stack, i64 0, i32 0
+    %referenceCount = load %ReferenceCount, ptr %stackReferenceCount
+    switch %ReferenceCount %referenceCount, label %decr [%ReferenceCount 0, label %free]
 
     decr:
-    %rc.1 = sub %Rc %rc, 1
-    store %Rc %rc.1, ptr %stkrc
+    %referenceCount.1 = sub %ReferenceCount %referenceCount, 1
+    store %ReferenceCount %referenceCount.1, ptr %stackReferenceCount
     ret void
 
     free:
-    %stksp = getelementptr %StkVal, %Stk %stk, i64 0, i32 1, i32 0
-    %sp = load %Sp, ptr %stksp
-    call fastcc void @eraseFrames(%Sp %sp)
+    %stackStackPointer = getelementptr %StackValue, %Stack %stack, i64 0, i32 1, i32 0
+    %stackRegion = getelementptr %StackValue, %Stack %stack, i64 0, i32 2
+    %stackRest = getelementptr %StackValue, %Stack %stack, i64 0, i32 4
 
-    %regionp = getelementptr %StkVal, %Stk %stk, i64 0, i32 2
-    %region = load %Region, ptr %regionp
+    %stackPointer = load %StackPointer, ptr %stackStackPointer
+    %region = load %Region, ptr %stackRegion
+    %rest = load %Stack, ptr %stackRest
 
+    call void @free(%Stack %stack)
+    call void @eraseFrames(%StackPointer %stackPointer)
     call void @eraseRegion(%Region %region)
 
-    call void @free(%Stk %stk)
+    %isNull = icmp eq %Stack %rest, null
+    br i1 %isNull, label %done, label %next
+
+next:
+    call void @eraseStack(%Stack %rest)
     ret void
-}
 
-define fastcc void @shareFrames(%Sp %sp) alwaysinline {
-    %newsp = getelementptr %FrameHeader, %Sp %sp, i64 -1
-    %stksharer = getelementptr %FrameHeader, %Sp %newsp, i64 0, i32 1
-    %sharer = load %Sharer, ptr %stksharer
-    tail call fastcc void %sharer(%Sp %newsp)
+done:
     ret void
 }
 
-define fastcc void @eraseFrames(%Sp %sp) alwaysinline {
-    %newsp = getelementptr %FrameHeader, %Sp %sp, i64 -1
-    %stkeraser = getelementptr %FrameHeader, %Sp %newsp, i64 0, i32 2
-    %eraser = load %Eraser, ptr %stkeraser
-    tail call fastcc void %eraser(%Sp %newsp)
+define private void @shareFrames(%StackPointer %stackPointer) alwaysinline {
+    %newStackPointer = getelementptr %FrameHeader, %StackPointer %stackPointer, i64 -1
+    %stackSharer = getelementptr %FrameHeader, %StackPointer %newStackPointer, i64 0, i32 1
+    %sharer = load %Sharer, ptr %stackSharer
+    tail call void %sharer(%StackPointer %newStackPointer)
     ret void
 }
 
-define void @forEachObject(ptr %elementp, ptr %end, ptr %f) alwaysinline {
-    %done = icmp uge ptr %elementp, %end
-    br i1 %done, label %return, label %erase
+define private void @eraseFrames(%StackPointer %stackPointer) alwaysinline {
+    %newStackPointer = getelementptr %FrameHeader, %StackPointer %stackPointer, i64 -1
+    %stackEraser = getelementptr %FrameHeader, %StackPointer %newStackPointer, i64 0, i32 2
+    %eraser = load %Eraser, ptr %stackEraser
+    tail call void %eraser(%StackPointer %newStackPointer)
+    ret void
+}
 
-erase:
-    %element = load %Pos, ptr %elementp
-    call void %f(%Pos %element)
+; RTS initialization
 
-    %nextelementp = getelementptr %Pos, ptr %elementp, i64 1
-    tail call void @forEachObject(ptr %nextelementp, ptr %end, ptr %f)
+define private tailcc void @topLevel(%Pos %val, %Stack %stack) {
+    %rest = call %Stack @underflowStack(%Stack %stack)
+    ; assert %rest == null
     ret void
+}
 
-return:
+define private void @topLevelSharer(%Environment %environment) {
+    ; TODO this should never be called
     ret void
 }
 
-define void @eraseRegion(%Region %region) alwaysinline {
-    %valuesbase = extractvalue %Region %region, 0, 1
-    call void @free(%Base %valuesbase)
+define private void @topLevelEraser(%Environment %environment) {
+    ; TODO this should never be called
+    ret void
+}
 
-    %objectsbase = extractvalue %Region %region, 1, 1
-    %objectssp = extractvalue %Region %region, 1, 0
-    call void @forEachObject(%Base %objectsbase, %Sp %objectssp, %Eraser @erasePositive)
-    call void @free(%Base %objectsbase)
+define private %Stack @withEmptyStack() {
+    ; TODO all stacks share the same source of fresh prompts
+    %prompt = call %Prompt @freshPrompt()
+    %stack = call %Stack @newStack(%Prompt %prompt)
 
-    %stringsbase = extractvalue %Region %region, 2, 1
-    %stringssp = extractvalue %Region %region, 2, 0
-    call void @forEachObject(%Base %stringsbase, %Sp %stringssp, %Eraser @c_buffer_refcount_decrement)
-    call void @free(%Base %stringsbase)
+    %stackStackPointer = getelementptr %StackValue, %Stack %stack, i64 0, i32 1, i32 0
+    %stackPointer = load %StackPointer, ptr %stackStackPointer
 
-    ret void
-}
+    %returnAddressPointer = getelementptr %FrameHeader, %StackPointer %stackPointer, i64 0, i32 0
+    %sharerPointer = getelementptr %FrameHeader, %StackPointer %stackPointer, i64 0, i32 1
+    %eraserPointer = getelementptr %FrameHeader, %StackPointer %stackPointer, i64 0, i32 2
 
-; RTS initialization
+    store %ReturnAddress @topLevel, ptr %returnAddressPointer
+    store %Sharer @topLevelSharer, ptr %sharerPointer
+    store %Eraser @topLevelEraser, ptr %eraserPointer
 
-define fastcc void @topLevel(%Env %env, %Sp noalias %sp) {
-    %base = load %Base, ptr @base
-    call void @free(%Base %base)
+    %stackPointer_2 = getelementptr %FrameHeader, %StackPointer %stackPointer, i64 1
+    store %StackPointer %stackPointer_2, ptr %stackStackPointer
 
-    %region = load %Region, ptr @region
-    %base.0 = extractvalue %Region %region, 0, 1
-    %base.1 = extractvalue %Region %region, 1, 1
-    %base.2 = extractvalue %Region %region, 2, 1
+    ret %Stack %stack
+}
 
-    call void @free(%Base %base.0)
-    call void @free(%Base %base.1)
-    call void @free(%Base %base.2)
+define void @resume_Int(%Stack %stack, %Int %argument) {
+    %stackPointer = call ccc %StackPointer @stackDeallocate(%Stack %stack, i64 24)
+    %returnAddressPointer = getelementptr %FrameHeader, %StackPointer %stackPointer, i64 0, i32 0
+    %returnAddress = load %ReturnAddress, ptr %returnAddressPointer
+    tail call tailcc void %returnAddress(%Int %argument, %Stack %stack)
+    ret void
+}
 
-    call void @free(%Env %env)
+define void @resume_Pos(%Stack %stack, %Pos %argument) {
+    %stackPointer = call ccc %StackPointer @stackDeallocate(%Stack %stack, i64 24)
+    %returnAddressPointer = getelementptr %FrameHeader, %StackPointer %stackPointer, i64 0, i32 0
+    %returnAddress = load %ReturnAddress, ptr %returnAddressPointer
+    tail call tailcc void %returnAddress(%Pos %argument, %Stack %stack)
     ret void
 }
 
-define fastcc void @topLevelSharer(%Env %env) {
-    ; TODO this should never be called
+define void @run(%Neg %f) {
+    ; fresh stack
+    %stack = call %Stack @withEmptyStack()
+
+    ; prepare call
+    %arrayPointer = extractvalue %Neg %f, 0
+    %object = extractvalue %Neg %f, 1
+    %functionPointerPointer = getelementptr ptr, ptr %arrayPointer, i64 0
+    %functionPointer = load ptr, ptr %functionPointerPointer
+
+    ; call
+    tail call tailcc %Pos %functionPointer(%Object %object, %Stack %stack)
     ret void
 }
 
-define fastcc void @topLevelEraser(%Env %env) {
-    ; TODO this should never be called
+define void @run_Int(%Neg %f, i64 %argument) {
+    ; fresh stack
+    %stack = call %Stack @withEmptyStack()
+
+    ; prepare call
+    %arrayPointer = extractvalue %Neg %f, 0
+    %object = extractvalue %Neg %f, 1
+    %functionPointerPointer = getelementptr ptr, ptr %arrayPointer, i64 0
+    %functionPointer = load ptr, ptr %functionPointerPointer
+
+    ; call
+    tail call tailcc %Pos %functionPointer(%Object %object, %Evidence 0, i64 %argument, %Stack %stack)
     ret void
 }
 
-; Primitive Types
+define void @run_Pos(%Neg %f, %Pos %argument) {
+    ; fresh stack
+    %stack = call %Stack @withEmptyStack()
 
-%Int = type i64
-%Double = type double
+    ; prepare call
+    %arrayPointer = extractvalue %Neg %f, 0
+    %object = extractvalue %Neg %f, 1
+    %functionPointerPointer = getelementptr ptr, ptr %arrayPointer, i64 0
+    %functionPointer = load ptr, ptr %functionPointerPointer
 
-%Evi = type i64
+    ; call
+    tail call tailcc %Pos %functionPointer(%Object %object, %Evidence 0, %Pos %argument, %Stack %stack)
+    ret void
+}