dex 和 mmap

// libcore/dalvik/src/main/java/dalvik/system/BaseDexClassLoader.java
public BaseDexClassLoader(String dexPath,
          String librarySearchPath, ClassLoader parent, ClassLoader[] sharedLibraryLoaders,
          ClassLoader[] sharedLibraryLoadersAfter,
          boolean isTrusted) {
      super(parent);
      // Setup shared libraries before creating the path list. ART relies on the class loader
      // hierarchy being finalized before loading dex files.
      this.sharedLibraryLoaders = sharedLibraryLoaders == null
              ? null
              : Arrays.copyOf(sharedLibraryLoaders, sharedLibraryLoaders.length);
      this.pathList = new DexPathList(this, dexPath, librarySearchPath, null, isTrusted);

      this.sharedLibraryLoadersAfter = sharedLibraryLoadersAfter == null
              ? null
              : Arrays.copyOf(sharedLibraryLoadersAfter, sharedLibraryLoadersAfter.length);
      // Run background verification after having set 'pathList'.
      this.pathList.maybeRunBackgroundVerification(this);

      reportClassLoaderChain();
  }

// libcore/dalvik/src/main/java/dalvik/system/DexPathList.java
DexPathList(ClassLoader definingContext, String dexPath,
          String librarySearchPath, File optimizedDirectory, boolean isTrusted) {
      
      // 略
      this.dexElements = makeDexElements(splitDexPath(dexPath), optimizedDirectory,
                                          suppressedExceptions, definingContext, isTrusted);
}

private static Element[] makeDexElements(List<File> files, File optimizedDirectory,
            List<IOException> suppressedExceptions, ClassLoader loader, boolean isTrusted) {
      // 略
       loadDexFile(file, optimizedDirectory, loader, elements);
}

// libcore/dalvik/src/main/java/dalvik/system/DexFile.java
private static Object openDexFile(String sourceName, String outputName, int flags,
        ClassLoader loader, DexPathList.Element[] elements) throws IOException {
    // Use absolute paths to enable the use of relative paths when testing on host.
    return openDexFileNative(new File(sourceName).getAbsolutePath(),
                              (outputName == null)
                                  ? null
                                  : new File(outputName).getAbsolutePath(),
                              flags,
                              loader,
                              elements);
}

// art/runtime/native/dalvik_system_DexFile.cc
static jobject DexFile_openDexFileNative(JNIEnv* env,
                                         jclass,
                                         jstring javaSourceName,
                                         jstring javaOutputName ATTRIBUTE_UNUSED,
                                         jint flags ATTRIBUTE_UNUSED,
                                         jobject class_loader,
                                         jobjectArray dex_elements) {
  ScopedUtfChars sourceName(env, javaSourceName);
  if (sourceName.c_str() == nullptr) {
    return nullptr;
  }

  std::vector<std::string> error_msgs;
  const OatFile* oat_file = nullptr;
  std::vector<std::unique_ptr<const DexFile>> dex_files =
      Runtime::Current()->GetOatFileManager().OpenDexFilesFromOat(sourceName.c_str(),
                                                                  class_loader,
                                                                  dex_elements,
                                                                  /*out*/ &oat_file,
                                                                  /*out*/ &error_msgs);
  return CreateCookieFromOatFileManagerResult(env, dex_files, oat_file, error_msgs);
}

// art/runtime/oat_file_manager.cc
std::vector<std::unique_ptr<const DexFile>> OatFileManager::OpenDexFilesFromOat(
    const char* dex_location,
    jobject class_loader,
    jobjectArray dex_elements,
    const OatFile** out_oat_file,
    std::vector<std::string>* error_msgs) {
  // 略

  // 这里是我发现的可能是最早的 mmap 的地方
  oat_file_assistant->GetOptimizationStatus(
      &odex_location, &compilation_filter, &compilation_reason, &odex_status);

  Runtime::Current()->GetAppInfo()->RegisterOdexStatus(
      dex_location,
      compilation_filter,
      compilation_reason,
      odex_status);
}

// art/runtime/oat_file_assistant.cc
void OatFileAssistant::GetOptimizationStatus(
  std::string* out_odex_location,
  std::string* out_compilation_filter,
  std::string* out_compilation_reason,
  std::string* out_odex_status) {
OatFileInfo& oat_file_info = GetBestInfo();
const OatFile* oat_file = GetBestInfo().GetFile();

if (oat_file == nullptr) {
  *out_odex_location = "error";
  *out_compilation_filter = "run-from-apk";
  *out_compilation_reason = "unknown";
  // This mostly happens when we cannot open the oat file.
  // Note that it's different than kOatCannotOpen.
  // TODO: The design of getting the BestInfo is not ideal,
  // as it's not very clear what's the difference between
  // a nullptr and kOatcannotOpen. The logic should be revised
  // and improved.
  *out_odex_status = "io-error-no-oat";
  return;

  // 略
}

// art/runtime/oat_file.cc
//  Open -> OpenOatFile -> Load -> ElfFileOpen  均在 oat_file 中 
bool ElfOatFile::ElfFileOpen(File* file,
                             bool writable,
                             bool executable,
                             bool low_4gb,
                             /*inout*/MemMap* reservation,
                             /*out*/std::string* error_msg) {
  ScopedTrace trace(__PRETTY_FUNCTION__);
  elf_file_.reset(ElfFile::Open(file,
                                writable,
                                /*program_header_only=*/ true,
                                low_4gb,
                                error_msg));
  if (elf_file_ == nullptr) {
    DCHECK(!error_msg->empty());
    return false;
  }
  bool loaded = elf_file_->Load(file, executable, low_4gb, reservation, error_msg);
  DCHECK(loaded || !error_msg->empty());
  return loaded;
}

// 后续的 Open 方法中会调用 setup，进而调用 MemMap::MapFile 进而调用 mmap