diff --git a/build/Android.common.mk b/build/Android.common.mk
index c07e6bd..08dc43f 100644
--- a/build/Android.common.mk
+++ b/build/Android.common.mk
@@ -40,7 +40,10 @@
 	src/dex_file.cc \
 	src/dex_instruction.cc \
 	src/dex_verifier.cc \
+	src/file.cc \
+	src/file_linux.cc \
 	src/heap.cc \
+	src/image_writer.cc \
 	src/intern_table.cc \
 	src/jni_compiler.cc \
 	src/jni_internal.cc \
@@ -51,6 +54,7 @@
 	src/object.cc \
 	src/object_bitmap.cc \
 	src/offsets.cc \
+	src/os_linux.cc \
 	src/runtime.cc \
 	src/space.cc \
 	src/stringpiece.cc \
@@ -87,6 +91,8 @@
 	src/dex_file_test.cc \
 	src/dex_instruction_visitor_test.cc \
 	src/exception_test.cc \
+	src/file_test.cc \
+	src/image_test.cc \
 	src/intern_table_test.cc \
 	src/jni_internal_test.cc.arm \
 	src/jni_compiler_test.cc.arm \
diff --git a/src/class_linker.cc b/src/class_linker.cc
index 64b31a2..50b1a07 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -43,10 +43,14 @@
   java_lang_Object->descriptor_ = "Ljava/lang/Object;";
   // backfill Object as the super class of Class
   java_lang_Class->super_class_ = java_lang_Object;
+  // mark as non-primitive for object_array_class
+  java_lang_Object->primitive_type_ = Class::kPrimNot;
 
   // object_array_class is for root_classes to provide the storage for these classes
   Class* object_array_class = AllocClass(java_lang_Class);
   CHECK(object_array_class != NULL);
+  object_array_class->descriptor_ = "[Ljava/lang/Object;";
+  object_array_class->component_type_ = java_lang_Object;
 
   // String and char[] are necessary so that FindClass can assign names to members
   Class* java_lang_String = AllocClass(java_lang_Class);
@@ -56,12 +60,15 @@
   java_lang_String->object_size_ = sizeof(String);
   Class* char_array_class = AllocClass(java_lang_Class);
   CHECK(char_array_class != NULL);
+  char_array_class->descriptor_ = "[C";
 
   // int[] and long[] are used for static field storage
   Class* int_array_class = AllocClass(java_lang_Class);
   CHECK(int_array_class != NULL);
+  int_array_class->descriptor_ = "[I";
   Class* long_array_class = AllocClass(java_lang_Class);
   CHECK(long_array_class != NULL);
+  long_array_class->descriptor_ = "[J";
 
   // Field and Method are necessary so that FindClass can link members
   Class* java_lang_reflect_Field = AllocClass(java_lang_Class);
@@ -219,7 +226,7 @@
 }
 
 Class* ClassLinker::AllocClass(Class* java_lang_Class) {
-  return down_cast<Class*>(java_lang_Class->NewInstance());
+  return java_lang_Class->NewInstance()->AsClass();
 }
 
 Class* ClassLinker::AllocClass() {
diff --git a/src/common_test.h b/src/common_test.h
index b9e7bcc..9acb06c 100644
--- a/src/common_test.h
+++ b/src/common_test.h
@@ -395,6 +395,38 @@
   return dex_file;
 }
 
