runtime/vdex_file.cc

/*
 * Copyright (C) 2016 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.
 */

#include "vdex_file.h"

#include <sys/mman.h>  // For the PROT_* and MAP_* constants.

#include <memory>

#include "base/bit_utils.h"
#include "base/logging.h"
#include "base/stl_util.h"
#include "base/unix_file/fd_file.h"
#include "dex_file.h"
#include "dex_file_loader.h"
#include "dex_to_dex_decompiler.h"

namespace art {

constexpr uint8_t VdexFile::Header::kVdexInvalidMagic[4];
constexpr uint8_t VdexFile::Header::kVdexMagic[4];
constexpr uint8_t VdexFile::Header::kVdexVersion[4];

bool VdexFile::Header::IsMagicValid() const {
  return (memcmp(magic_, kVdexMagic, sizeof(kVdexMagic)) == 0);
}

bool VdexFile::Header::IsVersionValid() const {
  return (memcmp(version_, kVdexVersion, sizeof(kVdexVersion)) == 0);
}

VdexFile::Header::Header(uint32_t number_of_dex_files,
                         uint32_t dex_size,
                         uint32_t verifier_deps_size,
                         uint32_t quickening_info_size)
    : number_of_dex_files_(number_of_dex_files),
      dex_size_(dex_size),
      verifier_deps_size_(verifier_deps_size),
      quickening_info_size_(quickening_info_size) {
  memcpy(magic_, kVdexMagic, sizeof(kVdexMagic));
  memcpy(version_, kVdexVersion, sizeof(kVdexVersion));
  DCHECK(IsMagicValid());
  DCHECK(IsVersionValid());
}

std::unique_ptr<VdexFile> VdexFile::Open(const std::string& vdex_filename,
                                         bool writable,
                                         bool low_4gb,
                                         bool unquicken,
                                         std::string* error_msg) {
  if (!OS::FileExists(vdex_filename.c_str())) {
    *error_msg = "File " + vdex_filename + " does not exist.";
    return nullptr;
  }

  std::unique_ptr<File> vdex_file;
  if (writable) {
    vdex_file.reset(OS::OpenFileReadWrite(vdex_filename.c_str()));
  } else {
    vdex_file.reset(OS::OpenFileForReading(vdex_filename.c_str()));
  }
  if (vdex_file == nullptr) {
    *error_msg = "Could not open file " + vdex_filename +
                 (writable ? " for read/write" : "for reading");
    return nullptr;
  }

  int64_t vdex_length = vdex_file->GetLength();
  if (vdex_length == -1) {
    *error_msg = "Could not read the length of file " + vdex_filename;
    return nullptr;
  }

  return Open(vdex_file->Fd(), vdex_length, vdex_filename, writable, low_4gb, unquicken, error_msg);
}

std::unique_ptr<VdexFile> VdexFile::Open(int file_fd,
                                         size_t vdex_length,
                                         const std::string& vdex_filename,
                                         bool writable,
                                         bool low_4gb,
                                         bool unquicken,
                                         std::string* error_msg) {
  std::unique_ptr<MemMap> mmap(MemMap::MapFile(
      vdex_length,
      (writable || unquicken) ? PROT_READ | PROT_WRITE : PROT_READ,
      unquicken ? MAP_PRIVATE : MAP_SHARED,
      file_fd,
      0 /* start offset */,
      low_4gb,
      vdex_filename.c_str(),
      error_msg));
  if (mmap == nullptr) {
    *error_msg = "Failed to mmap file " + vdex_filename + " : " + *error_msg;
    return nullptr;
  }

  std::unique_ptr<VdexFile> vdex(new VdexFile(mmap.release()));
  if (!vdex->IsValid()) {
    *error_msg = "Vdex file is not valid";
    return nullptr;
  }

  if (unquicken) {
    std::vector<std::unique_ptr<const DexFile>> unique_ptr_dex_files;
    if (!vdex->OpenAllDexFiles(&unique_ptr_dex_files, error_msg)) {
      return nullptr;
    }
    Unquicken(MakeNonOwningPointerVector(unique_ptr_dex_files),
              vdex->GetQuickeningInfo(),
              /* decompile_return_instruction */ false);
    // Update the quickening info size to pretend there isn't any.
    reinterpret_cast<Header*>(vdex->mmap_->Begin())->quickening_info_size_ = 0;
  }

  *error_msg = "Success";
  return vdex;
}

const uint8_t* VdexFile::GetNextDexFileData(const uint8_t* cursor) const {
  DCHECK(cursor == nullptr || (cursor > Begin() && cursor <= End()));
  if (cursor == nullptr) {
    // Beginning of the iteration, return the first dex file if there is one.
    return HasDexSection() ? DexBegin() : nullptr;
  } else {
    // Fetch the next dex file. Return null if there is none.
    const uint8_t* data = cursor + reinterpret_cast<const DexFile::Header*>(cursor)->file_size_;
    // Dex files are required to be 4 byte aligned. the OatWriter makes sure they are, see
    // OatWriter::SeekToDexFiles.
    data = AlignUp(data, 4);
    return (data == DexEnd()) ? nullptr : data;
  }
}

bool VdexFile::OpenAllDexFiles(std::vector<std::unique_ptr<const DexFile>>* dex_files,
                               std::string* error_msg) {
  size_t i = 0;
  for (const uint8_t* dex_file_start = GetNextDexFileData(nullptr);
       dex_file_start != nullptr;
       dex_file_start = GetNextDexFileData(dex_file_start), ++i) {
    size_t size = reinterpret_cast<const DexFile::Header*>(dex_file_start)->file_size_;
    // TODO: Supply the location information for a vdex file.
    static constexpr char kVdexLocation[] = "";
    std::string location = DexFileLoader::GetMultiDexLocation(i, kVdexLocation);
    std::unique_ptr<const DexFile> dex(DexFileLoader::Open(dex_file_start,
                                                           size,
                                                           location,
                                                           GetLocationChecksum(i),
                                                           nullptr /*oat_dex_file*/,
                                                           false /*verify*/,
                                                           false /*verify_checksum*/,
                                                           error_msg));
    if (dex == nullptr) {
      return false;
    }
    dex_files->push_back(std::move(dex));
  }
  return true;
}

// Utility class to easily iterate over the quickening data.
class QuickeningInfoIterator {
 public:
  QuickeningInfoIterator(uint32_t dex_file_index,
                         uint32_t number_of_dex_files,
                         const ArrayRef<const uint8_t>& quickening_info)
      : quickening_info_(quickening_info) {
    const unaligned_uint32_t* dex_file_indices = reinterpret_cast<const unaligned_uint32_t*>(
            quickening_info.data() +
            quickening_info.size() -
            number_of_dex_files * sizeof(uint32_t));
    current_code_item_end_ = (dex_file_index == number_of_dex_files - 1)
        ? dex_file_indices
        : reinterpret_cast<const unaligned_uint32_t*>(
              quickening_info_.data() + dex_file_indices[dex_file_index + 1]);
    current_code_item_ptr_ = reinterpret_cast<const uint32_t*>(
        quickening_info_.data() + dex_file_indices[dex_file_index]);
  }

