ART Image Format

JNI_CreateJavaVM
  Runtime::Create
    Runtime::Init
      Heap::Heap
        if (!image_file_name.empty()):
          ImageSpace::Create
            bool found_image = FindImageFilename
            if (found_image):
              return ImageSpace::Init
            else:
              GenerateImage
              return ImageSpace::Init

ImageSpace::GenerateImage
  // 设置 "dex2oat" 可执行程序的路径
  std::string dex2oat(Runtime::Current()->GetCompilerExecutable());
  arg_vector.push_back(dex2oat);

  // 设置 "--image" 参数, 使 dex2oat 知道要生成 boot.art
  std::string image_option_string("--image=");
  image_option_string += image_filename;
  arg_vector.push_back(image_option_string);

  // 指定要生成的 boot.art 的 image_begin_ 参数
  arg_vector.push_back(StringPrintf("--base=0x%x", ART_BASE_ADDRESS + base_offset));

  // Exec 会 fork 子进程执行 arg_vector, 并等待子进程返回
  return Exec(arg_vector, error_msg);

dex2oat:
  Dex2Oat::Create(&p_dex2oat,runtime_options,*compiler_options,..)
    // 启动 runtime, runtime_options 中没有 -Ximage 参数, 所以
    // runtime 不会初始化 image_space
    dex2oat->CreateRuntime(runtime_options, instruction_set)
  // 从 preloaded-classes 中读取 image_classes_  
  dex2oat->ReadImageClassesFromZip(image_classes_zip_filename,..)
  // 开始编译并生成 boot.oat
  dex2oat->CreateOatFile(boot_image_option,..)
    driver = new CompilerDriver(compiler_options_,...)
    driver->CompileAll(class_loader, dex_files, &timings);
      CompilerDriver::PreCompile(class_loader, dex_files,..)
      CompilerDriver::Compile(class_loader, dex_files,...)
    OatWriter oat_writer(dex_files, ...)
    driver->WriteElf(android_root, is_host, dex_files, &oat_writer, oat_file)
  dex2oat->CreateImageFile
    ImageWriter image_writer(compiler);
    image_writer.Write(image_filename, image_base, oat_filename, oat_location)
    ElfFixup::Fixup(oat_file.get(), oat_data_begin)

