diff --git a/src/class_linker.cc b/src/class_linker.cc
index 3341d88..505f86f 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -577,6 +577,8 @@
     execl(dex2oat.c_str(), dex2oat.c_str(),
           "--runtime-arg", "-Xms64m",
           "--runtime-arg", "-Xmx64m",
+          "--runtime-arg", "-classpath",
+          "--runtime-arg", Runtime::Current()->GetClassPath().c_str(),
           boot_image_option.c_str(),
           dex_file_option.c_str(),
           oat_file_option.c_str(),
@@ -2621,19 +2623,9 @@
     const char* descriptor = dex_file.StringByTypeIdx(type_idx);
     resolved = FindClass(descriptor, class_loader);
     if (resolved != NULL) {
-      Class* check = resolved;
-      while (check->IsArrayClass()) {
-        check = check->GetComponentType();
-      }
-      if (dex_cache != check->GetDexCache()) {
-        if (check->GetClassLoader() != NULL) {
-          Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
-              "Class with type index %d resolved by unexpected .dex", type_idx);
-          resolved = NULL;
-        }
-      }
-    }
-    if (resolved != NULL) {
+      // TODO: we used to throw here if resolved's class loader was not the
+      //       boot class loader. This was to permit different classes with the
+      //       same name to be loaded simultaneously by different loaders
       dex_cache->SetResolvedType(type_idx, resolved);
     } else {
       DCHECK(Thread::Current()->IsExceptionPending());
diff --git a/src/compiler.cc b/src/compiler.cc
index 0a4117d..fabd8fd 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -82,13 +82,24 @@
   }
 }
 