  bool Done() const {
    return current_code_item_ptr_ == current_code_item_end_;
  }

  void Advance() {
    current_code_item_ptr_ += 2;
  }

  uint32_t GetCurrentCodeItemOffset() const {
    return current_code_item_ptr_[0];
  }

  const ArrayRef<const uint8_t> GetCurrentQuickeningInfo() const {
    return ArrayRef<const uint8_t>(
        // Add sizeof(uint32_t) to remove the length from the data pointer.
        quickening_info_.data() + current_code_item_ptr_[1] + sizeof(uint32_t),
        *reinterpret_cast<const unaligned_uint32_t*>(
            quickening_info_.data() + current_code_item_ptr_[1]));
  }

 private:
  typedef __attribute__((__aligned__(1))) uint32_t unaligned_uint32_t;
  const ArrayRef<const uint8_t>& quickening_info_;
  const unaligned_uint32_t* current_code_item_ptr_;
  const unaligned_uint32_t* current_code_item_end_;

  DISALLOW_COPY_AND_ASSIGN(QuickeningInfoIterator);
};

void VdexFile::Unquicken(const std::vector<const DexFile*>& dex_files,
                         const ArrayRef<const uint8_t>& quickening_info,
                         bool decompile_return_instruction) {
  if (quickening_info.size() == 0 && !decompile_return_instruction) {
    // Bail early if there is no quickening info and no need to decompile
    // RETURN_VOID_NO_BARRIER instructions to RETURN_VOID instructions.
    return;
  }

  // When we do not decompile RETURN_VOID_NO_BARRIER use the faster
  // QuickeningInfoIterator, otherwise use the slower ClassDataItemIterator
  if (!decompile_return_instruction) {
    for (uint32_t i = 0; i < dex_files.size(); ++i) {
      for (QuickeningInfoIterator it(i, dex_files.size(), quickening_info);
           !it.Done();
           it.Advance()) {
        optimizer::ArtDecompileDEX(
            *dex_files[i]->GetCodeItem(it.GetCurrentCodeItemOffset()),
            it.GetCurrentQuickeningInfo(),
            decompile_return_instruction);
      }
    }
  } else {
    for (uint32_t i = 0; i < dex_files.size(); ++i) {
      QuickeningInfoIterator quick_it(i, dex_files.size(), quickening_info);
      for (uint32_t j = 0; j < dex_files[i]->NumClassDefs(); ++j) {
        const DexFile::ClassDef& class_def = dex_files[i]->GetClassDef(j);
        const uint8_t* class_data = dex_files[i]->GetClassData(class_def);
        if (class_data != nullptr) {
          for (ClassDataItemIterator class_it(*dex_files[i], class_data);
               class_it.HasNext();
               class_it.Next()) {
            if (class_it.IsAtMethod() && class_it.GetMethodCodeItem() != nullptr) {
              uint32_t offset = class_it.GetMethodCodeItemOffset();
              if (!quick_it.Done() && offset == quick_it.GetCurrentCodeItemOffset()) {
                optimizer::ArtDecompileDEX(
                    *class_it.GetMethodCodeItem(),
                    quick_it.GetCurrentQuickeningInfo(),
                    decompile_return_instruction);
                quick_it.Advance();
              } else {
                optimizer::ArtDecompileDEX(*class_it.GetMethodCodeItem(),
                                           /* quickened_info */ {},
                                           decompile_return_instruction);
              }
            }
          }
        }
      }
      DCHECK(quick_it.Done()) << "Failed to use all quickening info";
    }
  }
}

static constexpr uint32_t kNoDexFile = -1;

uint32_t VdexFile::GetDexFileIndex(const DexFile& dex_file) const {
  uint32_t dex_index = 0;
  for (const uint8_t* dex_file_start = GetNextDexFileData(nullptr);
       dex_file_start != dex_file.Begin();
       dex_file_start = GetNextDexFileData(dex_file_start)) {
    if (dex_file_start == nullptr) {
      return kNoDexFile;
    }
    dex_index++;
  }
  return dex_index;
}

void VdexFile::FullyUnquickenDexFile(const DexFile& target_dex_file,
                                     const DexFile& original_dex_file) const {
  uint32_t dex_index = GetDexFileIndex(original_dex_file);
  if (dex_index == kNoDexFile) {
    return;
  }

  constexpr bool kDecompileReturnInstruction = true;
  QuickeningInfoIterator it(dex_index, GetHeader().GetNumberOfDexFiles(), GetQuickeningInfo());
  // Iterate over the class definitions. Even if there is no quickening info,
  // we want to unquicken RETURN_VOID_NO_BARRIER instruction.
  for (uint32_t i = 0; i < target_dex_file.NumClassDefs(); ++i) {
    const DexFile::ClassDef& class_def = target_dex_file.GetClassDef(i);
    const uint8_t* class_data = target_dex_file.GetClassData(class_def);
    if (class_data != nullptr) {
      for (ClassDataItemIterator class_it(target_dex_file, class_data);
           class_it.HasNext();
           class_it.Next()) {
        if (class_it.IsAtMethod() && class_it.GetMethodCodeItem() != nullptr) {
          uint32_t offset = class_it.GetMethodCodeItemOffset();
          if (!it.Done() && offset == it.GetCurrentCodeItemOffset()) {
            optimizer::ArtDecompileDEX(
                *class_it.GetMethodCodeItem(),
                it.GetCurrentQuickeningInfo(),
                kDecompileReturnInstruction);
            it.Advance();
          } else {
            optimizer::ArtDecompileDEX(*class_it.GetMethodCodeItem(),
                                       ArrayRef<const uint8_t>(nullptr, 0),
                                       kDecompileReturnInstruction);
          }
        }
      }
    }
  }
}

const uint8_t* VdexFile::GetQuickenedInfoOf(const DexFile& dex_file,
                                            uint32_t code_item_offset) const {
  if (GetQuickeningInfo().size() == 0) {
    // Bail early if there is no quickening info.
    return nullptr;
  }

  uint32_t dex_index = GetDexFileIndex(dex_file);
  if (dex_index == kNoDexFile) {
    return nullptr;
  }

  for (QuickeningInfoIterator it(dex_index, GetHeader().GetNumberOfDexFiles(), GetQuickeningInfo());
       !it.Done();
       it.Advance()) {
    if (code_item_offset == it.GetCurrentCodeItemOffset()) {
      return it.GetCurrentQuickeningInfo().data();
    }
  }
  return nullptr;
}

}  // namespace art