ImageWriter::Write
  // 各种 bridge, trampoline 函数存在到 boot.oat 中,
  // 而生成 boot.art 中的 ArtMethod 需要引用它们, 因此这些
  // 函数需要经过后面的 GetOatAddress 转换
  interpreter_to_interpreter_bridge_offset_ =
      oat_file_->GetOatHeader().GetInterpreterToInterpreterBridgeOffset();
  // 从 ClassLinker 的 class_table_ 中除掉非 image_classes_ 的类, 所谓
  // image_classes_, 是指和 preloaded-classes 相关的那些类
  PruneNonImageClasses();
  gc::Heap* heap = Runtime::Current()->GetHeap();
  // 确保 heap 中只存在和 image_classes_ 相关的类和对象
  heap->CollectGarbage(false);
  AllocMemory()
    // 根据当前 heap 的大小分配一块临时内存 image_, 最终这块内存和
    // 后面分配的 image_bitmap_ 会一起被写入到 boot.art
    // 要注意的是, image_.Begin() 和 image_begin_ 没有关系: image_ 内存的地址不是固定的. 
    size_t length = RoundUp(Runtime::Current()->GetHeap()->GetTotalMemory(), kPageSize);
    image_.reset(MemMap::MapAnonymous("image writer image", NULL, length, PROT_READ | PROT_WRITE,
                                    true, &error_msg));
    // Create the image bitmap.
    // image_bitmap_ 这块内存的大小为 length/64
    image_bitmap_.reset(gc::accounting::ContinuousSpaceBitmap::Create("image bitmap", image_->Begin(),
                                                                    length));

  // 遍历 heap 上所有对象, 分配一个相对于 image_.Begin() 的 offset, 保存在 LockWord 中,
  // 更新 image_bitmap_, 并生成 ImageHeader
  CalculateNewObjectOffsets(oat_loaded_size, oat_data_offset);
    // 对某一个对象, 执行以下的 callback:
    ImageWriter::AssignImageOffset
      SetImageOffset(object, image_end_);
        mirror::Object* obj = reinterpret_cast<mirror::Object*>(image_->Begin() + offset);
        image_bitmap_->Set(obj);
        object->SetLockWord(LockWord::FromForwardingAddress(offset), false);
        image_end_ += RoundUp(object->SizeOf(), 8);  // 64-bit alignment

  // 复制所有对象对 AllocMemory 分配的临时内存, 使用上一步计算的 offset      
  CopyAndFixupObjects();
    // 对某一个对象, 执行以下 callback:
    CopyAndFixupObjectsCallback
      // offset 是上一步分配的 offset
      size_t offset = image_writer->GetImageOffset(obj);
      // image_ 是 AllocMemory 分配的临时内存
      byte* dst = image_writer->image_->Begin() + offset;
      const byte* src = reinterpret_cast<const byte*>(obj);
      size_t n = obj->SizeOf();
      memcpy(dst, src, n);
    // 所有对象被 copy 到 image_ 后, 对象中引用的地址还没有 fixup:
    // 还是原始 heap 中的地址, 需要通过 FixupObject 将对象中各 field 的引用
    // 修改为相对于 image_begin_ 的引用
    image_writer->FixupObject(obj, copy);
      // fixup 的过程主要是通过如下的 FixupVisitor 完成:
      Object* ref = obj->GetFieldObject(offset);
      // getImageAddress(ref) = (image_begin_ + GetImageOffset(ref)) !
      copy_->SetFieldObjectWithoutWriteBarrier(offset, image_writer_->GetImageAddress(ref));

      // ArtMethod 引用了 oat 中的函数, 也需要根据 oat_file_begin_ 进行 fixup
      if (orig->IsArtMethod<kVerifyNone>()):
        FixupMethod(orig->AsArtMethod<kVerifyNone>(), down_cast<ArtMethod*>(copy));

  // 不清楚 ART 在生成 boot.art 最后阶段的 patch oat 或 patch elf 具体是做什么的,
  // 但从代码片断上看, 和 arm literal 有关, 而且 arm literal 做为数据在 native code
  // 时都是通过绝对地址引用的, 当 oat_data 被加载到 oat_data_begin_ 后, literal 地址
  // 变化导致了相应的代码中的地址都需要改变
  PatchOatCodeAndMethods(oat_file.get());

  image_file(OS::CreateEmptyFile(image_filename.c_str()));
  image_file->WriteFully(image_->Begin(), image_end_)

JNI_CreateJavaVM
  Runtime::Create
    Runtime::Init
      Heap::Heap
        ImageSpace::Create
          ImageSpace::Init
        AddSpace(image_space);
        // 这一句表明了 zygote 使用 image_space 时的内存布局:
        // +--------------+
        // | image        |
        // +--------------+
        // | boot oat     |
        // +--------------+
        // | alloc spaces |
        // +--------------+
        requested_alloc_space_begin = AlignUp(oat_file_end_addr, kPageSize);
      // Heap::Heap() ends here
      // 
      if (GetHeap()->HasImageSpace()):
        class_linker_->InitFromImage();
          // boo.oat 已经被加载到合适的位置 (oat_file_begin_), 设置 cl 的一些函数指针
          quick_resolution_trampoline_ = oat_file.GetOatHeader().GetQuickResolutionTrampoline();
          ...
          // 从 image_header 的 image_roots 中获得 DexCache 对象的地址, 最终加入到 class path 和 dex_caches_ 中
          Object* dex_caches_object = space->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
          ...
          // 从 image_header 的 image_roots 中获得 class_roots, 并用它初始化 runtime 的 class_roots_
          class_roots(hs.NewHandle(space->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots)->AsObjectArray<mirror::Class>()));
          class_roots_ = GcRoot<mirror::ObjectArray<mirror::Class>>(class_roots.Get());
          Class::SetClassClass(class_roots->Get(kJavaLangClass));
          Reference::SetClass(GetClassRoot(kJavaLangRefReference));
          ...

