diff --git a/compiler/asmjit.stanza b/compiler/asmjit.stanza
index 2c382c43b..124162690 100644
--- a/compiler/asmjit.stanza
+++ b/compiler/asmjit.stanza
@@ -61,6 +61,7 @@ extern assembler_div_reg: (ptr<?>, ptr<?>) -> int
 extern assembler_mod_reg: (ptr<?>, ptr<?>) -> int
 extern assembler_cqo_reg: (ptr<?>) -> int
 extern assembler_cdq_reg: (ptr<?>) -> int
+extern assembler_nop: (ptr<?>) -> int
 extern assembler_and_reg: (ptr<?>, ptr<?>, ptr<?>) -> int
 extern assembler_and_int: (ptr<?>, ptr<?>, int) -> int
 extern assembler_or_reg: (ptr<?>, ptr<?>, ptr<?>) -> int
@@ -186,7 +187,7 @@ public lostanza deftype MemPtr :
 ;------------------------------------------------------------
 defmethod equal? (a:Gp, b:Gp) -> True|False :
   id(a) == id(b)
-  
+
 defmethod equal? (a:Xmm, b:Xmm) -> True|False :
   id(a) == id(b)
 
@@ -697,6 +698,9 @@ public lostanza defn btr (a:ref<Assembler>, dst:ref<Gp>, src:ref<Gp>) -> ref<Gp>
 public lostanza defn btr (a:ref<Assembler>, ptr:ref<MemPtr>, src:ref<Gp>) -> ref<Gp> :
   call-c assembler_btr_ptr_reg(a.value, ptr.value, src.value)
   return src
+public lostanza defn nop (a:ref<Assembler>) -> ref<False> :
+  call-c assembler_nop(a.value)
+  return false
 
 ;------------------------------------------------------------
 ;-------------------- Comparisons and Jumps -----------------
@@ -912,4 +916,3 @@ public lostanza defn ucomiss (a:ref<Assembler>, x:ref<Xmm>, y:ref<Xmm>) -> ref<F
 public lostanza defn ucomisd (a:ref<Assembler>, x:ref<Xmm>, y:ref<Xmm>) -> ref<False> :
   call-c assembler_ucomisd(a.value, x.value, y.value)
   return false
-
diff --git a/compiler/code-table.stanza b/compiler/code-table.stanza
index c40f628d4..6572d9c8e 100644
--- a/compiler/code-table.stanza
+++ b/compiler/code-table.stanza
@@ -12,7 +12,7 @@ defpackage stz/code-table :
 ;============================================================
 ;This contains all the generated code for the functions
 ;loaded into the virtual machine, as well as any additional
-;tables for performing the code encoding. 
+;tables for performing the code encoding.
 
 public deftype CodeTable
 
