diff --git a/src/class_linker.cc b/src/class_linker.cc
index 570d797..a2e05c5 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -58,13 +58,13 @@
 
 ClassLinker* ClassLinker::Create(const std::vector<const DexFile*>& boot_class_path,
                                  const std::vector<const DexFile*>& class_path,
-                                 InternTable* intern_table, Space* space) {
+                                 InternTable* intern_table, bool image) {
   CHECK_NE(boot_class_path.size(), 0U);
   UniquePtr<ClassLinker> class_linker(new ClassLinker(intern_table));
-  if (space == NULL) {
-    class_linker->Init(boot_class_path, class_path);
+  if (image) {
+    class_linker->InitFromImage(boot_class_path, class_path);
   } else {
-    class_linker->Init(boot_class_path, class_path, space);
+    class_linker->Init(boot_class_path, class_path);
   }
   // TODO: check for failure during initialization
   return class_linker.release();
@@ -115,16 +115,11 @@
   java_lang_String->SetStatus(Class::kStatusResolved);
 
   // Backfill Class descriptors missing until this point
-  // TODO: intern these strings
-  java_lang_Class->SetDescriptor(
-      String::AllocFromModifiedUtf8("Ljava/lang/Class;"));
-  java_lang_Object->SetDescriptor(
-      String::AllocFromModifiedUtf8("Ljava/lang/Object;"));
-  object_array_class->SetDescriptor(
-      String::AllocFromModifiedUtf8("[Ljava/lang/Object;"));
-  java_lang_String->SetDescriptor(
-      String::AllocFromModifiedUtf8("Ljava/lang/String;"));
-  char_array_class->SetDescriptor(String::AllocFromModifiedUtf8("[C"));
+  java_lang_Class->SetDescriptor(intern_table_->InternStrong("Ljava/lang/Class;"));
+  java_lang_Object->SetDescriptor(intern_table_->InternStrong("Ljava/lang/Object;"));
+  object_array_class->SetDescriptor(intern_table_->InternStrong("[Ljava/lang/Object;"));
+  java_lang_String->SetDescriptor(intern_table_->InternStrong("Ljava/lang/String;"));
+  char_array_class->SetDescriptor(intern_table_->InternStrong("[C"));
 
   // Create storage for root classes, save away our work so far (requires
   // descriptors)
@@ -156,7 +151,7 @@
   // Create int array type for AllocDexCache (done in AppendToBootClassPath)
   Class* int_array_class = AllocClass(java_lang_Class, sizeof(Class));
   int_array_class->SetArrayRank(1);
-  int_array_class->SetDescriptor(String::AllocFromModifiedUtf8("[I"));
+  int_array_class->SetDescriptor(intern_table_->InternStrong("[I"));
   int_array_class->SetComponentType(GetClassRoot(kPrimitiveInt));
   IntArray::SetArrayClass(int_array_class);
   SetClassRoot(kIntArrayClass, int_array_class);
@@ -179,14 +174,15 @@
   // Field and Method are necessary so that FindClass can link members
   Class* java_lang_reflect_Field = AllocClass(java_lang_Class, sizeof(FieldClass));
   CHECK(java_lang_reflect_Field != NULL);
-  java_lang_reflect_Field->SetDescriptor(String::AllocFromModifiedUtf8("Ljava/lang/reflect/Field;"));
+  java_lang_reflect_Field->SetDescriptor(intern_table_->InternStrong("Ljava/lang/reflect/Field;"));
   java_lang_reflect_Field->SetObjectSize(sizeof(Field));
   SetClassRoot(kJavaLangReflectField, java_lang_reflect_Field);
   java_lang_reflect_Field->SetStatus(Class::kStatusResolved);
   Field::SetClass(java_lang_reflect_Field);
 
   Class* java_lang_reflect_Method = AllocClass(java_lang_Class, sizeof(MethodClass));
-  java_lang_reflect_Method->SetDescriptor(String::AllocFromModifiedUtf8("Ljava/lang/reflect/Method;"));
+  java_lang_reflect_Method->SetDescriptor(
+      intern_table_->InternStrong("Ljava/lang/reflect/Method;"));
   CHECK(java_lang_reflect_Method != NULL);
   java_lang_reflect_Method->SetObjectSize(sizeof(Method));
   SetClassRoot(kJavaLangReflectMethod, java_lang_reflect_Method);
@@ -358,7 +354,7 @@
   init_done_ = true;
 }
 
-struct ClassLinker::InitCallbackState {
+struct ClassLinker::InitFromImageCallbackState {
   ClassLinker* class_linker;
 
   Class* class_roots[kClassRootsMax];
@@ -370,15 +366,14 @@
   Set dex_caches;
 };
 
-void ClassLinker::Init(const std::vector<const DexFile*>& boot_class_path,
-                       const std::vector<const DexFile*>& class_path,
-                       Space* space) {
+void ClassLinker::InitFromImage(const std::vector<const DexFile*>& boot_class_path,
+                                const std::vector<const DexFile*>& class_path) {
   CHECK(!init_done_);
 
   HeapBitmap* heap_bitmap = Heap::GetLiveBits();
   DCHECK(heap_bitmap != NULL);
 
-  InitCallbackState state;
+  InitFromImageCallbackState state;
   state.class_linker = this;
   for (size_t i = 0; i < kClassRootsMax; i++) {
     ClassRoot class_root = static_cast<ClassRoot>(i);
@@ -386,7 +381,7 @@
   }
 
   // reinit clases_ table
-  heap_bitmap->Walk(InitCallback, &state);
+  heap_bitmap->Walk(InitFromImageCallback, &state);
 
   // reinit class_roots_
   Class* object_array_class = state.class_roots[kObjectArrayClass];
@@ -396,21 +391,13 @@
     SetClassRoot(class_root, state.class_roots[class_root]);
   }
 
-  // reinit intern table
-  // TODO: remove interned_array, make all strings in image interned (and remove space argument)
-  ObjectArray<Object>* interned_array = space->GetImageHeader().GetInternedArray();
-  for (int32_t i = 0; i < interned_array->GetLength(); i++) {
-    String* string = interned_array->Get(i)->AsString();
-    intern_table_->RegisterStrong(string);
-  }
-
   // reinit array_interfaces_ from any array class instance, they should all be ==
   array_interfaces_ = GetClassRoot(kObjectArrayClass)->GetInterfaces();
   DCHECK(array_interfaces_ == GetClassRoot(kBooleanArrayClass)->GetInterfaces());
 
   // build a map from location to DexCache to match up with DexFile::GetLocation
   std::tr1::unordered_map<std::string, DexCache*> location_to_dex_cache;
-  typedef InitCallbackState::Set::const_iterator It;  // TODO: C++0x auto
+  typedef InitFromImageCallbackState::Set::const_iterator It;  // TODO: C++0x auto
   for (It it = state.dex_caches.begin(), end = state.dex_caches.end(); it != end; ++it) {
     DexCache* dex_cache = *it;
     std::string location = dex_cache->GetLocation()->ToModifiedUtf8();
@@ -454,11 +441,15 @@
   FinishInit();
 }
 
-void ClassLinker::InitCallback(Object* obj, void *arg) {
+void ClassLinker::InitFromImageCallback(Object* obj, void *arg) {
   DCHECK(obj != NULL);
   DCHECK(arg != NULL);
-  InitCallbackState* state = reinterpret_cast<InitCallbackState*>(arg);
+  InitFromImageCallbackState* state = reinterpret_cast<InitFromImageCallbackState*>(arg);
 
+  if (obj->IsString()) {
+    state->class_linker->intern_table_->RegisterStrong(obj->AsString());
+    return;
+  }
   if (!obj->IsClass()) {
     return;
   }
@@ -484,7 +475,7 @@
   }
 
   // check if this is a root, if so, register it
-  typedef InitCallbackState::Table::const_iterator It;  // TODO: C++0x auto
+  typedef InitFromImageCallbackState::Table::const_iterator It;  // TODO: C++0x auto
   It it = state->descriptor_to_class_root.find(descriptor);
   if (it != state->descriptor_to_class_root.end()) {
     ClassRoot class_root = it->second;
@@ -531,7 +522,7 @@
 
 DexCache* ClassLinker::AllocDexCache(const DexFile& dex_file) {
   DexCache* dex_cache = down_cast<DexCache*>(AllocObjectArray<Object>(DexCache::LengthAsArray()));
-  dex_cache->Init(String::AllocFromModifiedUtf8(dex_file.GetLocation().c_str()),
+  dex_cache->Init(intern_table_->InternStrong(dex_file.GetLocation().c_str()),
                   AllocObjectArray<String>(dex_file.NumStringIds()),
                   AllocObjectArray<Class>(dex_file.NumTypeIds()),
                   AllocObjectArray<Method>(dex_file.NumMethodIds()),
@@ -760,7 +751,7 @@
   if (klass->GetDescriptor() != NULL) {
     DCHECK(klass->GetDescriptor()->Equals(descriptor));
   } else {
-    klass->SetDescriptor(String::AllocFromModifiedUtf8(descriptor));
+    klass->SetDescriptor(intern_table_->InternStrong(descriptor));
   }
   uint32_t access_flags = dex_class_def.access_flags_;
   // Make sure there aren't any "bonus" flags set, since we use them for runtime
@@ -778,7 +769,7 @@
   size_t num_direct_methods = header.direct_methods_size_;
   size_t num_virtual_methods = header.virtual_methods_size_;
 
-  klass->SetSourceFile(String::AllocFromModifiedUtf8(dex_file.dexGetSourceFile(dex_class_def)));
+  klass->SetSourceFile(intern_table_->InternStrong(dex_file.dexGetSourceFile(dex_class_def)));
 
   // Load class interfaces.
   LoadInterfaces(dex_file, dex_class_def, klass);
@@ -885,12 +876,12 @@
   {
     int32_t utf16_length;
     std::string utf8(dex_file.CreateMethodDescriptor(method_id.proto_idx_, &utf16_length));
-    dst->SetSignature(String::AllocFromModifiedUtf8(utf16_length, utf8.c_str()));
+    dst->SetSignature(intern_table_->InternStrong(utf16_length, utf8.c_str()));
   }
   dst->SetProtoIdx(method_id.proto_idx_);
   dst->SetCodeItemOffset(src.code_off_);
   const char* shorty = dex_file.GetShorty(method_id.proto_idx_);
-  dst->SetShorty(String::AllocFromModifiedUtf8(shorty));
+  dst->SetShorty(intern_table_->InternStrong(shorty));
   dst->SetAccessFlags(src.access_flags_);
   dst->SetReturnTypeIdx(dex_file.GetProtoId(method_id.proto_idx_).return_type_idx_);
 
@@ -965,7 +956,7 @@
   Class* klass = AllocClass(sizeof(Class));
   CHECK(klass != NULL);
   klass->SetAccessFlags(kAccPublic | kAccFinal | kAccAbstract);
-  klass->SetDescriptor(String::AllocFromModifiedUtf8(descriptor));
+  klass->SetDescriptor(intern_table_->InternStrong(descriptor));
   klass->SetPrimitiveType(type);
   klass->SetStatus(Class::kStatusInitialized);
   bool success = InsertClass(descriptor, klass);
@@ -1078,7 +1069,7 @@
   if (new_class->GetDescriptor() != NULL) {
     DCHECK(new_class->GetDescriptor()->Equals(descriptor));
   } else {
-    new_class->SetDescriptor(String::AllocFromModifiedUtf8(descriptor.ToString().c_str()));
+    new_class->SetDescriptor(intern_table_->InternStrong(descriptor.ToString().c_str()));
   }
   Class* java_lang_Object = GetClassRoot(kJavaLangObject);
   new_class->SetSuperClass(java_lang_Object);
diff --git a/src/class_linker.h b/src/class_linker.h
index fa0c789..b250593 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -24,10 +24,10 @@
 
 class ClassLinker {
  public:
-  // Initializes the class linker using DexFile and an optional boot Space.
+  // Initializes the class linker using DexFiles and an optional an image.
   static ClassLinker* Create(const std::vector<const DexFile*>& boot_class_path,
                              const std::vector<const DexFile*>& class_path,
-                             InternTable* intern_table, Space* boot_space);
+                             InternTable* intern_table, bool image);
 
   ~ClassLinker();
 
@@ -153,12 +153,11 @@
   void Init(const std::vector<const DexFile*>& boot_class_path_,
             const std::vector<const DexFile*>& class_path_);
 
-  // Initialize class linker from pre-initialized space.
-  void Init(const std::vector<const DexFile*>& boot_class_path_,
-            const std::vector<const DexFile*>& class_path_,
-            Space* space);
-  static void InitCallback(Object* obj, void *arg);
-  struct InitCallbackState;
+  // Initialize class linker from pre-initialized image.
+  void InitFromImage(const std::vector<const DexFile*>& boot_class_path_,
+                     const std::vector<const DexFile*>& class_path_);
+  static void InitFromImageCallback(Object* obj, void *arg);
+  struct InitFromImageCallbackState;
 
   void FinishInit();
 
diff --git a/src/compiler/Ralloc.cc b/src/compiler/Ralloc.cc
index aaec17b..2161949 100644
--- a/src/compiler/Ralloc.cc
+++ b/src/compiler/Ralloc.cc
@@ -106,7 +106,7 @@
             // Skip past "this"
             sReg++;
         }
-        String* shorty = cUnit->method->GetShorty();
+        const String* shorty = cUnit->method->GetShorty();
         for (int i = 1; i < shorty->GetLength(); i++) {
             char arg = shorty->CharAt(i);
             // Is it wide?
diff --git a/src/image.h b/src/image.h
index 00f72ba..02d15de 100644
--- a/src/image.h
+++ b/src/image.h
@@ -15,8 +15,7 @@
  public:
   ImageHeader() {}
 
-  ImageHeader(uint32_t base_addr, uint32_t intern_addr)
-      : base_addr_(base_addr), intern_addr_(intern_addr) {
+  ImageHeader(uint32_t base_addr) : base_addr_(base_addr) {
     memcpy(magic_, kImageMagic, sizeof(kImageMagic));
     memcpy(version_, kImageVersion, sizeof(kImageVersion));
   }
@@ -35,10 +34,6 @@
     return reinterpret_cast<byte*>(base_addr_);
   }
 
-  ObjectArray<Object>* GetInternedArray() const {
-    return reinterpret_cast<ObjectArray<Object>*>(intern_addr_);
-  }
-
  private:
   static const byte kImageMagic[4];
   static const byte kImageVersion[4];
@@ -48,10 +43,6 @@
 
   // required base address for mapping the image.
   uint32_t base_addr_;
-
-  // absolute address of an Object[] of Strings to InternTable::RegisterStrong.
-  // TODO: remove after interning all Strings in image
-  uint32_t intern_addr_;
 };
 
 }  // namespace art
diff --git a/src/image_writer.cc b/src/image_writer.cc
index 859da86..c265838 100644
--- a/src/image_writer.cc
+++ b/src/image_writer.cc
@@ -57,41 +57,6 @@
   return true;
 }
 
-namespace {
-
-struct InternTableVisitorState {
-  int index;
-  ObjectArray<const Object>* interned_array;
-};
-
-void InternTableVisitor(const Object* obj, void* arg) {
-  InternTableVisitorState* state = reinterpret_cast<InternTableVisitorState*>(arg);
-  state->interned_array->Set(state->index++, obj);
-}
-
-ObjectArray<const Object>* CreateInternedArray() {
-  // build a Object[] of the interned strings for reinit
-  // TODO: avoid creating this future garbage
-  Runtime* runtime = Runtime::Current();
-  ClassLinker* class_linker = runtime->GetClassLinker();
-  const InternTable& intern_table = *runtime->GetInternTable();
-  size_t size = intern_table.Size();
-  CHECK_NE(0U, size);
-
-  Class* object_array_class = class_linker->FindSystemClass("[Ljava/lang/Object;");
-  ObjectArray<const Object>* interned_array = ObjectArray<const Object>::Alloc(object_array_class, size);
-
-  InternTableVisitorState state;
-  state.index = 0;
-  state.interned_array = interned_array;
-
-  intern_table.VisitRoots(InternTableVisitor, &state);
-
-  return interned_array;
-}
-
-} // namespace
-
 void ImageWriter::CalculateNewObjectOffsetsCallback(Object* obj, void *arg) {
   DCHECK(obj != NULL);
   DCHECK(arg != NULL);
@@ -99,9 +64,28 @@
   if (!image_writer->InSourceSpace(obj)) {
     return;
   }
-  image_writer->SetImageOffset(obj, image_writer->image_top_);
-  image_writer->image_top_ += RoundUp(obj->SizeOf(), 8);  // 64-bit alignment
-  DCHECK_LT(image_writer->image_top_, image_writer->image_->GetLength());
+
+  // if it is a string, we want to intern it if its not interned.
+  if (obj->IsString()) {
+    // we must be an interned string that was forward referenced and already assigned
+    if (IsImageOffsetAssigned(obj)) {
+      DCHECK_EQ(obj, obj->AsString()->Intern());
+      return;
+    }
+    String* interned = obj->AsString()->Intern();
+    if (obj != interned) {
+      if (!IsImageOffsetAssigned(interned)) {
+        // interned obj is after us, allocate its location early
+        image_writer->AssignImageOffset(interned);
+      }
+      // point those looking for this object to the interned version.
+      SetImageOffset(obj, GetImageOffset(interned));
+      return;
+    }
+    // else (obj == interned), nothing to do but fall through to the normal case
+  }
+
+  image_writer->AssignImageOffset(obj);
 
   // sniff out the DexCaches on this pass for use on the next pass
   if (obj->IsClass()) {
@@ -116,22 +100,18 @@
 }
 
 void ImageWriter::CalculateNewObjectOffsets() {
-  ObjectArray<const Object>* interned_array = CreateInternedArray();
-
   HeapBitmap* heap_bitmap = Heap::GetLiveBits();
   DCHECK(heap_bitmap != NULL);
   DCHECK_EQ(0U, image_top_);
 
-  // leave space for the header, but do not write it yet, we need to
-  // know where interned_array is going to end up
+  // leave space for the header, but do not write it yet
   image_top_ += RoundUp(sizeof(ImageHeader), 8); // 64-bit-alignment
 
   heap_bitmap->Walk(CalculateNewObjectOffsetsCallback, this);  // TODO: add Space-limited Walk
   DCHECK_LT(image_top_, image_->GetLength());
 
-  // return to write header at start of image with future location of interned_array
-  ImageHeader image_header(reinterpret_cast<uint32_t>(image_base_),
-                           reinterpret_cast<uint32_t>(GetImageAddress(interned_array)));
+  // return to write header at start of image
+  ImageHeader image_header(reinterpret_cast<uint32_t>(image_base_));
   memcpy(image_->GetAddress(), &image_header, sizeof(image_header));
 
   // Note that top_ is left at end of used space
diff --git a/src/image_writer.h b/src/image_writer.h
index 9dac31a..a5d3d6a 100644
--- a/src/image_writer.h
+++ b/src/image_writer.h
@@ -29,12 +29,25 @@
   bool Init();
 
   // we use the lock word to store the offset of the object in the image
-  static void SetImageOffset(Object* object, size_t offset) {
+  void AssignImageOffset(Object* object) {
     DCHECK(object != NULL);
     DCHECK(object->GetMonitor() == NULL);  // should be no lock
+    SetImageOffset(object, image_top_);
+    image_top_ += RoundUp(object->SizeOf(), 8);  // 64-bit alignment
+    DCHECK_LT(image_top_, image_->GetLength());
+  }
+  static void SetImageOffset(Object* object, size_t offset) {
+    DCHECK(object != NULL);
+    // should be no lock (but it might be forward referenced interned string)
+    DCHECK(object->GetMonitor() == NULL || object->IsString());
     DCHECK_NE(0U, offset);
     object->SetMonitor(reinterpret_cast<Monitor*>(offset));
   }
+  static size_t IsImageOffsetAssigned(const Object* object) {
+    DCHECK(object != NULL);
+    size_t offset = reinterpret_cast<size_t>(object->GetMonitor());
+    return offset != 0U;
+  }
   static size_t GetImageOffset(const Object* object) {
     DCHECK(object != NULL);
     size_t offset = reinterpret_cast<size_t>(object->GetMonitor());
diff --git a/src/intern_table.cc b/src/intern_table.cc
index 41c1b2a..aa27ace 100644
--- a/src/intern_table.cc
+++ b/src/intern_table.cc
@@ -24,11 +24,11 @@
   // Note: we deliberately don't visit the weak_interns_ table.
 }
 
-const String* InternTable::Lookup(Table& table, const String* s, uint32_t hash_code) {
+String* InternTable::Lookup(Table& table, String* s, uint32_t hash_code) {
   intern_table_lock_.AssertHeld();
   typedef Table::const_iterator It; // TODO: C++0x auto
   for (It it = table.find(hash_code), end = table.end(); it != end; ++it) {
-    const String* existing_string = it->second;
+    String* existing_string = it->second;
     if (existing_string->Equals(s)) {
       return existing_string;
     }
@@ -36,13 +36,13 @@
   return NULL;
 }
 
-const String* InternTable::Insert(Table& table, const String* s, uint32_t hash_code) {
+String* InternTable::Insert(Table& table, String* s, uint32_t hash_code) {
   intern_table_lock_.AssertHeld();
   table.insert(std::make_pair(hash_code, s));
   return s;
 }
 
-void InternTable::RegisterStrong(const String* s) {
+void InternTable::RegisterStrong(String* s) {
   MutexLock mu(intern_table_lock_);
   Insert(strong_interns_, s, s->GetHashCode());
 }
@@ -58,7 +58,7 @@
   }
 }
 
-const String* InternTable::Insert(const String* s, bool is_strong) {
+String* InternTable::Insert(String* s, bool is_strong) {
   MutexLock mu(intern_table_lock_);
 
   DCHECK(s != NULL);
@@ -66,13 +66,13 @@
 
   if (is_strong) {
     // Check the strong table for a match.
-    const String* strong = Lookup(strong_interns_, s, hash_code);
+    String* strong = Lookup(strong_interns_, s, hash_code);
     if (strong != NULL) {
       return strong;
     }
 
     // There is no match in the strong table, check the weak table.
-    const String* weak = Lookup(weak_interns_, s, hash_code);
+    String* weak = Lookup(weak_interns_, s, hash_code);
     if (weak != NULL) {
       // A match was found in the weak table. Promote to the strong table.
       Remove(weak_interns_, weak, hash_code);
@@ -84,12 +84,12 @@
   }
 
   // Check the strong table for a match.
-  const String* strong = Lookup(strong_interns_, s, hash_code);
+  String* strong = Lookup(strong_interns_, s, hash_code);
   if (strong != NULL) {
     return strong;
   }
   // Check the weak table for a match.
-  const String* weak = Lookup(weak_interns_, s, hash_code);
+  String* weak = Lookup(weak_interns_, s, hash_code);
   if (weak != NULL) {
     return weak;
   }
@@ -97,15 +97,23 @@
   return Insert(weak_interns_, s, hash_code);
 }
 
-const String* InternTable::InternStrong(int32_t utf16_length, const char* utf8_data) {
+String* InternTable::InternStrong(int32_t utf16_length, const char* utf8_data) {
   return Insert(String::AllocFromModifiedUtf8(utf16_length, utf8_data), true);
 }
 
-const String* InternTable::InternWeak(const String* s) {
+String* InternTable::InternStrong(const char* utf8_data) {
+  return Insert(String::AllocFromModifiedUtf8(utf8_data), true);
+}
+
+String* InternTable::InternStrong(String* s) {
+  return Insert(s, true);
+}
+
+String* InternTable::InternWeak(String* s) {
   return Insert(s, false);
 }
 
-bool InternTable::ContainsWeak(const String* s) {
+bool InternTable::ContainsWeak(String* s) {
   MutexLock mu(intern_table_lock_);
   const String* found = Lookup(weak_interns_, s, s->GetHashCode());
   return found == s;
diff --git a/src/intern_table.h b/src/intern_table.h
index fe84347..c814a1b 100644
--- a/src/intern_table.h
+++ b/src/intern_table.h
@@ -26,14 +26,20 @@
   InternTable();
 
   // Interns a potentially new string in the 'strong' table. (See above.)
-  const String* InternStrong(int32_t utf16_length, const char* utf8_data);
+  String* InternStrong(int32_t utf16_length, const char* utf8_data);
+
+  // Interns a potentially new string in the 'strong' table. (See above.)
+  String* InternStrong(const char* utf8_data);
+
+  // Interns a potentially new string in the 'strong' table. (See above.)
+  String* InternStrong(String* s);
 
   // Interns a potentially new string in the 'weak' table. (See above.)
-  const String* InternWeak(const String* s);
+  String* InternWeak(String* s);
 
   // Register a String trusting that it is safe to intern.
   // Used when reinitializing InternTable from an image.
-  void RegisterStrong(const String* s);
+  void RegisterStrong(String* s);
 
   // Removes all weak interns for which the predicate functor 'p' returns true.
   // (We use an explicit Predicate type rather than a template to keep implementation
@@ -44,19 +50,19 @@
   };
   void RemoveWeakIf(const Predicate& p);
 
-  bool ContainsWeak(const String* s);
+  bool ContainsWeak(String* s);
 
   size_t Size() const;
 
   void VisitRoots(Heap::RootVisitor* visitor, void* arg) const;
 
  private:
-  typedef std::tr1::unordered_multimap<int32_t, const String*> Table;
+  typedef std::tr1::unordered_multimap<int32_t, String*> Table;
 
-  const String* Insert(const String* s, bool is_strong);
+  String* Insert(String* s, bool is_strong);
 
-  const String* Lookup(Table& table, const String* s, uint32_t hash_code);
-  const String* Insert(Table& table, const String* s, uint32_t hash_code);
+  String* Lookup(Table& table, String* s, uint32_t hash_code);
+  String* Insert(Table& table, String* s, uint32_t hash_code);
   void Remove(Table& table, const String* s, uint32_t hash_code);
 
   mutable Mutex intern_table_lock_;
diff --git a/src/intern_table_test.cc b/src/intern_table_test.cc
index 0362b05..3f9fab0 100644
--- a/src/intern_table_test.cc
+++ b/src/intern_table_test.cc
@@ -90,9 +90,9 @@
   {
     // Strongs are never weak.
     InternTable t;
-    const String* foo_1 = t.InternStrong(3, "foo");
+    String* foo_1 = t.InternStrong(3, "foo");
     EXPECT_FALSE(t.ContainsWeak(foo_1));
-    const String* foo_2 = t.InternStrong(3, "foo");
+    String* foo_2 = t.InternStrong(3, "foo");
     EXPECT_FALSE(t.ContainsWeak(foo_2));
     EXPECT_EQ(foo_1, foo_2);
   }
@@ -100,9 +100,9 @@
   {
     // Weaks are always weak.
     InternTable t;
-    const String* foo_1 = t.InternWeak(String::AllocFromModifiedUtf8("foo"));
+    String* foo_1 = t.InternWeak(String::AllocFromModifiedUtf8("foo"));
     EXPECT_TRUE(t.ContainsWeak(foo_1));
-    const String* foo_2 = t.InternWeak(String::AllocFromModifiedUtf8("foo"));
+    String* foo_2 = t.InternWeak(String::AllocFromModifiedUtf8("foo"));
     EXPECT_TRUE(t.ContainsWeak(foo_2));
     EXPECT_EQ(foo_1, foo_2);
   }
@@ -110,9 +110,9 @@
   {
     // A weak can be promoted to a strong.
     InternTable t;
-    const String* foo_1 = t.InternWeak(String::AllocFromModifiedUtf8("foo"));
+    String* foo_1 = t.InternWeak(String::AllocFromModifiedUtf8("foo"));
     EXPECT_TRUE(t.ContainsWeak(foo_1));
-    const String* foo_2 = t.InternStrong(3, "foo");
+    String* foo_2 = t.InternStrong(3, "foo");
     EXPECT_FALSE(t.ContainsWeak(foo_2));
     EXPECT_EQ(foo_1, foo_2);
   }
@@ -120,9 +120,9 @@
   {
     // Interning a weak after a strong gets you the strong.
     InternTable t;
-    const String* foo_1 = t.InternStrong(3, "foo");
+    String* foo_1 = t.InternStrong(3, "foo");
     EXPECT_FALSE(t.ContainsWeak(foo_1));
-    const String* foo_2 = t.InternWeak(String::AllocFromModifiedUtf8("foo"));
+    String* foo_2 = t.InternWeak(String::AllocFromModifiedUtf8("foo"));
     EXPECT_FALSE(t.ContainsWeak(foo_2));
     EXPECT_EQ(foo_1, foo_2);
   }
diff --git a/src/java_lang_String.cc b/src/java_lang_String.cc
index fbabd43..9aa5221 100644
--- a/src/java_lang_String.cc
+++ b/src/java_lang_String.cc
@@ -148,8 +148,8 @@
 }
 
 jstring String_intern(JNIEnv* env, jobject javaThis) {
-  const String* s = Decode<String*>(env, javaThis);
-  const String* result = s->Intern();
+  String* s = Decode<String*>(env, javaThis);
+  String* result = s->Intern();
   return AddLocalReference<jstring>(env, result);
 }
 
diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index 0f464d2..0129fc5 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -144,7 +144,7 @@
 byte* CreateArgArray(ScopedJniThreadState& ts, Method* method, va_list ap) {
   size_t num_bytes = method->NumArgArrayBytes();
   UniquePtr<byte[]> arg_array(new byte[num_bytes]);
-  String* shorty = method->GetShorty();
+  const String* shorty = method->GetShorty();
   for (int i = 1, offset = 0; i < shorty->GetLength(); ++i) {
     switch (shorty->CharAt(i)) {
       case 'Z':
@@ -181,7 +181,7 @@
 byte* CreateArgArray(ScopedJniThreadState& ts, Method* method, jvalue* args) {
   size_t num_bytes = method->NumArgArrayBytes();
   UniquePtr<byte[]> arg_array(new byte[num_bytes]);
-  String* shorty = method->GetShorty();
+  const String* shorty = method->GetShorty();
   for (int i = 1, offset = 0; i < shorty->GetLength(); ++i) {
     switch (shorty->CharAt(i)) {
       case 'Z':
diff --git a/src/object.cc b/src/object.cc
index 3696374..d78eb24 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -359,7 +359,7 @@
 }
 
 size_t Method::NumArgArrayBytes() const {
-  String* shorty = GetShorty();
+  const String* shorty = GetShorty();
   size_t num_bytes = 0;
   for (int i = 1; i < shorty->GetLength(); ++i) {
     char ch = shorty->CharAt(i);
@@ -385,7 +385,7 @@
 // The number of reference arguments to this method including implicit this
 // pointer
 size_t Method::NumReferenceArgs() const {
-  String* shorty = GetShorty();
+  const String* shorty = GetShorty();
   size_t result = IsStatic() ? 0 : 1;  // The implicit this pointer.
   for (int i = 1; i < shorty->GetLength(); i++) {
     char ch = shorty->CharAt(i);
@@ -398,7 +398,7 @@
 
 // The number of long or double arguments
 size_t Method::NumLongOrDoubleArgs() const {
-  String* shorty = GetShorty();
+  const String* shorty = GetShorty();
   size_t result = 0;
   for (int i = 1; i < shorty->GetLength(); i++) {
     char ch = shorty->CharAt(i);
@@ -981,7 +981,7 @@
   java_lang_String_ = NULL;
 }
 
-const String* String::Intern() const {
+String* String::Intern() {
   return Runtime::Current()->GetInternTable()->InternWeak(this);
 }
 
diff --git a/src/object.h b/src/object.h
index 70a9b33..959abcb 100644
--- a/src/object.h
+++ b/src/object.h
@@ -1940,16 +1940,9 @@
                           klass, false);
   }
 
-  String* GetSourceFile() const {
-    DCHECK(IsLoaded());
-    return GetFieldPtr<String*>(
-        OFFSET_OF_OBJECT_MEMBER(Class, source_file_), false);
-  }
+  String* GetSourceFile() const;
 
-  void SetSourceFile(String* new_source_file) {
-    SetFieldPtr<String*>(OFFSET_OF_OBJECT_MEMBER(Class, source_file_),
-                             new_source_file, false);
-  }
+  void SetSourceFile(String* new_source_file);
 
  private:
   bool Implements(const Class* klass) const;
@@ -2419,7 +2412,7 @@
 
   uint16_t CharAt(int32_t index) const;
 
-  const String* Intern() const;
+  String* Intern();
 
   static String* AllocFromUtf16(int32_t utf16_length,
                                 const uint16_t* utf16_data_in,
@@ -2589,6 +2582,15 @@
                  new_descriptor, false);
 }
 
+inline String* Class::GetSourceFile() const {
+  DCHECK(IsLoaded());
+  return GetFieldObject<String*>(OFFSET_OF_OBJECT_MEMBER(Class, source_file_), false);
+}
+
+inline void Class::SetSourceFile(String* new_source_file) {
+  SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, source_file_), new_source_file, false);
+}
+
 inline uint32_t Method::GetAccessFlags() const {
   DCHECK(GetDeclaringClass()->IsLoaded());
   return GetField32(OFFSET_OF_OBJECT_MEMBER(Method, access_flags_), false);