dexoptanalyzer/dexoptanalyzer.cc - LeafOS-Project/android_art - Gitiles

 /*
  * Copyright (C) 2017 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 "dexoptanalyzer.h"

 #include <iostream>
 #include <string>
 #include <string_view>

 #include "android-base/stringprintf.h"
 #include "android-base/strings.h"
 #include "base/compiler_filter.h"
 #include "base/file_utils.h"
 #include "base/logging.h"  // For InitLogging.
 #include "base/mutex.h"
 #include "base/os.h"
 #include "base/string_view_cpp20.h"
 #include "base/utils.h"
 #include "class_linker.h"
 #include "class_loader_context.h"
 #include "dex/dex_file.h"
 #include "gc/heap.h"
 #include "gc/space/image_space.h"
 #include "noop_compiler_callbacks.h"
 #include "oat.h"
 #include "oat_file_assistant.h"
 #include "runtime.h"
 #include "thread-inl.h"
 #include "vdex_file.h"

 namespace art {
 namespace dexoptanalyzer {

 static int original_argc;
 static char** original_argv;

 static std::string CommandLine() {
   std::vector<std::string> command;
   command.reserve(original_argc);
   for (int i = 0; i < original_argc; ++i) {
     command.push_back(original_argv[i]);
   }
   return android::base::Join(command, ' ');
 }

 static void UsageErrorV(const char* fmt, va_list ap) {
   std::string error;
   android::base::StringAppendV(&error, fmt, ap);
   LOG(ERROR) << error;
 }

 static void UsageError(const char* fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
   UsageErrorV(fmt, ap);
   va_end(ap);
 }

 NO_RETURN static void Usage(const char *fmt, ...) {
   va_list ap;
   va_start(ap, fmt);
   UsageErrorV(fmt, ap);
   va_end(ap);

   UsageError("Command: %s", CommandLine().c_str());
   UsageError("  Performs a dexopt analysis on the given dex file and returns whether or not");
   UsageError("  the dex file needs to be dexopted.");
   UsageError("Usage: dexoptanalyzer [options]...");
   UsageError("");
   UsageError("  --dex-file=<filename>: the dex file which should be analyzed.");
   UsageError("");
   UsageError("  --isa=<string>: the instruction set for which the analysis should be performed.");
   UsageError("");
   UsageError("  --compiler-filter=<string>: the target compiler filter to be used as reference");
   UsageError("       when deciding if the dex file needs to be optimized.");
   UsageError("");
   UsageError("  --profile_analysis_result=<int>: the result of the profile analysis, used in");
   UsageError("       deciding if the dex file needs to be optimized.");
   UsageError("");
   UsageError("  --image=<filename>: optional, the image to be used to decide if the associated");
   UsageError("       oat file is up to date. Defaults to $ANDROID_ROOT/framework/boot.art.");
   UsageError("       Example: --image=/system/framework/boot.art");
   UsageError("");
   UsageError("  --runtime-arg <argument>: used to specify various arguments for the runtime,");
   UsageError("      such as initial heap size, maximum heap size, and verbose output.");
   UsageError("      Use a separate --runtime-arg switch for each argument.");
   UsageError("      Example: --runtime-arg -Xms256m");
   UsageError("");
   UsageError("  --android-data=<directory>: optional, the directory which should be used as");
   UsageError("       android-data. By default ANDROID_DATA env variable is used.");
   UsageError("");
   UsageError("  --oat-fd=number: file descriptor of the oat file which should be analyzed");
   UsageError("");
   UsageError("  --vdex-fd=number: file descriptor of the vdex file corresponding to the oat file");
   UsageError("");
   UsageError("  --zip-fd=number: specifies a file descriptor corresponding to the dex file.");
   UsageError("");
   UsageError("  --downgrade: optional, if the purpose of dexopt is to downgrade the dex file");
   UsageError("       By default, dexopt considers upgrade case.");
   UsageError("");
   UsageError("  --class-loader-context=<string spec>: a string specifying the intended");
   UsageError("      runtime loading context for the compiled dex files.");
   UsageError("");
   UsageError("  --class-loader-context-fds=<fds>: a colon-separated list of file descriptors");
   UsageError("      for dex files in --class-loader-context. Their order must be the same as");
   UsageError("      dex files in flattened class loader context.");
   UsageError("");
   UsageError("  --flatten-class-loader-context: parse --class-loader-context, flatten it and");
   UsageError("      print a colon-separated list of its dex files to standard output. Dexopt");
   UsageError("      needed analysis is not performed when this option is set.");
   UsageError("");
   UsageError("  --validate-bcp: validates the boot class path files (.art, .oat, .vdex).");
   UsageError("      Requires --isa and --image options to locate artifacts.");
   UsageError("");
   UsageError("Return code:");
   UsageError("  To make it easier to integrate with the internal tools this command will make");
   UsageError("    available its result (dexoptNeeded) as the exit/return code. i.e. it will not");
   UsageError("    return 0 for success and a non zero values for errors as the conventional");
   UsageError("    commands. The following return codes are possible:");
   UsageError("        kNoDexOptNeeded = 0");
   UsageError("        kDex2OatFromScratch = 1");
   UsageError("        kDex2OatForBootImageOat = 2");
   UsageError("        kDex2OatForFilterOat = 3");
   UsageError("        kDex2OatForBootImageOdex = 4");
   UsageError("        kDex2OatForFilterOdex = 5");

   UsageError("        kErrorInvalidArguments = 101");
   UsageError("        kErrorCannotCreateRuntime = 102");
   UsageError("        kErrorUnknownDexOptNeeded = 103");
   UsageError("");

   exit(static_cast<int>(ReturnCode::kErrorInvalidArguments));
 }

 class DexoptAnalyzer final {
  public:
   DexoptAnalyzer() :
       only_flatten_context_(false),
       only_validate_bcp_(false),
       downgrade_(false) {}

   void ParseArgs(int argc, char **argv) {
     original_argc = argc;
     original_argv = argv;

     Locks::Init();
     InitLogging(argv, Runtime::Abort);
     // Skip over the command name.
     argv++;
     argc--;

     if (argc == 0) {
       Usage("No arguments specified");
     }

     for (int i = 0; i < argc; ++i) {
       const char* raw_option = argv[i];
       const std::string_view option(raw_option);

       if (StartsWith(option, "--profile-analysis-result=")) {
         int parse_result = std::stoi(std::string(
             option.substr(strlen("--profile-analysis-result="))), nullptr, 0);
         if (parse_result != static_cast<int>(ProfileAnalysisResult::kOptimize) &&
             parse_result != static_cast<int>(ProfileAnalysisResult::kDontOptimizeSmallDelta) &&
             parse_result != static_cast<int>(ProfileAnalysisResult::kDontOptimizeEmptyProfiles)) {
           Usage("Invalid --profile-analysis-result= %d", parse_result);
         }
         profile_analysis_result_ = static_cast<ProfileAnalysisResult>(parse_result);
       } else if (StartsWith(option, "--dex-file=")) {
         dex_file_ = std::string(option.substr(strlen("--dex-file=")));
       } else if (StartsWith(option, "--compiler-filter=")) {
         const char* filter_str = raw_option + strlen("--compiler-filter=");
         if (!CompilerFilter::ParseCompilerFilter(filter_str, &compiler_filter_)) {
           Usage("Invalid compiler filter '%s'", raw_option);
         }
       } else if (StartsWith(option, "--isa=")) {
         const char* isa_str = raw_option + strlen("--isa=");
         isa_ = GetInstructionSetFromString(isa_str);
         if (isa_ == InstructionSet::kNone) {
           Usage("Invalid isa '%s'", raw_option);
         }
       } else if (StartsWith(option, "--image=")) {
         image_ = std::string(option.substr(strlen("--image=")));
       } else if (option == "--runtime-arg") {
         if (i + 1 == argc) {
           Usage("Missing argument for --runtime-arg\n");
         }
         ++i;
         runtime_args_.push_back(argv[i]);
       } else if (StartsWith(option, "--android-data=")) {
         // Overwrite android-data if needed (oat file assistant relies on a valid directory to
         // compute dalvik-cache folder). This is mostly used in tests.
         const char* new_android_data = raw_option + strlen("--android-data=");
         setenv("ANDROID_DATA", new_android_data, 1);
       } else if (option == "--downgrade") {
         downgrade_ = true;
       } else if (StartsWith(option, "--oat-fd=")) {
         oat_fd_ = std::stoi(std::string(option.substr(strlen("--oat-fd="))), nullptr, 0);
         if (oat_fd_ < 0) {
           Usage("Invalid --oat-fd %d", oat_fd_);
         }
       } else if (StartsWith(option, "--vdex-fd=")) {
         vdex_fd_ = std::stoi(std::string(option.substr(strlen("--vdex-fd="))), nullptr, 0);
         if (vdex_fd_ < 0) {
           Usage("Invalid --vdex-fd %d", vdex_fd_);
         }
       } else if (StartsWith(option, "--zip-fd=")) {
         zip_fd_ = std::stoi(std::string(option.substr(strlen("--zip-fd="))), nullptr, 0);
         if (zip_fd_ < 0) {
           Usage("Invalid --zip-fd %d", zip_fd_);
         }
       } else if (StartsWith(option, "--class-loader-context=")) {
         context_str_ = std::string(option.substr(strlen("--class-loader-context=")));
       } else if (StartsWith(option, "--class-loader-context-fds=")) {
         std::string str_context_fds_arg =
             std::string(option.substr(strlen("--class-loader-context-fds=")));
         std::vector<std::string> str_fds = android::base::Split(str_context_fds_arg, ":");
         for (const std::string& str_fd : str_fds) {
           context_fds_.push_back(std::stoi(str_fd, nullptr, 0));
           if (context_fds_.back() < 0) {
             Usage("Invalid --class-loader-context-fds %s", str_context_fds_arg.c_str());
           }
         }
       } else if (option == "--flatten-class-loader-context") {
         only_flatten_context_ = true;
       } else if (option == "--validate-bcp") {
         only_validate_bcp_ = true;
       } else {
         Usage("Unknown argument '%s'", raw_option);
       }
     }

     if (image_.empty()) {
       // If we don't receive the image, try to use the default one.
       // Tests may specify a different image (e.g. core image).
       std::string error_msg;
       image_ = GetDefaultBootImageLocation(&error_msg);

       if (image_.empty()) {
         LOG(ERROR) << error_msg;
         Usage("--image unspecified and ANDROID_ROOT not set or image file does not exist.");
       }
     }
   }

   bool CreateRuntime() const {
     RuntimeOptions options;
     // The image could be custom, so make sure we explicitly pass it.
     std::string img = "-Ximage:" + image_;
     options.push_back(std::make_pair(img, nullptr));
     // The instruction set of the image should match the instruction set we will test.
     const void* isa_opt = reinterpret_cast<const void*>(GetInstructionSetString(isa_));
     options.push_back(std::make_pair("imageinstructionset", isa_opt));
     // Explicit runtime args.
     for (const char* runtime_arg : runtime_args_) {
       options.push_back(std::make_pair(runtime_arg, nullptr));
     }
      // Disable libsigchain. We don't don't need it to evaluate DexOptNeeded status.
     options.push_back(std::make_pair("-Xno-sig-chain", nullptr));
     // Pretend we are a compiler so that we can re-use the same infrastructure to load a different
     // ISA image and minimize the amount of things that get started.
     NoopCompilerCallbacks callbacks;
     options.push_back(std::make_pair("compilercallbacks", &callbacks));
     // Make sure we don't attempt to relocate. The tool should only retrieve the DexOptNeeded
     // status and not attempt to relocate the boot image.
     options.push_back(std::make_pair("-Xnorelocate", nullptr));

     if (!Runtime::Create(options, false)) {
       LOG(ERROR) << "Unable to initialize runtime";
       return false;
     }
     // Runtime::Create acquired the mutator_lock_ that is normally given away when we
     // Runtime::Start. Give it away now.
     Thread::Current()->TransitionFromRunnableToSuspended(ThreadState::kNative);

     return true;
   }

   ReturnCode GetDexOptNeeded() const {
     if (!CreateRuntime()) {
       return ReturnCode::kErrorCannotCreateRuntime;
     }
     std::unique_ptr<Runtime> runtime(Runtime::Current());

     // Only when the runtime is created can we create the class loader context: the
     // class loader context will open dex file and use the MemMap global lock that the
     // runtime owns.
     std::unique_ptr<ClassLoaderContext> class_loader_context;
     if (!context_str_.empty()) {
       class_loader_context = ClassLoaderContext::Create(context_str_);
       if (class_loader_context == nullptr) {
         Usage("Invalid --class-loader-context '%s'", context_str_.c_str());
       }
     }
     if (class_loader_context != nullptr) {
       size_t dir_index = dex_file_.rfind('/');
       std::string classpath_dir = (dir_index != std::string::npos)
           ? dex_file_.substr(0, dir_index)
           : "";

       if (!class_loader_context->OpenDexFiles(classpath_dir,
                                               context_fds_,
                                               /*only_read_checksums=*/ true)) {
         return ReturnCode::kDex2OatFromScratch;
       }
     }

     std::unique_ptr<OatFileAssistant> oat_file_assistant;
     oat_file_assistant = std::make_unique<OatFileAssistant>(dex_file_.c_str(),
                                                             isa_,
                                                             class_loader_context.get(),
                                                             /*load_executable=*/ false,
                                                             /*only_load_trusted_executable=*/ false,
                                                             vdex_fd_,
                                                             oat_fd_,
                                                             zip_fd_);
     // Always treat elements of the bootclasspath as up-to-date.
     // TODO(calin): this check should be in OatFileAssistant.
     if (oat_file_assistant->IsInBootClassPath()) {
       return ReturnCode::kNoDexOptNeeded;
     }

     // If the compiler filter depends on profiles but the profiles are empty,
     // change the test filter to kVerify. It's what dex2oat also does.
     CompilerFilter::Filter actual_compiler_filter = compiler_filter_;
     if (CompilerFilter::DependsOnProfile(compiler_filter_) &&
         profile_analysis_result_ == ProfileAnalysisResult::kDontOptimizeEmptyProfiles) {
       actual_compiler_filter = CompilerFilter::kVerify;
     }

     // TODO: GetDexOptNeeded should get the raw analysis result instead of assume_profile_changed.
     bool assume_profile_changed = profile_analysis_result_ == ProfileAnalysisResult::kOptimize;
     int dexoptNeeded = oat_file_assistant->GetDexOptNeeded(actual_compiler_filter,
                                                            assume_profile_changed,
                                                            downgrade_);

     // Convert OatFileAssistant codes to dexoptanalyzer codes.
     switch (dexoptNeeded) {
       case OatFileAssistant::kNoDexOptNeeded: return ReturnCode::kNoDexOptNeeded;
       case OatFileAssistant::kDex2OatFromScratch: return ReturnCode::kDex2OatFromScratch;
       case OatFileAssistant::kDex2OatForBootImage: return ReturnCode::kDex2OatForBootImageOat;
       case OatFileAssistant::kDex2OatForFilter: return ReturnCode::kDex2OatForFilterOat;

       case -OatFileAssistant::kDex2OatForBootImage: return ReturnCode::kDex2OatForBootImageOdex;
       case -OatFileAssistant::kDex2OatForFilter: return ReturnCode::kDex2OatForFilterOdex;
       default:
         LOG(ERROR) << "Unknown dexoptNeeded " << dexoptNeeded;
         return ReturnCode::kErrorUnknownDexOptNeeded;
     }
   }

   // Validates the boot classpath and boot classpath extensions by checking the image checksums,
   // the oat files and the vdex files.
   //
   // Returns `ReturnCode::kNoDexOptNeeded` when all the files are up-to-date,
   // `ReturnCode::kDex2OatFromScratch` if any of the files are missing or out-of-date, and
   // `ReturnCode::kErrorCannotCreateRuntime` if the files could not be tested due to problem
   // creating a runtime.
   ReturnCode ValidateBcp() const {
     using ImageSpace = gc::space::ImageSpace;

     if (!CreateRuntime()) {
       return ReturnCode::kErrorCannotCreateRuntime;
     }
     std::unique_ptr<Runtime> runtime(Runtime::Current());

     auto dex_files = ArrayRef<const DexFile* const>(runtime->GetClassLinker()->GetBootClassPath());
     auto boot_image_spaces = ArrayRef<ImageSpace* const>(runtime->GetHeap()->GetBootImageSpaces());
     const std::string checksums = ImageSpace::GetBootClassPathChecksums(boot_image_spaces,
                                                                         dex_files);

     std::string error_msg;
     const std::vector<std::string>& bcp = runtime->GetBootClassPath();
     const std::vector<std::string>& bcp_locations = runtime->GetBootClassPathLocations();
     const std::vector<int>& bcp_fds = runtime->GetBootClassPathFds();
     const std::vector<std::string>& image_locations = runtime->GetImageLocations();
     const std::string bcp_locations_path = android::base::Join(bcp_locations, ':');
     if (!ImageSpace::VerifyBootClassPathChecksums(checksums,
                                                   bcp_locations_path,
                                                   ArrayRef<const std::string>(image_locations),
                                                   ArrayRef<const std::string>(bcp_locations),
                                                   ArrayRef<const std::string>(bcp),
                                                   ArrayRef<const int>(bcp_fds),
                                                   runtime->GetInstructionSet(),
                                                   &error_msg)) {
       LOG(INFO) << "Failed to verify boot class path checksums: " << error_msg;
       return ReturnCode::kDex2OatFromScratch;
     }

     const auto& image_spaces = runtime->GetHeap()->GetBootImageSpaces();
     size_t bcp_component_count = 0;
     for (const auto& image_space : image_spaces) {
       if (!image_space->GetImageHeader().IsValid()) {
         LOG(INFO) << "Image header is not valid: " << image_space->GetImageFilename();
         return ReturnCode::kDex2OatFromScratch;
       }
       const OatFile* oat_file = image_space->GetOatFile();
       if (oat_file == nullptr) {
         const std::string oat_path = ReplaceFileExtension(image_space->GetImageFilename(), "oat");
         LOG(INFO) << "Oat file missing: " << oat_path;
         return ReturnCode::kDex2OatFromScratch;
       }
       if (!oat_file->GetOatHeader().IsValid() ||
           !ImageSpace::ValidateOatFile(*oat_file, &error_msg)) {
         LOG(INFO) << "Oat file is not valid: " << oat_file->GetLocation() << " " << error_msg;
         return ReturnCode::kDex2OatFromScratch;
       }
       const VdexFile* vdex_file = oat_file->GetVdexFile();
       if (vdex_file == nullptr || !vdex_file->IsValid()) {
         LOG(INFO) << "Vdex file is not valid : " << oat_file->GetLocation();
         return ReturnCode::kDex2OatFromScratch;
       }
       bcp_component_count += image_space->GetComponentCount();
     }

     // If the number of components encountered in the image spaces does not match the number
     // of components expected from the boot classpath locations then something is missing.
     if (bcp_component_count != bcp_locations.size()) {
       for (size_t i = bcp_component_count; i < bcp_locations.size(); ++i) {
         LOG(INFO) << "Missing image file for " << bcp_locations[i];
       }
       return ReturnCode::kDex2OatFromScratch;
     }

     return ReturnCode::kNoDexOptNeeded;
   }

   ReturnCode FlattenClassLoaderContext() const {
     DCHECK(only_flatten_context_);
     if (context_str_.empty()) {
       return ReturnCode::kErrorInvalidArguments;
     }

     std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create(context_str_);
     if (context == nullptr) {
       Usage("Invalid --class-loader-context '%s'", context_str_.c_str());
     }

     std::cout << context->FlattenDexPaths() << std::flush;
     return ReturnCode::kFlattenClassLoaderContextSuccess;
   }

   ReturnCode Run() const {
     if (only_flatten_context_) {
       return FlattenClassLoaderContext();
     } else if (only_validate_bcp_) {
       return ValidateBcp();
     } else {
       return GetDexOptNeeded();
     }
   }

  private:
   std::string dex_file_;
   InstructionSet isa_;
   CompilerFilter::Filter compiler_filter_;
   std::string context_str_;
   bool only_flatten_context_;
   bool only_validate_bcp_;
   ProfileAnalysisResult profile_analysis_result_;
   bool downgrade_;
   std::string image_;
   std::vector<const char*> runtime_args_;
   int oat_fd_ = -1;
   int vdex_fd_ = -1;
   // File descriptor corresponding to apk, dex_file, or zip.
   int zip_fd_ = -1;
   std::vector<int> context_fds_;
 };

 static ReturnCode dexoptAnalyze(int argc, char** argv) {
   DexoptAnalyzer analyzer;

   // Parse arguments. Argument mistakes will lead to exit(kErrorInvalidArguments) in UsageError.
   analyzer.ParseArgs(argc, argv);
   return analyzer.Run();
 }

 }  // namespace dexoptanalyzer
 }  // namespace art

 int main(int argc, char **argv) {
   art::dexoptanalyzer::ReturnCode return_code = art::dexoptanalyzer::dexoptAnalyze(argc, argv);
   return static_cast<int>(return_code);
 }
	/*
	* Copyright (C) 2017 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 "dexoptanalyzer.h"

	#include <iostream>
	#include <string>
	#include <string_view>

	#include "android-base/stringprintf.h"
	#include "android-base/strings.h"
	#include "base/compiler_filter.h"
	#include "base/file_utils.h"
	#include "base/logging.h" // For InitLogging.
	#include "base/mutex.h"
	#include "base/os.h"
	#include "base/string_view_cpp20.h"
	#include "base/utils.h"
	#include "class_linker.h"
	#include "class_loader_context.h"
	#include "dex/dex_file.h"
	#include "gc/heap.h"
	#include "gc/space/image_space.h"
	#include "noop_compiler_callbacks.h"
	#include "oat.h"
	#include "oat_file_assistant.h"
	#include "runtime.h"
	#include "thread-inl.h"
	#include "vdex_file.h"

	namespace art {
	namespace dexoptanalyzer {

	static int original_argc;
	static char** original_argv;

	static std::string CommandLine() {
	std::vector<std::string> command;
	command.reserve(original_argc);
	for (int i = 0; i < original_argc; ++i) {
	command.push_back(original_argv[i]);
	}
	return android::base::Join(command, ' ');
	}

	static void UsageErrorV(const char* fmt, va_list ap) {
	std::string error;
	android::base::StringAppendV(&error, fmt, ap);
	LOG(ERROR) << error;
	}

	static void UsageError(const char* fmt, ...) {
	va_list ap;
	va_start(ap, fmt);
	UsageErrorV(fmt, ap);
	va_end(ap);
	}

	NO_RETURN static void Usage(const char *fmt, ...) {
	va_list ap;
	va_start(ap, fmt);
	UsageErrorV(fmt, ap);
	va_end(ap);

	UsageError("Command: %s", CommandLine().c_str());
	UsageError(" Performs a dexopt analysis on the given dex file and returns whether or not");
	UsageError(" the dex file needs to be dexopted.");
	UsageError("Usage: dexoptanalyzer [options]...");
	UsageError("");
	UsageError(" --dex-file=<filename>: the dex file which should be analyzed.");
	UsageError("");
	UsageError(" --isa=<string>: the instruction set for which the analysis should be performed.");
	UsageError("");
	UsageError(" --compiler-filter=<string>: the target compiler filter to be used as reference");
	UsageError(" when deciding if the dex file needs to be optimized.");
	UsageError("");
	UsageError(" --profile_analysis_result=<int>: the result of the profile analysis, used in");
	UsageError(" deciding if the dex file needs to be optimized.");
	UsageError("");
	UsageError(" --image=<filename>: optional, the image to be used to decide if the associated");
	UsageError(" oat file is up to date. Defaults to $ANDROID_ROOT/framework/boot.art.");
	UsageError(" Example: --image=/system/framework/boot.art");
	UsageError("");
	UsageError(" --runtime-arg <argument>: used to specify various arguments for the runtime,");
	UsageError(" such as initial heap size, maximum heap size, and verbose output.");
	UsageError(" Use a separate --runtime-arg switch for each argument.");
	UsageError(" Example: --runtime-arg -Xms256m");
	UsageError("");
	UsageError(" --android-data=<directory>: optional, the directory which should be used as");
	UsageError(" android-data. By default ANDROID_DATA env variable is used.");
	UsageError("");
	UsageError(" --oat-fd=number: file descriptor of the oat file which should be analyzed");
	UsageError("");
	UsageError(" --vdex-fd=number: file descriptor of the vdex file corresponding to the oat file");
	UsageError("");
	UsageError(" --zip-fd=number: specifies a file descriptor corresponding to the dex file.");
	UsageError("");
	UsageError(" --downgrade: optional, if the purpose of dexopt is to downgrade the dex file");
	UsageError(" By default, dexopt considers upgrade case.");
	UsageError("");
	UsageError(" --class-loader-context=<string spec>: a string specifying the intended");
	UsageError(" runtime loading context for the compiled dex files.");
	UsageError("");
	UsageError(" --class-loader-context-fds=<fds>: a colon-separated list of file descriptors");
	UsageError(" for dex files in --class-loader-context. Their order must be the same as");
	UsageError(" dex files in flattened class loader context.");
	UsageError("");
	UsageError(" --flatten-class-loader-context: parse --class-loader-context, flatten it and");
	UsageError(" print a colon-separated list of its dex files to standard output. Dexopt");
	UsageError(" needed analysis is not performed when this option is set.");
	UsageError("");
	UsageError(" --validate-bcp: validates the boot class path files (.art, .oat, .vdex).");
	UsageError(" Requires --isa and --image options to locate artifacts.");
	UsageError("");
	UsageError("Return code:");
	UsageError(" To make it easier to integrate with the internal tools this command will make");
	UsageError(" available its result (dexoptNeeded) as the exit/return code. i.e. it will not");
	UsageError(" return 0 for success and a non zero values for errors as the conventional");
	UsageError(" commands. The following return codes are possible:");
	UsageError(" kNoDexOptNeeded = 0");
	UsageError(" kDex2OatFromScratch = 1");
	UsageError(" kDex2OatForBootImageOat = 2");
	UsageError(" kDex2OatForFilterOat = 3");
	UsageError(" kDex2OatForBootImageOdex = 4");
	UsageError(" kDex2OatForFilterOdex = 5");

	UsageError(" kErrorInvalidArguments = 101");
	UsageError(" kErrorCannotCreateRuntime = 102");
	UsageError(" kErrorUnknownDexOptNeeded = 103");
	UsageError("");

	exit(static_cast<int>(ReturnCode::kErrorInvalidArguments));
	}

	class DexoptAnalyzer final {
	public:
	DexoptAnalyzer() :
	only_flatten_context_(false),
	only_validate_bcp_(false),
	downgrade_(false) {}

	void ParseArgs(int argc, char **argv) {
	original_argc = argc;
	original_argv = argv;

	Locks::Init();
	InitLogging(argv, Runtime::Abort);
	// Skip over the command name.
	argv++;
	argc--;

	if (argc == 0) {
	Usage("No arguments specified");
	}

	for (int i = 0; i < argc; ++i) {
	const char* raw_option = argv[i];
	const std::string_view option(raw_option);

	if (StartsWith(option, "--profile-analysis-result=")) {
	int parse_result = std::stoi(std::string(
	option.substr(strlen("--profile-analysis-result="))), nullptr, 0);
	if (parse_result != static_cast<int>(ProfileAnalysisResult::kOptimize) &&
	parse_result != static_cast<int>(ProfileAnalysisResult::kDontOptimizeSmallDelta) &&
	parse_result != static_cast<int>(ProfileAnalysisResult::kDontOptimizeEmptyProfiles)) {
	Usage("Invalid --profile-analysis-result= %d", parse_result);
	}
	profile_analysis_result_ = static_cast<ProfileAnalysisResult>(parse_result);
	} else if (StartsWith(option, "--dex-file=")) {
	dex_file_ = std::string(option.substr(strlen("--dex-file=")));
	} else if (StartsWith(option, "--compiler-filter=")) {
	const char* filter_str = raw_option + strlen("--compiler-filter=");
	if (!CompilerFilter::ParseCompilerFilter(filter_str, &compiler_filter_)) {
	Usage("Invalid compiler filter '%s'", raw_option);
	}
	} else if (StartsWith(option, "--isa=")) {
	const char* isa_str = raw_option + strlen("--isa=");
	isa_ = GetInstructionSetFromString(isa_str);
	if (isa_ == InstructionSet::kNone) {
	Usage("Invalid isa '%s'", raw_option);
	}
	} else if (StartsWith(option, "--image=")) {
	image_ = std::string(option.substr(strlen("--image=")));
	} else if (option == "--runtime-arg") {
	if (i + 1 == argc) {
	Usage("Missing argument for --runtime-arg\n");
	}
	++i;
	runtime_args_.push_back(argv[i]);
	} else if (StartsWith(option, "--android-data=")) {
	// Overwrite android-data if needed (oat file assistant relies on a valid directory to
	// compute dalvik-cache folder). This is mostly used in tests.
	const char* new_android_data = raw_option + strlen("--android-data=");
	setenv("ANDROID_DATA", new_android_data, 1);
	} else if (option == "--downgrade") {
	downgrade_ = true;
	} else if (StartsWith(option, "--oat-fd=")) {
	oat_fd_ = std::stoi(std::string(option.substr(strlen("--oat-fd="))), nullptr, 0);
	if (oat_fd_ < 0) {
	Usage("Invalid --oat-fd %d", oat_fd_);
	}
	} else if (StartsWith(option, "--vdex-fd=")) {
	vdex_fd_ = std::stoi(std::string(option.substr(strlen("--vdex-fd="))), nullptr, 0);
	if (vdex_fd_ < 0) {
	Usage("Invalid --vdex-fd %d", vdex_fd_);
	}
	} else if (StartsWith(option, "--zip-fd=")) {
	zip_fd_ = std::stoi(std::string(option.substr(strlen("--zip-fd="))), nullptr, 0);
	if (zip_fd_ < 0) {
	Usage("Invalid --zip-fd %d", zip_fd_);
	}
	} else if (StartsWith(option, "--class-loader-context=")) {
	context_str_ = std::string(option.substr(strlen("--class-loader-context=")));
	} else if (StartsWith(option, "--class-loader-context-fds=")) {
	std::string str_context_fds_arg =
	std::string(option.substr(strlen("--class-loader-context-fds=")));
	std::vector<std::string> str_fds = android::base::Split(str_context_fds_arg, ":");
	for (const std::string& str_fd : str_fds) {
	context_fds_.push_back(std::stoi(str_fd, nullptr, 0));
	if (context_fds_.back() < 0) {
	Usage("Invalid --class-loader-context-fds %s", str_context_fds_arg.c_str());
	}
	}
	} else if (option == "--flatten-class-loader-context") {
	only_flatten_context_ = true;
	} else if (option == "--validate-bcp") {
	only_validate_bcp_ = true;
	} else {
	Usage("Unknown argument '%s'", raw_option);
	}
	}

	if (image_.empty()) {
	// If we don't receive the image, try to use the default one.
	// Tests may specify a different image (e.g. core image).
	std::string error_msg;
	image_ = GetDefaultBootImageLocation(&error_msg);

	if (image_.empty()) {
	LOG(ERROR) << error_msg;
	Usage("--image unspecified and ANDROID_ROOT not set or image file does not exist.");
	}
	}
	}

	bool CreateRuntime() const {
	RuntimeOptions options;
	// The image could be custom, so make sure we explicitly pass it.
	std::string img = "-Ximage:" + image_;
	options.push_back(std::make_pair(img, nullptr));
	// The instruction set of the image should match the instruction set we will test.
	const void* isa_opt = reinterpret_cast<const void*>(GetInstructionSetString(isa_));
	options.push_back(std::make_pair("imageinstructionset", isa_opt));
	// Explicit runtime args.
	for (const char* runtime_arg : runtime_args_) {
	options.push_back(std::make_pair(runtime_arg, nullptr));
	}
	// Disable libsigchain. We don't don't need it to evaluate DexOptNeeded status.
	options.push_back(std::make_pair("-Xno-sig-chain", nullptr));
	// Pretend we are a compiler so that we can re-use the same infrastructure to load a different
	// ISA image and minimize the amount of things that get started.
	NoopCompilerCallbacks callbacks;
	options.push_back(std::make_pair("compilercallbacks", &callbacks));
	// Make sure we don't attempt to relocate. The tool should only retrieve the DexOptNeeded
	// status and not attempt to relocate the boot image.
	options.push_back(std::make_pair("-Xnorelocate", nullptr));

	if (!Runtime::Create(options, false)) {
	LOG(ERROR) << "Unable to initialize runtime";
	return false;
	}
	// Runtime::Create acquired the mutator_lock_ that is normally given away when we
	// Runtime::Start. Give it away now.
	Thread::Current()->TransitionFromRunnableToSuspended(ThreadState::kNative);

	return true;
	}

	ReturnCode GetDexOptNeeded() const {
	if (!CreateRuntime()) {
	return ReturnCode::kErrorCannotCreateRuntime;
	}
	std::unique_ptr<Runtime> runtime(Runtime::Current());

	// Only when the runtime is created can we create the class loader context: the
	// class loader context will open dex file and use the MemMap global lock that the
	// runtime owns.
	std::unique_ptr<ClassLoaderContext> class_loader_context;
	if (!context_str_.empty()) {
	class_loader_context = ClassLoaderContext::Create(context_str_);
	if (class_loader_context == nullptr) {
	Usage("Invalid --class-loader-context '%s'", context_str_.c_str());
	}
	}
	if (class_loader_context != nullptr) {
	size_t dir_index = dex_file_.rfind('/');
	std::string classpath_dir = (dir_index != std::string::npos)
	? dex_file_.substr(0, dir_index)
	: "";

	if (!class_loader_context->OpenDexFiles(classpath_dir,
	context_fds_,
	/only_read_checksums=/ true)) {
	return ReturnCode::kDex2OatFromScratch;
	}
	}

	std::unique_ptr<OatFileAssistant> oat_file_assistant;
	oat_file_assistant = std::make_unique<OatFileAssistant>(dex_file_.c_str(),
	isa_,
	class_loader_context.get(),
	/load_executable=/ false,
	/only_load_trusted_executable=/ false,
	vdex_fd_,
	oat_fd_,
	zip_fd_);
	// Always treat elements of the bootclasspath as up-to-date.
	// TODO(calin): this check should be in OatFileAssistant.
	if (oat_file_assistant->IsInBootClassPath()) {
	return ReturnCode::kNoDexOptNeeded;
	}

	// If the compiler filter depends on profiles but the profiles are empty,
	// change the test filter to kVerify. It's what dex2oat also does.
	CompilerFilter::Filter actual_compiler_filter = compiler_filter_;
	if (CompilerFilter::DependsOnProfile(compiler_filter_) &&
	profile_analysis_result_ == ProfileAnalysisResult::kDontOptimizeEmptyProfiles) {
	actual_compiler_filter = CompilerFilter::kVerify;
	}

	// TODO: GetDexOptNeeded should get the raw analysis result instead of assume_profile_changed.
	bool assume_profile_changed = profile_analysis_result_ == ProfileAnalysisResult::kOptimize;
	int dexoptNeeded = oat_file_assistant->GetDexOptNeeded(actual_compiler_filter,
	assume_profile_changed,
	downgrade_);

	// Convert OatFileAssistant codes to dexoptanalyzer codes.
	switch (dexoptNeeded) {
	case OatFileAssistant::kNoDexOptNeeded: return ReturnCode::kNoDexOptNeeded;
	case OatFileAssistant::kDex2OatFromScratch: return ReturnCode::kDex2OatFromScratch;
	case OatFileAssistant::kDex2OatForBootImage: return ReturnCode::kDex2OatForBootImageOat;
	case OatFileAssistant::kDex2OatForFilter: return ReturnCode::kDex2OatForFilterOat;

	case -OatFileAssistant::kDex2OatForBootImage: return ReturnCode::kDex2OatForBootImageOdex;
	case -OatFileAssistant::kDex2OatForFilter: return ReturnCode::kDex2OatForFilterOdex;
	default:
	LOG(ERROR) << "Unknown dexoptNeeded " << dexoptNeeded;
	return ReturnCode::kErrorUnknownDexOptNeeded;
	}
	}

	// Validates the boot classpath and boot classpath extensions by checking the image checksums,
	// the oat files and the vdex files.
	//
	// Returns `ReturnCode::kNoDexOptNeeded` when all the files are up-to-date,
	// `ReturnCode::kDex2OatFromScratch` if any of the files are missing or out-of-date, and
	// `ReturnCode::kErrorCannotCreateRuntime` if the files could not be tested due to problem
	// creating a runtime.
	ReturnCode ValidateBcp() const {
	using ImageSpace = gc::space::ImageSpace;

	if (!CreateRuntime()) {
	return ReturnCode::kErrorCannotCreateRuntime;
	}
	std::unique_ptr<Runtime> runtime(Runtime::Current());

	auto dex_files = ArrayRef<const DexFile* const>(runtime->GetClassLinker()->GetBootClassPath());
	auto boot_image_spaces = ArrayRef<ImageSpace* const>(runtime->GetHeap()->GetBootImageSpaces());
	const std::string checksums = ImageSpace::GetBootClassPathChecksums(boot_image_spaces,
	dex_files);

	std::string error_msg;
	const std::vector<std::string>& bcp = runtime->GetBootClassPath();
	const std::vector<std::string>& bcp_locations = runtime->GetBootClassPathLocations();
	const std::vector<int>& bcp_fds = runtime->GetBootClassPathFds();
	const std::vector<std::string>& image_locations = runtime->GetImageLocations();
	const std::string bcp_locations_path = android::base::Join(bcp_locations, ':');
	if (!ImageSpace::VerifyBootClassPathChecksums(checksums,
	bcp_locations_path,
	ArrayRef<const std::string>(image_locations),
	ArrayRef<const std::string>(bcp_locations),
	ArrayRef<const std::string>(bcp),
	ArrayRef<const int>(bcp_fds),
	runtime->GetInstructionSet(),
	&error_msg)) {
	LOG(INFO) << "Failed to verify boot class path checksums: " << error_msg;
	return ReturnCode::kDex2OatFromScratch;
	}

	const auto& image_spaces = runtime->GetHeap()->GetBootImageSpaces();
	size_t bcp_component_count = 0;
	for (const auto& image_space : image_spaces) {
	if (!image_space->GetImageHeader().IsValid()) {
	LOG(INFO) << "Image header is not valid: " << image_space->GetImageFilename();
	return ReturnCode::kDex2OatFromScratch;
	}
	const OatFile* oat_file = image_space->GetOatFile();
	if (oat_file == nullptr) {
	const std::string oat_path = ReplaceFileExtension(image_space->GetImageFilename(), "oat");
	LOG(INFO) << "Oat file missing: " << oat_path;
	return ReturnCode::kDex2OatFromScratch;
	}
	if (!oat_file->GetOatHeader().IsValid() \|\|
	!ImageSpace::ValidateOatFile(*oat_file, &error_msg)) {
	LOG(INFO) << "Oat file is not valid: " << oat_file->GetLocation() << " " << error_msg;
	return ReturnCode::kDex2OatFromScratch;
	}
	const VdexFile* vdex_file = oat_file->GetVdexFile();
	if (vdex_file == nullptr \|\| !vdex_file->IsValid()) {
	LOG(INFO) << "Vdex file is not valid : " << oat_file->GetLocation();
	return ReturnCode::kDex2OatFromScratch;
	}
	bcp_component_count += image_space->GetComponentCount();
	}

	// If the number of components encountered in the image spaces does not match the number
	// of components expected from the boot classpath locations then something is missing.
	if (bcp_component_count != bcp_locations.size()) {
	for (size_t i = bcp_component_count; i < bcp_locations.size(); ++i) {
	LOG(INFO) << "Missing image file for " << bcp_locations[i];
	}
	return ReturnCode::kDex2OatFromScratch;
	}

	return ReturnCode::kNoDexOptNeeded;
	}

	ReturnCode FlattenClassLoaderContext() const {
	DCHECK(only_flatten_context_);
	if (context_str_.empty()) {
	return ReturnCode::kErrorInvalidArguments;
	}

	std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create(context_str_);
	if (context == nullptr) {
	Usage("Invalid --class-loader-context '%s'", context_str_.c_str());
	}

	std::cout << context->FlattenDexPaths() << std::flush;
	return ReturnCode::kFlattenClassLoaderContextSuccess;
	}

	ReturnCode Run() const {
	if (only_flatten_context_) {
	return FlattenClassLoaderContext();
	} else if (only_validate_bcp_) {
	return ValidateBcp();
	} else {
	return GetDexOptNeeded();
	}
	}

	private:
	std::string dex_file_;
	InstructionSet isa_;
	CompilerFilter::Filter compiler_filter_;
	std::string context_str_;
	bool only_flatten_context_;
	bool only_validate_bcp_;
	ProfileAnalysisResult profile_analysis_result_;
	bool downgrade_;
	std::string image_;
	std::vector<const char*> runtime_args_;
	int oat_fd_ = -1;
	int vdex_fd_ = -1;
	// File descriptor corresponding to apk, dex_file, or zip.
	int zip_fd_ = -1;
	std::vector<int> context_fds_;
	};

	static ReturnCode dexoptAnalyze(int argc, char** argv) {
	DexoptAnalyzer analyzer;

	// Parse arguments. Argument mistakes will lead to exit(kErrorInvalidArguments) in UsageError.
	analyzer.ParseArgs(argc, argv);
	return analyzer.Run();
	}

	} // namespace dexoptanalyzer
	} // namespace art

	int main(int argc, char **argv) {
	art::dexoptanalyzer::ReturnCode return_code = art::dexoptanalyzer::dexoptAnalyze(argc, argv);
	return static_cast<int>(return_code);
	}