diff --git a/src/heap.cc b/src/heap.cc
index 98552a7..eae772f 100644
--- a/src/heap.cc
+++ b/src/heap.cc
@@ -353,7 +353,7 @@
   ptr = space->AllocWithGrowth(size);
   if (ptr != NULL) {
     //size_t new_footprint = dvmHeapSourceGetIdealFootprint();
-    size_t new_footprint = space->MaxAllowedFootprint();
+    size_t new_footprint = space->GetMaxAllowedFootprint();
     // TODO: may want to grow a little bit more so that the amount of
     //       free space is equal to the old free space + the
     //       utilization slop for the new allocation.
@@ -497,8 +497,8 @@
  *  3. Soft footprint: external allocation + spaces footprint + active space footprint
  *  4. Overhead: soft footprint excluding active.
  *
- * Layout: (Below might be incontiguous, but are lumped together to depict size.)
- * |---for external allocation---|---spaces footprint ("heap1")---|----active space footprint----|
+ * Layout: (The spaces below might not be contiguous, but are lumped together to depict size.)
+ * |----------------------spaces footprint--------- --------------|----active space footprint----|
  *                                                                |--active space allocated--|
  * |--------------------soft footprint (include active)--------------------------------------|
  * |----------------soft footprint excluding active---------------|
@@ -520,26 +520,14 @@
     max_allowed_footprint = Heap::maximum_size_;
   }
 
-  SetSoftLimit(max_allowed_footprint);
+  alloc_space_->SetMaxAllowedFootprint(max_allowed_footprint);
 }
 
-void Heap::SetSoftLimit(size_t soft_limit)
-{
-  // Compare against the actual footprint, rather than the
-  // max_allowed, because the heap may not have grown all the
-  // way to the allowed size yet.
-  //
-  size_t current_space_size = mspace_footprint(alloc_space_->mspace_);
-  if (soft_limit < current_space_size) {
-    // Don't let the space grow any more, and impose a soft limit.
-    mspace_set_max_allowed_footprint(alloc_space_->mspace_, current_space_size);
-  } else {
-    // Let the heap grow to the requested max
-    mspace_set_max_allowed_footprint(alloc_space_->mspace_, soft_limit);
-  }
-}
-
-static const size_t kHeapIdealFree = 1024 * 1024 * 2;
+// kHeapIdealFree is the ideal maximum free size, when we grow the heap for
+// utlization.
+static const size_t kHeapIdealFree = 2 * MB;
+// kHeapMinFree guarantees that you always have at least 512 KB free, when
+// you grow for utilization, regardless of target utilization ratio.
 static const size_t kHeapMinFree = kHeapIdealFree / 4;
 
 // Given the current contents of the active space, increase the allowed
diff --git a/src/heap.h b/src/heap.h
index d847a87..c25803f 100644
--- a/src/heap.h
+++ b/src/heap.h
@@ -92,8 +92,9 @@
   static void SetTargetHeapUtilization(float target) {
     target_utilization_ = target;
   }
+  // Sets the maximum number of bytes that the heap is allowed to allocate
+  // from the system.  Clamps to the appropriate maximum value.
   static void SetIdealFootprint(size_t max_allowed_footprint);
-  static void SetSoftLimit(size_t soft_limit);
 
   // Blocks the caller until the garbage collector becomes idle.
   static void WaitForConcurrentGcToComplete();
diff --git a/src/object_test.cc b/src/object_test.cc
index c13a19d..6979b75 100644
--- a/src/object_test.cc
+++ b/src/object_test.cc
@@ -162,29 +162,6 @@
   TestPrimitiveArray<ShortArray>(class_linker_);
 }
 
