cmds/installd/run_dex2oat.cpp - android_frameworks_native - Gitiles

 /*
  * Copyright (C) 2020 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.
  */
 #define LOG_TAG "installd"

 #include "run_dex2oat.h"

 #include <memory>
 #include <string>
 #include <vector>

 #include <android-base/file.h>
 #include <android-base/logging.h>
 #include <android-base/properties.h>
 #include <android-base/scopeguard.h>
 #include <android-base/stringprintf.h>
 #include <android-base/strings.h>
 #include <log/log.h>
 #include <server_configurable_flags/get_flags.h>

 using android::base::Basename;
 using android::base::StringPrintf;

 namespace android {
 namespace installd {

 namespace {

 // Should minidebug info be included in compiled artifacts? Even if this value is
 // "true," usage might still be conditional to other constraints, e.g., system
 // property overrides.
 static constexpr bool kEnableMinidebugInfo = true;

 static constexpr const char* kMinidebugInfoSystemProperty = "dalvik.vm.dex2oat-minidebuginfo";
 static constexpr bool kMinidebugInfoSystemPropertyDefault = false;
 static constexpr const char* kMinidebugDex2oatFlag = "--generate-mini-debug-info";
 static constexpr const char* kDisableCompactDexFlag = "--compact-dex-level=none";

 // Location of the JIT Zygote image.
 static const char* kJitZygoteImage =
     "boot.art:/nonx/boot-framework.art!/system/etc/boot-image.prof";

 std::vector<std::string> SplitBySpaces(const std::string& str) {
     if (str.empty()) {
         return {};
     }
     return android::base::Split(str, " ");
 }

 }  // namespace

 RunDex2Oat::RunDex2Oat(const char* dex2oat_bin, ExecVHelper* execv_helper)
   : dex2oat_bin_(dex2oat_bin), execv_helper_(execv_helper) {}

 void RunDex2Oat::Initialize(int zip_fd,
                             int oat_fd,
                             int input_vdex_fd,
                             int output_vdex_fd,
                             int image_fd,
                             const char* input_file_name,
                             const char* output_file_name,
                             int swap_fd,
                             const char* instruction_set,
                             const char* compiler_filter,
                             bool debuggable,
                             bool post_bootcomplete,
                             bool for_restore,
                             int profile_fd,
                             const char* class_loader_context,
                             const std::string& class_loader_context_fds,
                             int target_sdk_version,
                             bool enable_hidden_api_checks,
                             bool generate_compact_dex,
                             int dex_metadata_fd,
                             bool use_jitzygote_image,
                             const char* compilation_reason) {
     // Get the relative path to the input file.
     std::string input_basename = Basename(input_file_name);

     std::string dex2oat_Xms_arg = MapPropertyToArg("dalvik.vm.dex2oat-Xms", "-Xms%s");
     std::string dex2oat_Xmx_arg = MapPropertyToArg("dalvik.vm.dex2oat-Xmx", "-Xmx%s");

     std::string threads_format = "-j%s";
     std::string dex2oat_threads_arg = post_bootcomplete
             ? (for_restore
                 ? MapPropertyToArgWithBackup(
                         "dalvik.vm.restore-dex2oat-threads",
                         "dalvik.vm.dex2oat-threads",
                         threads_format)
                 : MapPropertyToArg("dalvik.vm.dex2oat-threads", threads_format))
             : MapPropertyToArg("dalvik.vm.boot-dex2oat-threads", threads_format);
     std::string cpu_set_format = "--cpu-set=%s";
     std::string dex2oat_cpu_set_arg = post_bootcomplete
             ? (for_restore
                 ? MapPropertyToArgWithBackup(
                         "dalvik.vm.restore-dex2oat-cpu-set",
                         "dalvik.vm.dex2oat-cpu-set",
                         cpu_set_format)
                 : MapPropertyToArg("dalvik.vm.dex2oat-cpu-set", cpu_set_format))
             : MapPropertyToArg("dalvik.vm.boot-dex2oat-cpu-set", cpu_set_format);

     std::string bootclasspath;
     char* dex2oat_bootclasspath = getenv("DEX2OATBOOTCLASSPATH");
     if (dex2oat_bootclasspath != nullptr) {
         bootclasspath = StringPrintf("-Xbootclasspath:%s", dex2oat_bootclasspath);
     }
     // If DEX2OATBOOTCLASSPATH is not in the environment, dex2oat is going to query
     // BOOTCLASSPATH.

     const std::string dex2oat_isa_features_key =
             StringPrintf("dalvik.vm.isa.%s.features", instruction_set);
     std::string instruction_set_features_arg =
         MapPropertyToArg(dex2oat_isa_features_key, "--instruction-set-features=%s");

     const std::string dex2oat_isa_variant_key =
             StringPrintf("dalvik.vm.isa.%s.variant", instruction_set);
     std::string instruction_set_variant_arg =
         MapPropertyToArg(dex2oat_isa_variant_key, "--instruction-set-variant=%s");

     const char* dex2oat_norelocation = "-Xnorelocate";

     const std::string dex2oat_flags = GetProperty("dalvik.vm.dex2oat-flags", "");
     std::vector<std::string> dex2oat_flags_args = SplitBySpaces(dex2oat_flags);
     ALOGV("dalvik.vm.dex2oat-flags=%s\n", dex2oat_flags.c_str());

     // If we are booting without the real /data, don't spend time compiling.
     std::string vold_decrypt = GetProperty("vold.decrypt", "");
     bool skip_compilation = vold_decrypt == "trigger_restart_min_framework" ||
                             vold_decrypt == "1";

     std::string updatable_bcp_packages =
         MapPropertyToArg("dalvik.vm.dex2oat-updatable-bcp-packages-file",
                          "--updatable-bcp-packages-file=%s");
     if (updatable_bcp_packages.empty()) {
       // Make dex2oat fail by providing non-existent file name.
       updatable_bcp_packages = "--updatable-bcp-packages-file=/nonx/updatable-bcp-packages.txt";
     }

     std::string resolve_startup_string_arg =
             MapPropertyToArg("persist.device_config.runtime.dex2oat_resolve_startup_strings",
                              "--resolve-startup-const-strings=%s");
     if (resolve_startup_string_arg.empty()) {
       // If empty, fall back to system property.
       resolve_startup_string_arg =
             MapPropertyToArg("dalvik.vm.dex2oat-resolve-startup-strings",
                              "--resolve-startup-const-strings=%s");
     }

     const std::string image_block_size_arg =
             MapPropertyToArg("dalvik.vm.dex2oat-max-image-block-size",
                              "--max-image-block-size=%s");

     const bool generate_debug_info = GetBoolProperty("debug.generate-debug-info", false);

     std::string image_format_arg;
     if (image_fd >= 0) {
         image_format_arg = MapPropertyToArg("dalvik.vm.appimageformat", "--image-format=%s");
     }

     std::string dex2oat_large_app_threshold_arg =
         MapPropertyToArg("dalvik.vm.dex2oat-very-large", "--very-large-app-threshold=%s");

     bool generate_minidebug_info = kEnableMinidebugInfo &&
             GetBoolProperty(kMinidebugInfoSystemProperty, kMinidebugInfoSystemPropertyDefault);

     std::string boot_image;
     if (use_jitzygote_image) {
       boot_image = StringPrintf("--boot-image=%s", kJitZygoteImage);
     } else {
       boot_image = MapPropertyToArg("dalvik.vm.boot-image", "--boot-image=%s");
     }

     // clang FORTIFY doesn't let us use strlen in constant array bounds, so we
     // use arraysize instead.
     std::string zip_fd_arg = StringPrintf("--zip-fd=%d", zip_fd);
     std::string zip_location_arg = StringPrintf("--zip-location=%s", input_basename.c_str());
     std::string input_vdex_fd_arg = StringPrintf("--input-vdex-fd=%d", input_vdex_fd);
     std::string output_vdex_fd_arg = StringPrintf("--output-vdex-fd=%d", output_vdex_fd);
     std::string oat_fd_arg = StringPrintf("--oat-fd=%d", oat_fd);
     std::string oat_location_arg = StringPrintf("--oat-location=%s", output_file_name);
     std::string instruction_set_arg = StringPrintf("--instruction-set=%s", instruction_set);
     std::string dex2oat_compiler_filter_arg;
     std::string dex2oat_swap_fd;
     std::string dex2oat_image_fd;
     std::string target_sdk_version_arg;
     if (target_sdk_version != 0) {
         target_sdk_version_arg = StringPrintf("-Xtarget-sdk-version:%d", target_sdk_version);
     }
     std::string class_loader_context_arg;
     std::string class_loader_context_fds_arg;
     if (class_loader_context != nullptr) {
         class_loader_context_arg = StringPrintf("--class-loader-context=%s",
                                                 class_loader_context);
         if (!class_loader_context_fds.empty()) {
             class_loader_context_fds_arg = StringPrintf("--class-loader-context-fds=%s",
                                                         class_loader_context_fds.c_str());
         }
     }

     if (swap_fd >= 0) {
         dex2oat_swap_fd = StringPrintf("--swap-fd=%d", swap_fd);
     }
     if (image_fd >= 0) {
         dex2oat_image_fd = StringPrintf("--app-image-fd=%d", image_fd);
     }

     // Compute compiler filter.
     bool have_dex2oat_relocation_skip_flag = false;
     if (skip_compilation) {
         dex2oat_compiler_filter_arg = "--compiler-filter=extract";
         have_dex2oat_relocation_skip_flag = true;
     } else if (compiler_filter != nullptr) {
         dex2oat_compiler_filter_arg = StringPrintf("--compiler-filter=%s", compiler_filter);
     }

     if (dex2oat_compiler_filter_arg.empty()) {
         dex2oat_compiler_filter_arg = MapPropertyToArg("dalvik.vm.dex2oat-filter",
                                                        "--compiler-filter=%s");
     }

     // Check whether all apps should be compiled debuggable.
     if (!debuggable) {
         debuggable = GetProperty("dalvik.vm.always_debuggable", "") == "1";
     }
     std::string profile_arg;
     if (profile_fd != -1) {
         profile_arg = StringPrintf("--profile-file-fd=%d", profile_fd);
     }

     // Get the directory of the apk to pass as a base classpath directory.
     std::string base_dir;
     std::string apk_dir(input_file_name);
     unsigned long dir_index = apk_dir.rfind('/');
     bool has_base_dir = dir_index != std::string::npos;
     if (has_base_dir) {
         apk_dir = apk_dir.substr(0, dir_index);
         base_dir = StringPrintf("--classpath-dir=%s", apk_dir.c_str());
     }

     std::string dex_metadata_fd_arg = "--dm-fd=" + std::to_string(dex_metadata_fd);

     std::string compilation_reason_arg = compilation_reason == nullptr
             ? ""
             : std::string("--compilation-reason=") + compilation_reason;

     ALOGV("Running %s in=%s out=%s\n", dex2oat_bin_.c_str(), input_basename.c_str(),
           output_file_name);

     // Disable cdex if update input vdex is true since this combination of options is not
     // supported.
     const bool disable_cdex = !generate_compact_dex || (input_vdex_fd == output_vdex_fd);

     AddArg(zip_fd_arg);
     AddArg(zip_location_arg);
     AddArg(input_vdex_fd_arg);
     AddArg(output_vdex_fd_arg);
     AddArg(oat_fd_arg);
     AddArg(oat_location_arg);
     AddArg(instruction_set_arg);

     AddArg(instruction_set_variant_arg);
     AddArg(instruction_set_features_arg);

     AddArg(boot_image);

     AddRuntimeArg(bootclasspath);
     AddRuntimeArg(dex2oat_Xms_arg);
     AddRuntimeArg(dex2oat_Xmx_arg);

     AddArg(updatable_bcp_packages);
     AddArg(resolve_startup_string_arg);
     AddArg(image_block_size_arg);
     AddArg(dex2oat_compiler_filter_arg);
     AddArg(dex2oat_threads_arg);
     AddArg(dex2oat_cpu_set_arg);
     AddArg(dex2oat_swap_fd);
     AddArg(dex2oat_image_fd);

     if (generate_debug_info) {
         AddArg("--generate-debug-info");
     }
     if (debuggable) {
         AddArg("--debuggable");
     }
     AddArg(image_format_arg);
     AddArg(dex2oat_large_app_threshold_arg);

     if (have_dex2oat_relocation_skip_flag) {
         AddRuntimeArg(dex2oat_norelocation);
     }
     AddArg(profile_arg);
     AddArg(base_dir);
     AddArg(class_loader_context_arg);
     AddArg(class_loader_context_fds_arg);
     if (generate_minidebug_info) {
         AddArg(kMinidebugDex2oatFlag);
     }
     if (disable_cdex) {
         AddArg(kDisableCompactDexFlag);
     }
     AddRuntimeArg(target_sdk_version_arg);
     if (enable_hidden_api_checks) {
         AddRuntimeArg("-Xhidden-api-policy:enabled");
     }

     if (dex_metadata_fd > -1) {
         AddArg(dex_metadata_fd_arg);
     }

     AddArg(compilation_reason_arg);

     // Do not add args after dex2oat_flags, they should override others for debugging.
     for (auto it = dex2oat_flags_args.begin(); it != dex2oat_flags_args.end(); ++it) {
         AddArg(*it);
     }

     execv_helper_->PrepareArgs(dex2oat_bin_);
 }

 RunDex2Oat::~RunDex2Oat() {}

 void RunDex2Oat::Exec(int exit_code) {
     LOG(ERROR) << "RunDex2Oat::Exec";
     execv_helper_->Exec(exit_code);
 }

 void RunDex2Oat::AddArg(const std::string& arg) {
     execv_helper_->AddArg(arg);
 }

 void RunDex2Oat::AddRuntimeArg(const std::string& arg) {
     execv_helper_->AddRuntimeArg(arg);
 }

 std::string RunDex2Oat::GetProperty(const std::string& key,
                                     const std::string& default_value) {
     return android::base::GetProperty(key, default_value);
 }

 bool RunDex2Oat::GetBoolProperty(const std::string& key, bool default_value) {
     return android::base::GetBoolProperty(key, default_value);
 }

 std::string RunDex2Oat::MapPropertyToArg(const std::string& property,
                                          const std::string& format,
                                          const std::string& default_value) {
     std::string prop = GetProperty(property, default_value);
     if (!prop.empty()) {
         return StringPrintf(format.c_str(), prop.c_str());
     }
     return "";
 }

 std::string RunDex2Oat::MapPropertyToArgWithBackup(
         const std::string& property,
         const std::string& backupProperty,
         const std::string& format,
         const std::string& default_value) {
     std::string value = GetProperty(property, default_value);
     if (!value.empty()) {
         return StringPrintf(format.c_str(), value.c_str());
     }
     return MapPropertyToArg(backupProperty, format, default_value);
 }

 }  // namespace installd
 }  // namespace android
	/*
	* Copyright (C) 2020 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.
	*/
	#define LOG_TAG "installd"

	#include "run_dex2oat.h"

	#include <memory>
	#include <string>
	#include <vector>

	#include <android-base/file.h>
	#include <android-base/logging.h>
	#include <android-base/properties.h>
	#include <android-base/scopeguard.h>
	#include <android-base/stringprintf.h>
	#include <android-base/strings.h>
	#include <log/log.h>
	#include <server_configurable_flags/get_flags.h>

	using android::base::Basename;
	using android::base::StringPrintf;

	namespace android {
	namespace installd {

	namespace {

	// Should minidebug info be included in compiled artifacts? Even if this value is
	// "true," usage might still be conditional to other constraints, e.g., system
	// property overrides.
	static constexpr bool kEnableMinidebugInfo = true;

	static constexpr const char* kMinidebugInfoSystemProperty = "dalvik.vm.dex2oat-minidebuginfo";
	static constexpr bool kMinidebugInfoSystemPropertyDefault = false;
	static constexpr const char* kMinidebugDex2oatFlag = "--generate-mini-debug-info";
	static constexpr const char* kDisableCompactDexFlag = "--compact-dex-level=none";

	// Location of the JIT Zygote image.
	static const char* kJitZygoteImage =
	"boot.art:/nonx/boot-framework.art!/system/etc/boot-image.prof";

	std::vector<std::string> SplitBySpaces(const std::string& str) {
	if (str.empty()) {
	return {};
	}
	return android::base::Split(str, " ");
	}

	} // namespace

	RunDex2Oat::RunDex2Oat(const char* dex2oat_bin, ExecVHelper* execv_helper)
	: dex2oat_bin_(dex2oat_bin), execv_helper_(execv_helper) {}

	void RunDex2Oat::Initialize(int zip_fd,
	int oat_fd,
	int input_vdex_fd,
	int output_vdex_fd,
	int image_fd,
	const char* input_file_name,
	const char* output_file_name,
	int swap_fd,
	const char* instruction_set,
	const char* compiler_filter,
	bool debuggable,
	bool post_bootcomplete,
	bool for_restore,
	int profile_fd,
	const char* class_loader_context,
	const std::string& class_loader_context_fds,
	int target_sdk_version,
	bool enable_hidden_api_checks,
	bool generate_compact_dex,
	int dex_metadata_fd,
	bool use_jitzygote_image,
	const char* compilation_reason) {
	// Get the relative path to the input file.
	std::string input_basename = Basename(input_file_name);

	std::string dex2oat_Xms_arg = MapPropertyToArg("dalvik.vm.dex2oat-Xms", "-Xms%s");
	std::string dex2oat_Xmx_arg = MapPropertyToArg("dalvik.vm.dex2oat-Xmx", "-Xmx%s");

	std::string threads_format = "-j%s";
	std::string dex2oat_threads_arg = post_bootcomplete
	? (for_restore
	? MapPropertyToArgWithBackup(
	"dalvik.vm.restore-dex2oat-threads",
	"dalvik.vm.dex2oat-threads",
	threads_format)
	: MapPropertyToArg("dalvik.vm.dex2oat-threads", threads_format))
	: MapPropertyToArg("dalvik.vm.boot-dex2oat-threads", threads_format);
	std::string cpu_set_format = "--cpu-set=%s";
	std::string dex2oat_cpu_set_arg = post_bootcomplete
	? (for_restore
	? MapPropertyToArgWithBackup(
	"dalvik.vm.restore-dex2oat-cpu-set",
	"dalvik.vm.dex2oat-cpu-set",
	cpu_set_format)
	: MapPropertyToArg("dalvik.vm.dex2oat-cpu-set", cpu_set_format))
	: MapPropertyToArg("dalvik.vm.boot-dex2oat-cpu-set", cpu_set_format);

	std::string bootclasspath;
	char* dex2oat_bootclasspath = getenv("DEX2OATBOOTCLASSPATH");
	if (dex2oat_bootclasspath != nullptr) {
	bootclasspath = StringPrintf("-Xbootclasspath:%s", dex2oat_bootclasspath);
	}
	// If DEX2OATBOOTCLASSPATH is not in the environment, dex2oat is going to query
	// BOOTCLASSPATH.

	const std::string dex2oat_isa_features_key =
	StringPrintf("dalvik.vm.isa.%s.features", instruction_set);
	std::string instruction_set_features_arg =
	MapPropertyToArg(dex2oat_isa_features_key, "--instruction-set-features=%s");

	const std::string dex2oat_isa_variant_key =
	StringPrintf("dalvik.vm.isa.%s.variant", instruction_set);
	std::string instruction_set_variant_arg =
	MapPropertyToArg(dex2oat_isa_variant_key, "--instruction-set-variant=%s");

	const char* dex2oat_norelocation = "-Xnorelocate";

	const std::string dex2oat_flags = GetProperty("dalvik.vm.dex2oat-flags", "");
	std::vector<std::string> dex2oat_flags_args = SplitBySpaces(dex2oat_flags);
	ALOGV("dalvik.vm.dex2oat-flags=%s\n", dex2oat_flags.c_str());

	// If we are booting without the real /data, don't spend time compiling.
	std::string vold_decrypt = GetProperty("vold.decrypt", "");
	bool skip_compilation = vold_decrypt == "trigger_restart_min_framework" \|\|
	vold_decrypt == "1";

	std::string updatable_bcp_packages =
	MapPropertyToArg("dalvik.vm.dex2oat-updatable-bcp-packages-file",
	"--updatable-bcp-packages-file=%s");
	if (updatable_bcp_packages.empty()) {
	// Make dex2oat fail by providing non-existent file name.
	updatable_bcp_packages = "--updatable-bcp-packages-file=/nonx/updatable-bcp-packages.txt";
	}

	std::string resolve_startup_string_arg =
	MapPropertyToArg("persist.device_config.runtime.dex2oat_resolve_startup_strings",
	"--resolve-startup-const-strings=%s");
	if (resolve_startup_string_arg.empty()) {
	// If empty, fall back to system property.
	resolve_startup_string_arg =
	MapPropertyToArg("dalvik.vm.dex2oat-resolve-startup-strings",
	"--resolve-startup-const-strings=%s");
	}

	const std::string image_block_size_arg =
	MapPropertyToArg("dalvik.vm.dex2oat-max-image-block-size",
	"--max-image-block-size=%s");

	const bool generate_debug_info = GetBoolProperty("debug.generate-debug-info", false);

	std::string image_format_arg;
	if (image_fd >= 0) {
	image_format_arg = MapPropertyToArg("dalvik.vm.appimageformat", "--image-format=%s");
	}

	std::string dex2oat_large_app_threshold_arg =
	MapPropertyToArg("dalvik.vm.dex2oat-very-large", "--very-large-app-threshold=%s");

	bool generate_minidebug_info = kEnableMinidebugInfo &&
	GetBoolProperty(kMinidebugInfoSystemProperty, kMinidebugInfoSystemPropertyDefault);

	std::string boot_image;
	if (use_jitzygote_image) {
	boot_image = StringPrintf("--boot-image=%s", kJitZygoteImage);
	} else {
	boot_image = MapPropertyToArg("dalvik.vm.boot-image", "--boot-image=%s");
	}

	// clang FORTIFY doesn't let us use strlen in constant array bounds, so we
	// use arraysize instead.
	std::string zip_fd_arg = StringPrintf("--zip-fd=%d", zip_fd);
	std::string zip_location_arg = StringPrintf("--zip-location=%s", input_basename.c_str());
	std::string input_vdex_fd_arg = StringPrintf("--input-vdex-fd=%d", input_vdex_fd);
	std::string output_vdex_fd_arg = StringPrintf("--output-vdex-fd=%d", output_vdex_fd);
	std::string oat_fd_arg = StringPrintf("--oat-fd=%d", oat_fd);
	std::string oat_location_arg = StringPrintf("--oat-location=%s", output_file_name);
	std::string instruction_set_arg = StringPrintf("--instruction-set=%s", instruction_set);
	std::string dex2oat_compiler_filter_arg;
	std::string dex2oat_swap_fd;
	std::string dex2oat_image_fd;
	std::string target_sdk_version_arg;
	if (target_sdk_version != 0) {
	target_sdk_version_arg = StringPrintf("-Xtarget-sdk-version:%d", target_sdk_version);
	}
	std::string class_loader_context_arg;
	std::string class_loader_context_fds_arg;
	if (class_loader_context != nullptr) {
	class_loader_context_arg = StringPrintf("--class-loader-context=%s",
	class_loader_context);
	if (!class_loader_context_fds.empty()) {
	class_loader_context_fds_arg = StringPrintf("--class-loader-context-fds=%s",
	class_loader_context_fds.c_str());
	}
	}

	if (swap_fd >= 0) {
	dex2oat_swap_fd = StringPrintf("--swap-fd=%d", swap_fd);
	}
	if (image_fd >= 0) {
	dex2oat_image_fd = StringPrintf("--app-image-fd=%d", image_fd);
	}

	// Compute compiler filter.
	bool have_dex2oat_relocation_skip_flag = false;
	if (skip_compilation) {
	dex2oat_compiler_filter_arg = "--compiler-filter=extract";
	have_dex2oat_relocation_skip_flag = true;
	} else if (compiler_filter != nullptr) {
	dex2oat_compiler_filter_arg = StringPrintf("--compiler-filter=%s", compiler_filter);
	}

	if (dex2oat_compiler_filter_arg.empty()) {
	dex2oat_compiler_filter_arg = MapPropertyToArg("dalvik.vm.dex2oat-filter",
	"--compiler-filter=%s");
	}

	// Check whether all apps should be compiled debuggable.
	if (!debuggable) {
	debuggable = GetProperty("dalvik.vm.always_debuggable", "") == "1";
	}
	std::string profile_arg;
	if (profile_fd != -1) {
	profile_arg = StringPrintf("--profile-file-fd=%d", profile_fd);
	}

	// Get the directory of the apk to pass as a base classpath directory.
	std::string base_dir;
	std::string apk_dir(input_file_name);
	unsigned long dir_index = apk_dir.rfind('/');
	bool has_base_dir = dir_index != std::string::npos;
	if (has_base_dir) {
	apk_dir = apk_dir.substr(0, dir_index);
	base_dir = StringPrintf("--classpath-dir=%s", apk_dir.c_str());
	}

	std::string dex_metadata_fd_arg = "--dm-fd=" + std::to_string(dex_metadata_fd);

	std::string compilation_reason_arg = compilation_reason == nullptr
	? ""
	: std::string("--compilation-reason=") + compilation_reason;

	ALOGV("Running %s in=%s out=%s\n", dex2oat_bin_.c_str(), input_basename.c_str(),
	output_file_name);

	// Disable cdex if update input vdex is true since this combination of options is not
	// supported.
	const bool disable_cdex = !generate_compact_dex \|\| (input_vdex_fd == output_vdex_fd);

	AddArg(zip_fd_arg);
	AddArg(zip_location_arg);
	AddArg(input_vdex_fd_arg);
	AddArg(output_vdex_fd_arg);
	AddArg(oat_fd_arg);
	AddArg(oat_location_arg);
	AddArg(instruction_set_arg);

	AddArg(instruction_set_variant_arg);
	AddArg(instruction_set_features_arg);

	AddArg(boot_image);

	AddRuntimeArg(bootclasspath);
	AddRuntimeArg(dex2oat_Xms_arg);
	AddRuntimeArg(dex2oat_Xmx_arg);

	AddArg(updatable_bcp_packages);
	AddArg(resolve_startup_string_arg);
	AddArg(image_block_size_arg);
	AddArg(dex2oat_compiler_filter_arg);
	AddArg(dex2oat_threads_arg);
	AddArg(dex2oat_cpu_set_arg);
	AddArg(dex2oat_swap_fd);
	AddArg(dex2oat_image_fd);

	if (generate_debug_info) {
	AddArg("--generate-debug-info");
	}
	if (debuggable) {
	AddArg("--debuggable");
	}
	AddArg(image_format_arg);
	AddArg(dex2oat_large_app_threshold_arg);

	if (have_dex2oat_relocation_skip_flag) {
	AddRuntimeArg(dex2oat_norelocation);
	}
	AddArg(profile_arg);
	AddArg(base_dir);
	AddArg(class_loader_context_arg);
	AddArg(class_loader_context_fds_arg);
	if (generate_minidebug_info) {
	AddArg(kMinidebugDex2oatFlag);
	}
	if (disable_cdex) {
	AddArg(kDisableCompactDexFlag);
	}
	AddRuntimeArg(target_sdk_version_arg);
	if (enable_hidden_api_checks) {
	AddRuntimeArg("-Xhidden-api-policy:enabled");
	}

	if (dex_metadata_fd > -1) {
	AddArg(dex_metadata_fd_arg);
	}

	AddArg(compilation_reason_arg);

	// Do not add args after dex2oat_flags, they should override others for debugging.
	for (auto it = dex2oat_flags_args.begin(); it != dex2oat_flags_args.end(); ++it) {
	AddArg(*it);
	}

	execv_helper_->PrepareArgs(dex2oat_bin_);
	}

	RunDex2Oat::~RunDex2Oat() {}

	void RunDex2Oat::Exec(int exit_code) {
	LOG(ERROR) << "RunDex2Oat::Exec";
	execv_helper_->Exec(exit_code);
	}

	void RunDex2Oat::AddArg(const std::string& arg) {
	execv_helper_->AddArg(arg);
	}

	void RunDex2Oat::AddRuntimeArg(const std::string& arg) {
	execv_helper_->AddRuntimeArg(arg);
	}

	std::string RunDex2Oat::GetProperty(const std::string& key,
	const std::string& default_value) {
	return android::base::GetProperty(key, default_value);
	}

	bool RunDex2Oat::GetBoolProperty(const std::string& key, bool default_value) {
	return android::base::GetBoolProperty(key, default_value);
	}

	std::string RunDex2Oat::MapPropertyToArg(const std::string& property,
	const std::string& format,
	const std::string& default_value) {
	std::string prop = GetProperty(property, default_value);
	if (!prop.empty()) {
	return StringPrintf(format.c_str(), prop.c_str());
	}
	return "";
	}

	std::string RunDex2Oat::MapPropertyToArgWithBackup(
	const std::string& property,
	const std::string& backupProperty,
	const std::string& format,
	const std::string& default_value) {
	std::string value = GetProperty(property, default_value);
	if (!value.empty()) {
	return StringPrintf(format.c_str(), value.c_str());
	}
	return MapPropertyToArg(backupProperty, format, default_value);
	}

	} // namespace installd
	} // namespace android