ImageSpace::Init
  // 从文件头读取 ImageHeader
  file->ReadFully(&image_header, sizeof(image_header));
  // 将 file->Fd() 对应的文件的 0 到 image_header.image_size_ 的内容
  // 映射到 image_header.image_begin_ 为首地址的内存.
  // 所以 map 就是 image_space 的内容
  map(MemMap::MapFileAtAddress(image_header.GetImageBegin(),
                              image_header.GetImageSize(),
                              PROT_READ | PROT_WRITE,
                              MAP_PRIVATE,
                              file->Fd(),
                              0,...))
  // 从文件的 image_header.image_bitmap_offset_ 位置开始, 映射
  // image_header.image_bitmap_size_ 大小的内容到任意地址 (nullptr)
  image_map(MemMap::MapFileAtAddress(nullptr, image_header.GetImageBitmapSize(),
                               PROT_READ, MAP_PRIVATE,
                               file->Fd(),
                               image_header.GetBitmapOffset(),
                               ...
                               ))
  // 使用 image_map 创建 image_space 的 bitmap 数据结构
  bitmap(ContinuousSpaceBitmap::CreateFromMemMap(bitmap_name, image_map.release(),
                               reinterpret_cast<byte*>(map->Begin()),
                               map->Size()));

  // 使用 map 创建 image_space 的数据结构
  space(new ImageSpace(image_filename, image_location,
                               map.release(), bitmap.release()));

  // 将 boot.oat 加载到 image_space 之后, 即 oat_file_begin_ 处
  // 最终是通过 ElfFile.Load 把 boot.oat 加载到 oat_file_begin_ 处,
  // ElfFile.Load 可以把 boot.oat 的 oatdata 加载到特定的位置, 是因为 ElfFixup 时已经
  // 将 oat_data_begin_ 信息写入到了 elf 文件中
  space->oat_file_.reset(space->OpenOatFile(image_filename, error_msg));
    // image_header.GetOatDataBegin 即 oat_data_begin_, 这个值与 boot.oat 中的相应的值是一致的
    oat_file = OatFile::Open(oat_filename, oat_filename, image_header.GetOatDataBegin(),...)
      OpenElfFile(file.get(), location, requested_base, false, executable, error_msg)
        ElfFileOpen(file, requested_base, writable, executable, error_msg);
          // elf_file_ 通过 elf 文件自身的信息就可以把 elf 加载到 oat_file_begin_ 处
          elf_file_->Load(executable, error_msg);

  // 下面从 image_space 中初始化一些 runtime 需要的数据
  Object* resolution_method = image_header.GetImageRoot(ImageHeader::kResolutionMethod);
  runtime->SetResolutionMethod(down_cast<mirror::ArtMethod*>(resolution_method));
  ...

ClassLinker::FindClass
  Class* klass = LookupClass(descriptor, class_loader.Get());
    // 从 cl 的 class_table_ 中查找
    Class* result = LookupClassFromTableLocked(descriptor, class_loader, hash);
    if (!result):
      // 从 ImageSpace 中查找
      Class* result = LookupClassFromImage(descriptor);
        ObjectArray<mirror::DexCache>* dex_caches = GetImageDexCaches();
        for each dex_cache:
          DexFile* dex_file = dex_cache->GetDexFile();
          DexFile::StringId* string_id = dex_file->FindStringId(descriptor);
          DexFile::TypeId* type_id = dex_file->FindTypeId(dex_file->GetIndexForStringId(*string_id));
          klass = dex_cache->GetResolvedType(type_idx);
    // 其它方式来 FindClass