@@ -37,6 +37,9 @@ public defmulti load-function (t:CodeTable,
 public defstruct LoadedFunction :
   address:Long
   trace-entries:Vector<TraceTableEntry>
+  safepoint-entries:Vector<SafepointTableEntry>
+  local-var-context:Vector<NamedLocalVar>
+  local-var-map-entries:Vector<LocalVarMapEntry>
 
 ;Represents the entry for use during backtraces.
 public defstruct TraceTableEntry :
@@ -45,6 +48,18 @@ public defstruct TraceTableEntry :
 with:
   printer => true
 
+public defstruct SafepointTableEntry :
+  pc: Long
+  id: Int
+with:
+  printer => true
+
+public defstruct LocalVarMapEntry :
+  pc: Long
+  indices: Tuple<Int> ;Sorted in increasing order, in local-var-context
+with:
+  printer => true
+
 ;============================================================
 ;================== Launch ==================================
 ;============================================================
@@ -80,7 +95,7 @@ public deftype EncodingResolver
 ;- live: The set of locals that are live at the moment.
 public defmulti liveness-map (r:EncodingResolver, live:Seqable<Int>, num-locals:Int) -> Int
 
-;Return the number of bytes used for the tag word of each object. 
+;Return the number of bytes used for the tag word of each object.
 public defmulti object-header-size (r:EncodingResolver) -> Int
 
 ;Return the number of bytes used to store an object on the heap.
@@ -120,10 +135,10 @@ public defmulti marker? (r:EncodingResolver, n:Int) -> True|False
 public defmulti tagbits (r:EncodingResolver, typeid:Int) -> Int
 
 ;Return the address of the given extern address.
-public defmulti extern-address (r:EncodingResolver, id:Int) -> Long  
+public defmulti extern-address (r:EncodingResolver, id:Int) -> Long
 
 ;Return the address of the given extern defn address.
-public defmulti extern-defn-address (r:EncodingResolver, id:Int) -> Long  
+public defmulti extern-defn-address (r:EncodingResolver, id:Int) -> Long
 
 ;------------------------------------------------------------
 ;----------------------- Convenience ------------------------
diff --git a/compiler/cvm-code-table.stanza b/compiler/cvm-code-table.stanza
index 0577b180b..9f785c477 100644
--- a/compiler/cvm-code-table.stanza
+++ b/compiler/cvm-code-table.stanza
@@ -46,15 +46,24 @@ lostanza defmethod load-function (table:ref<CVMCodeTable>,
 
   ;Add the offset to the trace entries so that we know their absolute position.
   val relocated-trace-entries = add-offset(trace-entries(encoded-function), new Long{offset})
+  val relocated-safepoint-entries = add-offset(safepoint-entries(encoded-function), new Long{offset})
+  val relocated-local-var-map-entries = add-offset(local-var-map-entries(encoded-function), new Long{offset})
 
   ;Return the new loaded function
-  return LoadedFunction(new Long{offset}, relocated-trace-entries)
+  return LoadedFunction(new Long{offset}, relocated-trace-entries, relocated-safepoint-entries,
+                        local-var-context(encoded-function), relocated-local-var-map-entries)
 
 ;Add 'offset' to the 'pc' of every entry in 'trace-entries' and return
 ;the result.
 defn add-offset (trace-entries:Seqable<TraceTableEntry>, offset:Long) -> Vector<TraceTableEntry> :
   to-vector<TraceTableEntry> $ for e in trace-entries seq :
     TraceTableEntry(pc(e) + offset, entry(e))
+defn add-offset (safepoint-entries:Seqable<SafepointTableEntry>, offset:Long) -> Vector<SafepointTableEntry> :
+  to-vector<SafepointTableEntry> $ for e in safepoint-entries seq :
+    SafepointTableEntry(pc(e) + offset, id(e))
+defn add-offset (local-var-map-entries:Seqable<LocalVarMapEntry>, offset:Long) -> Vector<LocalVarMapEntry> :
+  to-vector<LocalVarMapEntry> $ for e in local-var-map-entries seq :
+    LocalVarMapEntry(pc(e) + offset, indices(e))
 
 ;============================================================
 ;================== Launch ==================================
diff --git a/compiler/cvm-encoder.stanza b/compiler/cvm-encoder.stanza
index 0d96d72e8..6135ca848 100644
--- a/compiler/cvm-encoder.stanza
+++ b/compiler/cvm-encoder.stanza
@@ -18,13 +18,16 @@ defpackage stz/cvm-encoder :
 public defstruct EncodedFunction :
   buffer: ByteBuffer
   trace-entries: Vector<TraceTableEntry>
+  safepoint-entries: Vector<SafepointTableEntry>
+  local-var-context:Vector<NamedLocalVar>
+  local-var-map-entries:Vector<LocalVarMapEntry>
 
 public defn encode (func:VMFunction,
                     resolver:EncodingResolver,
                     backend:Backend) -> EncodedFunction :
   ;Encode instructions into this byte buffer
   val buffer = ByteBuffer()
-  
+
   ;All instructions are sized to be multiples of 4 bytes, and thus
   ;we use address / 4 as a "position" in the instruction stream.
   defn buffer-pos () : write-position(buffer) / 4
@@ -32,9 +35,12 @@ public defn encode (func:VMFunction,
   ;Accumulate file information entries for implementing
   ;stack traces.
   val trace-entry-table = Vector<TraceTableEntry>()
+  val safepoint-entry-table = Vector<SafepointTableEntry>()
   defn record-trace-entry (entry:StackTraceInfo|False) :
     match(entry:StackTraceInfo) :
       add(trace-entry-table, TraceTableEntry(to-long(write-position(buffer)), entry))
+  val local-var-context = Vector<NamedLocalVar>()
+  val local-var-maps = Vector<LocalVarMapEntry>()
 
   ;Delay the generation of this instruction,
   ;Instruction takes up the given number of 'instruction-words'.
@@ -698,7 +704,7 @@ public defn encode (func:VMFunction,
   ;Use delayed actions and encode instructions
   within delay-actions() :
     encode(func as VMMultifn|VMFunc)
-  EncodedFunction(buffer, trace-entry-table)
+  EncodedFunction(buffer, trace-entry-table, safepoint-entry-table, local-var-context, local-var-maps)
 
 ;============================================================
 ;====================== Utilities ===========================
diff --git a/compiler/dl-ir.stanza b/compiler/dl-ir.stanza
index 5ae0c0a04..90b42cba5 100644
--- a/compiler/dl-ir.stanza
+++ b/compiler/dl-ir.stanza
@@ -1106,6 +1106,13 @@ public val CORE-FULL-LIST-ID = register $ core-typeid(`FullList)
 public val CORE-NIL-LIST-ID = register $ core-typeid(`NilList)
 public val CORE-STRING-ID = register $ core-typeid(`String)
 public val CORE-SYMBOL-ID = register $ core-typeid(`Symbol)
+public val CORE-STRING-SYMBOL-ID = register $ core-typeid(`StringSymbol)
+public val CORE-BYTE-ARRAY-ID = register $ core-typeid(`ByteArray)
+public val CORE-CHAR-ARRAY-ID = register $ core-typeid(`CharArray)
+public val CORE-INT-ARRAY-ID = register $ core-typeid(`IntArray)
+public val CORE-LONG-ARRAY-ID = register $ core-typeid(`LongArray)
+public val CORE-FLOAT-ARRAY-ID = register $ core-typeid(`FloatArray)
+public val CORE-DOUBLE-ARRAY-ID = register $ core-typeid(`DoubleArray)
 public val CORE-UNIQUE-ID = register $ core-typeid(`Unique)
 public val CORE-MAYBE-ID = register $ core-typeid(`Maybe)
 public val CORE-ONE-ID = register $ core-typeid(`One)
diff --git a/compiler/jit-code-table.stanza b/compiler/jit-code-table.stanza
index 981dfba63..e07cb16e3 100644
--- a/compiler/jit-code-table.stanza
+++ b/compiler/jit-code-table.stanza
@@ -31,7 +31,7 @@ public defstruct JITStubs :
 
 public defn JITCodeTable (resolver:EncodingResolver, backend:Backend) -> JITCodeTable :
   val runtime = jit-runtime-new()
-  val stubs = make-jit-stubs(runtime, resolver, backend)  
+  val stubs = make-jit-stubs(runtime, resolver, backend)
   #JITCodeTable(runtime, stubs)
 
 ;============================================================
@@ -52,12 +52,13 @@ defmethod load-function (table:JITCodeTable,
   val oldf = get?(funcs(table), fid)
   match(oldf:Func) :
     release(runtime(table), oldf)
-  
+
   ;Add the function into the table so that we can release them later.
   put<Func>(funcs(table), fid, func(encoded-function))
 
   ;Return the loaded function
-  LoadedFunction(value(func(encoded-function)), trace-entries(encoded-function))
+  LoadedFunction(value(func(encoded-function)), trace-entries(encoded-function), safepoint-entries(encoded-function),
+                 local-var-context(encoded-function), local-var-maps(encoded-function))
 
 ;============================================================
 ;================== Launch ==================================
@@ -68,7 +69,7 @@ lostanza defmethod launch (vmstate-address:ref<Long>, table:ref<JITCodeTable>, f
   val fptr = launch as ptr<( (ptr<VMState>, long, long) -> int )>
   val vmstate = vmstate-address.value as ptr<VMState>
   call-c [fptr](vmstate, call-prim crsp() as long, func-id.value)
-  return false    
+  return false
 
 ;============================================================
 ;===================== Free =================================
@@ -96,6 +97,6 @@ defn put<T> (xs:Vector<T|False>, k:Int, v:T) :
   if k >= length(xs) :
     lengthen(xs, k + 1, false)
   xs[k] = v
-  
+
 defn get?<?T> (xs:Vector<?T>, k:Int) -> T|False :
   if k < length(xs) : xs[k]
diff --git a/compiler/jit-encoder.stanza b/compiler/jit-encoder.stanza
index 2a97291b1..2fdce62eb 100644
--- a/compiler/jit-encoder.stanza
+++ b/compiler/jit-encoder.stanza
@@ -51,6 +51,9 @@ val COMPUTE-ABSOLUTE-ADDRESSES = TimerLabel(JIT-ENCODER, suffix("Compute absolut
 public defstruct EncodedFunction :
   func: Func
   trace-entries: Vector<TraceTableEntry>
+  safepoint-entries: Vector<SafepointTableEntry>
+  local-var-context: Vector<NamedLocalVar>
+  local-var-maps: Vector<LocalVarMapEntry>
 
 ;============================================================
 ;=================== Configuration ==========================
@@ -89,7 +92,7 @@ lostanza defn call-collect-stack-trace-addr () -> ref<Long> :
 ;================== Register Conventions ====================
 ;============================================================
 ;Decide on which x86 registers to use for all our virtual machine
-;quantities. This is backend-specific. 
+;quantities. This is backend-specific.
 ;
 ;# Notes about Assignment #
 ;- X86 div and shl instructions uses RAX, RDX, RCX as special registers.
@@ -330,7 +333,7 @@ defn branch-is-final? (resolver:EncodingResolver, b:VMBranch) :
 ;
 ;- vmstate.current_stack.stack_pointer.locals[0 to n]: Locali
 ;  JIT code for single function assumes cached in register.
-;  Needs to be written to in-memory structure when current stack frame changes. 
+;  Needs to be written to in-memory structure when current stack frame changes.
 ;
 ;- vmstate.registers[0 to n]: VMRegi
 ;  JIT code assumes cached in register.
@@ -351,6 +354,7 @@ defenum EnterExit: (Enter, Exit)
 ;The information about a function's local frame.
 defstruct FuncInfo :
   deftable:IntTable<VMDef>
+  name-table:IntTable<String> ;empty if no debug info present
   used-labels:IntSet
   max-local:Int
   num-locals:Int
@@ -366,7 +370,10 @@ defn AsmGen (code:CodeHolder,
              a:Assembler,
              resolver:EncodingResolver,
              func-info:FuncInfo|False,
-             trace-entry-table:Vector<TraceTableEntry>|False,
+             trace-entry-table:Vector<TraceTableEntry>,
+             safepoint-entry-table:Vector<SafepointTableEntry>,
+             local-var-context:Vector<NamedLocalVar>,
+             local-var-maps:Vector<LocalVarMapEntry>,
              backend:Backend) :
 
   ;=========================================================
@@ -386,29 +393,35 @@ defn AsmGen (code:CodeHolder,
   val local-deftable = match(func-info:FuncInfo) :
     deftable(func-info)
 
+  ;Extract the local name table if there is one.
+  val local-name-table = match(func-info:FuncInfo) : name-table(func-info)
+                         else : IntTable<String>()
   ;Force retrieve the input FuncInfo.
   defn func-info! () -> FuncInfo :
     if func-info is False :
       fatal("No function information is given.")
     func-info as FuncInfo
 
+  ;Retrieve the stack frame slot that the local is stored in.
+  defn name? (l:Local) :
+    get?(local-name-table, index(l))
+
   ;Force retrieve the deftable.
   defn deftable! () -> IntTable<VMDef> :
     local-deftable as IntTable<VMDef>
 
-  ;Retrieve the stack frame slot that the local is
-  ;stored in.
+  ;Retrieve the stack frame slot that the local is stored in.
   defn slot (l:Local) -> Int :
     /local(deftable!()[index(l)])
 
   ;Call slot if x is a Local otherwise return dummy value 0.
   ;The dummy value is fine because in this case the instruction
-  ;doesn't have a return value anyway. 
+  ;doesn't have a return value anyway.
   defn slot? (x:Local|False) -> Int :
     match(x:Local) : slot(x)
     else : 0
 
-  ;Call slot if x is a Local otherwise return dummy value 0.
+  ;Call slot if x is a Local, otherwise report an error.
   defn slot! (x:Local|False) -> Int :
     match(x:Local) : slot(x)
     else : fatal("x is expected to be a Local.")
@@ -444,7 +457,7 @@ defn AsmGen (code:CodeHolder,
   ;=========================================================
   val label-table = IntTable<Label>()
   val label-counter = to-seq(0 to false)
-  
+
   ;Return the AsmJIT Label corresponding to the VM label
   ;with the given identifier.
   defn get-label (n:Int) -> Label :
@@ -461,24 +474,61 @@ defn AsmGen (code:CodeHolder,
   defn* gen-label () -> Int :
     val l = next(label-counter)
     val used-labels = used-labels(func-info!())
-    gen-label() when used-labels[l] else l  
+    gen-label() when used-labels[l] else l
+
+  ;=========================================================
+  ;================= Locals Debug Table ====================
+  ;=========================================================
+  defn stack-offset (slot:Int) :
+    slot * SIZEOF-LONG + STACK-FRAME-SLOTS-OFFSET
+  defn stack-offset (local:Local) :
+    stack-offset(slot(local))
+  val emit-varmaps? = not empty?(local-name-table)
+  val named-local-var-map = IntArray(length(deftable!()) when emit-varmaps? else 0, -1)
+  for i in 0 to length(named-local-var-map) do :
+    val local = Local(i)
+    match(name?(local)) :
+      (name:String) :
+        val n = length(local-var-context)
+        add(local-var-context, NamedLocalVar(stack-offset(local), name))
+        named-local-var-map[i] = n
+      (f:False) : false
+  defn index-in-context (local:Local) :
+    named-local-var-map[index(local)]
+  var last-record-live:RecordLiveIns|False = false
+  ;Add the given instruction location to the locals table.
+  defn record-locals (pos:Label) :
+    if emit-varmaps? :
+      match(last-record-live:RecordLiveIns) :
+        val live = to-tuple(filter({name?(_) != false}, live(last-record-live)))
+        if not empty?(live) :
+          val indices = qsort(map(index-in-context, live))
+          val offset = label-offset(code, pos)
+          add(local-var-maps, LocalVarMapEntry(offset, indices))
 
   ;=========================================================
   ;================= Stack Trace Table =====================
   ;=========================================================
   ;Add the given instruction location to the stack trace table.
   defn record-trace-entry (pos:Label, entry:StackTraceInfo|False) :
-    fatal("No trace table given.") when trace-entry-table is False
-    val table = trace-entry-table as Vector<TraceTableEntry>
     match(entry:StackTraceInfo) :
-      val offset = label-offset(code, pos)      
-      add(table, TraceTableEntry(offset, entry))
+      record-locals(pos)
+      val offset = label-offset(code, pos)
+      add(trace-entry-table, TraceTableEntry(offset, entry))
+
+  ;=========================================================
+  ;================== Safepoint Table ======================
+  ;=========================================================
+  ;Add the given instruction location to the safepoint table.
+  defn record-safepoint-location (pos:Label, id:Int) :
+    val offset = label-offset(code, pos)
+    add(safepoint-entry-table, SafepointTableEntry(offset, id))
 
   ;=========================================================
   ;================ Structure Accessors ====================
   ;=========================================================
 
-  ;Set and Get all the structure fields. 
+  ;Set and Get all the structure fields.
   #for (get-field in [get-vmstate-registers
                       get-vmstate-global-offsets
                       get-vmstate-global-mem
@@ -587,7 +637,7 @@ defn AsmGen (code:CodeHolder,
 
     val memptr = MemPtr(reg(BaseReg), OFFSET)
     defn get-field (dst:Gp) :
-      mov(a, dst, memptr)      
+      mov(a, dst, memptr)
     defn set-field (value:Gp) :
       mov(a, memptr, value)
 
@@ -597,8 +647,7 @@ defn AsmGen (code:CodeHolder,
     match(func-info:FuncInfo) :
       to-tuple $
         for i in 0 to num-locals() seq :
-          val offset = i * SIZEOF-LONG + STACK-FRAME-SLOTS-OFFSET
-          MemPtr(reg(StackPointerReg), offset)
+          MemPtr(reg(StackPointerReg), stack-offset(i))
     else :
       []
   defn stack-local (i:Int) -> Gp|MemPtr :
@@ -690,7 +739,7 @@ defn AsmGen (code:CodeHolder,
           sub(a, reg(StackPointerReg), current-frame-size())
         else :
           save-reg(StackPointerReg)
-    false      
+    false
 
   ;Switch from Standard JIT code to the system stack.
   ;Uses Tmp1, Tmp2 internally.
@@ -750,13 +799,22 @@ defn AsmGen (code:CodeHolder,
     set-vmstate-registers(reg(Tmp2))
     set-vmstate-system-registers(reg(Tmp1))
 
+  defn save-cached-local (slot:Int) :
+    mov(a, stack-local-mem(slot), stack-local(slot) as Gp)
+  defn restore-cached-local (slot:Int) :
+    mov(a, stack-local(slot) as Gp, stack-local-mem(slot))
   defn restore-locals-cache () :
     for i in 0 to length(LOCAL-ITEMS) do :
-      mov(a, stack-local(i) as Gp, stack-local-mem(i))
-
+      restore-cached-local(i)
   defn save-locals-cache () :
     for i in 0 to length(LOCAL-ITEMS) do :
-      mov(a, stack-local-mem(i), stack-local(i) as Gp)
+      save-cached-local(i)
+  defn save-locals-cache (live:Tuple<Local>) :
+    val limit = length(LOCAL-ITEMS)
+    for local in live do :
+      if name?(local) != false : ;Debugger can only observe named locals
+        val i = index(local)
+        if i < limit : save-cached-local(i)
 
   defn restore-vm-registers-cache () :
     for i in 0 to length(VMREG-ITEMS) do :
@@ -842,7 +900,7 @@ defn AsmGen (code:CodeHolder,
     ;Ensure we can handle this case.
     if length(args) > length(callc-regs(registers)) :
       fatal("Too many arguments for simple C calling convention.")
-      
+
     ;Ensure 1-by-1 moves are enough to implement parallel-move semantics.
     for i in 1 to length(args) do :
       val argi = args[i]
@@ -857,11 +915,11 @@ defn AsmGen (code:CodeHolder,
     if contains?(callc-regs(registers), callc-return(registers)) :
       fatal("The return register was not expected to be one of the \
              calling registers.")
-                 
+
     ;Move the arguments into their proper locations.
     for (param in callc-regs(registers), arg in args) do :
       mov(a, param, arg)
-      
+
     ;Call the function
     if c-num-spill-slots(backend) > 0 :
       sub(a, rsp, c-num-spill-slots(backend) * 8)
@@ -869,14 +927,14 @@ defn AsmGen (code:CodeHolder,
     call(a, callc-return(registers))
     if c-num-spill-slots(backend) > 0 :
       add(a, rsp, c-num-spill-slots(backend) * 8)
-    
+
     ;Move the result to the desired register
     match(ret:Gp) :
       if ret != callc-return(registers) :
         mov(a, ret, callc-return(registers))
 
   ;Assume that we are in the standard JIT context, emit code to
-  ;call faddr with args. If ret is provided, then store result in ret afterwards.  
+  ;call faddr with args. If ret is provided, then store result in ret afterwards.
   defn simple-call-c-from-jit-context (ret:Gp|False, faddr:Long, args:Tuple<Gp>) :
     switch-context-stanza-to-jit(Exit, true, false)
     simple-c-call(ret, faddr, args)
@@ -981,7 +1039,7 @@ defn AsmGen (code:CodeHolder,
     switch(size) :
       4 : movss(a, stack-local(slot), v)
       8 : movsd(a, stack-local(slot), v)
-    false        
+    false
 
   ;Put y, z, locals into registers, and chooses a result register to
   ;store x, and calls f with the resulting registers.
@@ -993,7 +1051,7 @@ defn AsmGen (code:CodeHolder,
     ;Retrieve y and z as registers.
     val yloc = stack-local(y,reg(Tmp2))
     val zloc = stack-local(z,reg(Tmp3))
-    
+
     ;Put x into reg(Tmp1), and then store reg(Tmp1) into memory.
     defn compute-with-x-in-tmp1 () :
       f(reg(Tmp1), yloc, zloc)
@@ -1060,7 +1118,7 @@ defn AsmGen (code:CodeHolder,
   ;f must return the register holding the result.
   ;This result is stored back into the x local.
   defn compute-with-rax-rdx (f:Gp -> Gp, x:Int, size:Int) :
-    ;Tmp2 is not rax or rdx. 
+    ;Tmp2 is not rax or rdx.
     set-local(x, f(reg(Tmp2)), size)
 
   ;Reserves RCX for use by f, and chooses a result register for x.
@@ -1157,7 +1215,7 @@ defn AsmGen (code:CodeHolder,
     ;Dispatch based upon type of value.
     match(v) :
       ;Immediates that don't require temporary registers to
-      ;retrieve. 
+      ;retrieve.
       (v:Local) :
         mov-to-x(stack-local(slot(v)), false)
       (v:NumConst) :
@@ -1174,11 +1232,11 @@ defn AsmGen (code:CodeHolder,
       (v:CodeId) : mov-to-x(id(v), false)
       (v:ExternId) : mov-to-x(extern-address(resolver,id(v)), false)
       (v:ExternDefnId) : mov-to-x(extern-defn-address(resolver,id(v)), false)
-      
+
       ;Immediates that require temporary registers to retrieve.
       ;Uses Tmp1 and Tmp2
       (v:GlobalId) :
-        ;TMP1:int = global-offset[v]        
+        ;TMP1:int = global-offset[v]
         get-vmstate-global-offsets(reg(Tmp2))
         mov(a, reg(Tmp1), MemPtr(reg(Tmp2), id(v) * SIZEOF-LONG, SIZEOF-LONG))
         ;x = addr(global-mem[TMP1])
@@ -1193,7 +1251,7 @@ defn AsmGen (code:CodeHolder,
         get-vmstate-data-mem(reg(Tmp2))
         lea(a, reg(Tmp2), MemPtr(reg(Tmp2), gp32(reg(Tmp1)), 3, 0))
         mov-to-x(reg(Tmp2), false)
-      (v:ConstId) : 
+      (v:ConstId) :
         get-vmstate-const-table(reg(Tmp2))
         mov-to-x(MemPtr(reg(Tmp2), id(v) * SIZEOF-LONG, SIZEOF-LONG), false)
 
@@ -1210,7 +1268,7 @@ defn AsmGen (code:CodeHolder,
   defn get-reg (x:Local|VMType, i:Int) :
     match(x:Local) :
       mov-using-tmp(stack-local(slot(x)), vm-register(i), reg(Tmp1))
-      
+
   ;Retrieve value in register 0 to n and put in given locals xs (if not VMType).
   defn get-regs (xs:Seqable<Local|VMType>) :
     do(get-reg, xs, 0 to false)
@@ -1226,7 +1284,7 @@ defn AsmGen (code:CodeHolder,
   defn to-local (x:VMImm, num:Int) -> Int :
     match(x:Local) :
       slot(x)
-    else : 
+    else :
       val index = temp-local(num)
       set-local(index, x)
       index
@@ -1240,7 +1298,7 @@ defn AsmGen (code:CodeHolder,
   ;The stub expects the following inputs:
   ;- return (TMP2-REG): The address to return to after stack extension is completed.
   ;- size-required (TMP3-REG): The number of additional bytes required from the stack.
-  defn make-extend-stack-stub () : 
+  defn make-extend-stack-stub () :
     ;Save the return address in current-stack.pc.
     set-stack-pc(reg(Tmp2))
 
@@ -1288,7 +1346,7 @@ defn AsmGen (code:CodeHolder,
   ;   before the CALL instruction.
   ;2) Therefore we need to push an odd number of items onto the stack to
   ;   ensure that our own CALL instructions are 16-byte aligned.
-  ;   In the body of JIT generated code, RSP will be 0x???????0. 
+  ;   In the body of JIT generated code, RSP will be 0x???????0.
   defn make-jit-launch-stub () :
     ;Save incoming arguments
     push(a, reg(Tmp1))                 ;Save Dummy for 16-byte stack alignment.
@@ -1304,10 +1362,10 @@ defn AsmGen (code:CodeHolder,
     val return-to-stanza-label = new-label(a)            ;stackframe.returnpc = return-to-stanza-label
     lea(a, reg(Tmp1), MemPtr(return-to-stanza-label))
     set-return(reg(Tmp1))
-    
+
     ;Jump to the entry point of the initial function.
     mov(a, reg(Tmp1), vm-function(reg(Tmp3), 0))
-    jmp(a, reg(Tmp1))                           
+    jmp(a, reg(Tmp1))
 
     ;Return from the initial function.
     bind(a, return-to-stanza-label)
@@ -1319,7 +1377,7 @@ defn AsmGen (code:CodeHolder,
     pop(a, reg(Tmp1)) ;POP CRSP (Unused).
     pop(a, reg(Tmp1)) ;POP VMState (Unused).
     pop(a, reg(Tmp1)) ;POP Dummy
-    
+
     ;Return from to NonJITContext.
     ret(a)
 
@@ -1339,7 +1397,7 @@ defn AsmGen (code:CodeHolder,
   defn emit-dispatch (format:Int, ys:Tuple<VMImm>, labels:Tuple<Label>) -> False :
     ;Put dispatch arguments into registers.
     set-regs(ys)
-    
+
     ;Emit idx (Tmp1) = read-dispatch-table(format)
     read-dispatch-table(reg(Tmp1), format)
 
@@ -1367,7 +1425,7 @@ defn AsmGen (code:CodeHolder,
   defn emit-reserve (size:Gp|Long) -> Label :
     ;Label for end of reservation stub.
     val end-label = new-label(a)
-    
+
     ;Let Tmp1 = num-bytes on heap.
     val header-size = object-header-size(resolver)
     match(size) :
@@ -1377,17 +1435,17 @@ defn AsmGen (code:CodeHolder,
         and-op(a, reg(Tmp1), -8)
       (size:Long) :
         mov(a, reg(Tmp1), size + to-long(header-size))
-        
+
     ;Let Tmp2 = heap-top + num-bytes
     get-vmstate-heap-top(reg(Tmp2))
     add(a, reg(Tmp2), reg(Tmp1))
-    
+
     ;Let Tmp3 = heap-limit
     ;Goto end when heap-top + num-bytes <= heap-limit
     get-vmstate-heap-limit(reg(Tmp3))
     cmp(a, reg(Tmp2), reg(Tmp3))
     jbe(a, end-label)
-    
+
     ;Call reserve function
     mov-using-tmp(vm-register(0), to-long(false-marker(resolver)), reg(Tmp2))
     mov-using-tmp(vm-register(1), 1L, reg(Tmp2))
@@ -1396,7 +1454,7 @@ defn AsmGen (code:CodeHolder,
 
     ;End of reservation
     bind(a, end-label)
-    
+
     ;Return return label of call.
     ret
 
@@ -1448,7 +1506,7 @@ defn AsmGen (code:CodeHolder,
   ;Call directly using the C-calling convention.
   defn emit-fast-callc (f:VMImm, xs:Tuple<Local|VMType>, ys:Tuple<VMImm>) :
     ;This is added to CRSP before the call.
-    ;In the body of JIT generated code, launcher ensures that RSP will be 0x???????0. 
+    ;In the body of JIT generated code, launcher ensures that RSP will be 0x???????0.
     ;The System-V convention requires that RSP by 0x???????0 before the CALL instruction.
     ;Therefore we ensure that the number of slots is even.
     defn crsp-offset (records:CallCRecords) -> Int :
@@ -1481,17 +1539,17 @@ defn AsmGen (code:CodeHolder,
           ;So preload them into one of the VMRegister slots.
           (y:GlobalId|DataId|ConstId) :
             val mem = vm-register-mem(i)
-            
+
             ;Emit instructions to preload the argument if we haven't done
             ;it already.
             set-imm(mem, y) when add(preloaded-args, i)
-            
+
             mem
-            
+
           ;Locals are either stored in a register or in the current stack frame.
           (y:Local) :
             stack-local(slot(y))
-            
+
           ;The rest of the immediates do not currently occupy a register,
           ;and they can be loaded directly into a register without using any temporaries.
           (y:VMImm) :
@@ -1504,7 +1562,7 @@ defn AsmGen (code:CodeHolder,
         ;the values are never currently held in an xmm register.
         val v = value(arg) as StdArg|ShadowArg
         add(accum, SetCArg(get-arg-value(index(v)), to-dst(loc(arg))))
-        
+
       ;Set the num-float register
       add(accum, SetCArg(num-real-args(records), rax))
 
@@ -1521,13 +1579,13 @@ defn AsmGen (code:CodeHolder,
       val blocked-regs = [reg(RegistersReg),
                           reg(StackPointerReg),
                           rsp]
-                          
+
       ;Create the list of available registers.
       val available-regs = to-tuple $
         for r in gp64s seq? :
           if contains?(blocked-regs, r) : None()
           else : One(Reg(id(r)))
-          
+
       ;Create the ShuffleProblem representing the transfer
       ;of values to registers.
       val prob = ShuffleProblem(available-regs, map(to-mov,cargs)) where :
@@ -1570,18 +1628,18 @@ defn AsmGen (code:CodeHolder,
                     (src-loc:Gp|MemPtr|Int, dst-loc:Gp) : mov(a, dst-loc, src-loc)
                     (src-loc:VMImm, dst-loc:Gp) : set-imm(dst-loc, src-loc)
                     (src-loc:Gp, dst-loc:Xmm) : movsd(a, dst-loc, src-loc)
-                    (src-loc:Gp, dst-loc:MemPtr) : mov(a, dst-loc, src-loc)                
+                    (src-loc:Gp, dst-loc:MemPtr) : mov(a, dst-loc, src-loc)
                 ;Reg-to-Reg shuffling moving.
                 (f:False) :
                   val src-reg = to-gp(src(ins) as Reg)
                   val dst-reg = to-gp(dst(ins) as Reg)
                   mov(a, dst-reg, src-reg)
-                  
+
           ;A Mem-to-mem move.
           (ins:MoveUsingTmp) :
             val set-carg = id(ins) as SetCArg
             val tmp-reg = to-gp(/reg(ins))
-            ;Move from the source to the temp register.            
+            ;Move from the source to the temp register.
             match(src(set-carg)) :
               (src:Gp|MemPtr|Int) : mov(a, tmp-reg, src)
               (src:VMImm) : set-imm(tmp-reg, src)
@@ -1589,7 +1647,7 @@ defn AsmGen (code:CodeHolder,
             match(dst(set-carg)) :
               (dst:Gp|MemPtr) : mov(a, dst, tmp-reg)
               (dst:Xmm) : movsd(a, dst, tmp-reg)
-          
+
           ;Swap registers should not be necessary.
           (ins:SaveSwap|RestoreSwap) :
             fatal("Save/Restore swap registers not expected.")
@@ -1619,7 +1677,7 @@ defn AsmGen (code:CodeHolder,
     val set-cargs = compute-set-c-args(records)
     write-cargs-to-registers(set-cargs)
     call-f(records)
-    switch-context-stanza-to-jit(Enter, true, true)    
+    switch-context-stanza-to-jit(Enter, true, true)
     move-return-to-local(records, xs)
 
   ;Call using the C trampoline.
@@ -1640,7 +1698,7 @@ defn AsmGen (code:CodeHolder,
       val num-int-args-index = next(layout-counter, 1)
       val int-args-index = next(layout-counter, num-int-args(records))
       val num-floats-in-call-index = next(layout-counter,1)
-      
+
       ;Given the location that the argument should be stored,
       ;return the index in the register buffer that we should
       ;store the argument that is desired by the trampoline code.
@@ -1649,19 +1707,19 @@ defn AsmGen (code:CodeHolder,
           (l:RegLoc) : num-floats-in-call-index - 1 - index(l)
           (l:FRegLoc) : num-int-args-index - 1 - index(l)
           (l:MemLoc) : num-float-args-index - 1 - index(l)
-          
+
       ;Assign registers
       for arg in args(records) do :
         val r = register-index(loc(arg))
         val v = value(arg) as StdArg|ShadowArg
         val y = ys[index(v)]
         set-reg(r, y)
-        
+
       ;Set number of arguments
       set-reg(num-stack-args-index, NumConst(num-mem-args(records)))
       set-reg(num-float-args-index, NumConst(num-real-args(records)))
       set-reg(num-int-args-index, NumConst(num-int-args(records) + 1))
-      set-reg(num-floats-in-call-index, NumConst(num-real-args(records)))              
+      set-reg(num-floats-in-call-index, NumConst(num-real-args(records)))
 
     ;Emit instructions for calling the C function f.
     defn call-c-trampoline (f:VMImm) :
@@ -1676,7 +1734,7 @@ defn AsmGen (code:CodeHolder,
           reg(Tmp1)
         (f:ExternDefnId) :
           mov(a, reg(Tmp1), extern-defn-address(resolver,id(f)))
-          reg(Tmp1)          
+          reg(Tmp1)
       ;Call the C trampoline in a new stack frame.
       simple-call-c-in-new-frame-from-jit-context(
         false,
@@ -1696,7 +1754,7 @@ defn AsmGen (code:CodeHolder,
     val records = compute-callc-records(xs, ys)
     write-records-to-registers(records, ys)
     call-c-trampoline(f)
-    move-return-to-local(records, xs)    
+    move-return-to-local(records, xs)
 
   ;=========================================================
   ;================ 1-Operand Primitive ====================
@@ -1738,7 +1796,7 @@ defn AsmGen (code:CodeHolder,
         ;Xmm0 = 0.0f
         xor-op(a, reg(Tmp1), reg(Tmp1))
         cvtsi2ss(a, xmm0, reg(Tmp1))
-        ;Xmm1 = y        
+        ;Xmm1 = y
         set-imm(reg(Tmp1), y)
         movss(a, xmm1, reg(Tmp1))
         ;xmm0 = xmm0 - y
@@ -1749,7 +1807,7 @@ defn AsmGen (code:CodeHolder,
         ;Xmm0 = 0.0f
         xor-op(a, reg(Tmp1), reg(Tmp1))
         cvtsi2sd(a, xmm0, reg(Tmp1))
-        ;Xmm1 = y        
+        ;Xmm1 = y
         set-imm(reg(Tmp1), y)
         movsd(a, xmm1, reg(Tmp1))
         ;xmm0 = xmm0 - y
@@ -1890,7 +1948,7 @@ defn AsmGen (code:CodeHolder,
         ;Let reg(Tmp1) = stack
         set-imm(reg(Tmp1), y)
         simple-call-c-from-jit-context(false, call-print-stack-trace-addr(), [reg(VMStateReg), reg(Tmp1)])
-        set-local-using-tmp(x, 0L, 8, reg(Tmp1)) 
+        set-local-using-tmp(x, 0L, 8, reg(Tmp1))
       COLLECT-STACK-TRACE-OPCODE :
         ;Let reg(Tmp1) = stack
         set-imm(reg(Tmp1), y)
@@ -1901,13 +1959,13 @@ defn AsmGen (code:CodeHolder,
         tzcnt(a, reg(Tmp1), reg(Tmp1))
         set-local(x, reg(Tmp1), 8)
       else :
-        fatal("Unhandled opcode %_." % [opcode])     
+        fatal("Unhandled opcode %_." % [opcode])
 
   ;=========================================================
   ;================ 2-Operand Primitive ====================
   ;=========================================================
   ;Emit instructions for 2-operand basic op: x = y opcode z
-  defn emit-op2 (a:Assembler, opcode:Int, x:Int, y:Int, z:Int) -> False :    
+  defn emit-op2 (a:Assembler, opcode:Int, x:Int, y:Int, z:Int) -> False :
     switch(opcode) :
       INT-ADD-OPCODE :
         within (xreg, yreg, zreg) = compute-op2-with-temp-regs(x, y, z, 8) :
@@ -1921,7 +1979,7 @@ defn AsmGen (code:CodeHolder,
         within (xreg, yreg, zreg) = compute-op2-with-temp-regs(x, y, z, 8) :
           mov(a, xreg, yreg)
           shr(a, xreg, 32)
-          imul(a, xreg, zreg)          
+          imul(a, xreg, zreg)
       INT-AND-OPCODE :
         within (xreg, yreg, zreg) = compute-op2-with-temp-regs(x, y, z, 8) :
           mov(a, xreg, yreg)
@@ -2007,7 +2065,7 @@ defn AsmGen (code:CodeHolder,
           boolref-cmp-set(yreg, zreg, xreg, set-e)
       REF-NE-OPCODE :
         within (xreg, yreg, zreg) = compute-op2-with-temp-regs(x, y, z, 8) :
-          boolref-cmp-set(yreg, zreg, xreg, set-ne)          
+          boolref-cmp-set(yreg, zreg, xreg, set-ne)
       EQ-OPCODE-REF :
         within (xreg, yreg, zreg) = compute-op2-with-temp-regs(x, y, z, 8) :
           cmp-set(yreg, zreg, xreg, set-e, 8)
@@ -2055,7 +2113,7 @@ defn AsmGen (code:CodeHolder,
           cmpf-set(zreg, yreg, xreg, set-a, 4)
       LT-OPCODE-DOUBLE :
         within (xreg, yreg, zreg) = compute-op2-with-temp-fregs(x, y, z, 8, 8) :
-          cmpf-set(zreg, yreg, xreg, set-a, 8)          
+          cmpf-set(zreg, yreg, xreg, set-a, 8)
       GT-OPCODE-INT :
         within (xreg, yreg, zreg) = compute-op2-with-temp-regs(x, y, z, 8) :
           cmp-set(yreg, zreg, xreg, set-g, 4)
@@ -2343,7 +2401,7 @@ defn AsmGen (code:CodeHolder,
         within (xreg, yreg, zreg) = compute-op2-with-temp-regs(x, y, z, 8) :
           bt(a, MemPtr(zreg,0), yreg)
           mov(a, xreg, 0)
-          set-c(a, gp8(xreg))          
+          set-c(a, gp8(xreg))
       TEST-AND-SET-BIT-OPCODE :
         ;x = test and set bit yreg at address zreg.
         within (xreg, yreg, zreg) = compute-op2-with-temp-regs(x, y, z, 8) :
@@ -2365,7 +2423,7 @@ defn AsmGen (code:CodeHolder,
         val zreg = stack-local(z, reg(Tmp3))
         btr(a, MemPtr(zreg,0), yreg)
       else :
-        fatal("Unimplemented opcode %_" % [opcode])     
+        fatal("Unimplemented opcode %_" % [opcode])
     false
 
   ;=========================================================
@@ -2542,7 +2600,7 @@ defn AsmGen (code:CodeHolder,
       je(a, n1-label)
       jmp(a, n2-label)
     ;Start
-    driver()    
+    driver()
 
   ;=========================================================
   ;============== Emit General Instanceof ==================
@@ -2568,21 +2626,21 @@ defn AsmGen (code:CodeHolder,
       (ins:TCallIns) :
         set-regs(ys(ins))
         set-imm(reg(Tmp2), f(ins))
-        goto-function(reg(Tmp2), 0)            
+        goto-function(reg(Tmp2), 0)
 
       (ins:TCallClosureIns) :
         set-regs(ys(ins))
         ;Load Tmp2 = func.code
         set-imm(reg(Tmp2), f(ins))
         mov(a, reg(Tmp2), MemPtr(reg(Tmp2), object-header-size(resolver) + FUNCTION-CODE-OFFSET - ref-offset(resolver)))
-        goto-function(reg(Tmp2), 0)            
+        goto-function(reg(Tmp2), 0)
 
       (ins:CallIns) :
         set-regs(ys(ins))
         set-imm(reg(Tmp2), f(ins))
         val ret = call-from-jit-context(reg(Tmp2))
         get-regs(xs(ins))
-        record-trace-entry(ret, trace-entry(ins))            
+        record-trace-entry(ret, trace-entry(ins))
 
       (ins:CallClosureIns) :
         set-regs(ys(ins))
@@ -2591,14 +2649,14 @@ defn AsmGen (code:CodeHolder,
         mov(a, reg(Tmp2), MemPtr(reg(Tmp2), object-header-size(resolver) + FUNCTION-CODE-OFFSET - ref-offset(resolver)))
         val ret = call-from-jit-context(reg(Tmp2))
         get-regs(xs(ins))
-        record-trace-entry(ret, trace-entry(ins))        
+        record-trace-entry(ret, trace-entry(ins))
 
       (ins:CallCIns) :
-        if USE-DIRECT-C-CALLS? : 
+        if USE-DIRECT-C-CALLS? :
           emit-fast-callc(f(ins), xs(ins), ys(ins))
         else :
           emit-callc(f(ins), xs(ins), ys(ins))
-        
+
       (ins:YieldIns) :
         ;current-stack.pc = after-yield.
         val after-yield = new-label(a)
@@ -2632,17 +2690,27 @@ defn AsmGen (code:CodeHolder,
         record-trace-entry(after-yield, trace-entry(ins))
 
         ;Retrieve the registers
-        get-regs(xs(ins))                        
+        get-regs(xs(ins))
 
       (ins:ReturnIns) :
         set-regs(xs(ins))
         get-return(reg(Tmp1))
-        jmp(a, reg(Tmp1))          
+        jmp(a, reg(Tmp1))
 
       (ins:DumpIns) :
         false
 
+      (ins:SafepointIns) :
+        match(last-record-live:RecordLiveIns) :
+          save-locals-cache(live(last-record-live))
+        val lbl = new-label(a)
+        bind(a, lbl)
+        nop(a)
+        record-trace-entry(lbl, trace-entry(ins))
+        record-safepoint-location(lbl, id(ins))
+
       (ins:RecordLiveIns) :
+        last-record-live = ins
         val live-map = liveness-map(resolver, seq(slot, live(ins)), num-locals())
         mov(a, reg(Tmp1), live-map)
         set-liveness-map(reg(Tmp1))
@@ -2662,7 +2730,7 @@ defn AsmGen (code:CodeHolder,
             val xreg = local(x*, reg(Tmp1))
             val yreg = local(y*, reg(Tmp2))
             val zreg = local(z*, reg(Tmp3))
-            val size = size(imm-type(z(ins)))                
+            val size = size(imm-type(z(ins)))
             mov(a, MemPtr(xreg, yreg, 0, offset*, size), gp(zreg,size))
           ;No variable offset
           (y:False) :
@@ -2676,10 +2744,10 @@ defn AsmGen (code:CodeHolder,
       (ins:StoreWithBarrierIns) :
         ;Compute the offset from x depending upon whether x is a Ref or a pointer.
         val offset* = offset(ins) - ref-offset(resolver) + object-header-size(resolver)
-        
+
         ;Store z into a local so we can retrieve it without using additional registers.
         val z* = to-local(z(ins), 2)
-        
+
         ;Compute the address to store to. Put it in Tmp1.
         ;Determine whether we have a variable-offset.
         match(y(ins)) :
@@ -2695,15 +2763,15 @@ defn AsmGen (code:CodeHolder,
             val x* = to-local(x(ins), 0)
             val xreg = local(x*, reg(Tmp1))
             lea(a, reg(Tmp1), MemPtr(xreg, offset*, 8))
-            
-        ;Store the value into the address        
+
+        ;Store the value into the address
         val zreg = local(z*, reg(Tmp2))
         mov(a, MemPtr(reg(Tmp1),0), zreg)
 
         ;Set remembered-bit for write barrier.
         shr(a, reg(Tmp1), 3)                     ;Convert base to bit index.
         get-vmstate-heap-bitset-base(reg(Tmp2))  ;Retrieve bitset-base.
-        bts(a, MemPtr(reg(Tmp2),0), reg(Tmp1))   ;Set bit        
+        bts(a, MemPtr(reg(Tmp2),0), reg(Tmp1))   ;Set bit
 
       (ins:LoadIns) :
         ;Compute the offset from y depending upon whether y is a Ref or a pointer.
@@ -2728,7 +2796,7 @@ defn AsmGen (code:CodeHolder,
             val size = size(imm-type(x(ins)))
             within xreg = update-local(slot(x(ins)), reg(Tmp1), size) :
               mov(a, gp(xreg,size), MemPtr(yreg, offset*, size))
-              
+
       (ins:Op0Ins) :
         match(op(ins)) :
           (op:FlushVMOp) :
@@ -2736,14 +2804,14 @@ defn AsmGen (code:CodeHolder,
             set-local(slot?(x(ins)), reg(VMStateReg), 8)
           (op:CRSPOp) :
             mov(a, reg(Tmp1), saved-crsp)
-            set-local(slot?(x(ins)), reg(Tmp1), 8)                
+            set-local(slot?(x(ins)), reg(Tmp1), 8)
 
       (ins:Op1Ins) :
         match(op(ins)) :
           (op:InstanceofOp) :
             ;Retrieve the format.
             val format = match-format(resolver, [[type(op)]])
-            
+
             ;Push argument into register
             set-reg(0, y(ins))
 
@@ -2784,7 +2852,7 @@ defn AsmGen (code:CodeHolder,
         val x* = to-local(x(ins), 0)
         val y* = to-local(y(ins), 1)
         emit-branch(code, x*, y*, get-label(n1(ins)), get-label(n2(ins)))
-        
+
       (ins:AllocIns) :
         defn alloc-multiple-objects () :
           ;Compute total number of bytes on heap.
@@ -2798,26 +2866,26 @@ defn AsmGen (code:CodeHolder,
           ;Allocate each object
           val xs-slots = map(slot, xs(ins))
           emit-alloc(xs-slots, map(to-long,obj-sizes), types(ins))
-          
+
         defn alloc-single-object () :
           ;Sanity check.
           fatal("Multiple variable-sized allocations.") when length(sizes(ins)) > 1
           ;Store the size into reg(Tmp1).
           set-imm(reg(Tmp1), sizes(ins)[0])
-          
+
           ;Reserve bytes
           val ret = emit-reserve(reg(Tmp1))
           record-trace-entry(ret, trace-entry(ins))
-          
+
           ;Allocate the object
           val x = xs(ins)[0]
           set-imm(reg(Tmp3), sizes(ins)[0])
-          emit-alloc([slot(x)], [reg(Tmp3)], [types(ins)[0]])              
+          emit-alloc([slot(x)], [reg(Tmp3)], [types(ins)[0]])
 
         ;Dispatch
         if all?({_ is NumConst}, sizes(ins)) : alloc-multiple-objects()
         else : alloc-single-object()
-        
+
       (ins:DispatchIns) :
         ;Retrieve the dispatch format.
         val [types, dests] = split-types-and-dests(branches(ins))
@@ -2839,7 +2907,7 @@ defn AsmGen (code:CodeHolder,
 
           ;Perform Dispatch. First branch is the default branch.
           emit-dispatch(format, ys(ins), get-labels(cat([default(ins)], dests)))
-          
+
       (ins:MethodDispatchIns) :
         ;Retrieve format
         val format = method-format(resolver, multi(ins), length(ys(ins)), length(zs(ins)))
@@ -2855,7 +2923,7 @@ defn AsmGen (code:CodeHolder,
         ;returns the (2 + id of the function) to dispatch to.
         val code-label = new-label(a)
         cmp(a, reg(Tmp1), 2)
-        jge(a, code-label)            
+        jge(a, code-label)
         cmp(a, reg(Tmp1), 0)
         je(a, get-label(default(ins)))
         jmp(a, get-label(amb(ins)))
@@ -2877,14 +2945,14 @@ defn AsmGen (code:CodeHolder,
   defn emit-function-prelude (args:Tuple<Local|VMType>, extend-stack:Func) :
     ;Label after stack extension
     val after-stack-extension = new-label(a)
-    
+
     ;Check whether we need to extend the stack.
     val size-required = current-frame-size() + SIZEOF-STACK-FRAME
     lea(a, reg(Tmp3), MemPtr(reg(StackPointerReg), size-required))
     val limit = compute-stack-limit(reg(Tmp2))
     cmp(a, reg(Tmp3), limit)
     jbe(a, after-stack-extension)
-    
+
     ;Call extend-stack
     lea(a, reg(Tmp2), MemPtr(after-stack-extension))
     mov(a, reg(Tmp3), size-required)
@@ -2933,9 +3001,9 @@ defn AsmGen (code:CodeHolder,
     ;Emit each of the arities
     for (arity in arities, index in 0 to false) do :
       val after-func-label = new-label(a)
-      cmp(a, arity-reg, arity)        
+      cmp(a, arity-reg, arity)
       jne(a, after-func-label)
-      emit-arity-code(index)        
+      emit-arity-code(index)
       bind(a, after-func-label)
     ;Default branch
     emit-arity-code(false)
@@ -2962,30 +3030,27 @@ defn AsmGen (code:CodeHolder,
 ;============================================================
 
 public defn make-jit-stubs (rt:JitRuntime, resolver:EncodingResolver, backend:Backend) -> JITStubs :
+  val no-trace-entry-table = Vector<TraceTableEntry>()
+  val no-safepoint-entry-table = Vector<SafepointTableEntry>()
+  val no-local-var-context = Vector<NamedLocalVar>()
+  val no-local-var-maps = Vector<LocalVarMapEntry>()
+
+
   ;Make a Func given an emitter function.
   defn make-stub-func (emit-code:AsmGen -> ?) -> Func :
     within (code, assembler) = gen-code(rt) :
-      emit-code(AsmGen(code, assembler, resolver, false, false, backend))
-  ;Compile all stubs    
+      emit-code(AsmGen(code, assembler, resolver, false,
+                       no-trace-entry-table,
+                       no-safepoint-entry-table,
+                       no-local-var-context,
+                       no-local-var-maps,
+                       backend))
+  ;Compile all stubs
   JITStubs(
     make-stub-func(emit-jit-launch)
     make-stub-func(emit-extend-stack))
 
-;============================================================
-;======== Compute Absolute Addresses of Trace Entries =======
-;============================================================
-
-;Convert the relative addresses in the trace table entries to
-;absolute addresses.
-;- trace-entries: The trace table entries with addresses relative to the function.
-;- func: The generated ASMJit function, which has an absolute address.
-defn compute-absolute-addresses! (trace-entries:Vector<TraceTableEntry>,
-                                  func:Func) -> False :
-  val func-address = address(func)
-  for e in trace-entries map! :
-    TraceTableEntry(func-address + pc(e), entry(e))
-
-;Return the address of the function. 
+;Return the address of the function.
 lostanza defn address (func:ref<Func>) -> ref<Long> :
   return new Long{func.value as long}
 
@@ -2999,52 +3064,65 @@ public defn encode (func:VMFunction,
                     rt:JitRuntime,
                     resolver:EncodingResolver,
                     backend:Backend) -> EncodedFunction :
-                  
-  ;Retrieve the FuncInfo for the function.                
-  defn func-info (f:VMFunc) -> FuncInfo :
+
+  ;Retrieve the FuncInfo for the function.
+  defn func-info (f:VMFunc) :
     ;Compute number of locals in function.
     ;Extra 3 locals for temporary moving.
     val max-local = maximum(-1, seq(local, defs(f)))
-    val num-locals = max-local + 1 + 3          
+    val num-locals = max-local + 1 + 3
 
     ;Definitions
     val deftable = to-inttable(id, defs(f))
 
+    ;Debug names for some of the definitions
+    val local-name-table = to-inttable<String> $
+      for v in filter({not global?(_)}, entries(debug-name-table(f))) seq :
+        id(v) => name(v)
+
     ;Labels
     val used-labels = to-intset(seq(n, filter-by<LabelIns>(ins(f))))
 
     ;Function Info
-    FuncInfo(deftable, used-labels, max-local, num-locals)    
-
-  ;Generate code for multifn
-  defn emit-multifn (code:CodeHolder, assembler:Assembler, trace-entry-table:Vector<TraceTableEntry>, f:VMMultifn) :
-    val gen = AsmGen(code, assembler, resolver, false, trace-entry-table, backend)
-    within func-index = emit-multi-arity-dispatch(gen, arg(f), map(key,funcs(f))) :
-      match(func-index:Int) :
-        val entry = funcs(f)[func-index]
-        emit-fn(code, assembler, trace-entry-table, value(entry))
-      else :
-        emit-fn(code, assembler, trace-entry-table, default(f))
-
-  ;Generate code for single fn
-  defn emit-fn (code:CodeHolder, assembler:Assembler, trace-entry-table:Vector<TraceTableEntry>, f:VMFunc) :
-    within log-time(JIT-EMIT-FN) :
-      val gen = AsmGen(code, assembler, resolver, func-info(f), trace-entry-table, backend)
-      emit-function-prelude(gen, args(f), extend-stack(stubs))
-      emit-arg-bit-extensions(gen, args(f)) when externfn?
-      do(emit-ins{gen, _}, ins(f))
+    FuncInfo(deftable, local-name-table, used-labels, max-local, num-locals)
 
   ;Launch!
   within log-time(JIT-ENCODER) :
     val trace-entry-table = Vector<TraceTableEntry>()
+    val safepoint-entry-table = Vector<SafepointTableEntry>()
+    val local-var-context = Vector<NamedLocalVar>()
+    val local-var-maps = Vector<LocalVarMapEntry>()
     val jit-func = within (code, assembler) = gen-code(rt) :
+      defn AsmGen (func-info:FuncInfo|False) :
+        /AsmGen(code, assembler, resolver, func-info, trace-entry-table, safepoint-entry-table,
+                local-var-context, local-var-maps, backend)
+      ;Generate code for single fn
+      defn emit-fn (f:VMFunc) :
+        within log-time(JIT-EMIT-FN) :
+          val gen = AsmGen(func-info(f))
+          emit-function-prelude(gen, args(f), extend-stack(stubs))
+          emit-arg-bit-extensions(gen, args(f)) when externfn?
+          do(emit-ins{gen, _}, ins(f))
+      ;Generate code for multifn
+      defn emit-multifn (f:VMMultifn) :
+        val gen = AsmGen(false)
+        within func-index = emit-multi-arity-dispatch(gen, arg(f), map(key,funcs(f))) :
+          val func = match(func-index:Int) : value(funcs(f)[func-index])
+                     else : default(f)
+          emit-fn(func)
       match(func) :
-        (func:VMMultifn) : emit-multifn(code, assembler, trace-entry-table, func)
-        (func:VMFunc) : emit-fn(code, assembler, trace-entry-table, func)
+        (func:VMMultifn) : emit-multifn(func)
+        (func:VMFunc) : emit-fn(func)
 
-    ;Relocate trace addresses
+    ;Fixup trace addresses
     within log-time(COMPUTE-ABSOLUTE-ADDRESSES) :
-      compute-absolute-addresses!(trace-entry-table, jit-func)
+      val base = address(jit-func)
+      for e in trace-entry-table map! :
+        TraceTableEntry(base + pc(e), entry(e))
+      for e in safepoint-entry-table map! :
+        SafepointTableEntry(base + pc(e), id(e))
+      for e in local-var-maps map! :
+        LocalVarMapEntry(base + pc(e), indices(e))
 
     ;Return the final encoded function
-    EncodedFunction(jit-func, trace-entry-table)
\ No newline at end of file
+    EncodedFunction(jit-func, trace-entry-table, safepoint-entry-table, local-var-context, local-var-maps)
diff --git a/compiler/main.stanza b/compiler/main.stanza
index 427c43687..4a3f99255 100644
--- a/compiler/main.stanza
+++ b/compiler/main.stanza
@@ -271,7 +271,7 @@ defn ensure-proper-verbose-level! (cmd-args:CommandArgs) :
     val setting:Maybe<String> = cmd-args["verbose"]
     if not empty?(setting) :
       match(to-int(value!(setting))) :
-        (v:Int) : 
+        (v:Int) :
           if v < 1 or v > 10 :
             throw(ArgParseError("The '-verbose' flag requires an integer between 1 and 10."))
         (f:False) :
@@ -921,6 +921,65 @@ defn run-test-command () :
           flags,
           run-tests-msg, intercept-no-match-exceptions(run-tests))
 
+;============================================================
+;====================== Debug Command =======================
+;============================================================
+
+defn debug-command () :
+  ;Flags
+  val flags = [
+    Flag("pkg", ZeroOrMoreFlag, OptionalFlag,
+      "The set of additional directories to look in for .pkg files.")
+    Flag("flags", ZeroOrMoreFlag, OptionalFlag,
+      "The set of compile-time flags to be set before beginning execution.")
+    common-stanza-flag("pkg-cache")
+    common-stanza-flag("verbose")
+    common-stanza-flag("macros")
+    Flag("-", AllRemainingFlag, OptionalFlag,
+      "If provided, the remaining arguments after this flag will be set as the command line arguments for the REPL session.")]
+
+  ;Verify that the passed options are good.
+  defn verify-args (cmd-args:CommandArgs) :
+    ensure-proper-verbose-level!(cmd-args)
+
+  ;Main action for command
+  val launch-msg = "Debug Stanza files directly using the Stanza virtual machine."
+  defn launch-run (cmd-args:CommandArgs) :
+    within run-with-verbose-flag(cmd-args) :
+      read-config-file()
+
+      ;Add pkg directories to pkg-dirs
+      for dir in get?(cmd-args, "pkg", []) do :
+        STANZA-PKG-DIRS = cons(dir, STANZA-PKG-DIRS)
+
+      ;Add flags
+      for flag in get?(cmd-args, "flags", []) do :
+        add-flag(to-symbol(flag))
+
+      if not flag-defined?(`debug) : add-flag(`debug)
+
+      ;Add platform flag
+      add-flag(platform-flag(OUTPUT-PLATFORM))
+
+      ;Setup command line arguments.
+      val new-cmd-args = to-tuple $ cat(["debug"], get?(cmd-args, "-", []))
+      set-command-line-arguments(new-cmd-args)
+
+      ;Run in REPL
+      debug-in-repl(args(cmd-args),
+                    get?(cmd-args, "macros", []),
+                    get?(cmd-args, "pkg-cache", false))
+
+  ;Command definition
+  Command(
+    name = "debug",
+    argtype = AtLeastOneArg,
+    arg-description = "the .stanza/.proj input files or Stanza package names to execute in the virtual machine.",
+    flags = flags,
+    description = launch-msg,
+    verify = verify-args,
+    action = intercept-no-match-exceptions(launch-run))
+
 ;============================================================
 ;================= Dependency Analysis Command ==============
 ;============================================================
@@ -1181,6 +1240,7 @@ add-stanza-command(install-command())
 add-stanza-command(compile-command())
 add-stanza-command(repl-command())
 add-stanza-command(run-command())
+add-stanza-command(debug-command())
 add-stanza-command(compile-test-command())
 add-stanza-command(compile-macros-command())
 add-stanza-command(run-test-command())
diff --git a/compiler/packed-debug-table.stanza b/compiler/packed-debug-table.stanza
index edc1492ed..512d4445d 100644
--- a/compiler/packed-debug-table.stanza
+++ b/compiler/packed-debug-table.stanza
@@ -1,6 +1,9 @@
 defpackage stz/packed-debug-table :
   import core
   import collections
+  import stz/stable-arrays
+  import stz/vm
+  import stz/vm-table
 
 ;<doc>=======================================================
 ;====================== Documentation =======================
@@ -97,4 +100,87 @@ public defn pack (p:StaticPacker, t:DebugTable) -> False :
     emit-comment(p, "End of debug table")
 
   ;Launch!
-  emit-overall-table(t)
\ No newline at end of file
+  emit-overall-table(t)
+
+;============================================================
+;================= Dynamic Packing Algorithm ================
+;============================================================
+
+
+;The memory layout of the entire debug table.
+;public lostanza deftype DebugTableLayout :
+;  num-packages:long
+;  packages:ptr<PackageDebugInfoLayout> ...
+
+;The memory layout of the definitions within a specific package.
+;public lostanza deftype PackageDebugInfoLayout :
+;  num-entries:long
+;  package:ptr<byte>
+;  entries:DebugEntryLayout ...
+
+;The memory layout for the entry of one variable.
+;public lostanza deftype DebugEntryLayout :
+;  name:ptr<byte>
+;  offset:long
+
+public defn pack (t:DebugTable, vm:VirtualMachine) -> False :
+  val packages = packages(t)
+  val emitter = make-binary-emitter() where :
+    defn make-binary-emitter () :
+      var table-section-size:Int = 8 ;num-packages:long
+      var package-section-size:Int = 0
+      var string-section-size:Int = 0
+      for pkg in packages do :
+        table-section-size = table-section-size + 8 ;packages:ptr<PackageDebugInfoLayout>
+        val num-entries = length(entries(pkg))
+        val pkg-size = 16 + (num-entries * 16) ;num-entries:long + package:ptr<byte> + sizeof(DebugEntryLayout) * num-entries
+        package-section-size = package-section-size + pkg-size
+        string-section-size = string-section-size + size(name(pkg))
+        for e in entries(pkg) do :
+          string-section-size = string-section-size + size(name(e))
+      /make-binary-emitter(table-section-size, package-section-size, string-section-size, vm)
+  val global-offsets = global-offsets(vm)
+  table-section-emit(emitter, num-packages) where :
+    val num-packages = to-long(length(packages))
+  for pkg in packages do :
+    table-section-emit(emitter, package-section-pos(emitter))
+    package-section-emit(emitter, num-entries) where :
+      val num-entries = to-long(length(entries(pkg)))
+    package-section-emit(emitter, string-section-emit(emitter, name(pkg)))
+    for e in entries(pkg) do :
+      package-section-emit(emitter, string-section-emit(emitter, name(e)))
+      package-section-emit(emitter, global-offsets[offset(e)])
+lostanza defn make-binary-emitter (t-size:ref<Int>, p-size:ref<Int>, s-size:ref<Int>, vm:ref<VirtualMachine>) -> ref<DebugTableEmitter> :
+  val table-section-size = t-size.value
+  val package-section-size = p-size.value
+  val string-section-size = s-size.value
+  val table-section-start = call-c clib/malloc(table-section-size + package-section-size + string-section-size)
+  val package-section-start = table-section-start + table-section-size
+  val string-section-start = package-section-start + package-section-size
+  vm.vmstate.debug-table = table-section-start
+  return new DebugTableEmitter{table-section-start, package-section-start, string-section-start}
+lostanza deftype DebugTableEmitter :
+  var table-section-pos:ptr<?>
+  var package-section-pos:ptr<?>
+  var string-section-pos:ptr<?>
+lostanza defn package-section-pos (e:ref<DebugTableEmitter>) -> ref<Long> :
+  return new Long{e.package-section-pos as long}
+lostanza defn table-section-emit (e:ref<DebugTableEmitter>, x:ref<Long>) -> ref<False> :
+  e.table-section-pos = emit(e.table-section-pos, x.value)
+  return false
+lostanza defn package-section-emit (e:ref<DebugTableEmitter>, x:ref<Long>) -> ref<False> :
+  e.package-section-pos = emit(e.package-section-pos, x.value)
+  return false
+lostanza defn string-section-emit (e:ref<DebugTableEmitter>, s:ref<String>) -> ref<Long> :
+  val size = size(s).value
+  val p:ptr<?> = e.string-section-pos
+  e.string-section-pos = p + size
+  call-c clib/memcpy(p, addr!(s.chars), size)
+  return new Long{p as long}
+lostanza defn emit (p:ptr<long>, v:long) -> ptr<long> :
+  p[0] = v
+  return addr(p[1])
+defn size (s:String) :
+  length(s) + 1
+lostanza defn global-offsets (vm:ref<VirtualMachine>) -> ref<StableLongArray> :
+  return vm.vmtable.global-offsets
diff --git a/compiler/packed-safepoint-table.stanza b/compiler/packed-safepoint-table.stanza
index 55e5fe5b6..9f6d8748c 100644
--- a/compiler/packed-safepoint-table.stanza
+++ b/compiler/packed-safepoint-table.stanza
@@ -41,13 +41,13 @@ Binary Representation:
 public defstruct FileSafepoints :
   filename:String
   entries:Tuple<SafepointEntry>
-  
+
 ;Represents all of the locations for a given safepoint.
 public defstruct SafepointEntry :
   line:Int
   records:Tuple<SafepointRecord>
 
-;Represents a single safepoint. 
+;Represents a single safepoint.
 public defstruct SafepointRecord :
   location:SafepointLocation
   group:Int
@@ -61,7 +61,7 @@ public defstruct SafepointLabel <: SafepointLocation:
   id:Int
 
 ;Used for dynamically compiled code. Refers to the
-;address of the safepoint. 
+;address of the safepoint.
 public defstruct SafepointAddress <: SafepointLocation:
   address:Long
 
@@ -93,7 +93,7 @@ public defn pack (safepoints:Tuple<FileSafepoints>, packer:StaticPacker) -> Fals
   defn make-address-list (locs:Tuple<SafepointRecord>) -> Int :
     val l = make-label(packer)
     add(address-lists, l => locs)
-    l    
+    l
 
   ;Emit SafePointTable
   val filepointers = map(make-label{packer}, safepoints)
@@ -105,7 +105,7 @@ public defn pack (safepoints:Tuple<FileSafepoints>, packer:StaticPacker) -> Fals
   for (fp in filepointers, sp in safepoints) do :
     emit-label(packer, fp)
     emit(packer, to-long(length(entries(sp))))
-    emit-pointer-to-label(packer, make-string-label(filename(sp)))    
+    emit-pointer-to-label(packer, make-string-label(filename(sp)))
     for entry in entries(sp) do :
       emit(packer, to-long(line(entry)))
       emit-pointer-to-label(packer, make-address-list(records(entry)))
@@ -146,7 +146,7 @@ defsyntax safepoint-table :
   defproduction rec: SafepointRecord
   defrule rec = (?loc:#loc (group ?group:#int)) :
     SafepointRecord(loc, group)
-  
+
   defproduction loc: SafepointLocation
   defrule loc = (L[?id:#int]) : SafepointLabel(id)
   defrule loc = (A[?address:#int]) : SafepointAddress(to-long(address))
@@ -174,8 +174,8 @@ defn main () :
       filename: "myhelper.stanza"
       line 11 : (L[20] (group 0), L[21] (group 1))
       line 14 : (L[25] (group 1)))
-      
-  val label-counter = to-seq(100 to false)    
+
+  val label-counter = to-seq(100 to false)
   val test-packer = new StaticPacker :
     defmethod make-label (this) :
       next(label-counter)
diff --git a/compiler/params.stanza b/compiler/params.stanza
index fcb3780ef..47595633c 100644
--- a/compiler/params.stanza
+++ b/compiler/params.stanza
@@ -1,5 +1,5 @@
 ;See License.txt for details about licensing.
-
+()
 defpackage stz/params :
    import core
    import collections
diff --git a/compiler/repl.stanza b/compiler/repl.stanza
index 4ffe08a21..8a3635922 100644
--- a/compiler/repl.stanza
+++ b/compiler/repl.stanza
@@ -38,6 +38,7 @@ defpackage stz/repl :
   import stz/aux-file
   import core/sha256
   import stz/package-stamps
+  import stz/pkg-saver
   import stz/terminal-style
   import stz/macroexpander
   import stz/timing-log-api
@@ -45,7 +46,7 @@ defpackage stz/repl :
   import stz/verbose
   import stz/loaded-dynamic-libraries
   import stz/extern-defn-table
-  import stz/pkg-saver
+  import stz-debug/debugger
 
 ;============================================================
 ;====================== Timers ==============================
@@ -252,7 +253,7 @@ public defn register-initial-repl-syntax (name:Symbol) :
 ;============================================================
 ;==================== REPL Initial Load =====================
 ;============================================================
-public val REPL-INITIAL-LOAD-PACKAGES = Vector<Symbol|String>()
+public val REPL-INITIAL-LOAD-PACKAGES = to-vector<Symbol|String>([`core])
 public defn register-initial-repl-package (name:Symbol|String) :
   add(REPL-INITIAL-LOAD-PACKAGES, name)
 
@@ -278,9 +279,11 @@ defmulti inside (repl:REPL, package:Symbol|False) -> False
 defmulti clear (repl:REPL) -> False
 defmulti use-syntax (repl:REPL, inputs:Tuple<Symbol>, add-to-existing?:True|False) -> False
 defmulti shutdown (repl:REPL) -> False
+defmulti debug-files (repl:REPL, inputs:Tuple<String|Symbol>) -> False
 
 public defn REPL (macro-plugins:Tuple<String>,
-                  pkg-cache-dir:String|False) :
+                  pkg-cache-dir:String|False,
+                  debug?:True|False) :
   ;============================================================
   ;===================== REPL State ===========================
   ;============================================================
@@ -334,6 +337,20 @@ public defn REPL (macro-plugins:Tuple<String>,
   ;Load files
   ;Returns the name of the last package that was loaded if any.
   defn load-files (inputs:Tuple<String|Symbol>) -> Symbol|False :
+    val inputs* = load-inputs(inputs)
+    if not empty?(inputs*) :
+      within intercept-errors() :
+        val vmpackages = within log-time(REPL-COMPILE-TO-VMPACKAGES) :
+          compile-to-vmpackages(to-tuple(inputs*), live-recs, false, debug?)
+        load-dynamic-libraries(dylibs, proj-manager(), vmpackages)
+        within log-time(REPL-LOAD-INTO-VM) :
+          load(vm, vmpackages, false)
+        within log-time(REPL-INIT-PACKAGES) :
+          init-packages(vmpackages)
+        if not empty?(vmpackages) :
+          val n = length(vmpackages)
+          name(vmpackages[n - 1])
+  defn load-inputs (inputs:Tuple<String|Symbol>) :
     ;Load project files separately
     var proj-files-added?: True|False = false
     val inputs* = Vector<String|Symbol>()
@@ -348,19 +365,31 @@ public defn REPL (macro-plugins:Tuple<String>,
     ;Update the macroexpander if necessary.
     if proj-files-added? :
       set-proj-manager(macroexpander, proj-manager())
+    to-tuple(inputs*)
 
+  defn debug-files (inputs:Tuple<String|Symbol>) -> False :
+    val inputs* = load-inputs(inputs)
     if not empty?(inputs*) :
       within intercept-errors() :
         val vmpackages = within log-time(REPL-COMPILE-TO-VMPACKAGES) :
-          compile-to-vmpackages(to-tuple(inputs*), live-recs, false)
+          compile-to-vmpackages(to-tuple(inputs*), live-recs, false, debug?)
         load-dynamic-libraries(dylibs, proj-manager(), vmpackages)
         within log-time(REPL-LOAD-INTO-VM) :
           load(vm, vmpackages, false)
-        within log-time(REPL-INIT-PACKAGES) :
-          init-packages(vmpackages)
-        if not empty?(vmpackages) :
-          val n = length(vmpackages)
-          name(vmpackages[n - 1])
+        val app = new App :
+          defmethod state (this) :
+            get-state(vm)
+          defmethod run (this) :
+            init-packages(vmpackages)
+            0
+          defmethod stack-trace (this) :
+            collect-current-stack-trace(vm)
+          defmethod class-name (this, id:Int) :
+            class-name(id, vm)
+          defmethod stack-pointer (this) :
+            get-current-stack-pointer(vm)
+        debug(app)
+    false
 
   ;Ensure that a package is loaded
   defn ensure-package-loaded (package:Symbol) :
@@ -384,7 +413,7 @@ public defn REPL (macro-plugins:Tuple<String>,
   defn update-files () :
     within intercept-errors() :
       val inputs = changed-files(file-env)
-      val vmpackages = compile-to-vmpackages(inputs, live-recs, false)
+      val vmpackages = compile-to-vmpackages(inputs, live-recs, false, debug?)
       load-dynamic-libraries(dylibs, proj-manager(), vmpackages)
       load(vm, vmpackages, false)
       init-packages(vmpackages)
@@ -394,7 +423,7 @@ public defn REPL (macro-plugins:Tuple<String>,
     within log-time(REPL-RELOAD) :
       within intercept-errors() :
         val inputs = changed-files(file-env)
-        val vmpackages = compile-to-vmpackages(inputs, {[]}, false)
+        val vmpackages = compile-to-vmpackages(inputs, {[]}, false, debug?)
         load-dynamic-libraries(dylibs, proj-manager(), vmpackages)
         load(vm, vmpackages, false)
 
@@ -417,7 +446,7 @@ public defn REPL (macro-plugins:Tuple<String>,
   defn load-repl (form) :
     within intercept-errors() :
       val ipackage = to-ipackage(form)
-      val vmpackages = compile-to-vmpackages([ipackage], live-recs, name(ipackage))
+      val vmpackages = compile-to-vmpackages([ipackage], live-recs, name(ipackage), debug?)
       load-dynamic-libraries(dylibs, proj-manager(), vmpackages)
       load(vm, vmpackages, false)
       register-repl(repl-env, name(ipackage))
@@ -442,7 +471,8 @@ public defn REPL (macro-plugins:Tuple<String>,
 
   defn compile-to-vmpackages (inputs:Tuple<String|Symbol|IPackage>,
                               live-recs: Tuple<PackageIO> -> Tuple<Rec>,
-                              repl-package?:Symbol|False) -> Tuple<VMPackage> :
+                              repl-package?:Symbol|False,
+                              debug?:True|False) -> Tuple<VMPackage> :
     ;Compile to epackages
     val proj-manager = proj-manager()
     set-proj-manager(macroexpander, proj-manager)
@@ -466,6 +496,8 @@ public defn REPL (macro-plugins:Tuple<String>,
         false
       defmethod macroexpander (this) :
         macroexpander
+      defmethod debug? (this) :
+        debug?
 
     ;Register file associations with file environment.
     do(register{file-env, _}, pkgstamps(result))
@@ -496,7 +528,7 @@ public defn REPL (macro-plugins:Tuple<String>,
               val lowered = within log-time(REPL-LOWER-TO-UNOPTIMIZED) :
                 lower-unoptimized(p)
               within log-time(REPL-COMPILE-LOWERED) :
-                compile(lowered, false)
+                compile(lowered, debug?)
             vprintln("REPL: Done Compiling EPackage %_ to VMPackage." % [name(p)])
             if name(p) != repl-package? :
               save-when-appropriate(pkgsaver, StdPkg(vmp, false, false))
@@ -534,7 +566,6 @@ public defn REPL (macro-plugins:Tuple<String>,
   ;============================================================
   ;===================== REPL Structure =======================
   ;============================================================
-  load-files([`core])
   load-files(to-tuple(REPL-INITIAL-LOAD-PACKAGES))
   new REPL :
     defmethod load-files (this, inputs:Tuple<String|Symbol>, go-inside?:True|False) :
@@ -573,6 +604,8 @@ public defn REPL (macro-plugins:Tuple<String>,
         throw(ReplErrors([e]))
     defmethod shutdown (this) :
       shutdown(vm)
+    defmethod debug-files (this, inputs:Tuple<String|Symbol>) :
+      debug-files(inputs)
 
 ;============================================================
 ;==================== Externs ===============================
@@ -1007,7 +1040,7 @@ public defn repl (args:Tuple<String>,
                   style:TerminalStyle,
                   macro-plugins:Tuple<String>,
                   pkg-cache-dir:String|False) :
-  val repl = REPL(macro-plugins, pkg-cache-dir)
+  val repl = REPL(macro-plugins, pkg-cache-dir, false)
 
   ;Create a LoadExp expression out of the command line
   ;arguments. And execute them in the REPL.
@@ -1068,7 +1101,7 @@ public defn run-in-repl (args:Tuple<String>,
                          macro-plugins:Tuple<String>,
                          pkg-cache-dir:String|False) :
   val repl = within log-time(REPL-CREATION) :
-    REPL(macro-plugins, pkg-cache-dir)
+    REPL(macro-plugins, pkg-cache-dir, false)
   try:
     within log-time(REPL-EXP-EVALUATION) :
       eval-exp(repl, make-load-exp(args, false))
@@ -1076,7 +1109,31 @@ public defn run-in-repl (args:Tuple<String>,
     shutdown(repl)
 
 defn make-load-exp (args:Tuple<String>, go-inside?:True|False) :
-  val inputs = for a in args map :
+  Load(make-inputs(args), go-inside?)
+
+defn make-inputs (args:Tuple<String>) :
+  for a in args map :
     if index-of-char(a, '.') is Int : a
     else : to-symbol(a)
-  Load(inputs, go-inside?)
\ No newline at end of file
+
+;============================================================
+;=================== Debug Immediately ======================
+;============================================================
+
+;Debug the given arguments in the virtual
+;machine. Implements the 'stanza debug' command.
+public defn debug-in-repl (args:Tuple<String>,
+                           macro-plugins:Tuple<String>,
+                           pkg-cache-dir:String|False) :
+  val repl = REPL(macro-plugins, pkg-cache-dir, true)
+  try:
+    debug-files(repl, make-inputs(args))
+  finally:
+    shutdown(repl)
+
+lostanza defn get-state (vm:ref<VirtualMachine>) -> ref<AppState> :
+  return new AppState{vm.vmstate as ptr<core/VMState>}
+
+lostanza defn get-current-stack-pointer (vm:ref<VirtualMachine>) -> ref<Long> :
+  val current-stack = vm.vmstate.heap.current-stack as ref<Stack>
+  return new Long{current-stack.stack-pointer as long}
diff --git a/compiler/stitcher.stanza b/compiler/stitcher.stanza
index 3fb95579e..60865006b 100644
--- a/compiler/stitcher.stanza
+++ b/compiler/stitcher.stanza
@@ -339,16 +339,7 @@ public defn Stitcher (packages:Collection<VMPackage>, bindings:Bindings|False, s
     ;Each entry, gid => tag, means that the type with id 'gid'
     ;should be represented using tag 'tag'.
     val core-tag-table = IntTable<Int>()
-    for entry in [CORE-FALSE-ID => FALSE-TYPE
-                  CORE-TRUE-ID => TRUE-TYPE
-                  CORE-BYTE-ID => BYTE-TYPE
-                  CORE-CHAR-ID => CHAR-TYPE
-                  CORE-INT-ID => INT-TYPE
-                  CORE-FLOAT-ID => FLOAT-TYPE
-                  CORE-STACK-ID => STACK-TYPE
-                  CORE-FN-ID => FN-TYPE
-                  CORE-TYPE-ID => TYPE-TYPE
-                  CORE-LIVENESS-TRACKER-ID => LIVENESS-TRACKER-TYPE] do :
+    for entry in FIXED-TYPE-IDS do :
       val gid = id-indices[key(entry)]
       core-tag-table[gid] = value(entry)
 
diff --git a/compiler/vm-analyze.stanza b/compiler/vm-analyze.stanza
index 044d3dae9..abf1e22b3 100644
--- a/compiler/vm-analyze.stanza
+++ b/compiler/vm-analyze.stanza
@@ -87,7 +87,7 @@ public defn analyze (func:VMFunc) -> VMFunc :
         loop(i + 1, i + 1)
       else :
         loop(i + 1, current-start)
-        
+
     if i < num-ins :
       val ins = ins(func)[i]
       match(ins) :
@@ -103,7 +103,7 @@ public defn analyze (func:VMFunc) -> VMFunc :
           ;Add successors
           for dest in ins do-dest :
             add(successors, current-start, Label(dest))
-            
+
           ;Start next block
           loop(i + 1, i + 1)
         (ins:VMIns&OperationIns) :
@@ -123,10 +123,10 @@ public defn analyze (func:VMFunc) -> VMFunc :
     defd[start] = to-list(def-set)
     clear(def-set)
     clear(use-set)
-    
+
   ;Start from first instruction
   loop(0, 0)
-  
+
   ;Backpatch label destinations
   for entry in successors map! :
     for dest in value(entry) map :
@@ -146,7 +146,7 @@ public defn analyze (func:VMFunc) -> VMFunc :
   propagate(set1, set2) where :
     val set1 = IntSet()
     add-all(set1, ordering)
-    val set2 = IntSet()    
+    val set2 = IntSet()
     defn* propagate (update:IntSet, dirty:IntSet) :
       for b in ordering do :
         if update[b] :
@@ -168,7 +168,7 @@ public defn analyze (func:VMFunc) -> VMFunc :
                 add(dirty, p)
       if not empty?(dirty) :
         propagate(dirty, update)
-  
+
   ;Print out result
   ;println("Analyzing function:")
   ;within indented() :
@@ -214,7 +214,7 @@ public defn analyze (func:VMFunc) -> VMFunc :
   val allocations = allocate(usages, num-usages)
   ;println("===== Variable Allocations =====")
   ;within indented() :
-  ;  do(println, allocations)      
+  ;  do(println, allocations)
 
   ;Compute which values are references
   val ref-set = IntSet()
@@ -229,12 +229,12 @@ public defn analyze (func:VMFunc) -> VMFunc :
     clear(use-set)
     for s in successors![b] do :
       add-all(use-set, used[s])
-    
+
     ;Utility functions
     defn add-use (v:Int) : add(use-set, v)
     defn remove-use (v:Int) : remove(use-set, v)
     defn used-locals () : to-tuple(seq(Local, filter({ref-set[_]}, use-set)))
-    
+
     ;Sweep through instructions backwards
     for i in reverse(b through last-i) do :
       val ins = ins(func)[i]
@@ -247,11 +247,12 @@ public defn analyze (func:VMFunc) -> VMFunc :
           add(ins-buffer, ins)
           do-args(add-use, ins)
         (ins:VMIns&OperationIns) :
-          add(ins-buffer, ins)
           do-results(remove-use, ins)
+          add(ins-buffer, ins)
           if leaves-frame?(ins) :
+            ;After code reversal RecordLiveIns precedes leaving frame instruction
             add(ins-buffer, RecordLiveIns(used-locals()))
-          do-args(add-use, ins)          
+          do-args(add-use, ins)
   reverse!(ins-buffer)
 
   ;println("===== Calculated Liveness =====")
@@ -262,7 +263,7 @@ public defn analyze (func:VMFunc) -> VMFunc :
   val defs* = for def in defs(func) map :
     VMDef(id(def), type(def), get?(allocations, id(def), 0))
   sub-defs(sub-ins(func, to-tuple(ins-buffer)), defs*)
-      
+
 defn add<?T> (t:IntTable<List<?T>>, i:Int, v:T) :
   update(t, cons{v, _}, i)
 
@@ -275,7 +276,7 @@ with: (printer => true)
 ;================= Allocation Algorithm =====================
 ;============================================================
 
-defn allocate (usages:Vector<Use>, num-usages:IntTable<Int>) :  
+defn allocate (usages:Vector<Use>, num-usages:IntTable<Int>) :
   ;Declare tables
   val freelist = FreeIndexList()
   val slot-table = IntTable<Int>() ;slot-table[variable] = slot-index
@@ -311,7 +312,7 @@ deftype DestinationIns :
   Branch1Ins <: DestinationIns
   Branch2Ins <: DestinationIns
   ReturnIns <: DestinationIns
-  TCallIns <: DestinationIns  
+  TCallIns <: DestinationIns
   TCallClosureIns <: DestinationIns
   MatchIns <: DestinationIns
   DispatchIns <: DestinationIns
@@ -338,7 +339,7 @@ deftype OperationIns :
   SafepointIns <: OperationIns
 
 ;Assumes that the results are loaded from registers in sequential order,
-;and that we are sweeping through instructions backwards. 
+;and that we are sweeping through instructions backwards.
 ;Therefore sweeps through results in opposite order.
 ;Example: (x, y) = __
 ;         __ = (x)
@@ -347,14 +348,14 @@ deftype OperationIns :
 ;         Ly = __
 ;         __ = Lx
 ;Therefore it is important that Lx is still considered live
-;when local for Ly is assigned. 
+;when local for Ly is assigned.
 
 defn do-results (func:Int -> ?, i:OperationIns) :
   defn f? (x:Local|VMType|False) :
     match(x:Local) : func(index(x))
   defn f? (xs:Seqable<Local|VMType>) :
-    do(f?, xs)    
-    
+    do(f?, xs)
+
   match(i) :
     (i:CallIns) : f?(in-reverse(xs(i)))
     (i:CallClosureIns) : f?(in-reverse(xs(i)))
@@ -378,8 +379,8 @@ defn do-args (func:Int -> ?, i:OperationIns|DestinationIns) :
   defn f? (y:VMImm|False) :
     match(y:Local) : func(index(y))
   defn f? (ys:Tuple<VMImm>) :
-    do(f?, ys)  
-    
+    do(f?, ys)
+
   match(i) :
     (i:CallIns) : (f?(f(i)), f?(ys(i)))
     (i:CallClosureIns) : (f?(f(i)), f?(ys(i)))
@@ -424,7 +425,7 @@ defn do-dest (f:Int -> ?, i:DestinationIns) :
 
 defn leaves-frame? (i:OperationIns) :
   match(i) :
-    (i:CallIns|CallClosureIns|CallCIns|YieldIns|AllocIns) : true
+    (i:CallIns|CallClosureIns|CallCIns|YieldIns|AllocIns|SafepointIns) : true
     (i:Op1Ins) : leaves-frame?(op(i))
     (i) : false
 
@@ -467,7 +468,7 @@ defn FreeIndexList () :
     swap(x, items[len])
     len = len + 1
 
-  defn make-item () :    
+  defn make-item () :
     val x = length(items)
     add(items, x)
     add(indices, x)
@@ -478,7 +479,7 @@ defn FreeIndexList () :
     val item = items[len]
     take-item(item)
     item
-    
+
   new FreeIndexList :
     defmethod next (this) : next-free()
     defmethod free (this, x:Int) : free-item(x)
diff --git a/compiler/vm-ids.stanza b/compiler/vm-ids.stanza
index 94ceaa0d6..a38aa90ca 100644
--- a/compiler/vm-ids.stanza
+++ b/compiler/vm-ids.stanza
@@ -8,6 +8,7 @@ defpackage stz/vm-ids :
   import stz/const-pool
   import stz/loaded-dynamic-libraries
   import stz/extern-defn-table
+  import stz/packed-debug-table
 
 ;<doc>=======================================================
 ;================== VirtualMachine Ids ======================
@@ -70,22 +71,7 @@ public defmulti package-init (ids:VMIds, package:Symbol) -> Int|False
 public defn VMIds (dylibs:LoadedDynamicLibraries,
                    extern-defns:ExternDefnTable) :
   ;Fixed Ids
-  val fixed-ids = [
-    CORE-EXTEND-HEAP-ID => EXTEND-HEAP-FN
-    CORE-EXTEND-STACK-ID => EXTEND-STACK-FN
-    CORE-INIT-CONSTS-ID => INIT-CONSTS-FN
-    CORE-EXECUTE-TOPLEVEL-COMMAND-ID => EXECUTE-TOPLEVEL-COMMAND-FN    
-    CORE-FALSE-ID => FALSE-TYPE
-    CORE-TRUE-ID => TRUE-TYPE
-    CORE-BYTE-ID => BYTE-TYPE
-    CORE-CHAR-ID => CHAR-TYPE
-    CORE-INT-ID => INT-TYPE
-    CORE-FLOAT-ID => FLOAT-TYPE
-    CORE-STACK-ID => STACK-TYPE
-    CORE-FN-ID => FN-TYPE
-    CORE-TYPE-ID => TYPE-TYPE
-    CORE-LIVENESS-TRACKER-ID => LIVENESS-TRACKER-TYPE,
-    CORE-UNIQUE-ID => UNIQUE-TYPE]
+  val fixed-ids = to-tuple(cat(FIXED-TYPE-IDS, BUILTIN-FUNCTION-IDS))
 
   ;Fundamental State
   val id-table = HashTable<RecId,Int>()
@@ -96,7 +82,9 @@ public defn VMIds (dylibs:LoadedDynamicLibraries,
   val const-pool = ConstantPool()
   val package-inits = HashTable<Symbol,Int|False>()
   val callback-table = IntTable<Int>()
-  
+  val safepoint-counter = to-seq(0 to false)
+  val safepoint-group-counter = to-seq(0 to false)
+
   ;Generating new ids
   defn id-counter (pred:RecId -> True|False) :
     val vs = seq(value, filter(pred{key(_)}, fixed-ids))
@@ -105,7 +93,7 @@ public defn VMIds (dylibs:LoadedDynamicLibraries,
   val code-id-counter = id-counter({_ is FnId})
   val class-id-counter = id-counter({_ is TypeId})
   val global-id-counter = id-counter({_ is ValId})
-  
+
   ;Dependency Tracking
   val function-dependencies = Vector<Tuple<Rec>>()
   val class-dependencies = Vector<Tuple<Rec>>()
@@ -169,42 +157,87 @@ public defn VMIds (dylibs:LoadedDynamicLibraries,
       val classes = Vector<LoadedClass>()
       val funcs = Vector<VMDefn>()
       val callbacks = Vector<Callback>()
+      val global-debug-table = Vector<PackageDebugInfo>()
+      val safepoints = make-safepoint-table() where :
+        defn make-safepoint-table () :
+          ;Let's ignore file 'base' for now. stitcher-safepoints ignores 'base' too.
+          HashTable-init<String, Vector<VMSafepointInfo>>(make-file-table)
+        defn make-file-table (file:String) :
+          Vector<VMSafepointInfo>()
       store-exported-recs-in-id-table(seq(packageio, pkgs))
       for pkg in pkgs do :
         val local-to-global-map = local-to-global-table(pkg)
+        val local-safepoint-map = local-to-global-safepoints(pkg)
         record-package-init(pkg, local-to-global-map)
         add(packages, make-load-package(pkg, local-to-global-map))
         add-all(classes, resolved-classes(pkg, local-to-global-map))
-        add-all(funcs, resolved-defns(pkg, local-to-global-map))
+        add-all(funcs, resolved-defns(pkg, local-to-global-map, local-safepoint-map))
         add-all(callbacks, resolved-callbacks(pkg, local-to-global-map))
+        val global-debug-entries = to-tuple $ for e in filter(global?, entries(debug-name-table(pkg))) seq :
+          DebugEntry(name(e), local-to-global-map[id(e)]) ;Use id instaed of not-yet-known offset
+        if not empty?(global-debug-entries) :
+          add(global-debug-table, PackageDebugInfo(to-string(name(pkg)), global-debug-entries))
         val iotable = IOTable(packageio(pkg))
         record-dependencies(iotable, local-to-global-map, /classes(pkg))
         record-dependencies(iotable, local-to-global-map, /funcs(pkg))
+        val safepoint-group-table = IntTable-init<Int>(next{safepoint-group-counter})
+        for file in files(safepoint-table(pkg)) do :
+          val file-safepoints = safepoints[filename(file)]
+          for entry in entries(file) do :
+            val id = local-safepoint-map[id(entry)]
+            val group = safepoint-group-table[group(entry)]
+            add(file-safepoints, VMSafepointInfo(id, line(entry), column(entry), group))
+      val safepoint-table = to-tuple $ for file-entry in safepoints seq :
+        val filename = key(file-entry)
+        val entries = to-tuple(qsort(value(file-entry), is-less?)) where :
+          defn is-less? (a:VMSafepointInfo, b:VMSafepointInfo) :
+            if line(a) == line(b) :
+              if column(a) == column(b) :
+                id(a) < id(b)
+              else :
+                column(a) < column(b)
+            else :
+              line(a) < line(b)
+        VMFileSafepoints("", filename, entries)
       LoadUnit(
         to-tuple(packages),
         form-new-datas(data-pool, num-existing-datas),
         form-new-consts(const-pool, num-existing-classes),
         to-tuple(classes),
         to-tuple(funcs),
-        to-tuple(callbacks))
+        to-tuple(callbacks),
+        DebugTable(to-tuple(global-debug-table)),
+        safepoint-table,
+        next(safepoint-counter))
 
-    ;Resolve all ids in the given item using the given given global-ids table.
+    ;Resolve all ids in the given item using given global-ids table.
     ;- x: The item to resolve ids for.
     ;- global-ids: The table containing the mapping from old to new ids.
     defn resolve-ids<?T> (x:VMItem&?T, global-ids:IntTable<Int>) -> T :
       defn resolve (x:VMItem) : map-id({global-ids[_]}, vm-map(resolve,x))
       resolve(x) as VMItem&T
 
+    ;Compute table mapping local ids of safepoints to a globally unique
+    ;safepoint id.
+    defn local-to-global-safepoints (pkg:VMPackage) -> IntTable<Int> :
+      val mapping = IntTable<Int>()
+      for file in files(safepoint-table(pkg)) do :
+        for entry in entries(file) do :
+          val local-id = id(entry)
+          val global-id = next(safepoint-counter)
+          mapping[local-id] = global-id
+      mapping
+
     ;Compute table mapping locals to globals for definitions in package.
     defn local-to-global-table (pkg:VMPackage) -> IntTable<Int> :
       ;Create the mapping table.
       val mapping-table = IntTable<Int>()
-      
+
       ;First, all exported records already have assigned ids, so look
       ;them up.
       for i in cat(imports(packageio(pkg)), exports(packageio(pkg))) do :
         mapping-table[n(i)] = id-table[id(rec(i))]
-        
+
       ;Private definitions that are not exported will not
       ;have any ids yet, so create global ids for any remaining items.
       defn create-ids<?T> (entries: VMPackage -> Tuple<?T>,
@@ -217,7 +250,7 @@ public defn VMIds (dylibs:LoadedDynamicLibraries,
       create-ids(classes, id, next{class-id-counter})
       create-ids(funcs, id, next{code-id-counter})
       create-ids(externs, id, id{dylibs, name(pkg), name(_)})
-      
+
       ;Then create ids for datas and consts
       for d in datas(pkg) do :
         val local-id = id(d)
@@ -234,7 +267,7 @@ public defn VMIds (dylibs:LoadedDynamicLibraries,
         val gid = mapping-table[fid(e)]
         if not key?(callback-table, gid) :
           callback-table[gid] = id(extern-defns, lbl(e))
-        
+
       ;Return ids
       mapping-table
 
@@ -258,21 +291,27 @@ public defn VMIds (dylibs:LoadedDynamicLibraries,
         LoadedClass(name(pkg), resolve-ids(c, local-to-global-map))
 
     ;Resolve a single func
-    defn resolved-defn (func:VMDefn, local-to-global-map:IntTable<Int>) :
+    defn resolved-defn (func:VMDefn,
+                        local-to-global-map:IntTable<Int>,
+                        local-to-global-safepoints:IntTable<Int>) :
       defn gid (n:Int) : local-to-global-map[n]
       defn resolve-ids (x:VMItem) :
         match(x) :
           (x:ExternDefnId) : ExternDefnId(callback-table[gid(id(x))])
+          (x:SafepointIns) : SafepointIns(local-to-global-safepoints[id(x)], trace-entry!(x))
           (x) : map-id(gid, vm-map(resolve-ids, x))
       new VMDefn :
         defmethod id (this) : gid(id(func))
         defmethod dependencies (this) : map(gid, dependencies(func))
-        defmethod func (this) : resolve-ids(/func(func)) as VMFunction
+        defmethod func (this) :
+          resolve-ids(/func(func)) as VMFunction
 
     ;Resolve all funcs from packages
-    defn resolved-defns (pkg:VMPackage, local-to-global-map:IntTable<Int>) :
+    defn resolved-defns (pkg:VMPackage,
+                         local-to-global-map:IntTable<Int>,
+                         local-to-global-safepoints:IntTable<Int>) :
       for f in funcs(pkg) seq :
-        resolved-defn(f, local-to-global-map)
+        resolved-defn(f, local-to-global-map, local-to-global-safepoints)
 
     ;Resolve all Callbacks for extern defns
     defn resolved-callbacks (pkg:VMPackage, local-to-global-map:IntTable<Int>) :
@@ -287,7 +326,7 @@ public defn VMIds (dylibs:LoadedDynamicLibraries,
         val ds = map({iotable[_]}, dependencies(c))
         val global-id = local-to-global-map[id(c)]
         put(class-dependencies, global-id, ds, [])
-        
+
     ;Record function dependencies
     defn record-dependencies (iotable:IOTable, local-to-global-map:IntTable<Int>, funcs:Tuple<VMDefn>) :
       for f in funcs do :
@@ -305,7 +344,7 @@ public defn VMIds (dylibs:LoadedDynamicLibraries,
     defn form-new-consts (pool:ConstantPool, num-existing-consts:Int) :
       val values = consts(pool)
       to-tuple $ for i in num-existing-consts to length(values) seq :
-        VMConst(i, values[i])        
+        VMConst(i, values[i])
 
     ;Launch
     driver()
@@ -313,7 +352,7 @@ public defn VMIds (dylibs:LoadedDynamicLibraries,
   ;Return datastructure
   new VMIds :
     defmethod package-init (this, pkg:Symbol) :
-      package-inits[pkg]      
+      package-inits[pkg]
     defmethod class-rec (this, global-id:Int) :
       get?(class-recs, global-id, false) as StructRec|TypeRec|False
     defmethod function-dependencies (this, f:Int) :
@@ -329,7 +368,7 @@ deftype CodeRec :
   ExternFnRec <: CodeRec
 deftype ClassRec :
   StructRec <: ClassRec
-  TypeRec <: ClassRec  
+  TypeRec <: ClassRec
 
 ;============================================================
 ;=============== Vector Utility Functions ===================
@@ -345,3 +384,52 @@ defn put<?T> (xs:Vector<?T>, i:Int, v:T, default:T) :
 defn get?<?T> (xs:Vector<?T>, i:Int, default:?T) :
   xs[i] when i < length(xs) else default
 
+;============================================================
+;================== Storing Safepoints ======================
+;============================================================
+;<comment>
+;Stores all the safepoints from all packages.
+;The ids of the safepoints will be globally unique.
+defstruct AllSafepoints :
+  id-counter:Seq<Int>
+  file-safepoints:Vector<FileSafepoints>
+
+;Holds all of the safepoints in a specific file.
+;The ids of all the safepoints will be globally unique.
+defstruct FileSafepoints :
+  base:String
+  filename:String
+  safepoints:Vector<VMSafepointInfo>
+
+;Add all of the safepoints from the given file to the table
+;of all safepoints.
+;Returns the mapping of local ids to global ids.
+;Each entry, LID => GID, means that:
+;- LID is the package local id for the safepoint.
+;- GID is the globally unique id for the safepoint.
+defn add-safepoints (table:AllSafepoints,
+                     file:VMFileSafepoints) ->
+                     Vector<KeyValue<Int,Int>> :
+  val mapping = Vector<KeyValue<Int,Int>>()
+  val file-safepoints = get-file-safepoints(table, base(file), filename(file))
+  for entry in entries(file) do :
+    val new-id = next(id-counter(table))
+    add(mapping, id(entry) => new-id)
+    val new-entry = sub-id(entry, new-id)
+    add(safepoints(file-safepoints), new-entry)
+  mapping
+
+;Helper: Retrieve the 'FileSafepoints' table corresponding to
+;the given base and filename.
+defn get-file-safepoints (table:AllSafepoints,
+                          base:String,
+                          filename:String) -> FileSafepoints:
+  val safepoints =
+    for file in file-safepoints(table) find :
+      /base(file) == base and
+      /filename(file) == filename
+
+  match(safepoints:FileSafepoints) :
+    safepoints
+  else :
+;<comment>
\ No newline at end of file
diff --git a/compiler/vm-ir.stanza b/compiler/vm-ir.stanza
index deb57da88..f845e7b2b 100644
--- a/compiler/vm-ir.stanza
+++ b/compiler/vm-ir.stanza
@@ -24,9 +24,48 @@ public val STACK-TYPE = 6
 public val FN-TYPE = 7
 public val TYPE-TYPE = 8
 public val LIVENESS-TRACKER-TYPE = 9
-public val NUM-BUILTIN-CONCRETE-TYPES = 10
-public val UNIQUE-TYPE = 10
-public val NUM-BUILTIN-TYPES = 11
+public val DOUBLE-TYPE = 10
+public val STRING-TYPE = 11
+public val STRING-SYMBOL-TYPE = 12
+public val BOX-TYPE = 13
+public val TUPLE-TYPE = 14
+public val BYTE-ARRAY-TYPE = 15
+public val CHAR-ARRAY-TYPE = 16
+public val INT-ARRAY-TYPE = 17
+public val LONG-ARRAY-TYPE = 18
+public val FLOAT-ARRAY-TYPE = 19
+public val DOUBLE-ARRAY-TYPE = 20
+public val FULL-LIST-TYPE = 21
+public val NIL-LIST-TYPE = 22
+public val NUM-BUILTIN-CONCRETE-TYPES = 23
+public val UNIQUE-TYPE = 23
+public val NUM-BUILTIN-TYPES = 24
+
+public val FIXED-TYPE-IDS = [
+  CORE-FALSE-ID => FALSE-TYPE
+  CORE-TRUE-ID => TRUE-TYPE
+  CORE-BYTE-ID => BYTE-TYPE
+  CORE-CHAR-ID => CHAR-TYPE
+  CORE-INT-ID => INT-TYPE
+  CORE-FLOAT-ID => FLOAT-TYPE
+  CORE-DOUBLE-ID => DOUBLE-TYPE
+  CORE-STACK-ID => STACK-TYPE
+  CORE-FN-ID => FN-TYPE
+  CORE-TYPE-ID => TYPE-TYPE
+  CORE-LIVENESS-TRACKER-ID => LIVENESS-TRACKER-TYPE
+  CORE-STRING-ID => STRING-TYPE
+  CORE-STRING-SYMBOL-ID => STRING-SYMBOL-TYPE
+  CORE-BOX-ID => BOX-TYPE
+  CORE-TUPLE-ID => TUPLE-TYPE
+  CORE-FULL-LIST-ID => FULL-LIST-TYPE
+  CORE-NIL-LIST-ID => NIL-LIST-TYPE
+  CORE-BYTE-ARRAY-ID => BYTE-ARRAY-TYPE
+  CORE-CHAR-ARRAY-ID => CHAR-ARRAY-TYPE
+  CORE-INT-ARRAY-ID => INT-ARRAY-TYPE
+  CORE-LONG-ARRAY-ID => LONG-ARRAY-TYPE
+  CORE-FLOAT-ARRAY-ID => FLOAT-ARRAY-TYPE
+  CORE-DOUBLE-ARRAY-ID => DOUBLE-ARRAY-TYPE
+]
 
 public val EXTEND-HEAP-FN = 0
 public val EXTEND-STACK-FN = 1
@@ -34,6 +73,13 @@ public val INIT-CONSTS-FN = 2
 public val EXECUTE-TOPLEVEL-COMMAND-FN = 3
 public val NUM-BUILTIN-FNS = 4
 
+public val BUILTIN-FUNCTION-IDS = [
+  CORE-EXTEND-HEAP-ID => EXTEND-HEAP-FN
+  CORE-EXTEND-STACK-ID => EXTEND-STACK-FN
+  CORE-INIT-CONSTS-ID => INIT-CONSTS-FN
+  CORE-EXECUTE-TOPLEVEL-COMMAND-ID => EXECUTE-TOPLEVEL-COMMAND-FN
+]
+
 ;============================================================
 ;================== Design of Instructions ==================
 ;============================================================
@@ -141,12 +187,12 @@ public defstruct VMDefn :
 
 ;Indicates that the function 'fid' is called externally.
 ;- lbl: If given, the static label of this function. When statically-compiled,
-;  this label is exposed for use by external code. 
+;  this label is exposed for use by external code.
 ;- fid: The 'id' of the function of the body. Function is guaranteed
 ;  to be a VMFunc object.
 ;- a1: The argument types of the function. Guaranteed to be
 ;  consistent with the 'fid' definition.
-;- a2: The return type of the function. 
+;- a2: The return type of the function.
 public defstruct VMExternDefn :
   lbl: Symbol|False
   fid: Int with: (updater => sub-fid)
@@ -357,7 +403,7 @@ public defstruct DerefOp <: VMOp
 public defstruct VMDebugNameTable :
   entries: Tuple<VMDebugName>
 
-;Represents a human-readable name for the given
+ ;Represents a human-readable name for the given
 ;identifier.
 ;- global?: If true, then 'id' refers to a package global. Otherwise,
 ;  it refers to a function-local definition.
@@ -394,11 +440,21 @@ public defstruct VMFileSafepoints :
   entries:Tuple<VMSafepointInfo>
 
 public defstruct VMSafepointInfo :
-  id:Int
+  id:Int with: (updater => sub-id)
   line:Int
   column:Int
   group:Int
 
+;------------------------------------------------------------
+;---------------------- Locals Table ------------------------
+;------------------------------------------------------------
+
+public defstruct NamedLocalVar :
+  stack-offset:Int
+  name:String
+with:
+  printer => true
+
 ;============================================================
 ;==================== Convenience ===========================
 ;============================================================
@@ -802,7 +858,7 @@ defmethod print (o:OutputStream, t:VMDebugNameTable) :
 defmethod print (o:OutputStream, e:VMDebugName) :
   val global-str = "global " when global?(e)
               else "local "
-  print(o, "debugname %_L%_ (name = %~)" % [id(e), global-str, name(e)])
+  print(o, "debugname %_L%_ (name = %~)" % [global-str, id(e), name(e)])
 
 defmethod print (o:OutputStream, x:VMDebugInfoTable) :
   if empty?(entries(x)) :
diff --git a/compiler/vm-load-unit.stanza b/compiler/vm-load-unit.stanza
index 8c7dccc8e..b68d82208 100644
--- a/compiler/vm-load-unit.stanza
+++ b/compiler/vm-load-unit.stanza
@@ -2,6 +2,7 @@ defpackage stz/vm-load-unit :
   import core
   import collections
   import stz/vm-ir
+  import stz/packed-debug-table
   import stz/printing-utils
 
 ;<doc>=======================================================
@@ -50,7 +51,7 @@ All newly defined extern defn callbacks are listed here.
 
 Within each function:
   ExternId will refer to the index of the address of the extern.
-  ExternDefnId will refer to the index of the callback. 
+  ExternDefnId will refer to the index of the callback.
 
 ;============================================================
 ;=======================================================<doc>
@@ -62,6 +63,9 @@ public defstruct LoadUnit :
   classes: Tuple<LoadedClass>
   funcs: Tuple<VMDefn>
   callbacks: Tuple<Callback>
+  debug-table: DebugTable
+  safepoints: Tuple<VMFileSafepoints>
+  max-safepoint-id: Int
 
 public defstruct LoadedClass :
   package:Symbol
diff --git a/compiler/vm-table.stanza b/compiler/vm-table.stanza
index cdc7f5427..dd23c0cfb 100644
--- a/compiler/vm-table.stanza
+++ b/compiler/vm-table.stanza
@@ -40,7 +40,7 @@ defpackage stz/vm-table :
 public lostanza deftype VMTable :
   ;Branches
   branch-table:ref<BranchTable>
-  
+
   ;Globals
   global-table:ref<Vector<LoadedGlobal|False>>      ;For globals
   var global-offsets:ref<StableLongArray>           ;For global offsets
@@ -64,7 +64,7 @@ public lostanza deftype VMTable :
   var function-addresses:ref<StableLongArray>
 
   ;Trace Entries
-  trace-table:ref<HashTable<Long,StackTraceInfo>>           
+  trace-table:ref<HashTable<Long,StackTraceInfo>>
 
 ;============================================================
 ;======================= Initialization =====================
@@ -76,7 +76,7 @@ public lostanza defn VMTable (class-table:ref<ClassTable>,
   return new VMTable{
     ;Branches
     branch-table,
-    
+
     ;Globals
     Vector<LoadedGlobal|False>(),
     StableLongArray(new Int{32}, new Long{-1L}),
@@ -98,7 +98,7 @@ public lostanza defn VMTable (class-table:ref<ClassTable>,
 
     ;Functions
     StableLongArray(new Int{1024}, new Long{-1}),
-    
+
     ;Trace Table
     HashTable<Long,StackTraceInfo>()}
 
@@ -129,16 +129,16 @@ public defn ClassTable () :
   defn instanceof? (child:Int, t:TypeSet) :
     for p in t test-instanceof? :
       parent?(class-tree, child, type(p))
-    
+
   new ClassTable :
     defmethod add (this, cs:Collection<LoadedClass>) :
       ;Add the classes to the class dynamic tree.
       defn node-state (c:VMClass) -> NodeState :
         match(c) :
           (c:VMAbstractClass) : NodeState(id(c), parents(c), children(c), false)
-          (c) : NodeState(id(c), parents(c), [], true)      
+          (c) : NodeState(id(c), parents(c), [], true)
       add(class-tree, seq(node-state{class(_)}, cs))
-      
+
       ;Add the classes to the packed class table.
       defn record? (c:VMClass) -> Maybe<ClassTableRecord> :
         match(c) :
@@ -152,10 +152,10 @@ public defn ClassTable () :
             None()
       val records = to-tuple(seq?(record?{class(_)}, cs))
       packed-table = pack(records, packed-table)
-      
+
       ;Add the classes to the class table.
       for c in cs do :
-        class-table[id(class(c))] = c        
+        class-table[id(class(c))] = c
     defmethod add (this, l:TreeListener) :
       add(class-tree, l)
     defmethod get (this, c:Int) :
@@ -361,7 +361,7 @@ lostanza defn non-negative? (xs:ref<Array<Int>>, i:ref<Int>) -> long :
     else : return 0L
   else :
     return 0L
-  
+
 ;============================================================
 ;===================== Function Loading =====================
 ;============================================================
@@ -370,18 +370,18 @@ public lostanza defn load-function (vmt:ref<VMTable>,
                                     func:ref<VMDefn>,
                                     externfn?:ref<True|False>,
                                     resolver:ref<EncodingResolver>,
-                                    backend:ref<Backend>) -> ref<False> :
+                                    backend:ref<Backend>) -> ref<LoadedFunction> :
   ;Encode the function and load it into the code table.
-  val load-result = load-function(vmt.code-table, id(func), /func(func), externfn?, resolver, backend)
+  val loaded-function = load-function(vmt.code-table, id(func), /func(func), externfn?, resolver, backend)
 
   ;Store the function address into the function-addresses table.
   val id = id(func)
-  vmt.function-addresses = put(vmt.function-addresses, id, address(load-result), new Long{-1})
+  vmt.function-addresses = put(vmt.function-addresses, id, address(loaded-function), new Long{-1})
 
   ;Store the fileinfos into fileinfo table.
-  load-trace-entries(vmt, trace-entries(load-result))
+  load-trace-entries(vmt, trace-entries(loaded-function))
 
-  return false
+  return loaded-function
 
 ;============================================================
 ;========================= Utility ==========================
diff --git a/compiler/vm.stanza b/compiler/vm.stanza
index 9277ce400..3ccf26ca3 100644
--- a/compiler/vm.stanza
+++ b/compiler/vm.stanza
@@ -1,31 +1,35 @@
 defpackage stz/vm :
   import core
+  import core/local-table
+  import core/safepoints
+  import core/sighandler
+  import core/stack-trace
   import collections
-  import stz/vm-ir
-  import stz/vm-load-unit
-  import stz/typeset
-  import stz/vm-table
-  import stz/vm-ids
-  import stz/dl-ir
+  import stz/absolute-info
+  import stz/backend
   import stz/basic-ops
-  import stz/stable-arrays
   import stz/branch-table
-  import stz/backend
-  import stz/utils
-  import stz/extern-intrinsics
   import stz/code-table
+  import stz/code-template-table
   import stz/cvm-code-table
+  import stz/dl-ir
+  import stz/extern-defn-table
+  import stz/extern-intrinsics
   import stz/jit-code-table
-  import stz/vm-structures
+  import stz/loaded-dynamic-libraries
+  import stz/packed-debug-table
   import stz/params
+  import stz/stable-arrays
   import stz/timing-log-api
-  import stz/verbose
-  import stz/loaded-dynamic-libraries
-  import stz/extern-defn-table
-  import stz/code-template-table
-  import stz/absolute-info
   import stz/trace-info
-  import core/stack-trace
+  import stz/typeset
+  import stz/utils
+  import stz/verbose
+  import stz/vm-ids
+  import stz/vm-ir
+  import stz/vm-load-unit
+  import stz/vm-structures
+  import stz/vm-table
 
 ;<doc>=======================================================
 ;================= Virtual Machine Interface ================
@@ -376,6 +380,9 @@ public lostanza defn VirtualMachine (dylibs:ref<LoadedDynamicLibraries>, backend
 
   vmstate.trie-table = null
   vmstate.class-table = null
+  vmstate.debug-table = no-debug-table()
+  vmstate.safepoint-table = no-safepoint-table()
+  vmstate.local-var-table = no-local-vars-table()
   val extern-defns = ExternDefnTable(backend)
   val vm-ids = VMIds(dylibs, extern-defns)
   val class-table = ClassTable()
@@ -388,6 +395,25 @@ public lostanza defn VirtualMachine (dylibs:ref<LoadedDynamicLibraries>, backend
   update-vmstate(vm)
   return vm
 
+lostanza defn no-debug-table () -> ptr<?> :
+  val p:ptr<long> = call-c clib/malloc(sizeof(long))
+  [p] = 0 ;num-packages field is immutable
+  return p
+lostanza defn no-safepoint-table () -> ptr<?> :
+  val p:ptr<long> = call-c clib/malloc(sizeof(SafepointTable))
+  [p] = 0 ;num-files field is immutable
+  return p
+lostanza defn no-local-vars-table () -> ptr<?> :
+  val p:ptr<?> = call-c clib/malloc(sizeof(LSLocalVarTable))
+  val limit:ptr<?> = p + sizeof(LSLocalVarTable)
+  for (var q:ptr<ptr<?>> = p, q < limit, q = q + sizeof(ptr<?>)) :
+    [q] = zero-length-container()
+  return p
+lostanza defn zero-length-container () -> ptr<?> :
+  val p:ptr<long> = call-c clib/malloc(sizeof(long))
+  [p] = 0 ;length field, either long or int
+  return p
+
 ;Make an appropriate CodeTable depending on whether the user has
 ;enabled the JIT.
 defn make-code-table (resolver:EncodingResolver, backend:Backend) -> CodeTable :
@@ -553,41 +579,37 @@ defn print-stack-entry (e:StackTraceEntry) -> False :
 
 
 lostanza defn collect-stack-trace (stack:ptr<Stack>, vmtable:ref<VMTable>, livemap:ref<LiveMapTable>) -> ptr<PackedStackTrace> :
-  val buffer = collect-stack-trace-entries(stack, vmtable, livemap)
+  return pack(collect-stack-trace-entries(stack, vmtable, livemap))
 
-  ;Pack items into stable memory.
+;Pack items into stable memory.
+lostanza defn pack (buffer:ref<Vector<StackTraceEntry>>) -> ptr<PackedStackTrace> :
   val builder = StackTraceBuilder()
   add-entries(builder, buffer)
   return pack(builder)
-
 defn add-entries (b:StackTraceBuilder, es:Seqable<StackTraceEntry>) :
   for e in es do :
     add-entry(b, e)
 
+public lostanza defn collect-current-stack-trace (vm:ref<VirtualMachine>) -> ref<SingleStackTrace> :
+  val buffer = collect-current-stack-trace-entries(current-stack(vm), vmtable(vm), live-map-table(vm))
+  return new SingleStackTrace{pack(buffer)}
+
 ;------------------------------------------------------------
 ;-------------------- Common Utilities ----------------------
 ;------------------------------------------------------------
 
-defn make-entry (ip:Long, sp:Long, st-info:StackTraceInfo) :
-  StackTraceEntry(ip, sp, package(st-info), signature(st-info), info(st-info))
-
 lostanza defn collect-stack-trace-entries (stack:ptr<Stack>,
                                            vmtable:ref<VMTable>,
                                            livemap:ref<LiveMapTable>) -> ref<Vector<StackTraceEntry>> :
+  val trace-table = vmtable.trace-table
   ;Accumulate all entries into a buffer.
   val buffer = Vector<StackTraceEntry>()
-
   ;Discover return addresses
   val end-sp = stack.stack-pointer
   labels :
     begin : goto loop(stack.frames)
     loop (sp:ptr<StackFrame>) :
-      ;Store in return buffer
-      ;if it exists in the file info table
-      val ret = new Long{sp.return}
-      match(get?(vmtable.trace-table, ret)) :
-        (info:ref<StackTraceInfo>) : add(buffer, make-entry(ret, new Long{sp as long}, info))
-        (info) : ()
+      add-entry(buffer, new Long{sp.return}, new Long{sp as long}, trace-table)
 
       ;Continue if we're not at the end of the stack
       if sp < end-sp :
@@ -596,12 +618,40 @@ lostanza defn collect-stack-trace-entries (stack:ptr<Stack>,
         val num-slots = num-slots(stackmap).value
         val next-frame = addr(sp.slots[num-slots]) as ptr<StackFrame>
         goto loop(next-frame)
+  reverse!(buffer)
+  return buffer
+defn add-entry (buffer:Vector<StackTraceEntry>, pc:Long, sp:Long, trace-table:HashTable<Long,StackTraceInfo>) :
+  val st-info = get?(trace-table, pc)
+  ;Store in the buffer if it exists in the stack trace table
+  match(st-info:StackTraceInfo) :
+    add(buffer, StackTraceEntry(pc, sp, package(st-info), signature(st-info), info(st-info)))
+
+lostanza defn collect-current-stack-trace-entries (stack:ptr<Stack>,
+                                                   vmtable:ref<VMTable>,
+                                                   livemap:ref<LiveMapTable>) -> ref<Vector<StackTraceEntry>> :
+  val trace-table = vmtable.trace-table
+  ;Accumulate all entries into a buffer.
+  val buffer = Vector<StackTraceEntry>()
+  ;Discover return addresses
+  val end-sp = stack.stack-pointer
+  labels :
+    begin : goto loop(stack.frames)
+    loop (sp:ptr<StackFrame>) :
+      ;Continue if we're not at the end of the stack
+      if sp < end-sp :
+        add-entry(buffer, new Long{sp.return}, new Long{sp as long}, trace-table)
 
+        val map-index = sp.liveness-map as int
+        val stackmap = get(livemap, new Int{map-index})
+        val num-slots = num-slots(stackmap).value
+        val next-frame = addr(sp.slots[num-slots]) as ptr<StackFrame>
+        goto loop(next-frame)
+      else :
+        add-entry(buffer, get-sighandler-instruction-address(), new Long{sp as long}, trace-table)
   ;Return the vector of entries in reverse order
   reverse!(buffer)
   return buffer
 
-
 ;============================================================
 ;==================== Heap/Stack Extension ==================
 ;============================================================
@@ -808,6 +858,11 @@ lostanza defn print-tag (ref:long) -> int :
 lostanza defn function-addresses (vmt:ref<VMTable>) -> ref<StableLongArray> :
   return vmt.function-addresses
 
+public defn class-name (id:Int, vm:VirtualMachine) :
+  match(class-table(vm)[id]) :
+    (class:VMLeafClass) : name(class)
+    (class:VMArrayClass) : name(class)
+
 ;============================================================
 ;================= Instruction Encoding =====================
 ;============================================================
@@ -894,6 +949,13 @@ public defn load (vm:VirtualMachine, vmps:Collection<VMPackage>, keep-existing-g
         for c in callbacks(load-unit) do :
           set-signature(extern-defns(vm), index(c), function-id(c), a1(c), a2(c))
 
+      ;Map safepoint id to its addr
+      val safepoint-map = Array<Vector<Long>>(max-safepoint-id(load-unit))
+      for i in 0 to length(safepoint-map) do :
+        safepoint-map[i] = Vector<Long>()
+
+      val local-table-packer = LocalTablePacker()
+
       ;Load functions
       vprintln("VM: Encoding functions")
       within log-time(LOAD-FUNCTIONS) :
@@ -904,7 +966,10 @@ public defn load (vm:VirtualMachine, vmps:Collection<VMPackage>, keep-existing-g
                                                  dynamic-libraries(vm), extern-defns(vm))
         ;Load each of the functions.
         for f in funcs(load-unit) do :
-          load-function(vmt, f, callback-set[id(f)], encoding-resolver, backend(vm))
+          val loaded-function = load-function(vmt, f, callback-set[id(f)], encoding-resolver, backend(vm))
+          for safepoint-entry in safepoint-entries(loaded-function) do:
+            add(safepoint-map[id(safepoint-entry)], pc(safepoint-entry))
+          add(local-table-packer, local-var-context(loaded-function), local-var-map-entries(loaded-function))
 
       ;Load datas and consts
       vprintln("VM: Loading datas and constants")
@@ -921,6 +986,18 @@ public defn load (vm:VirtualMachine, vmps:Collection<VMPackage>, keep-existing-g
       within log-time(UPDATE-VMSTATE) :
         update-vmstate(vm)
 
+      vprintln("VM: Building debug table")
+      dispose-debug-table(vm)
+      pack(debug-table(load-unit), vm)
+
+      vprintln("VM: Building local var table")
+      dispose-local-var-table(vm)
+      pack(local-table-packer, vm)
+
+      vprintln("VM: Building safepoint table")
+      dispose-safepoints(vm)
+      pack(safepoints(load-unit), safepoint-map, vm)
+
       ;If core has been loaded, then initialize the constants by running
       ;the initialize-constants function.
       if core-loaded?(vm) :
@@ -975,6 +1052,320 @@ public lostanza defn clear-globals (vm:ref<VirtualMachine>) -> ref<False> :
     globals[i] = void-marker()
   return false
 
+lostanza defn dispose-debug-table (vm:ref<VirtualMachine>) -> ref<False> :
+  val vms:ptr<VMState> = vm.vmstate
+  val debug-table = vms.debug-table
+  vms.debug-table = null
+  call-c clib/free(debug-table)
+  return false
+
+;============================================================
+;==================== Safepoint Table =======================
+;============================================================
+
+;Preconditions (guarenteed by vm-ids):
+;- VMFileSafepoints with duplicate filenames are merged
+;- VMInfoEntries are sorted by line number in each VMFieSafepoints
+defn pack (safepoint-table:Tuple<VMFileSafepoints>, locations:Array<Vector<Long>>, vm:VirtualMachine) -> False :
+  val safepoints = compact(safepoint-table, locations)
+  val table = start-safepoint-table(length(safepoints))
+  for file-safepoints in safepoints do :
+    val entries = entries(file-safepoints)
+    val file = start-file-safepoints(filename(file-safepoints), count-lines(entries))
+    var i = 0
+    val entries-length = length(entries)
+    while i < entries-length :
+      val current-line = line(entries[i])
+      var next = i
+      var count = 0
+      while next < entries-length and current-line == line(entries[next]) :
+        val id = id(entries[next])
+        count = count + length(locations[id])
+        next = next + 1
+      val address-list = create-address-list(count)
+      while i < next :
+        val entry = entries[i]
+        val group = group(entry)
+        for loc in locations[id(entry)] do :
+          append-safepoint-address(address-list, loc, group)
+        i = i + 1
+      append-entry(file, current-line, address-list)
+    finish-file-safepoints(table, file)
+  finish-safepoint-table(table, vm)
+
+defn compact (safepoints:Tuple<VMFileSafepoints>, locations:Array<Vector<Long>>) :
+  ;Are there any unreferenced safepoint entries?
+  if empty?(safepoints) or find(empty?, locations) is False :
+    safepoints
+  else :
+    val new-file-safepoints = Vector<VMFileSafepoints>(length(safepoints))
+    defn unreferenced? (entry:VMSafepointInfo) : empty?(locations[id(entry)])
+    for file in safepoints do :
+      val entries = entries(file)
+      if not empty?(entries) :
+        ;Any unreferenced entries?
+        if find(unreferenced?, entries) is False :
+          add(new-file-safepoints, file)
+        else :
+          val new-entries = Vector<VMSafepointInfo>(length(entries))
+          for entry in entries do :
+            if not unreferenced?(entry) :
+              add(new-entries, entry)
+          if not empty?(new-entries) :
+            val new-file = VMFileSafepoints(base(file), filename(file), to-tuple(new-entries))
+            add(new-file-safepoints, new-file)
+    to-tuple(new-file-safepoints)
+
+lostanza defn start-safepoint-table (length:ref<Int>) -> ref<BinaryEmitter> :
+  val num-files = length.value
+  val emitter = make-binary-emitter(sizeof(SafepointTable) + num-files * sizeof(ptr<FileSafepoints>))
+  emit-long(emitter, num-files)
+  return emitter
+lostanza defn finish-safepoint-table (emitter:ref<BinaryEmitter>, vm:ref<VirtualMachine>) -> ref<False> :
+  vm.vmstate.safepoint-table = emitter.start
+  return false
+
+extern strdup: ptr<byte> -> ptr<byte>
+lostanza defn start-file-safepoints (name:ref<String>, length:ref<Int>) -> ref<BinaryEmitter> :
+  val num-entries = length.value as long
+  val filename = call-c strdup(addr!(name.chars))
+  val emitter = make-binary-emitter(sizeof(FileSafepoints) + num-entries * sizeof(SafepointEntry))
+  emit-long(emitter, num-entries)
+  emit(emitter, filename)
+  return emitter
+lostanza defn finish-file-safepoints (table:ref<BinaryEmitter>, file:ref<BinaryEmitter>) -> ref<False> :
+  return emit(table, file.start)
+lostanza defn append-entry (file:ref<BinaryEmitter>, line:ref<Int>, address-list:ref<BinaryEmitter>) -> ref<False> :
+  emit-long(file, line.value)
+  return emit(file, address-list.start)
+lostanza defn create-address-list (length:ref<Int>) -> ref<BinaryEmitter> :
+  val len = length.value as long
+  val emitter = make-binary-emitter(sizeof(AddressList) + len * sizeof(SafepointAddress))
+  emit-long(emitter, len)
+  return emitter
+lostanza defn append-safepoint-address (address-list:ref<BinaryEmitter>, loc:ref<Long>, group:ref<Int>) -> ref<False> :
+  emit-long(address-list, loc.value)
+  return emit-long(address-list, group.value)
+
+defn count-lines (entries:Tuple<VMSafepointInfo>) :
+  var count = 0
+  var previous = -1
+  for info in entries do :
+    val current = line(info)
+    if current != previous :
+      previous = current
+      count = count + 1
+  count
+
+lostanza defn dispose-safepoints (vm:ref<VirtualMachine>) -> ref<False> :
+  val vms:ptr<VMState> = vm.vmstate
+  val safepoint-table = vms.safepoint-table as ptr<SafepointTable>
+  if safepoint-table != null :
+    val num-files = safepoint-table.num-files
+    for (var i:long = 0, i < num-files, i = i + 1L) :
+      dispose-safepoints(safepoint-table.files[i])
+    vms.safepoint-table = null
+  return false
+lostanza defn dispose-safepoints (safepoints:ptr<FileSafepoints>) -> ref<False> :
+  call-c clib/free(safepoints.filename)
+  val num-entries = safepoints.num-entries
+  for (var i:long = 0, i < num-entries, i = i + 1L) :
+    call-c clib/free(safepoints.entries[i].address-list)
+  return false
+
+;============================================================
+;==================== Local Var Table =======================
+;============================================================
+
+defstruct LocalTablePacker :
+  var-names:StringPool with: (default => StringPool())
+  named-vars:Vector<LocalVar> with: (default => Vector<LocalVar>())
+  context-lengths:Vector<Int> with: (default => Vector<Int>())
+  varmaps:Vector<VarMapEntry> with: (default => Vector<VarMapEntry>())
+  index-maps:Vector<Tuple<Int>> with: (default => Vector<Tuple<Int>>())
+  index-map-table:HashTable<Tuple<Int>,Int> with: (default => HashTable<Tuple<Int>,Int>())
+defstruct LocalVar :
+  stack-offset:Int
+  name-offset:Int
+defstruct VarMapEntry :
+  pc:Long
+  context-index:Int
+  index-map-index:Int
+
+defn add (packer:LocalTablePacker, cntx:Vector<NamedLocalVar>, maps:Vector<LocalVarMapEntry>) :
+  if not empty?(maps) :
+    val context-lengths = context-lengths(packer)
+    val cntx-index = length(context-lengths)
+    add(context-lengths, length(cntx))
+
+    add-all(named-vars(packer), seq(LocalVar, cntx)) where :
+      defn LocalVar (v:NamedLocalVar) :
+        /LocalVar(stack-offset(v), /add(var-names(packer), name(v)))
+
+    add-all(varmaps(packer), seq(VarMapEntry, maps)) where :
+      defn VarMapEntry (v:LocalVarMapEntry) :
+        /VarMapEntry(pc(v), cntx-index, index-map-index(indices(v))) where :
+          defn index-map-index (vars:Tuple<Int>) -> Int :
+            val index-maps = index-maps(packer)
+            val index-map-table = index-map-table(packer)
+            match(get?(index-map-table, vars)) :
+              (i:Int) :
+                i
+              (f:False) :
+                val i = length(index-maps)
+                add(index-maps, vars)
+                index-map-table[vars] = i
+                i
+
+defn pack (packer:LocalTablePacker, vm:VirtualMachine) -> False :
+  ;See LSLocalVarTable and local-table-stitcher for the details.
+  val LSLocalVarTable-size = 5 * 8
+  val e = make-binary-emitter(LSLocalVarTable-size)
+  emit(e, emit-varmaps(packer))
+  emit(e, emit-contexts(packer))
+  emit(e, emit-named-vars(packer))
+  emit(e, emit-index-maps(packer))
+  emit(e, emit-indices(packer))
+  set-local-var-table(e, vm)
+  false
+lostanza defn set-local-var-table (e:ref<BinaryEmitter>, vm:ref<VirtualMachine>) -> ref<False> :
+  vm.vmstate.local-var-table = e.start
+  return false
+defn emit-varmaps (packer:LocalTablePacker) -> BinaryEmitter :
+  val varmaps = varmaps(packer)
+  val length = length(varmaps)
+  val VarMapEntry-size = 8 + 4 + 4
+  val varmaps-size = 8 + VarMapEntry-size * length
+  val e = make-binary-emitter(varmaps-size)
+  emit-long(e, length)
+  for v in varmaps do :
+    emit-long(e, pc(v))
+    emit-int(e, context-index(v))
+    emit-int(e, index-map-index(v))
+  e
+defn emit-contexts (packer:LocalTablePacker) -> BinaryEmitter :
+  val context-lengths = context-lengths(packer)
+  val length = length(context-lengths) + 1
+  val contexts-size = 4 * (length + 1)
+  val e = make-binary-emitter(contexts-size)
+  emit-int(e, length)
+  var base = 0
+  for len in context-lengths do :
+    emit-int(e, base)
+    base = base + len
+  emit-int(e, base)
+  e
+defn emit-named-vars (packer:LocalTablePacker) -> BinaryEmitter :
+  val var-names = var-names(packer)
+  val vars = named-vars(packer)
+  val vars-size = 8 + 16 * length(vars) ;long length + sizeof(LSNamedVar)
+  val var-names-size = pos(var-names)
+  ;There is no pointer to string table in LSLocalVarTable. Let's append
+  ;string table to named vars to avoid memory leak
+  val e = make-binary-emitter(vars-size + var-names-size)
+  emit-long(e, length(vars))
+  for v in vars do :
+    emit-long(e, stack-offset(v))
+    emit-addr(e, name-offset(v) + vars-size)
+  for x in map(var-names) do :
+    copy(e, value(x), key(x))
+  e
+defn emit-index-maps (packer:LocalTablePacker) -> BinaryEmitter :
+  val index-maps = index-maps(packer)
+  val index-maps-length = length(index-maps)
+  val index-maps-size = 4 + 4 * (index-maps-length + 1)
+  val e = make-binary-emitter(index-maps-size)
+  emit-int(e, index-maps-length)
+  var base = 0
+  for map in index-maps do :
+    emit-int(e, base)
+    base = base + length(map)
+  emit-int(e, base)
+  e
+defn emit-indices (packer:LocalTablePacker) -> BinaryEmitter :
+  val index-maps = index-maps(packer)
+  val num-indices = sum(seq(length, index-maps))
+  val indices-size = 4 + 4 * num-indices
+  val e = make-binary-emitter(indices-size)
+  emit-int(e, num-indices)
+  for i in cat-all(index-maps) do :
+    emit-int(e, i)
+  e
+
+lostanza defn dispose-local-var-table (vm:ref<VirtualMachine>) -> ref<False> :
+  val vms:ptr<VMState> = vm.vmstate
+  val local-var-table:ptr<LSLocalVarTable> = vms.local-var-table
+  vms.local-var-table = null
+  if local-var-table != null :
+    call-c clib/free(local-var-table.varmaps)
+    call-c clib/free(local-var-table.contexts)
+    call-c clib/free(local-var-table.named-vars)
+    call-c clib/free(local-var-table.index-maps)
+    call-c clib/free(local-var-table.indices)
+    call-c clib/free(local-var-table)
+  return false
+
+lostanza defn emit-long (e:ref<BinaryEmitter>, v:ref<Int>) -> ref<False> :
+  return emit-long(e, v.value)
+lostanza defn emit-addr (e:ref<BinaryEmitter>, offset:ref<Int>) -> ref<False> :
+  return emit(e, e.start + offset.value)
+
+defstruct StringPool :
+  map:HashTable<String,Int> ;Maps string value to the offset from the pool start
+  pos:Int with: (setter => set-pos)
+defn StringPool () :
+  StringPool(HashTable<String,Int>(), 0)
+defn add (pool:StringPool, s:String) -> Int :
+  val map = map(pool)
+  match(get?(map, s)) :
+    (pos:Int):
+      pos
+    (f:False):
+      val pos = pos(pool)
+      map[s] = pos
+      set-pos(pool, pos + size(s))
+      pos
+defn size (s:String) :
+  length(s) + 1
+
+lostanza deftype BinaryEmitter :
+  start:ptr<?>
+  var p:ptr<?>
+lostanza defn make-binary-emitter (size:long) -> ref<BinaryEmitter> :
+  val p:ptr<?> = call-c clib/malloc(size)
+  return new BinaryEmitter{p, p}
+lostanza defn make-binary-emitter (size:ref<Long>) -> ref<BinaryEmitter> :
+  return make-binary-emitter(size.value)
+lostanza defn make-binary-emitter (size:ref<Int>) -> ref<BinaryEmitter> :
+  return make-binary-emitter(to-long(size))
+lostanza defn emit (p:ptr<int>, v:int) -> ptr<int> :
+  [p] = v
+  return addr(p[1])
+lostanza defn emit (p:ptr<long>, v:long) -> ptr<long> :
+  [p] = v
+  return addr(p[1])
+lostanza defn emit (dst:ptr<?>, src:ptr<?>, len:long) -> ptr<?> :
+  return call-c clib/memcpy(dst, src, len) + len
+lostanza defn emit (dst:ptr<?>, s:ref<String>) -> ptr<?> :
+  return emit(dst, addr!(s.chars), s.length + 1)
+lostanza defn emit-int (emitter:ref<BinaryEmitter>, value:int) -> ref<False> :
+  emitter.p = emit(emitter.p as ptr<int>, value)
+  return false
+lostanza defn emit-long (emitter:ref<BinaryEmitter>, value:long) -> ref<False> :
+  emitter.p = emit(emitter.p as ptr<long>, value)
+  return false
+lostanza defn emit-int (emitter:ref<BinaryEmitter>, x:ref<Int>) -> ref<False> :
+  return emit-int(emitter, x.value)
+lostanza defn emit-long (emitter:ref<BinaryEmitter>, x:ref<Long>) -> ref<False> :
+  return emit-long(emitter, x.value)
+lostanza defn emit (emitter:ref<BinaryEmitter>, value:ptr<?>) -> ref<False> :
+  return emit-long(emitter, value as long)
+lostanza defn emit (emitter:ref<BinaryEmitter>, value:ref<BinaryEmitter>) -> ref<False> :
+  return emit(emitter, value.start)
+lostanza defn copy (emitter:ref<BinaryEmitter>, pos:ref<Int>, s:ref<String>) -> ref<False> :
+  call-c clib/memcpy(emitter.p + pos.value, addr!(s.chars), s.length + 1)
+  return false
+
 ;============================================================
 ;========= Launching the Initialization Function ============
 ;============================================================
@@ -1011,7 +1402,9 @@ lostanza defn launch-init (vm:ref<VirtualMachine>, fid:ref<Int>) -> ref<True|Fal
 
 public defn shutdown (vm:VirtualMachine) :
   free-code-table(vm)
-
+  dispose-debug-table(vm)
+  dispose-local-var-table(vm)
+  dispose-safepoints(vm)
 lostanza defn free-code-table (vm:ref<VirtualMachine>) -> ref<False> :
   free(vm.vmtable.code-table)
   return false
diff --git a/debug/debugger-main.stanza b/debug/debugger-main.stanza
new file mode 100644
index 000000000..279a78f46
--- /dev/null
+++ b/debug/debugger-main.stanza
@@ -0,0 +1,61 @@
+defpackage stz-debug/debugger-main :
+  import core
+  import core/dynamic-library
+  import core/sighandler
+  import core/stack-trace
+  import stz-debug/debugger
+  import stz-debug/read-stack-trace
+
+lostanza deftype CompiledApp <: App :
+  vms : ptr<core/VMState>
+  main : ptr<?>
+defmethod state (app:CompiledApp) : get-state(app)
+defmethod run (app:CompiledApp) : run-app(app)
+defmethod stack-trace (app:CompiledApp) : read-stack-trace(app)
+defmethod class-name (app:CompiledApp, id:Int) : get-class-name(app, id)
+defmethod stack-pointer (app:CompiledApp) : get-sighandler-stack-pointer()
+
+lostanza defn get-state (app:ref<CompiledApp>) -> ref<AppState> :
+  return new AppState{app.vms}
+lostanza defn run-app (app:ref<CompiledApp>) -> ref<Int> :
+  val main = app.main as ptr<( (int, ptr<ptr<byte>>) -> int )>
+  val result = call-c [main](clib/input_argc - 1, addr(clib/input_argv[1]))
+  return new Int{result}
+lostanza defn read-stack-trace (app:ref<CompiledApp>) -> ref<SingleStackTrace> :
+  return read-stack-trace(app.vms)
+lostanza defn get-class-name (app:ref<CompiledApp>, id:ref<Int>) -> ref<String> :
+  return String(get-class-name(app, id.value))
+lostanza defn get-class-name (app:ref<CompiledApp>, id:int) -> ptr<byte> :
+  val record = app.vms.class-table[id].record
+  return (record + record.num-bytes) as ptr<byte>
+
+lostanza defn load-app (path:ref<String>) -> ref<CompiledApp>:
+  val lib = dynamic-library-open(path)
+  unprotect-code(lib)
+  return new CompiledApp{vmstate(lib).address, main(lib).address}
+defn vmstate (lib:DynamicLibrary) :
+  dynamic-library-symbol(lib, "stanza_vmstate")
+defn main (lib:DynamicLibrary) :
+  dynamic-library-symbol(lib, "main")
+lostanza defn unprotect-code (lib:ref<DynamicLibrary>) -> ref<False> :
+  val start = dynamic-library-symbol(lib, String("stanza_text_section_start")).address
+  val end = dynamic-library-symbol(lib, String("stanza_text_section_end")).address
+  val start-page = align-down-to-page-size(start)
+  val limit-page = align-down-to-page-size(end + (PAGE-SIZE - 1L))
+  call-c mprotect(start-page, limit-page - start-page, 0x7)
+  return false
+extern mprotect: (ptr<?>, long, int) -> int
+lostanza val PAGE-SIZE:long = 4096
+lostanza defn align-down-to-page-size (p:ptr<?>) -> ptr<?> :
+  val x = p as long
+  val y = x & (- PAGE-SIZE)
+  return y as ptr<?>
+
+defn main () :
+  val args = command-line-arguments()
+  if length(args) < 2 :
+    println("Usage: %_ app-path app-args")
+    exit(-1)
+  val app = load-app(args[1])
+  debug(app)
+main()
diff --git a/debug/debugger.stanza b/debug/debugger.stanza
index 82f52bcbb..3b1f83953 100644
--- a/debug/debugger.stanza
+++ b/debug/debugger.stanza
@@ -7,7 +7,6 @@ defpackage stz-debug/debugger :
   import core/debug-table
   import core/sighandler
   import stz/line-noise-prompter
-  import stz-debug/read-stack-trace
   import core/stack-trace
   import core/local-table
 
@@ -23,7 +22,7 @@ defn* command-loop (running?:True|False) -> False :
             defn no-core-packages (package:Symbol, sig:String|False) -> True|False :
               package != `core
             ;Print out the stack trace using the filter.
-            print-stack-trace(current-output-stream(), read-app-stack-trace(), no-core-packages)
+            print-stack-trace(current-output-stream(), stack-trace(app), no-core-packages)
           else :
             println("Program is not running.")
           ;Do not advance the program.
@@ -40,9 +39,12 @@ defn* command-loop (running?:True|False) -> False :
           print-locals(ip, sp)
           loop()
         (locals) :
-          val ip = get-sighandler-instruction-address()
-          val sp = get-sighandler-stack-pointer()
-          print-locals(ip, sp)
+          if running? :
+            val ip = get-sighandler-instruction-address()
+            val sp = stack-pointer(app)
+            print-locals(ip, sp)
+          else :
+            println("Program is not running.")
           loop()
         (break ?filename ?line) :
           set-breakpoint(unwrap-token(filename) as String, unwrap-token(line) as Int)
@@ -69,7 +71,7 @@ defn* command-loop (running?:True|False) -> False :
         (stop) :
           if running? :
             println("Stopping the program.")
-          throw(Exception("Program stopped."))
+          quit()
         (quit) :
           quit()
         (help) :
@@ -103,14 +105,11 @@ defn print-help (msg:String|False) :
   println-all(help)
 
 defn run () :
-  println("debug> Program finished wth completion code %_." % [run-main()])
+  println("debug> Program finished wth completion code %_." % [run(app)])
 defn quit () :
   println("Quitting.")
   exit(0)
 
-lostanza defn read-app-stack-trace () -> ref<SingleStackTrace> :
-  return read-stack-trace(app-vms)
-
 lostanza defn print-safepoints () -> ref<False> :
   return dump-safepoint-table(app-safepoints())
 
@@ -217,6 +216,7 @@ lostanza defn find (list:ptr<AddressList>, ip:ptr<?>) -> ptr<SafepointAddress> :
 defn print-locals (ip:Long, sp:Long) :
   val ctxt = context(app-locals, ip)
   match(ctxt:VarContext) :
+    val len = length(ctxt)
     if length(ctxt) == 0 :
       println("No named locals recorded.")
     else :
@@ -244,45 +244,14 @@ lostanza defn print-variable (name:ref<String>, p:ptr<long>) -> ref<False> :
 defn print-variable (name:String, type:String, value:String) :
   println("  var %_ : %_ = %_" % [name, type, value])
 
-lostanza defn run-main () -> ref<Int> :
-  val main = app-main as ptr<( (int, ptr<ptr<byte>>) -> int )>
-  val result = call-c [main](clib/input_argc - 1, addr(clib/input_argv[1]))
-  return new Int{result}
-
-lostanza defn load-app (path:ref<String>) -> ref<False>:
-  val lib = dynamic-library-open(path)
-  unprotect-code(lib)
-  val vms = vmstate(lib).address as ptr<core/VMState>
-  app-vms = vms
-  app_safepoint_table = app-vms.safepoint-table ;Export safepoint table to native code
-  app-locals = LocalVarTable(vms.local-var-table)
-  app-globals = DebugTable(vms.debug-table)
-  app-main = dynamic-library-symbol(lib, String("main")).address
-  call-c set_SIGINT_handler()
-  return false
-defn vmstate (lib:DynamicLibrary) :
-  dynamic-library-symbol(lib, String("stanza_vmstate"))
 lostanza defn app-safepoints () -> ptr<SafepointTable> :
   return app_safepoint_table
 extern set_SIGINT_handler : () -> int
 
-lostanza defn unprotect-code (lib:ref<DynamicLibrary>) -> ref<False> :
-  val start = dynamic-library-symbol(lib, String("stanza_text_section_start")).address
-  val end = dynamic-library-symbol(lib, String("stanza_text_section_end")).address
-  val start-page = align-down-to-page-size(start)
-  val limit-page = align-down-to-page-size(end + (PAGE-SIZE - 1L))
-  call-c mprotect(start-page, limit-page - start-page, 0x7)
-  return false
-extern mprotect: (ptr<?>, long, int) -> int
-lostanza val PAGE-SIZE:long = 4096
-lostanza defn align-down-to-page-size (p:ptr<?>) -> ptr<?> :
-  val x = p as long
-  val y = x & (- PAGE-SIZE)
-  return y as ptr<?>
-
 ;Debugger state
 lostanza var app-vms : ptr<core/VMState>
-lostanza var app-main : ptr<?>
+var app-run : (() -> Int)
+var app-exit : (() -> False)
 var app-locals : LocalVarTable
 var app-globals : DebugTable
 
@@ -311,10 +280,7 @@ public lostanza defn type-of (v:long) -> ref<String> :
   val type-id = type-id(v)
   if type-id < 0 : return String("Unknown")
   if type-id == tagof(core/Box) : return type-of(unbox(v))
-  return String(app-class-name(type-id))
-lostanza defn app-class-name (x:long) -> ptr<byte> :
-  val record = app-vms.class-table[x].record
-  return (record + record.num-bytes) as ptr<byte>
+  return app-class-name(new Int{type-id as int})
 
 lostanza defn untag (x:long) -> ptr<?> :
   #if-not-defined(OPTIMIZE) :
@@ -322,6 +288,7 @@ lostanza defn untag (x:long) -> ptr<?> :
     if tagbits != 1 : fatal("Not a heap-allocated object!")
   return (x - 1 + 8) as ptr<?>
 
+;Recognized types ids must be registered in FIXED-TYPE-IDS
 deftype RecognizedType :
   True <: RecognizedType
   False <: RecognizedType
@@ -689,17 +656,33 @@ lostanza defn forget-stepping-coroutine () -> ref<False> :
     [stepping-coroutine-ptr] = false
   return false
 
-defn main () :
-  val args = command-line-arguments()
-  if length(args) < 2 :
-    println("Usage: %_ app-path app-args")
-    exit(-1)
-  load-app(args[1])
+var app:App
+defn app-state () : state(app)
+defn app-class-name (id:Int) : class-name(app, id)
+
+public deftype App
+public lostanza deftype AppState :
+  vms:ptr<core/VMState>
+public defmulti state (app:App) -> AppState
+public defmulti run (app:App) -> Int
+public defmulti stack-trace (app:App) -> SingleStackTrace
+public defmulti class-name (app:App, id:Int) -> String
+public defmulti stack-pointer (app:App) -> Long
+
+public defn debug (app:App) -> False :
+  /app = app
+  init()
   set-sighandler(when-paused-at-safepoint)
-
   println("Paused at entry")
   try :
     command-loop(false)
   catch (e:Exception) :
     println(e)
-main()
+lostanza defn init () -> ref<False> :
+  val vms = app-state().vms
+  app-vms = vms
+  app_safepoint_table = vms.safepoint-table ;Export safepoint table to native code
+  app-locals = LocalVarTable(vms.local-var-table)
+  app-globals = DebugTable(vms.debug-table)
+  call-c set_SIGINT_handler()
+  return false
diff --git a/libs/asmjit/src/bindings/stz-asmjit.cpp b/libs/asmjit/src/bindings/stz-asmjit.cpp
index 7da14b031..c61db0ccd 100644
--- a/libs/asmjit/src/bindings/stz-asmjit.cpp
+++ b/libs/asmjit/src/bindings/stz-asmjit.cpp
@@ -143,6 +143,9 @@ void assembler_cqo_reg(Assembler *a){
 void assembler_cdq_reg(Assembler *a){
   a->cdq();
 }
+void assembler_nop(Assembler *a){
+  a->nop();
+}
 void assembler_add_int(Assembler *a, const Gp *dst, int src) {
   a->add(*dst, src);
 }
diff --git a/libs/asmjit/src/bindings/stz-asmjit.h b/libs/asmjit/src/bindings/stz-asmjit.h
index 2de342830..ff3f1a814 100644
--- a/libs/asmjit/src/bindings/stz-asmjit.h
+++ b/libs/asmjit/src/bindings/stz-asmjit.h
@@ -63,7 +63,8 @@ extern "C" {
   void assembler_div_reg(Assembler *a, const Gp *divisor);  
   void assembler_mod_reg(Assembler *a, const Gp *divisor);
   void assembler_cqo_reg(Assembler *a);
-  void assembler_cdq_reg(Assembler *a);  
+  void assembler_cdq_reg(Assembler *a);
+  void assembler_nop(Assembler *a);    
   void assembler_add_int(Assembler *a, const Gp *dst, int);
   void assembler_sub_int(Assembler *a, const Gp *dst, int);
   void assembler_sub_reg(Assembler *a, const Gp *dst, const Gp *src);
diff --git a/scratch/print-safepoints.stanza b/scratch/print-safepoints.stanza
new file mode 100644
index 000000000..e0842286e
--- /dev/null
+++ b/scratch/print-safepoints.stanza
@@ -0,0 +1,155 @@
+;  Agenda:
+;- run an app under debugger
+;- set breakpoints at source lines
+;- view stack trace
+;- view global and local variables
+;- view locals in selected stack frame
+;- structural inspection of variables
+;- application output redirection
+;- step in and over global variable initializations
+;- step in, over and out function calls and coroutines
+;- step over loops
+;- pause and continue infinite loop
+;- restart debugging session
+
+defpackage print-safepoints :
+  import core
+  import collections
+
+;Expand 'Globals' and step over the initializations.
+;Pay attention to value changes.
+val GLOBAL-A = "Hello world"
+var GLOBAL-B:Int = 23
+val GLOBAL-C = [23, "Hello"]
+val GLOBAL-D = CharArray(3, 'A')
+val GLOBAL-E = ByteArray(3, 5Y)
+val GLOBAL-F = IntArray(3, 1)
+val GLOBAL-G = Array<Int>(3, 1)
+var GLOBAL-H:List = List(42, "Timon")
+val GLOBAL-I = `core
+val GLOBAL-J = to-char(0x07Y)
+val GLOBAL-K = CharArray(3, to-char(0x0AY))
+
+defn test (i:Int) :
+  println("=== test started %_ ===" % [i])
+  for j in 0 to 10 do :
+    println("=== test iteration %_ ===" % [j])
+  println("=== test finished %_ ===" % [i])
+
+defn f0 (a:Int) :
+  println("f0(%_)" % [a])
+  f1(a + a)
+  f1(a + a)
+  println(a)
+
+defn f1 (b:Int) :
+  println("f1(%_)" % [b])
+  f2(b + b)
+  f2(b + b)
+  println(b)
+
+defn f2 (c:Int) :
+  ;Select caller's frames in stack trace to see their locals in 'Locals' view
+  println("f2(%_)" % [c])
+  println(c)
+
+defn my-process (co:Coroutine<Int,String>, a:Int) -> String :
+  ;Step in or over suspends
+   println("Came in a = %_" % [a])
+   println("Passing out Timon")
+   val b = suspend(co, "Timon")
+
+   println("Came in b = %_" % [b])
+   println("Passing out and")
+   val c = suspend(co, "and")
+
+   println("Came in c = %_" % [c])
+   println("Passing out Pumbaa")
+   val d = suspend(co, "Pumbaa")
+
+   println("Came in d = %_" % [d])
+   println("Coroutine is done")
+   "Done"
+
+defn coroutine-test () :
+  println("Create coroutine")
+  val co = Coroutine<Int,String>(my-process)
+
+  ;Step in or over resumes
+  println("\nResume with 42")
+  val x = resume(co, 42)
+  println("Got back x = %_" % [x])
+
+  println("\nResume with 43")
+  val y = resume(co, 43)
+  println("Got back y = %_" % [y])
+
+  println("\nResume with 44")
+  val z = resume(co, 44)
+  println("Got back z = %_" % [z])
+
+  println("\nResume with 45")
+  val w = resume(co, 45)
+  println("Got back w = %_" % [w])
+
+defn random-selection-test () :
+  ;Step in or over here. Pay attention to locals.
+  val items = ["Hello", 0, 'X']
+  val x = items[rand(3)]
+  val y = items[rand(3)]
+  match(x, y) :
+    (x:Int, y:Int) :
+      println("Both integers")
+    (x:String, y:String) :
+      println("Both strings")
+    (x:Char, y:Char) :
+      println("Both chars")
+    (x:Int, y:String) :
+      println("Int and String")
+    (x:Char, y:Int) :
+      println("Char and Int")
+    (x:String, y:Char) :
+      println("String and Char")
+    (x:Int, y:Char) :
+      println("Int and Char")
+    (x, y) :
+      println("Default case")
+      println("x is %_" % [object-type(x)])
+      println("y is %_" % [object-type(y)])
+
+defn infinite-loop () -> False :
+  println("=== Infinite loop ===")
+  for i in 0 to false do :
+    println("=== Infinite Loop Iteration %_ ===" % [i])
+  false
+
+defn main () :
+  ;Step over these to lines to show stdout and stderr redirection
+  println("=== Hello world ===")
+  println(STANDARD-ERROR-STREAM, "Hello from error stream");
+
+  ;Step in this function call
+  f0(10)
+  ;Step over this function call
+  f0(11)
+
+  ;Step over this line to skip the loop
+  for i in 0 to 5 do :
+    println("=== Iteration %_ ===" % [i])
+    test(i)
+    GLOBAL-B = GLOBAL-B * 10
+    GLOBAL-H = cons(GLOBAL-B, GLOBAL-H)
+  ;Inspect GLOBAL-H linked list here
+
+  ;Step in this coroutine test
+  coroutine-test()
+
+  ;Set a breakpoint at 'match' and continue
+  for i in 0 to 20 do :
+    random-selection-test()
+
+  ;Continue, let this loop run for a while, then pause.
+  infinite-loop()
+  println("=== FINISHED ===")
+
+main()
diff --git a/stanza.proj b/stanza.proj
index 1804eca53..15c6f2ddc 100644
--- a/stanza.proj
+++ b/stanza.proj
@@ -1,4 +1,5 @@
 include "examples/stanza.proj"
+include "build-stanza.proj" 
 
 package stz/line-noise-prompter requires :
   ccfiles:
@@ -82,7 +83,7 @@ package stz/macro-plugin requires :
 include "debug/stanza.proj"
 
 build stanza-debugger :
-  inputs: stz-debug/debugger
+  inputs: stz-debug/debugger-main
   pkg: "pkgs"
   o: "stanza-debugger"
 
diff --git a/tests/dev-linker.stanza b/tests/dev-linker.stanza
index 646f72b84..40e544e34 100644
--- a/tests/dev-linker.stanza
+++ b/tests/dev-linker.stanza
@@ -67,7 +67,7 @@ defn conan-vars (platform:Symbol,
   val system-dir = to-string("%_/system" % [build-dir])
   val conan-root = to-string("%_/.conan" % [projdir(stmt)])
   [`conan-system-includes => system-dir
-   `conan-root => conan-root]  
+   `conan-root => conan-root]
 
 ;Retrieve a bunch of dummy package managers for testing.
 defn manager-infos (names:Tuple<String>) -> Tuple<ForeignPackageManagerInfo> :
@@ -88,7 +88,7 @@ defn read-example-proj (filenames:Tuple<String>) -> ProjFile :
       ;manager-infos(get?(cmdargs, "package-managers", []))
     defmethod package-manager-variables (this, params:ForeignPackageParamsStmt, platform:Symbol) :
       switch(package-manager(params)) :
-        `conan : conan-vars(platform, params)        
+        `conan : conan-vars(platform, params)
   read-proj-files(filenames, platform, env)
 
 defn LinkEnv () :
@@ -172,13 +172,14 @@ defn try-link (cmdargs:CommandArgs) :
   val proj-files = cmdargs["proj"]
   val build-settings = BuildSettings(
     BuildPackages(packages, false),  ;inputs
-    [],                              ;vm-packages                      
+    [],                              ;vm-packages
     `os-x,                           ;platform
     AsmFile("myprog.s", false)       ;assembly
     "myprog",                        ;output
     false,                           ;external-dependencies
     false,                           ;pkg-dir
     false,                           ;optimize?
+    false,                           ;debug?
     [],                              ;ccfiles
     [],                              ;ccflags
     [],                              ;flags