+class ScratchFile {
+ public:
+  ScratchFile() {
+    std::string filename_template;
+    filename_template = getenv("ANDROID_DATA");
+    filename_template += "/TmpFile-XXXXXX";
+    filename_.reset(strdup(filename_template.c_str()));
+    CHECK(filename_ != NULL);
+    fd_ = mkstemp(filename_.get());
+    CHECK_NE(-1, fd_);
+  }
+
+  ~ScratchFile() {
+    int unlink_result = unlink(filename_.get());
+    CHECK_EQ(0, unlink_result);
+    int close_result = close(fd_);
+    CHECK_EQ(0, close_result);
+  }
+
+  const char* GetFilename() const {
+    return filename_.get();
+  }
+
+  int GetFd() const {
+    return fd_;
+  }
+
+ private:
+  scoped_ptr_malloc<char> filename_;
+  int fd_;
+};
+
 class RuntimeTest : public testing::Test {
  protected:
   virtual void SetUp() {
diff --git a/src/dex_file.cc b/src/dex_file.cc
index da6ae9d..0ccdba4 100644
--- a/src/dex_file.cc
+++ b/src/dex_file.cc
@@ -14,6 +14,7 @@
 #include "globals.h"
 #include "logging.h"
 #include "object.h"
+#include "os.h"
 #include "scoped_ptr.h"
 #include "stringprintf.h"
 #include "thread.h"
@@ -151,15 +152,15 @@
                                 adjacent_dex_filename.end(),
                                 ".dex");
   // Example adjacent_dex_filename = dir/foo.dex
-  struct stat sb;
-  if (stat(adjacent_dex_filename.c_str(), &sb) == 0) {
+  if (OS::FileExists(adjacent_dex_filename.c_str())) {
     DexFile* adjacent_dex_file = DexFile::OpenFile(adjacent_dex_filename);
     if (adjacent_dex_file != NULL) {
-      // We don't verify anything in this case, because we aren't in
-      // the cache and typically the file is in the readonly /system
-      // area, so if something is wrong, there is nothing we can do.
-      return adjacent_dex_file;
+        // We don't verify anything in this case, because we aren't in
+        // the cache and typically the file is in the readonly /system
+        // area, so if something is wrong, there is nothing we can do.
+        return adjacent_dex_file;
     }
+    return NULL;
   }
 
   char resolved[PATH_MAX];
@@ -198,9 +199,11 @@
   // Example cache_path = /data/art-cache/parent@dir@foo.jar@classes.dex.1a2b3c4d
 
   while (true) {
-    DexFile* cached_dex_file = DexFile::OpenFile(cache_path);
-    if (cached_dex_file != NULL) {
-      return cached_dex_file;
+    if (OS::FileExists(cache_path.c_str())) {
+      DexFile* cached_dex_file = DexFile::OpenFile(cache_path);
+      if (cached_dex_file != NULL) {
+        return cached_dex_file;
+      }
     }
 
     // Try to open the temporary cache file, grabbing an exclusive
@@ -245,7 +248,11 @@
 
     // We have the correct file open and locked. Extract classes.dex
     TmpFile tmp_file(cache_path_tmp);
-    bool success = zip_entry->Extract(fd->GetFd());
+    scoped_ptr<File> file(OS::FileFromFd(cache_path_tmp.c_str(), fd->GetFd()));
+    if (file == NULL) {
+      return NULL;
+    }
+    bool success = zip_entry->Extract(*file);
     if (!success) {
       return NULL;
     }
diff --git a/src/file.cc b/src/file.cc
new file mode 100644
index 0000000..df934e9
--- /dev/null
+++ b/src/file.cc
@@ -0,0 +1,36 @@
+// Copyright 2009 Google Inc. All Rights Reserved.
+
+#include "file.h"
+
+namespace art {
+
+bool File::ReadFully(void* buffer, int64_t num_bytes) {
+  int64_t remaining = num_bytes;
+  char* current_buffer = reinterpret_cast<char*>(buffer);
+  while (remaining > 0) {
+    int bytes_read = Read(current_buffer, remaining);
+    if (bytes_read <= 0) {
+      return false;
+    }
+    remaining -= bytes_read;  // Reduce the number of remaining bytes.
+    current_buffer += bytes_read;  // Move the buffer forward.
+  }
+  return true;
+}
+
+
+bool File::WriteFully(const void* buffer, int64_t num_bytes) {
+  int64_t remaining = num_bytes;
+  const char* current_buffer = reinterpret_cast<const char*>(buffer);
+  while (remaining > 0) {
+    int bytes_read = Write(current_buffer, remaining);
+    if (bytes_read < 0) {
+      return false;
+    }
+    remaining -= bytes_read;  // Reduce the number of remaining bytes.
+    current_buffer += bytes_read;  // Move the buffer forward.
+  }
+  return true;
+}
+
+}  // namespace art
diff --git a/src/file.h b/src/file.h
new file mode 100644
index 0000000..680872e
--- /dev/null
+++ b/src/file.h
@@ -0,0 +1,49 @@
+// Copyright 2009 Google Inc. All Rights Reserved.
+
+#ifndef ART_SRC_FILE_H_
+#define ART_SRC_FILE_H_
+
+#include <stdint.h>
+#include <sys/types.h>
+
+namespace art {
+
+class File {
+ public:
+  virtual ~File() { }
+
+  virtual int64_t Read(void* buffer, int64_t num_bytes) = 0;
+  virtual int64_t Write(const void* buffer, int64_t num_bytes) = 0;
+
+  // ReadFully and WriteFully do attempt to transfer all of the bytes to/from
+  // the buffer. In the event of short accesses they will loop internally until
+  // the whole buffer has been transferred or an error occurs. If an error
+  // occurred the result will be set to false.
+  virtual bool ReadFully(void* buffer, int64_t num_bytes);
+  virtual bool WriteFully(const void* buffer, int64_t num_bytes);
+  bool WriteByte(uint8_t byte) {
+    return WriteFully(&byte, 1);
+  }
+
+  // Get the length of the file. Returns a negative value if the length cannot
+  // be determined (e.g. not seekable device).
+  virtual off_t Length() = 0;
+
+  // Get the current position in the file.
+  // Returns a negative value if position cannot be determined.
+  virtual off_t Position() = 0;
+
+  const char* name() const { return name_; }
+
+ protected:
+  explicit File(const char* name) : name_(name) { }
+  virtual void Close() = 0;
+  virtual bool IsClosed() = 0;
+
+ private:
+  const char* name_;
+};
+
+}  // namespace art
+
+#endif  // ART_SRC_FILE_H_
diff --git a/src/file_linux.cc b/src/file_linux.cc
new file mode 100644
index 0000000..367dbe8
--- /dev/null
+++ b/src/file_linux.cc
@@ -0,0 +1,64 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+
+#include "file_linux.h"
+
+#include <errno.h>
+#include <unistd.h>
+
+#include "logging.h"
+
+namespace art {
+
+LinuxFile::~LinuxFile() {
+  // Close the file if necessary (unless it's a standard stream).
+  if (auto_close_ && fd_ > STDERR_FILENO) {
+    Close();
+  }
+}
+
+void LinuxFile::Close() {
+  DCHECK_GT(fd_, 0);
+  int err = close(fd_);
+  if (err != 0) {
+    PLOG(WARNING) << "Problem closing " << name();
+  }
+  fd_ = kClosedFd;
+}
+
+
+bool LinuxFile::IsClosed() {
+  return fd_ == kClosedFd;
+}
+
+
+int64_t LinuxFile::Read(void* buffer, int64_t num_bytes) {
+  DCHECK_GE(fd_, 0);
+  return read(fd_, buffer, num_bytes);
+}
+
+
+int64_t LinuxFile::Write(const void* buffer, int64_t num_bytes) {
+  DCHECK_GE(fd_, 0);
+  return write(fd_, buffer, num_bytes);
+}
+
+
+off_t LinuxFile::Position() {
+  DCHECK_GE(fd_, 0);
+  return lseek(fd_, 0, SEEK_CUR);
+}
+
+
+off_t LinuxFile::Length() {
+  DCHECK_GE(fd_, 0);
+  off_t position = lseek(fd_, 0, SEEK_CUR);
+  if (position < 0) {
+    // The file is not capable of seeking. Return an error.
+    return -1;
+  }
+  off_t result = lseek(fd_, 0, SEEK_END);
+  lseek(fd_, position, SEEK_SET);
+  return result;
+}
+
+}  // namespace art
diff --git a/src/file_linux.h b/src/file_linux.h
new file mode 100644
index 0000000..7e36ada
--- /dev/null
+++ b/src/file_linux.h
@@ -0,0 +1,34 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+
+#ifndef ART_SRC_FILE_LINUX_H_
+#define ART_SRC_FILE_LINUX_H_
+
+#include "file.h"
+
+namespace art {
+
+class LinuxFile : public File {
+ public:
+  LinuxFile(const char* name, int fd, bool auto_close) :
+        File(name), fd_(fd), auto_close_(auto_close) {}
+  virtual ~LinuxFile();
+
+  virtual void Close();
+  virtual bool IsClosed();
+
+  virtual int64_t Read(void* buffer, int64_t num_bytes);
+  virtual int64_t Write(const void* buffer, int64_t num_bytes);
+
+  virtual off_t Length();
+  virtual off_t Position();
+
+ private:
+  static const int kClosedFd = -1;
+
+  int fd_;
+  bool auto_close_;
+};
+
+}  // namespace art
+
+#endif  // ART_SRC_FILE_LINUX_H_
diff --git a/src/file_test.cc b/src/file_test.cc
new file mode 100644
index 0000000..d019d09
--- /dev/null
+++ b/src/file_test.cc
@@ -0,0 +1,47 @@
+// Copyright 2009 Google Inc. All Rights Reserved.
+
+#include "common_test.h"
+#include "file.h"
+#include "os.h"
+#include "scoped_ptr.h"
+
+#include "gtest/gtest.h"
+
+namespace art {
+
+class FileTest : public RuntimeTest {};
+
+TEST_F(FileTest, Read) {
+  std::string filename = GetLibCoreDexFileName();
+  scoped_ptr<File> file(OS::OpenBinaryFile(filename.c_str(), false));
+  ASSERT_TRUE(file != NULL);
+  EXPECT_STREQ(filename.c_str(), file->name());
+  char buffer[3];
+  buffer[0] = '\0';
+  EXPECT_TRUE(file->ReadFully(buffer, 2));  // ReadFully returns true.
+  buffer[2] = '\0';
+  EXPECT_STREQ("PK", buffer); // zip file magic
+  EXPECT_FALSE(file->WriteByte(1));  // Cannot write to a read-only file.
+}
+
+
+TEST_F(FileTest, FileLength) {
+  std::string filename = GetLibCoreDexFileName();
+  scoped_ptr<File> file(OS::OpenBinaryFile(filename.c_str(), false));
+  ASSERT_TRUE(file != NULL);
+  EXPECT_NE(0, file->Length());
+}
+
+
+TEST_F(FileTest, FilePosition) {
+  std::string filename = GetLibCoreDexFileName();
+  scoped_ptr<File> file(OS::OpenBinaryFile(filename.c_str(), false));
+  ASSERT_TRUE(file != NULL);
+  char buf[4];
+  EXPECT_TRUE(file->ReadFully(buf, 2));
+  EXPECT_EQ(2, file->Position());
+  EXPECT_TRUE(file->ReadFully(buf, 2));
+  EXPECT_EQ(4, file->Position());
+}
+
+}  // namespace art
diff --git a/src/heap.h b/src/heap.h
index c71080e..698535f 100644
--- a/src/heap.h
+++ b/src/heap.h
@@ -24,11 +24,7 @@
 
   typedef void (RootVistor)(Object* root, void* arg);
 
-  static bool Init() {
-    return Init(kStartupSize, kMaximumSize);
-  }
-
-  static bool Init(size_t staring_size, size_t maximum_size);
+  static bool Init(size_t starting_size, size_t maximum_size);
 
   static void Destroy();
 
diff --git a/src/image_test.cc b/src/image_test.cc
new file mode 100644
index 0000000..80ccfa0
--- /dev/null
+++ b/src/image_test.cc
@@ -0,0 +1,28 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+#include "common_test.h"
+#include "image_writer.h"
+
+#include "gtest/gtest.h"
+
+namespace art {
+
+class ImageTest : public RuntimeTest {};
+
+TEST_F(ImageTest, WriteRead) {
+  UseLibCoreDex();
+  scoped_ptr<DexFile> libcore_dex_file(GetLibCoreDex());
+  EXPECT_TRUE(libcore_dex_file.get() != NULL);
+
+  // TODO garbage collect before writing
+  const std::vector<Space*>& spaces = Heap::GetSpaces();
+  // can't currently deal with writing a space that might have pointers between spaces
+  CHECK_EQ(1U, spaces.size());
+
+  ImageWriter writer;
+  ScratchFile tmp;
+  bool success = writer.Write(spaces[0], tmp.GetFilename(), reinterpret_cast<byte*>(0x5000000));
+  EXPECT_TRUE(success);
+}
+
+}  // namespace art
diff --git a/src/image_writer.cc b/src/image_writer.cc
new file mode 100644
index 0000000..0014724
--- /dev/null
+++ b/src/image_writer.cc
@@ -0,0 +1,132 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+#include "image_writer.h"
+
+#include <sys/mman.h>
+#include <vector>
+
+#include "file.h"
+#include "globals.h"
+#include "heap.h"
+#include "logging.h"
+#include "object.h"
+#include "space.h"
+#include "utils.h"
+
+namespace art {
+
+bool ImageWriter::Write(Space* space, const char* filename, byte* image_base) {
+  image_base_ = image_base;
+  if (!Init(space)) {
+    return false;
+  }
+  CalculateNewObjectOffsets();
+  CopyAndFixupObjects();
+  
+  scoped_ptr<File> file(OS::OpenBinaryFile(filename, true));
+  if (file == NULL) {
+    return false;
+  }
+  return file->WriteFully(mem_map_->GetAddress(), top_);
+}
+
+bool ImageWriter::Init(Space* space) {
+  size_t size = space->Size();
+  int prot = PROT_READ | PROT_WRITE;
+  int flags = MAP_PRIVATE | MAP_ANONYMOUS;
+  size_t length = RoundUp(size, kPageSize);
+  mem_map_.reset(MemMap::Map(length, prot, flags));
+  if (mem_map_ == NULL) {
+    PLOG(ERROR) << "mmap failed";
+    return false;
+  }
+  return true;
+}
+
+void ImageWriter::CalculateNewObjectOffsets() {
+  HeapBitmap* heap_bitmap = Heap::GetLiveBits();
+  DCHECK(heap_bitmap != NULL);
+  DCHECK_EQ(0U, top_);
+  top_ += sizeof(uint64_t);  // leave a header, ensures objects have non-zero offset for DCHECKs
+  heap_bitmap->Walk(CalculateNewObjectOffsetsCallback, this);
+  DCHECK_LT(top_, mem_map_->GetLength());
+  // Note that top_ is left at end of used space
+}
+
+void ImageWriter::CalculateNewObjectOffsetsCallback(Object *obj, void *arg) {
+  DCHECK(obj != NULL);
+  DCHECK(arg != NULL);
+  ImageWriter* image_writer = reinterpret_cast<ImageWriter*>(arg);
+  image_writer->SetImageOffset(obj, image_writer->top_);
+  image_writer->top_ += RoundUp(obj->Size(), 8);  // 64-bit alignment
+  DCHECK_LT(image_writer->top_, image_writer->mem_map_->GetLength());
+}
+
+void ImageWriter::CopyAndFixupObjects() {
+  HeapBitmap* heap_bitmap = Heap::GetLiveBits();
+  DCHECK(heap_bitmap != NULL);
+  heap_bitmap->Walk(CopyAndFixupObjectsCallback, this);
+}
+
+void ImageWriter::CopyAndFixupObjectsCallback(Object *obj, void *arg) {
+  DCHECK(obj != NULL);
+  DCHECK(arg != NULL);
+  ImageWriter* image_writer = reinterpret_cast<ImageWriter*>(arg);
+  
+  size_t offset = image_writer->GetImageOffset(obj);
+  byte* dst = image_writer->mem_map_->GetAddress() + offset;
+  byte* src = reinterpret_cast<byte*>(obj);
+  size_t n = obj->Size();
+  DCHECK_LT(offset + n, image_writer->mem_map_->GetLength());
+  memcpy(dst, src, n);
+  Object* copy = reinterpret_cast<Object*>(dst);
+  image_writer->FixupObject(obj, copy);
+}
+
+void ImageWriter::FixupObject(Object* orig, Object* copy) {
+  DCHECK(orig != NULL);
+  DCHECK(copy != NULL);
+  copy->klass_ = down_cast<Class*>(GetImageAddress(orig->klass_));
+  // TODO specical case init of pointers to malloc data (or removal of these pointers)
+  if (orig->IsObjectArray()) {
+    FixupObjectArray(orig->AsObjectArray<Object>(), down_cast<ObjectArray<Object>*>(copy));
+  } else {
+    FixupInstanceFields(orig, copy);
+  }
+}
+
+void ImageWriter::FixupObjectArray(ObjectArray<Object>* orig, ObjectArray<Object>* copy) {
+  for (size_t i = 0; i < orig->GetLength(); ++i) {
+    const Object* element = orig->Get(i);
+    copy->Set(i, GetImageAddress(element));
+  }
+}
+
+void ImageWriter::FixupInstanceFields(Object* orig, Object* copy) {
+  uint32_t ref_offsets = orig->GetClass()->GetReferenceOffsets();
+  if (ref_offsets != CLASS_WALK_SUPER) {
+    // Found a reference offset bitmap.  Fixup the specified offsets.
+    while (ref_offsets != 0) {
+      size_t right_shift = CLZ(ref_offsets);
+      size_t byte_offset = CLASS_OFFSET_FROM_CLZ(right_shift);
+      const Object* ref = orig->GetFieldObject(byte_offset);
+      copy->SetFieldObject(byte_offset, GetImageAddress(ref));
+      ref_offsets &= ~(CLASS_HIGH_BIT >> right_shift);
+    }
+  } else {
+    // There is no reference offset bitmap for this class.  Walk up
+    // the class inheritance hierarchy and find reference offsets the
+    // hard way.
+    for (Class *klass = orig->GetClass();
+         klass != NULL;
+         klass = klass->GetSuperClass()) {
+      for (size_t i = 0; i < klass->NumReferenceInstanceFields(); ++i) {
+        size_t field_offset = klass->GetInstanceField(i)->GetOffset();
+        const Object* ref = orig->GetFieldObject(field_offset);
+        copy->SetFieldObject(field_offset, GetImageAddress(ref));
+      }
+    }
+  }
+}
+
+}  // namespace art
diff --git a/src/image_writer.h b/src/image_writer.h
new file mode 100644
index 0000000..ac4a557
--- /dev/null
+++ b/src/image_writer.h
@@ -0,0 +1,68 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+#ifndef ART_SRC_IMAGE_H_
+#define ART_SRC_IMAGE_H_
+
+#include <cstddef>
+#include <stdint.h>
+
+#include "mem_map.h"
+#include "object.h"
+#include "os.h"
+#include "scoped_ptr.h"
+
+namespace art {
+
+class ImageWriter {
+
+ public:
+  ImageWriter() : top_(0), image_base_(NULL) {};
+  bool Write(Space* space, const char* filename, byte* image_base);
+  ~ImageWriter() {};
+
+ private:
+
+  bool Init(Space* space);
+
+  // we use the lock word to store the offset of the object in the image
+  void SetImageOffset(Object* object, size_t offset) {
+    DCHECK(object != NULL);
+    DCHECK(object->monitor_ == NULL);  // should be no lock
+    DCHECK_NE(0U, offset);
+    object->monitor_ = reinterpret_cast<Monitor*>(offset);
+  }
+  size_t GetImageOffset(const Object* object) {
+    DCHECK(object != NULL);
+    size_t offset = reinterpret_cast<size_t>(object->monitor_);
+    DCHECK_NE(0U, offset);
+    return offset;
+  }
+  Object* GetImageAddress(const Object* object) {
+    if (object == NULL) {
+      return NULL;
+    }
+    return reinterpret_cast<Object*>(image_base_ + GetImageOffset(object));
+  }
+
+  void CalculateNewObjectOffsets();
+  static void CalculateNewObjectOffsetsCallback(Object *obj, void *arg);
+
+  void CopyAndFixupObjects();
+  static void CopyAndFixupObjectsCallback(Object *obj, void *arg);
+  void FixupObject(Object* orig, Object* copy);
+  void FixupObjectArray(ObjectArray<Object>* orig, ObjectArray<Object>* copy);
+  void FixupInstanceFields(Object* orig, Object* copy);
+
+  // memory mapped for generating the image
+  scoped_ptr<MemMap> mem_map_;
+
+  // Offset to the free space in mem_map_ 
+  size_t top_;
+
+  // Target base address for the output image
+  byte* image_base_;
+};
+
+}  // namespace art
+
+#endif  // ART_SRC_IMAGE_H_
diff --git a/src/jni_compiler.cc b/src/jni_compiler.cc
index b7d8f5d..07aeec3 100644
--- a/src/jni_compiler.cc
+++ b/src/jni_compiler.cc
@@ -365,7 +365,7 @@
 }
 
 void* JniCompiler::AllocateCode(size_t size) {
-  CHECK_LT(((jni_code_top_ - jni_code_) + size), jni_code_size_);
+  CHECK_LT(((jni_code_top_ - jni_code_->GetAddress()) + size), jni_code_->GetLength());
   void *result = jni_code_top_;
   jni_code_top_ += size;
   return result;
@@ -374,18 +374,13 @@
 JniCompiler::JniCompiler() {
   // TODO: this shouldn't be managed by the JniCompiler, we should have a
   // code cache.
-  jni_code_size_ = kPageSize;
-  jni_code_ = static_cast<byte*>(mmap(NULL, jni_code_size_,
-                                      PROT_READ | PROT_WRITE | PROT_EXEC,
-                                      MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
-  CHECK_NE(MAP_FAILED, jni_code_);
-  jni_code_top_ = jni_code_;
+  jni_code_.reset(MemMap::Map(kPageSize,
+                              PROT_READ | PROT_WRITE | PROT_EXEC,
+                              MAP_ANONYMOUS | MAP_PRIVATE));
+  CHECK(jni_code_ !=  NULL);
+  jni_code_top_ = jni_code_->GetAddress();
 }
 
-JniCompiler::~JniCompiler() {
-  // TODO: this shouldn't be managed by the JniCompiler, we should have a
-  // code cache.
-  CHECK_EQ(0, munmap(jni_code_, jni_code_size_));
-}
+JniCompiler::~JniCompiler() {}
 
 }  // namespace art
diff --git a/src/jni_compiler.h b/src/jni_compiler.h
index c0b14cb..f1bd4e2 100644
--- a/src/jni_compiler.h
+++ b/src/jni_compiler.h
@@ -6,6 +6,8 @@
 #include "calling_convention.h"
 #include "globals.h"
 #include "macros.h"
+#include "mem_map.h"
+#include "scoped_ptr.h"
 
 namespace art {
 
@@ -31,11 +33,8 @@
   // A poor man's code cache
   void* AllocateCode(size_t size);
 
-  // Base of memory region for allocated code
-  byte* jni_code_;
-
-  // Allocated code size
-  size_t jni_code_size_;
+  // Allocated code
+  scoped_ptr<MemMap> jni_code_;
 
   // Pointer to the free space
   byte* jni_code_top_;
diff --git a/src/jni_compiler_test.cc b/src/jni_compiler_test.cc
index 6211d8f..f717014 100644
--- a/src/jni_compiler_test.cc
+++ b/src/jni_compiler_test.cc
@@ -7,7 +7,9 @@
 #include "common_test.h"
 #include "dex_file.h"
 #include "jni_compiler.h"
+#include "mem_map.h"
 #include "runtime.h"
+#include "scoped_ptr.h"
 #include "thread.h"
 #include "gtest/gtest.h"
 
@@ -18,10 +20,10 @@
   virtual void SetUp() {
     RuntimeTest::SetUp();
     // Create thunk code that performs the native to managed transition
-    thunk_code_size_ = kPageSize;
-    thunk_ = mmap(NULL, thunk_code_size_, PROT_READ | PROT_WRITE | PROT_EXEC,
-                  MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
-    CHECK_NE(MAP_FAILED, thunk_);
+    thunk_code_.reset(MemMap::Map(kPageSize,
+                                  PROT_READ | PROT_WRITE | PROT_EXEC,
+                                  MAP_ANONYMOUS | MAP_PRIVATE));
+    CHECK(thunk_code_ !=  NULL);
     Assembler thk_asm;
     // TODO: shouldn't have machine specific code in a general purpose file
 #if defined(__i386__)
@@ -62,7 +64,7 @@
 #error Unimplemented
 #endif
     size_t cs = thk_asm.CodeSize();
-    MemoryRegion code(thunk_, cs);
+    MemoryRegion code(thunk_code_->GetAddress(), cs);
     thk_asm.FinalizeInstructions(code);
     thunk_entry1_ = reinterpret_cast<jint (*)(const void*, art::Method*,
                                               Thread*, jobject, jint, jint,
@@ -77,7 +79,6 @@
   virtual void TearDown() {
     // Release thunk code
     CHECK(runtime_->DetachCurrentThread());
-    CHECK_EQ(0, munmap(thunk_, thunk_code_size_));
   }
 
   // Run generated code associated with method passing and returning int size
@@ -114,8 +115,7 @@
     return result;
   }
 
-  void* thunk_;
-  size_t thunk_code_size_;
+  scoped_ptr<MemMap> thunk_code_;
   jint (*thunk_entry1_)(const void*, Method*, Thread*, jobject, jint, jint,
                         jint);
   jdouble (*thunk_entry2_)(const void*, Method*, Thread*, jobject, jdouble,
diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index 6e61001..9c2093c 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -1892,6 +1892,7 @@
 };
 
 void MonitorEnterHelper(JNIEnv* env, jobject obj) {
+  env = Thread::Current()->GetJniEnv();  // XXX bdc do not commit workaround
   CHECK_EQ(Thread::Current()->GetJniEnv(), env);
   MonitorEnter(env, obj);  // Ignore the result.
 }
diff --git a/src/mark_stack.cc b/src/mark_stack.cc
index 47aaf0c..19dc1c1 100644
--- a/src/mark_stack.cc
+++ b/src/mark_stack.cc
@@ -22,13 +22,14 @@
 
 bool MarkStack::Init(size_t maximum_size) {
   size_t length = 64 * MB;
-  void* addr = mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-  if (addr == MAP_FAILED) {
+  mem_map_.reset(MemMap::Map(length, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS));
+  if (mem_map_ == NULL) {
     PLOG(ERROR) << "mmap failed";
     return false;
   }
+  byte* addr = mem_map_->GetAddress();
   base_ = reinterpret_cast<const Object**>(addr);
-  limit_ = reinterpret_cast<const Object**>((byte*)addr + length);
+  limit_ = reinterpret_cast<const Object**>(addr + length);
   ptr_ = reinterpret_cast<Object const**>(addr);
   int result = madvise(addr, length, MADV_DONTNEED);
   if (result == -1) {
@@ -37,11 +38,6 @@
   return true;
 }
 
-MarkStack::~MarkStack() {
-  int result = munmap((void*)base_, limit_ - base_);
-  if (result == -1) {
-    PLOG(WARNING) << "munmap failed";
-  }
-}
+MarkStack::~MarkStack() {}
 
 }  // namespace art
diff --git a/src/mark_stack.h b/src/mark_stack.h
index eeeb79c..38252c2 100644
--- a/src/mark_stack.h
+++ b/src/mark_stack.h
@@ -5,6 +5,8 @@
 
 #include "logging.h"
 #include "macros.h"
+#include "mem_map.h"
+#include "scoped_ptr.h"
 
 namespace art {
 
@@ -41,6 +43,9 @@
 
   bool Init(size_t maximum_size);
 
+  // Memory mapping of the mark stack.
+  scoped_ptr<MemMap> mem_map_;
+
   // Base of the mark stack.
   const Object* const* base_;
 
diff --git a/src/mark_sweep.cc b/src/mark_sweep.cc
index 523b9e4..5d7c139 100644
--- a/src/mark_sweep.cc
+++ b/src/mark_sweep.cc
@@ -13,8 +13,6 @@
 #include "space.h"
 #include "thread.h"
 
-#define CLZ(x) __builtin_clz(x)
-
 namespace art {
 
 size_t MarkSweep::reference_referent_offset_ = 0;  // TODO
@@ -205,7 +203,7 @@
   DCHECK(obj->GetClass() != NULL);
   MarkObject(obj->GetClass());
   if (obj->IsObjectArray()) {
-    const ObjectArray<Object>* array = obj->AsObjectArray();
+    const ObjectArray<Object>* array = obj->AsObjectArray<Object>();
     for (size_t i = 0; i < array->GetLength(); ++i) {
       const Object* element = array->Get(i);
       MarkObject(element);
diff --git a/src/mem_map.h b/src/mem_map.h
new file mode 100644
index 0000000..4625f91
--- /dev/null
+++ b/src/mem_map.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_SRC_MEM_MAP_H_
+#define ART_SRC_MEM_MAP_H_
+
+#include <sys/mman.h>
+
+#include "utils.h"
+
+namespace art {
+
+// Used to keep track of mmap segments.
+class MemMap {
+ public:
+
+  // Request an anonymous region of a specified length.
+  //
+  // On success, returns returns a MemMap instance.  On failure, returns a NULL;
+  static MemMap* Map(size_t length, int prot, int flags) {
+    size_t page_aligned_size = RoundUp(length, kPageSize);
+    byte* addr = reinterpret_cast<byte*>(mmap(NULL,
+                                              page_aligned_size,
+                                              prot,
+                                              MAP_ANONYMOUS | flags,
+                                              -1,
+                                              0));
+    if (addr == MAP_FAILED) {
+      return NULL;
+    }
+    return new MemMap(addr, length, addr, page_aligned_size);
+  }
+
+  // Map part of a file, taking care of non-page aligned offsets.  The
+  // "start" offset is absolute, not relative.
+  //
+  // On success, returns returns a MemMap instance.  On failure, returns a NULL;
+  static MemMap* Map(size_t length, int prot, int flags, int fd, off_t start) {
+    // adjust to be page-aligned
+    int page_offset = start % kPageSize;
+    off_t page_aligned_offset = start - page_offset;
+    size_t page_aligned_size = length + page_offset;
+    byte* addr = reinterpret_cast<byte*>(mmap(NULL,
+                                              page_aligned_size,
+                                              prot,
+                                              MAP_FILE | flags,
+                                              fd,
+                                              page_aligned_offset));
+    if (addr == MAP_FAILED) {
+      return NULL;
+    }
+    return new MemMap(addr+page_offset, length, addr, page_aligned_size);
+  }
+
+  ~MemMap() {
+    Unmap();
+  };
+
+  // Release a memory mapping, returning true on success or it was previously unmapped.
+  bool Unmap() {
+    if (base_addr_ == NULL && base_length_ == 0) {
+      return true;
+    }
+    int result = munmap(base_addr_, base_length_);
+    base_addr_ = NULL;
+    base_length_ = 0;
+    if (result == -1) {
+      return false;
+    }
+    return true;
+  }
+
+  byte* GetAddress() const {
+    return addr_;
+  }
+
+  size_t GetLength() const {
+    return length_;
+  }
+
+ private:
+  MemMap(byte* addr, size_t length, void* base_addr, size_t base_length)
+      : addr_(addr), length_(length), base_addr_(base_addr), base_length_(base_length) {
+    CHECK(addr_ != NULL);
+    CHECK(length_ != 0);
+    CHECK(base_addr_ != NULL);
+    CHECK(base_length_ != 0);
+  };
+
+  byte*  addr_;              // start of data
+  size_t length_;            // length of data
+
+  void*  base_addr_;         // page-aligned base address
+  size_t base_length_;       // length of mapping
+};
+
+}  // namespace art
+
+#endif  // ART_SRC_MEM_MAP_H_
diff --git a/src/memory_region.h b/src/memory_region.h
index 3d04d91..f1a3ec5 100644
--- a/src/memory_region.h
+++ b/src/memory_region.h
@@ -76,8 +76,6 @@
 
   void* pointer_;
   size_t size_;
-
-  DISALLOW_COPY_AND_ASSIGN(MemoryRegion);
 };
 
 }  // namespace art
diff --git a/src/object.h b/src/object.h
index 927729c..cb7f379 100644
--- a/src/object.h
+++ b/src/object.h
@@ -118,11 +118,14 @@
   }
 
   Class* GetClass() const {
+    DCHECK(klass_ != NULL);
     return klass_;
   }
 
   bool InstanceOf(const Class* klass) const;
 
+  size_t Size() const;
+
   void MonitorEnter() {
     monitor_->Enter();
   }
@@ -152,12 +155,14 @@
   }
 
   const Object* GetFieldObject(size_t field_offset) const {
-    const byte* raw_addr = reinterpret_cast<const byte*>(this) + field_offset;
-    return *reinterpret_cast<Object* const*>(raw_addr);
+    Object* that = const_cast<Object*>(this);
+    Object* other = that->GetFieldObject(field_offset);
+    return const_cast<const Object*>(other);
   }
 
   Object* GetFieldObject(size_t field_offset) {
-    return const_cast<Object*>(GetFieldObject(field_offset));
+    byte* raw_addr = reinterpret_cast<byte*>(this) + field_offset;
+    return *reinterpret_cast<Object**>(raw_addr);
   }
 
   void SetFieldObject(size_t offset, Object* new_value) {
@@ -166,26 +171,30 @@
     // TODO: write barrier
   }
 
-  bool IsClass() const {
-    UNIMPLEMENTED(FATAL);
-    return true;
-  }
+  bool IsClass() const;
 
   Class* AsClass() {
+    DCHECK(IsClass());
     return down_cast<Class*>(this);
   }
 
   const Class* AsClass() const {
+    DCHECK(IsClass());
     return down_cast<const Class*>(this);
   }
 
-  bool IsObjectArray() const {
-    UNIMPLEMENTED(FATAL);
-    return true;
+  bool IsObjectArray() const;
+
+  template<class T>
+  ObjectArray<T>* AsObjectArray() {
+    DCHECK(IsObjectArray());
+    return down_cast<ObjectArray<T>*>(this);
   }
 
-  const ObjectArray<Object>* AsObjectArray() const {
-    return down_cast<const ObjectArray<Object>*>(this);
+  template<class T>
+  const ObjectArray<T>* AsObjectArray() const {
+    DCHECK(IsObjectArray());
+    return down_cast<const ObjectArray<T>*>(this);
   }
 
   bool IsReference() const {
@@ -213,9 +222,16 @@
     return true;
   }
 
-  bool IsArray() const {
-    UNIMPLEMENTED(FATAL);
-    return true;
+  bool IsArray() const;
+
+  Array* AsArray() {
+    DCHECK(IsArray());
+    return down_cast<Array*>(this);
+  }
+
+  const Array* AsArray() const {
+    DCHECK(IsArray());
+    return down_cast<const Array*>(this);
   }
 
  public:
@@ -578,17 +594,23 @@
 
 class Array : public Object {
  public:
+  static size_t Size(size_t component_count,
+                     size_t component_size) {
+    return sizeof(Array) + component_count * component_size;
+  }
   static Array* Alloc(Class* array_class,
                       size_t component_count,
                       size_t component_size) {
-    size_t size = sizeof(Array) + component_count * component_size;
-    Array* array = down_cast<Array*>(Heap::AllocObject(array_class, size));
+    size_t size = Size(component_count, component_size);
+    Array* array = Heap::AllocObject(array_class, size)->AsArray();
     if (array != NULL) {
       array->SetLength(component_count);
     }
     return array;
   }
 
+  size_t Size() const;
+
   uint32_t GetLength() const {
     return length_;
   }
@@ -611,9 +633,7 @@
  public:
   static ObjectArray<T>* Alloc(Class* object_array_class,
                                size_t length) {
-    return down_cast<ObjectArray<T>*>(Array::Alloc(object_array_class,
-                                                   length,
-                                                   sizeof(uint32_t)));
+    return Array::Alloc(object_array_class, length, sizeof(uint32_t))->AsObjectArray<T>();
   }
 
   T* const * GetData() const {
@@ -775,6 +795,24 @@
     return component_type_;
   }
 
+  size_t GetComponentSize() const {
+    switch (component_type_->descriptor_[0]) {
+      case 'B': return 1;  // byte
+      case 'C': return 2;  // char
+      case 'D': return 8;  // double
+      case 'F': return 4;  // float
+      case 'I': return 4;  // int
+      case 'J': return 8;  // long
+      case 'S': return 2;  // short
+      case 'Z': return 1;  // boolean
+      case 'L': return sizeof(Object*);
+      case '[': return sizeof(Array*);
+      default: 
+        LOG(ERROR) << "Unknown component type " << component_type_->descriptor_;
+        return 0;
+    }
+  }
+
   const StringPiece& GetDescriptor() const {
     DCHECK_NE(0, descriptor_.size());
     return descriptor_;
@@ -1115,6 +1153,28 @@
   return klass->IsAssignableFrom(klass_);
 }
 
+inline bool Object::IsClass() const {
+  return klass_ == klass_->klass_;
+}
+
+inline bool Object::IsObjectArray() const {
+  return IsArray() && !klass_->component_type_->IsPrimitive();
+}
+
+inline bool Object::IsArray() const {
+  return klass_->IsArray();
+}
+
+inline size_t Object::Size() const {
+  if (IsArray()) {
+    return AsArray()->Size();
+  }
+  return klass_->object_size_;
+}
+
+inline size_t Array::Size() const {
+  return Size(GetLength(), klass_->GetComponentSize());
+}
 
 class DataObject : public Object {
  public:
diff --git a/src/object_bitmap.cc b/src/object_bitmap.cc
index 85fee73..fc3c2ee4 100644
--- a/src/object_bitmap.cc
+++ b/src/object_bitmap.cc
@@ -21,8 +21,6 @@
 
 namespace art {
 
-#define CLZ(x) __builtin_clz(x)
-
 HeapBitmap* HeapBitmap::Create(byte* base, size_t length) {
   scoped_ptr<HeapBitmap> bitmap(new HeapBitmap(base, length));
   if (!bitmap->Init(base, length)) {
@@ -38,12 +36,12 @@
 bool HeapBitmap::Init(const byte* base, size_t max_size) {
   CHECK(base != NULL);
   size_t length = HB_OFFSET_TO_INDEX(max_size) * kWordSize;
-  void* words = mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-  if (words == MAP_FAILED) {
+  mem_map_.reset(MemMap::Map(length, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS));
+  if (mem_map_ == NULL) {
     LOG(ERROR) << "mmap failed";
     return false;
   }
-  words_ = static_cast<unsigned long*>(words);
+  words_ = reinterpret_cast<word*>(mem_map_->GetAddress());
   num_bytes_ = length;
   base_ = reinterpret_cast<uintptr_t>(base);
   max_ = base_ - 1;
@@ -51,15 +49,7 @@
 }
 
 // Clean up any resources associated with the bitmap.
-HeapBitmap::~HeapBitmap() {
-  if (words_ != NULL) {
-    int result = munmap(words_, num_bytes_);
-    if (result == -1) {
-      PLOG(WARNING) << "munmap failed";
-    }
-    words_ = NULL;
-  }
-}
+HeapBitmap::~HeapBitmap() {}
 
 // Fill the bitmap with zeroes.  Returns the bitmap's memory to the
 // system as a side-effect.
@@ -169,8 +159,8 @@
   void** pb = pointer_buf;
   size_t start = HB_OFFSET_TO_INDEX(base - live_bitmap.base_);
   size_t end = HB_OFFSET_TO_INDEX(max - live_bitmap.base_);
-  unsigned long* live = live_bitmap.words_;
-  unsigned long* mark = mark_bitmap.words_;
+  word* live = live_bitmap.words_;
+  word* mark = mark_bitmap.words_;
   for (size_t i = start; i <= end; i++) {
     unsigned long garbage = live[i] & ~mark[i];
     if (garbage != 0) {
diff --git a/src/object_bitmap.h b/src/object_bitmap.h
index d766a83..3cc973c 100644
--- a/src/object_bitmap.h
+++ b/src/object_bitmap.h
@@ -20,6 +20,8 @@
 
 #include "globals.h"
 #include "logging.h"
+#include "mem_map.h"
+#include "scoped_ptr.h"
 
 namespace art {
 
@@ -117,7 +119,9 @@
 
   bool Init(const byte* base, size_t length);
 
-  unsigned long* words_;
+  scoped_ptr<MemMap> mem_map_;
+
+  word* words_;
 
   size_t num_bytes_;
 
diff --git a/src/os.h b/src/os.h
new file mode 100644
index 0000000..440c997
--- /dev/null
+++ b/src/os.h
@@ -0,0 +1,28 @@
+// Copyright 2009 Google Inc. All Rights Reserved.
+
+#ifndef ART_SRC_OS_H_
+#define ART_SRC_OS_H_
+
+namespace art {
+
+// Interface to the underlying OS platform.
+
+class File;
+
+class OS {
+ public:
+
+  // Open a file. The returned file must be deleted by the caller.
+  static File* OpenBinaryFile(const char* name, bool writable);
+  static File* OpenTextFile(const char* name, bool writable);
+
+  // Create a file from an already open file descriptor
+  static File* FileFromFd(const char* name, int fd);
+
+  // Check if a file exists.
+  static bool FileExists(const char* name);
+};
+
+}  // namespace art
+
+#endif  // ART_SRC_OS_H_
diff --git a/src/os_linux.cc b/src/os_linux.cc
new file mode 100644
index 0000000..da8ea38
--- /dev/null
+++ b/src/os_linux.cc
@@ -0,0 +1,43 @@
+// Copyright 2010 Google Inc. All Rights Reserved.
+
+#include "os.h"
+
+#include <cstddef>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include "file_linux.h"
+
+namespace art {
+
+File* OS::OpenBinaryFile(const char* name, bool writable) {
+  int flags = O_RDONLY;
+  if (writable) {
+    flags = (O_RDWR | O_CREAT | O_TRUNC);
+  }
+  int fd = open(name, flags, 0666);
+  if (fd < 0) {
+    return NULL;
+  }
+  return new LinuxFile(name, fd, true);
+}
+
+File* OS::OpenTextFile(const char* name, bool writable) {
+  return OpenBinaryFile(name, writable);
+}
+
+File* OS::FileFromFd(const char* name, int fd) {
+  return new LinuxFile(name, fd, false);
+}
+
+bool OS::FileExists(const char* name) {
+  struct stat st;
+  if (stat(name, &st) == 0) {
+    return S_ISREG(st.st_mode);  // TODO Deal with symlinks?
+  } else {
+    return false;
+  }
+}
+
+}  // namespace art
diff --git a/src/runtime_test.cc b/src/runtime_test.cc
index 4b59cb3..3949ac8 100644
--- a/src/runtime_test.cc
+++ b/src/runtime_test.cc
@@ -1,6 +1,6 @@
 // Copyright 2011 Google Inc. All Rights Reserved.
 
-#include "src/runtime.h"
+#include "runtime.h"
 
 #include "gtest/gtest.h"
 
diff --git a/src/scoped_ptr.h b/src/scoped_ptr.h
index c76a64e..4d9b9b6 100644
--- a/src/scoped_ptr.h
+++ b/src/scoped_ptr.h
@@ -18,9 +18,9 @@
 //  implementation of the scoped_ptr class, and its closely-related brethren,
 //  scoped_array, scoped_ptr_malloc, and make_scoped_ptr.
 
+#include "logging.h"
 #include "macros.h"
 
-#include <assert.h>
 #include <stdlib.h>
 
 #include <algorithm>
@@ -71,13 +71,13 @@
   }
 
   // Accessors to get the owned object.
-  // operator* and operator-> will assert() if there is no current object.
+  // operator* and operator-> will DCHECK() if there is no current object.
   C& operator*() const {
-    assert(ptr_ != NULL);
+    DCHECK(ptr_ != NULL);
     return *ptr_;
   }
   C* operator->() const  {
-    assert(ptr_ != NULL);
+    DCHECK(ptr_ != NULL);
     return ptr_;
   }
   C* get() const { return ptr_; }
@@ -190,10 +190,10 @@
   }
 
   // Get one element of the current object.
-  // Will assert() if there is no current object, or index i is negative.
+  // Will DCHECK() if there is no current object, or index i is negative.
   C& operator[](std::ptrdiff_t i) const {
-    assert(i >= 0);
-    assert(array_ != NULL);
+    DCHECK_GE(i, 0);
+    DCHECK(array_ != NULL);
     return array_[i];
   }
 
@@ -295,15 +295,15 @@
   }
 
   // Get the current object.
-  // operator* and operator-> will cause an assert() failure if there is
+  // operator* and operator-> will cause an DCHECK() failure if there is
   // no current object.
   C& operator*() const {
-    assert(ptr_ != NULL);
+    DCHECK(ptr_ != NULL);
     return *ptr_;
   }
 
   C* operator->() const {
-    assert(ptr_ != NULL);
+    DCHECK(ptr_ != NULL);
     return ptr_;
   }
 
diff --git a/src/space.cc b/src/space.cc
index 9f01838..c3d763c 100644
--- a/src/space.cc
+++ b/src/space.cc
@@ -48,30 +48,22 @@
   size_t length = RoundUp(maximum_size_, kPageSize);
   int prot = PROT_READ | PROT_WRITE;
   int flags = MAP_PRIVATE | MAP_ANONYMOUS;
-  void* base = mmap(NULL, length, prot, flags, -1, 0);
-  if (base == MAP_FAILED) {
+  mem_map_.reset(MemMap::Map(length, prot, flags));
+  if (mem_map_ == NULL) {
     PLOG(ERROR) << "mmap failed";
     return false;
   }
-  base_ = static_cast<byte*>(base);
+  base_ = mem_map_->GetAddress();
   limit_ = base_ + length;
-  mspace_ = CreateMallocSpace(base, startup_size_, maximum_size_);
+  mspace_ = CreateMallocSpace(base_, startup_size_, maximum_size_);
   if (mspace_ == NULL) {
-    munmap(base_, length);
+    mem_map_->Unmap();
     return false;
   }
   return true;
 }
 
-Space::~Space() {
-  if (base_ == NULL) {
-    return;
-  }
-  int result = munmap(base_, limit_ - base_);
-  if (result == -1) {
-    PLOG(WARNING) << "munmap failed";
-  }
-}
+Space::~Space() {}
 
 Object* Space::AllocWithoutGrowth(size_t num_bytes) {
   return reinterpret_cast<Object*>(mspace_calloc(mspace_, 1, num_bytes));
diff --git a/src/space.h b/src/space.h
index 3cfa505..7b72bba 100644
--- a/src/space.h
+++ b/src/space.h
@@ -5,6 +5,8 @@
 
 #include "globals.h"
 #include "macros.h"
+#include "mem_map.h"
+#include "scoped_ptr.h"
 
 namespace art {
 
@@ -29,21 +31,21 @@
 
   void Grow(size_t num_bytes);
 
-  byte* GetBase() {
+  byte* GetBase() const {
     return base_;
   }
 
-  byte* GetLimit() {
+  byte* GetLimit() const {
     return limit_;
   }
 
-  size_t Size() {
+  size_t Size() const {
     return limit_ - base_;
   }
 
   size_t AllocationSize(const Object* obj);
 
-  bool IsCondemned() {
+  bool IsCondemned() const {
     return true;  // TODO
   }
 
@@ -68,6 +70,8 @@
 
   void* mspace_;
 
+  scoped_ptr<MemMap> mem_map_;
+
   byte* base_;
 
   byte* limit_;
diff --git a/src/utils.h b/src/utils.h
index ddecef9..842db63 100644
--- a/src/utils.h
+++ b/src/utils.h
@@ -4,6 +4,7 @@
 #define ART_SRC_UTILS_H_
 
 #include "globals.h"
+#include "logging.h"
 #include "stringprintf.h"
 
 namespace art {
@@ -96,6 +97,8 @@
   return static_cast<int>(x & 0x0000003F);
 }
 
+#define CLZ(x) __builtin_clz(x)
+
 static inline bool NeedsEscaping(uint16_t ch) {
   return (ch < ' ' || ch > '~');
 }
diff --git a/src/zip_archive.cc b/src/zip_archive.cc
index 2c63150..fe263ba 100644
--- a/src/zip_archive.cc
+++ b/src/zip_archive.cc
@@ -24,13 +24,13 @@
 namespace art {
 
 // Get 2 little-endian bytes.
-static uint32_t Le16ToHost(const uint8_t* src) {
+static uint32_t Le16ToHost(const byte* src) {
   return ((src[0] <<  0) |
           (src[1] <<  8));
 }
 
 // Get 4 little-endian bytes.
-static uint32_t Le32ToHost(const uint8_t* src) {
+static uint32_t Le32ToHost(const byte* src) {
   return ((src[0] <<  0) |
           (src[1] <<  8) |
           (src[2] << 16) |
@@ -114,22 +114,7 @@
   return data_offset;
 }
 
-// Write until all bytes have been written, returning true on success
-bool WriteFully(int fd, const uint8_t* buf, size_t count) {
-  while (count != 0) {
-    ssize_t actual = TEMP_FAILURE_RETRY(write(fd, buf, count));
-    if (actual < 0) {
-      return false;
-    }
-    if (actual != static_cast<ssize_t>(count)) {
-      buf += actual;
-    }
-    count -= actual;
-  }
-  return true;
-}
-
-static bool CopyFdToFd(int out, int in, size_t count) {
+static bool CopyFdToFile(File& file, int in, size_t count) {
   const size_t kBufSize = 32768;
   uint8_t buf[kBufSize];
 
@@ -139,7 +124,7 @@
     if (actual != static_cast<ssize_t>(bytes_to_read)) {
       return false;
     }
-    if (!WriteFully(out, buf, bytes_to_read)) {
+    if (!file.WriteFully(buf, bytes_to_read)) {
       return false;
     }
     count -= bytes_to_read;
@@ -149,7 +134,7 @@
 
 class ZStream {
  public:
-  ZStream(uint8_t* write_buf, size_t write_buf_size) {
+  ZStream(byte* write_buf, size_t write_buf_size) {
     // Initialize the zlib stream struct.
     memset(&zstream_, 0, sizeof(zstream_));
     zstream_.zalloc = Z_NULL;
@@ -173,7 +158,7 @@
   z_stream zstream_;
 };
 
-static bool InflateToFd(int out, int in, size_t uncompressed_length, size_t compressed_length) {
+static bool InflateToFile(File& out, int in, size_t uncompressed_length, size_t compressed_length) {
   const size_t kBufSize = 32768;
   scoped_array<uint8_t> read_buf(new uint8_t[kBufSize]);
   scoped_array<uint8_t> write_buf(new uint8_t[kBufSize]);
@@ -227,7 +212,7 @@
     if (zstream->Get().avail_out == 0 ||
         (zerr == Z_STREAM_END && zstream->Get().avail_out != kBufSize)) {
       size_t bytes_to_write = zstream->Get().next_out - write_buf.get();
-      if (!WriteFully(out, write_buf.get(), bytes_to_write)) {
+      if (!out.WriteFully(write_buf.get(), bytes_to_write)) {
         return false;
       }
       zstream->Get().next_out = write_buf.get();
@@ -247,7 +232,7 @@
   return true;
 }
 
-bool ZipEntry::Extract(int fd) {
+bool ZipEntry::Extract(File& file) {
 
   off_t data_offset = GetDataOffset();
   if (data_offset == -1) {
@@ -262,9 +247,9 @@
   // for uncompressed data).
   switch (GetCompressionMethod()) {
     case kCompressStored:
-      return CopyFdToFd(fd, zip_archive_->fd_, GetUncompressedLength());
+      return CopyFdToFile(file, zip_archive_->fd_, GetUncompressedLength());
     case kCompressDeflated:
-      return InflateToFd(fd, zip_archive_->fd_, GetUncompressedLength(), GetCompressedLength());
+      return InflateToFile(file, zip_archive_->fd_, GetUncompressedLength(), GetCompressedLength());
     default:
       return false;
   }
@@ -376,7 +361,7 @@
   }
 
   off_t eocd_offset = search_start + i;
-  const uint8_t* eocd_ptr = scan_buf.get() + i;
+  const byte* eocd_ptr = scan_buf.get() + i;
 
   DCHECK(eocd_offset < file_length);
 
@@ -399,7 +384,7 @@
   }
 
   // It all looks good.  Create a mapping for the CD.
-  dir_map_.reset(MemMap::Map(fd_, dir_offset, dir_size));
+  dir_map_.reset(MemMap::Map(dir_size, PROT_READ, MAP_SHARED, fd_, dir_offset));
   if (dir_map_ == NULL) {
     LOG(WARNING) << "Zip: cd map failed " << strerror(errno);
     return false;
@@ -411,12 +396,12 @@
 }
 
 bool ZipArchive::Parse() {
-  const uint8_t* cd_ptr = reinterpret_cast<const uint8_t*>(dir_map_->GetAddress());
+  const byte* cd_ptr = dir_map_->GetAddress();
   size_t cd_length = dir_map_->GetLength();
 
   // Walk through the central directory, adding entries to the hash
   // table and verifying values.
-  const uint8_t* ptr = cd_ptr;
+  const byte* ptr = cd_ptr;
   for (int i = 0; i < num_entries_; i++) {
     if (Le32ToHost(ptr) != kCDESignature) {
       LOG(WARNING) << "Zip: missed a central dir sig (at " << i << ")";
diff --git a/src/zip_archive.h b/src/zip_archive.h
index 858afe0..8001fa3 100644
--- a/src/zip_archive.h
+++ b/src/zip_archive.h
@@ -22,8 +22,10 @@
 #include <sys/mman.h>
 #include <zlib.h>
 
+#include "file.h"
 #include "globals.h"
 #include "logging.h"
+#include "mem_map.h"
 #include "scoped_ptr.h"
 #include "stringpiece.h"
 #include "unordered_map.h"
@@ -37,13 +39,13 @@
 
  public:
   // Uncompress an entry, in its entirety, to an open file descriptor.
-  bool Extract(int fd);
+  bool Extract(File& file);
 
   uint32_t GetCrc32();
 
  private:
 
-  ZipEntry(ZipArchive* zip_archive, const uint8_t* ptr) : zip_archive_(zip_archive), ptr_(ptr) {};
+  ZipEntry(ZipArchive* zip_archive, const byte* ptr) : zip_archive_(zip_archive), ptr_(ptr) {};
 
   // Zip compression methods
   enum {
@@ -64,78 +66,11 @@
   ZipArchive* zip_archive_;
 
   // pointer to zip entry within central directory
-  const uint8_t* ptr_;
+  const byte* ptr_;
 
   friend class ZipArchive;
 };
 
-// Used to keep track of unaligned mmap segments.
-class MemMap {
- public:
-
-  // Map part of a file into a shared, read-only memory segment.  The "start"
-  // offset is absolute, not relative.
-  //
-  // On success, returns returns a MemMap instance.  On failure, returns a NULL;
-  static MemMap* Map(int fd, off_t start, size_t length) {
-    // adjust to be page-aligned
-    int page_offset = start % kPageSize;
-    off_t page_aligned_offset = start - page_offset;
-    size_t page_aligned_size = length + page_offset;
-    uint8_t* addr = reinterpret_cast<uint8_t*>(mmap(NULL,
-                                                    page_aligned_size,
-                                                    PROT_READ,
-                                                    MAP_FILE | MAP_SHARED,
-                                                    fd,
-                                                    page_aligned_offset));
-    if (addr == MAP_FAILED) {
-      return NULL;
-    }
-    return new MemMap(addr+page_offset, length, addr, page_aligned_size);
-  }
-
-  ~MemMap() {
-    Unmap();
-  };
-
-  // Release a memory mapping, returning true on success or it was previously unmapped.
-  bool Unmap() {
-    if (base_addr_ == NULL && base_length_ == 0) {
-      return true;
-    }
-    int result = munmap(base_addr_, base_length_);
-    if (result != 0) {
-      return false;
-    }
-    base_addr_ = NULL;
-    base_length_ = 0;
-    return true;
-  }
-
-  void* GetAddress() {
-    return addr_;
-  }
-
-  size_t GetLength() {
-    return length_;
-  }
-
- private:
-  MemMap(void* addr, size_t length, void* base_addr, size_t base_length)
-      : addr_(addr), length_(length), base_addr_(base_addr), base_length_(base_length) {
-    CHECK(addr_ != NULL);
-    CHECK(length_ != 0);
-    CHECK(base_addr_ != NULL);
-    CHECK(base_length_ != 0);
-  };
-
-  void*   addr_;              // start of data
-  size_t  length_;            // length of data
-
-  void*   base_addr_;         // page-aligned base address
-  size_t  base_length_;       // length of mapping
-};
-
 class ZipArchive {
  public:
 
@@ -184,7 +119,7 @@
   uint16_t num_entries_;
   off_t dir_offset_;
   scoped_ptr<MemMap> dir_map_;
-  typedef std::tr1::unordered_map<StringPiece, const uint8_t*> DirEntries;
+  typedef std::tr1::unordered_map<StringPiece, const byte*> DirEntries;
   DirEntries dir_entries_;
 
   friend class ZipEntry;
diff --git a/src/zip_archive_test.cc b/src/zip_archive_test.cc
index 788e8fc..74b3795 100644
--- a/src/zip_archive_test.cc
+++ b/src/zip_archive_test.cc
@@ -5,6 +5,7 @@
 #include <sys/types.h>
 
 #include "common_test.h"
+#include "os.h"
 #include "zip_archive.h"
 #include "gtest/gtest.h"
 
@@ -12,47 +13,17 @@
 
 class ZipArchiveTest : public RuntimeTest {};
 
-class TmpFile {
- public:
-  TmpFile() {
-    std::string filename_template;
-    filename_template = getenv("ANDROID_DATA");
-    filename_template += "/TmpFile-XXXXXX";
-    filename_.reset(strdup(filename_template.c_str()));
-    CHECK(filename_ != NULL);
-    fd_ = mkstemp(filename_.get());
-    CHECK_NE(-1, fd_);
-  }
-
-  ~TmpFile() {
-    int unlink_result = unlink(filename_.get());
-    CHECK_EQ(0, unlink_result);
-    int close_result = close(fd_);
-    CHECK_EQ(0, close_result);
-  }
-
-  const char* GetFilename() const {
-    return filename_.get();
-  }
-
-  int GetFd() const {
-    return fd_;
-  }
-
- private:
-  scoped_ptr_malloc<char> filename_;
-  int fd_;
-};
-
 TEST_F(ZipArchiveTest, FindAndExtract) {
   scoped_ptr<ZipArchive> zip_archive(ZipArchive::Open(GetLibCoreDexFileName()));
   ASSERT_TRUE(zip_archive != false);
   scoped_ptr<ZipEntry> zip_entry(zip_archive->Find("classes.dex"));
   ASSERT_TRUE(zip_entry != false);
 
-  TmpFile tmp;
+  ScratchFile tmp;
   ASSERT_NE(-1, tmp.GetFd());
-  bool success = zip_entry->Extract(tmp.GetFd());
+  scoped_ptr<File> file(OS::FileFromFd(tmp.GetFilename(), tmp.GetFd()));
+  ASSERT_TRUE(file != NULL);
+  bool success = zip_entry->Extract(*file);
   ASSERT_TRUE(success);
   close(tmp.GetFd());