-void Compiler::CompileAll(const ClassLoader* class_loader) {
+void Compiler::CompileAll(const ClassLoader* class_loader,
+    const std::vector<const DexFile*>& dex_files) {
   DCHECK(!Runtime::Current()->IsStarted());
-  Resolve(class_loader);
-  Verify(class_loader);
-  InitializeClassesWithoutClinit(class_loader);
-  Compile(class_loader);
-  SetCodeAndDirectMethods(class_loader);
+  for (size_t i = 0; i != dex_files.size(); ++i) {
+    ResolveDexFile(class_loader, *dex_files[i]);
+  }
+  for (size_t i = 0; i != dex_files.size(); ++i) {
+    VerifyDexFile(class_loader, *dex_files[i]);
+  }
+  for (size_t i = 0; i != dex_files.size(); ++i) {
+    InitializeClassesWithoutClinit(class_loader, *dex_files[i]);
+  }
+  for (size_t i = 0; i != dex_files.size(); ++i) {
+    CompileDexFile(class_loader, *dex_files[i]);
+  }
+  for (size_t i = 0; i != dex_files.size(); ++i) {
+    SetCodeAndDirectMethodsDexFile(*dex_files[i]);
+  }
 }
 
 void Compiler::CompileOne(const Method* method) {
diff --git a/src/compiler.h b/src/compiler.h
index c09e2c2..a8ea205 100644
--- a/src/compiler.h
+++ b/src/compiler.h
@@ -25,8 +25,8 @@
 
   ~Compiler();
 
-  // Compile all Methods of all the Classes of all the DexFiles that are part of a ClassLoader.
-  void CompileAll(const ClassLoader* class_loader);
+  void CompileAll(const ClassLoader* class_loader,
+                  const std::vector<const DexFile*>& class_path);
 
   // Compile a single Method
   void CompileOne(const Method* method);
diff --git a/src/compiler_test.cc b/src/compiler_test.cc
index d1b377a..823aa48 100644
--- a/src/compiler_test.cc
+++ b/src/compiler_test.cc
@@ -19,7 +19,7 @@
  protected:
 
   void CompileAll(const ClassLoader* class_loader) {
-    compiler_->CompileAll(class_loader);
+    compiler_->CompileAll(class_loader, ClassLoader::GetCompileTimeClassPath(class_loader));
     MakeAllExecutable(class_loader);
   }
 
diff --git a/src/dex2oat.cc b/src/dex2oat.cc
index 6cf6df6..231ca9c 100644
--- a/src/dex2oat.cc
+++ b/src/dex2oat.cc
@@ -94,6 +94,34 @@
   bool do_unlink_;
 };
 
+// Returns true if dex_files has a dex with the named location.
+bool DexFilesContains(const std::vector<const DexFile*>& dex_files, const std::string& location) {
+  for (size_t i = 0; i < dex_files.size(); ++i) {
+    if (dex_files[i]->GetLocation() == location) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Appends to dex_files any elements of class_path that it doesn't already
+// contain. This will open those dex files as necessary.
+void OpenClassPathFiles(const std::string& class_path, std::vector<const DexFile*>& dex_files) {
+  std::vector<std::string> parsed;
+  Split(class_path, ':', parsed);
+  for (size_t i = 0; i < parsed.size(); ++i) {
+    if (DexFilesContains(dex_files, parsed[i])) {
+      continue;
+    }
+    const DexFile* dex_file = DexFile::Open(parsed[i], Runtime::Current()->GetHostPrefix());
+    if (dex_file == NULL) {
+      LOG(WARNING) << "Failed to open dex file " << parsed[i];
+    } else {
+      dex_files.push_back(dex_file);
+    }
+  }
+}
+
 int dex2oat(int argc, char** argv) {
   // Skip over argv[0].
   argv++;
@@ -272,13 +300,17 @@
 
   // ClassLoader creation needs to come after Runtime::Create
   SirtRef<ClassLoader> class_loader(NULL);
+  std::vector<const DexFile*> dex_files;
   if (!boot_image_option.empty()) {
-    std::vector<const DexFile*> dex_files;
     DexFile::OpenDexFiles(dex_filenames, dex_files, host_prefix);
-    for (size_t i = 0; i < dex_files.size(); i++) {
-      class_linker->RegisterDexFile(*dex_files[i]);
+    std::vector<const DexFile*> class_path_files(dex_files);
+    OpenClassPathFiles(runtime->GetClassPath(), class_path_files);
+    for (size_t i = 0; i < class_path_files.size(); i++) {
+      class_linker->RegisterDexFile(*class_path_files[i]);
     }
-    class_loader.reset(PathClassLoader::AllocCompileTime(dex_files));
+    class_loader.reset(PathClassLoader::AllocCompileTime(class_path_files));
+  } else {
+    dex_files = runtime->GetClassLinker()->GetBootClassPath();
   }
 
   // if we loaded an existing image, we will reuse values from the image roots.
@@ -302,7 +334,7 @@
   }
   Compiler compiler(kThumb2, image_filename != NULL);
   if (method_names.empty()) {
-    compiler.CompileAll(class_loader.get());
+    compiler.CompileAll(class_loader.get(), dex_files);
   } else {
     for (size_t i = 0; i < method_names.size(); i++) {
       // names are actually class_descriptor + name + signature.
diff --git a/src/oat_test.cc b/src/oat_test.cc
index e3186de..17a00e4 100644
--- a/src/oat_test.cc
+++ b/src/oat_test.cc
@@ -11,11 +11,12 @@
 
 TEST_F(OatTest, WriteRead) {
   const bool compile = false;  // DISABLED_ due to the time to compile libcore
+  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
 
   SirtRef<ClassLoader> class_loader(NULL);
   if (compile) {
     compiler_.reset(new Compiler(kThumb2, false));
-    compiler_->CompileAll(class_loader.get());
+    compiler_->CompileAll(class_loader.get(), class_linker->GetBootClassPath());
   }
 
   ScratchFile tmp;
@@ -23,15 +24,13 @@
   ASSERT_TRUE(success);
 
   if (compile) {  // OatWriter strips the code, regenerate to compare
-    compiler_->CompileAll(class_loader.get());
+    compiler_->CompileAll(class_loader.get(), class_linker->GetBootClassPath());
   }
   UniquePtr<OatFile> oat_file(OatFile::Open(std::string(tmp.GetFilename()), "", NULL));
   ASSERT_TRUE(oat_file.get() != NULL);
   const OatHeader& oat_header = oat_file->GetOatHeader();
   ASSERT_EQ(1U, oat_header.GetDexFileCount());
 
-  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
-
   const DexFile& dex_file = *java_lang_dex_file_.get();
   const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
   for (size_t i = 0; i < dex_file.NumClassDefs(); i++) {