-extern "C" Object* artAllocObjectFromCode(uint32_t type_idx, Method* method);
-TEST_F(ObjectTest, AllocObjectFromCode) {
-  // pretend we are trying to call 'new String' from Object.toString
-  Class* java_lang_Object = class_linker_->FindSystemClass("Ljava/lang/Object;");
-  Method* toString = java_lang_Object->FindVirtualMethod("toString", "()Ljava/lang/String;");
-  uint32_t type_idx = FindTypeIdxByDescriptor(*java_lang_dex_file_.get(), "Ljava/lang/String;");
-  Object* string = artAllocObjectFromCode(type_idx, toString);
-  EXPECT_TRUE(string->IsString());
-}
-
-extern "C" Array* artAllocArrayFromCode(uint32_t type_idx, Method* method, int32_t component_count);
-TEST_F(ObjectTest, AllocArrayFromCode) {
-  // pretend we are trying to call 'new char[3]' from String.toCharArray
-  Class* java_lang_String = class_linker_->FindSystemClass("Ljava/lang/String;");
-  Method* toCharArray = java_lang_String->FindVirtualMethod("toCharArray", "()[C");
-  uint32_t type_idx = FindTypeIdxByDescriptor(*java_lang_dex_file_.get(), "[C");
-  Object* array = artAllocArrayFromCode(type_idx, toCharArray, 3);
-  EXPECT_TRUE(array->IsArrayInstance());
-  EXPECT_EQ(3, array->AsArray()->GetLength());
-  EXPECT_TRUE(array->GetClass()->IsArrayClass());
-  EXPECT_TRUE(array->GetClass()->GetComponentType()->IsPrimitive());
-}
-
 extern "C" Array* artCheckAndAllocArrayFromCode(uint32_t type_idx, Method* method,
                                                 int32_t component_count);
 TEST_F(ObjectTest, CheckAndAllocArrayFromCode) {
diff --git a/src/runtime_support.cc b/src/runtime_support.cc
index 2bcd7d9..49191b7 100644
--- a/src/runtime_support.cc
+++ b/src/runtime_support.cc
@@ -414,17 +414,22 @@
 
 // Given the context of a calling Method, use its DexCache to resolve a type to a Class. If it
 // cannot be resolved, throw an error. If it can, use it to create an instance.
-extern "C" Object* artAllocObjectFromCode(uint32_t type_idx, Method* method) {
+extern "C" Object* artAllocObjectFromCode(uint32_t type_idx, Method* method, Thread* self, Method** sp) {
+  // Place a special frame at the TOS that will save all callee saves
+  Runtime* runtime = Runtime::Current();
+  *sp = runtime->GetCalleeSaveMethod();
+  self->SetTopOfStack(sp, 0);
+
   Class* klass = method->GetDexCacheResolvedTypes()->Get(type_idx);
   if (klass == NULL) {
-    klass = Runtime::Current()->GetClassLinker()->ResolveType(type_idx, method);
+    klass = runtime->GetClassLinker()->ResolveType(type_idx, method);
     if (klass == NULL) {
-      DCHECK(Thread::Current()->IsExceptionPending());
+      DCHECK(self->IsExceptionPending());
       return NULL;  // Failure
     }
   }
-  if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(klass, true)) {
-    DCHECK(Thread::Current()->IsExceptionPending());
+  if (!runtime->GetClassLinker()->EnsureInitialized(klass, true)) {
+    DCHECK(self->IsExceptionPending());
     return NULL;  // Failure
   }
   return klass->AllocObject();
@@ -465,7 +470,12 @@
 
 // Given the context of a calling Method, use its DexCache to resolve a type to an array Class. If
 // it cannot be resolved, throw an error. If it can, use it to create an array.
-extern "C" Array* artAllocArrayFromCode(uint32_t type_idx, Method* method, int32_t component_count) {
+extern "C" Array* artAllocArrayFromCode(uint32_t type_idx, Method* method, int32_t component_count, Thread* self, Method** sp) {
+  // Place a special frame at the TOS that will save all callee saves
+  Runtime* runtime = Runtime::Current();
+  *sp = runtime->GetCalleeSaveMethod();
+  self->SetTopOfStack(sp, 0);
+
   if (component_count < 0) {
     Thread::Current()->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;", "%d",
                                          component_count);
diff --git a/src/runtime_support_asm.S b/src/runtime_support_asm.S
index 7d4c906..0e73d83 100644
--- a/src/runtime_support_asm.S
+++ b/src/runtime_support_asm.S
@@ -245,13 +245,13 @@
      * Called by managed code to allocate an object
      */
 art_alloc_object_from_code:
-    str    sp, [R9, #THREAD_TOP_OF_MANAGED_STACK_OFFSET]    @ record top of stack and pc in case of
-    str    lr, [R9, #THREAD_TOP_OF_MANAGED_STACK_PC_OFFSET] @ walking stack
-    stmdb  sp!, {lr}               @ Save LR
-    sub    sp, #12                 @ Align stack
-    bl     artAllocObjectFromCode  @ (uint32_t type_idx, Method* method)
-    add    sp, #12
-    ldmia  sp!, {lr}               @ restore LR
+    SETUP_CALLEE_SAVE_FRAME
+    mov    r2, r9                  @ pass Thread::Current
+    mov    r3, sp                  @ pass SP
+    bl     artAllocObjectFromCode  @ (uint32_t type_idx, Method* method, Thread*, SP)
+    add    sp, #16
+    vpop   {s0-s31}
+    pop    {r1-r11, lr}
     cmp    r0, #0                  @ success if result is non-null
     movne  pc, lr                  @ return on success
                                    @ set up for throwing exception
@@ -266,13 +266,13 @@
      * Called by managed code to allocate an array
      */
 art_alloc_array_from_code:
-    str    sp, [R9, #THREAD_TOP_OF_MANAGED_STACK_OFFSET]    @ record top of stack and pc in case of
-    str    lr, [R9, #THREAD_TOP_OF_MANAGED_STACK_PC_OFFSET] @ walking stack
-    stmdb  sp!, {lr}              @ Save LR
-    sub    sp, #12                @ Align stack
-    bl     artAllocArrayFromCode  @ (uint32_t type_idx, Method* method, int32_t component_count)
-    add    sp, #12
-    ldmia  sp!, {lr}              @ restore LR
+    SETUP_CALLEE_SAVE_FRAME
+    mov    r3, r9                 @ pass Thread::Current
+    str    sp, [sp, #0]           @ pass SP
+    bl     artAllocArrayFromCode  @ (uint32_t type_idx, Method* method, int32_t component_count, Thread*, SP)
+    add    sp, #16
+    vpop   {s0-s31}
+    pop    {r1-r11, lr}
     cmp    r0, #0                 @ success if result is non-null
     movne  pc, lr                 @ return on success
                                   @ set up for throwing exception
diff --git a/src/space.cc b/src/space.cc
index 1852b0d..1b887d8 100644
--- a/src/space.cc
+++ b/src/space.cc
@@ -203,11 +203,29 @@
   mspace_walk_free_pages(mspace_, DontNeed, &num_bytes_released);
 }
 
-size_t Space::MaxAllowedFootprint() {
+size_t Space::GetMaxAllowedFootprint() {
   DCHECK(mspace_ != NULL);
   return mspace_max_allowed_footprint(mspace_);
 }
 
+void Space::SetMaxAllowedFootprint(size_t limit)
+{
+  DCHECK(mspace_ != NULL);
+
+  // Compare against the actual footprint, rather than the
+  // max_allowed, because the heap may not have grown all the
+  // way to the allowed size yet.
+  //
+  size_t current_space_size = mspace_footprint(mspace_);
+  if (limit < current_space_size) {
+    // Don't let the space grow any more.
+    mspace_set_max_allowed_footprint(mspace_, current_space_size);
+  } else {
+    // Let the heap grow to the requested limit.
+    mspace_set_max_allowed_footprint(mspace_, limit);
+  }
+}
+
 void Space::Grow(size_t new_size) {
   UNIMPLEMENTED(FATAL);
 }
diff --git a/src/space.h b/src/space.h
index 83c94a0..758d80c 100644
--- a/src/space.h
+++ b/src/space.h
@@ -36,7 +36,8 @@
 
   void Trim();
 
-  size_t MaxAllowedFootprint();
+  size_t GetMaxAllowedFootprint();
+  void SetMaxAllowedFootprint(size_t limit);
 
   void Grow(size_t num_bytes);
 
@@ -102,8 +103,6 @@
 
   byte* limit_;
 
-  friend class Heap;
-
   DISALLOW_COPY_AND_ASSIGN(Space);
 };