runtime/dexopt_test.cc - platform/art - Git at Google


            
            /*

            
             * 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 "dexopt_test.h"


            #include <gtest/gtest.h>

            
            #include <procinfo/process_map.h>


            #include <string>

            
            #include <vector>


            #include "android-base/stringprintf.h"

            
            #include "android-base/strings.h"

            
            #include "arch/instruction_set.h"

            
            #include "base/file_utils.h"

            
            #include "base/mem_map.h"

            
            #include "common_runtime_test.h"

            
            #include "compiler_callbacks.h"

            
            #include "dex/art_dex_file_loader.h"

            
            #include "dex/dex_file_loader.h"

            
            #include "dex2oat_environment_test.h"

            
            #include "gc/space/image_space.h"

            
            #include "hidden_api.h"

            
            #include "oat/oat.h"

            
            #include "oat/oat_file_assistant.h"

            
            #include "profile/profile_compilation_info.h"


            namespace art HIDDEN {

            
            void DexoptTest::SetUp() {

            
              ReserveImageSpace();

            
              Dex2oatEnvironmentTest::SetUp();

            
            }


            void DexoptTest::PreRuntimeCreate() {

            
              std::string error_msg;

            
              UnreserveImageSpace();

            
            }


            void DexoptTest::PostRuntimeCreate() { ReserveImageSpace(); }


            bool DexoptTest::Dex2Oat(const std::vector<std::string>& args, std::string* error_msg) {

            
              std::vector<std::string> argv;

            
              if (!CommonRuntimeTest::StartDex2OatCommandLine(&argv, error_msg)) {

            
                return false;

            
              }


              Runtime* runtime = Runtime::Current();

            
              if (runtime->GetHiddenApiEnforcementPolicy() == hiddenapi::EnforcementPolicy::kEnabled) {

            
                argv.push_back("--runtime-arg");

            
                argv.push_back("-Xhidden-api-policy:enabled");

            
              }


              if (!kIsTargetBuild) {

            
                argv.push_back("--host");

            
              }


              argv.insert(argv.end(), args.begin(), args.end());


              std::string command_line(android::base::Join(argv, ' '));

            
              return Exec(argv, error_msg);

            
            }


            std::string DexoptTest::GenerateAlternateImage(const std::string& scratch_dir) {

            
              std::vector<std::string> libcore_dex_files = GetLibCoreDexFileNames();

            
              std::vector<std::string> libcore_dex_locations = GetLibCoreDexLocations();


              std::string image_dir = scratch_dir + GetInstructionSetString(kRuntimeISA);

            
              int mkdir_result = mkdir(image_dir.c_str(), 0700);

            
              CHECK_EQ(0, mkdir_result) << image_dir.c_str();


              std::vector<std::string> extra_args{

            
                  "--compiler-filter=verify",

            
                  android::base::StringPrintf("--base=0x%08x", ART_BASE_ADDRESS),

            
              };

            
              std::string filename_prefix = image_dir + "/boot-interpreter";

            
              ArrayRef<const std::string> dex_files(libcore_dex_files);

            
              ArrayRef<const std::string> dex_locations(libcore_dex_locations);

            
              std::string error_msg;

            
              bool ok = CompileBootImage(extra_args, filename_prefix, dex_files, dex_locations, &error_msg);

            
              EXPECT_TRUE(ok) << error_msg;


              return scratch_dir + "boot-interpreter.art";

            
            }


            void DexoptTest::GenerateOatForTest(const std::string& dex_location,

            
                                                const std::string& oat_location,

            
                                                CompilerFilter::Filter filter,

            
                                                bool with_alternate_image,

            
                                                const char* compilation_reason,

            
                                                const std::vector<std::string>& extra_args) {

            
              std::vector<std::string> args;

            
              args.push_back("--dex-file=" + dex_location);

            
              args.push_back("--oat-file=" + oat_location);

            
              args.push_back("--compiler-filter=" + CompilerFilter::NameOfFilter(filter));

            
              args.push_back("--runtime-arg");


              // Use -Xnorelocate regardless of the relocate argument.

            
              // We control relocation by redirecting the dalvik cache when needed

            
              // rather than use this flag.

            
              args.push_back("-Xnorelocate");


              ScratchFile profile_file;

            
              if (CompilerFilter::DependsOnProfile(filter)) {

            
                // Create a profile with some basic content so that dex2oat

            
                // doesn't get an empty profile and changes the filter to verify.

            
                std::string error_msg;

            
                std::vector<std::unique_ptr<const DexFile>> dex_files;

            
                ArtDexFileLoader dex_file_loader(dex_location);

            
                ASSERT_TRUE(dex_file_loader.Open(

            
                    /*verify=*/false, /*verify_checksum=*/false, &error_msg, &dex_files));

            
                EXPECT_GE(dex_files.size(), 1U);

            
                std::unique_ptr<const DexFile>& dex_file = dex_files[0];

            
                ProfileCompilationInfo info;


                info.AddClass(*dex_file, dex::TypeIndex(0));


                ASSERT_TRUE(info.Save(profile_file.GetFd()));

            
                ASSERT_EQ(0, profile_file.GetFile()->Flush());


                // Set the argument

            
                args.push_back("--profile-file=" + profile_file.GetFilename());

            
              }


              std::string image_location = GetImageLocation();

            
              std::optional<ScratchDir> scratch;

            
              if (with_alternate_image) {

            
                scratch.emplace();  // Create the scratch directory for the generated boot image.

            
                std::string alternate_image_location = GenerateAlternateImage(scratch->GetPath());

            
                args.push_back("--boot-image=" + alternate_image_location);

            
              }


              if (compilation_reason != nullptr) {

            
                args.push_back("--compilation-reason=" + std::string(compilation_reason));

            
              }


              args.insert(args.end(), extra_args.begin(), extra_args.end());


              std::string error_msg;

            
              ASSERT_TRUE(Dex2Oat(args, &error_msg)) << error_msg;


              // Verify the odex file was generated as expected.

            
              std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/-1,

            
                                                               oat_location,

            
                                                               oat_location,

            
                                                               /*executable=*/false,

            
                                                               /*low_4gb=*/false,

            
                                                               dex_location,

            
                                                               &error_msg));

            
              ASSERT_TRUE(odex_file.get() != nullptr) << error_msg;

            
              EXPECT_EQ(filter, odex_file->GetCompilerFilter());


              if (CompilerFilter::DependsOnImageChecksum(filter)) {

            
                std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create(/*spec=*/"");

            
                OatFileAssistant oat_file_assistant(dex_location.c_str(),

            
                                                    kRuntimeISA,

            
                                                    context.get(),

            
                                                    /*load_executable=*/false);


                bool match = oat_file_assistant.ValidateBootClassPathChecksums(*odex_file, &error_msg);

            
                ASSERT_EQ(!with_alternate_image, match) << error_msg;

            
              }

            
            }


            void DexoptTest::GenerateOdexForTest(const std::string& dex_location,

            
                                                 const std::string& odex_location,

            
                                                 CompilerFilter::Filter filter,

            
                                                 const char* compilation_reason,

            
                                                 const std::vector<std::string>& extra_args) {

            
              GenerateOatForTest(dex_location,

            
                                 odex_location,

            
                                 filter,

            
                                 /*with_alternate_image=*/false,

            
                                 compilation_reason,

            
                                 extra_args);

            
            }


            void DexoptTest::GenerateOatForTest(const char* dex_location,

            
                                                CompilerFilter::Filter filter,

            
                                                bool with_alternate_image) {

            
              std::string oat_location;

            
              std::string error_msg;

            
              ASSERT_TRUE(OatFileAssistant::DexLocationToOatFilename(

            
                  dex_location, kRuntimeISA, &oat_location, &error_msg))

            
                  << error_msg;

            
              GenerateOatForTest(dex_location, oat_location, filter, with_alternate_image);

            
            }


            void DexoptTest::GenerateOatForTest(const char* dex_location, CompilerFilter::Filter filter) {

            
              GenerateOatForTest(dex_location, filter, /*with_alternate_image=*/false);

            
            }


            void DexoptTest::GenerateSdmDmForTest(const std::string& dex_location,

            
                                                  const std::string& sdm_location,

            
                                                  const std::string& dm_location,

            
                                                  CompilerFilter::Filter filter,

            
                                                  bool include_app_image,

            
                                                  const char* compilation_reason,

            
                                                  const std::vector<std::string>& extra_args) {

            
              std::string tmp_dir = GetScratchDir() + "/sdm_tmp";

            
              ASSERT_EQ(0, mkdir(tmp_dir.c_str(), 0700));


              std::string odex_location = tmp_dir + "/TestDex.odex";

            
              std::string vdex_location = tmp_dir + "/TestDex.vdex";

            
              std::string art_location;


              std::vector<std::string> extra_args_with_app_image = extra_args;

            
              if (include_app_image) {

            
                art_location = tmp_dir + "/TestDex.art";

            
                extra_args_with_app_image.push_back("--app-image-file=" + art_location);

            
              }


              // Generate temporary ODEX, VDEX, and ART files in order to create the SDM and DM files from.

            
              ASSERT_NO_FATAL_FAILURE(GenerateOdexForTest(

            
                  dex_location, odex_location, filter, compilation_reason, extra_args_with_app_image));


              // Create the SDM and DM files.

            
              ASSERT_NO_FATAL_FAILURE(CreateSecureDexMetadata(odex_location, art_location, sdm_location));

            
              ASSERT_NO_FATAL_FAILURE(CreateDexMetadata(vdex_location, dm_location, /*page_aligned=*/true));


              // Cleanup the temporary files.

            
              ASSERT_NO_FATAL_FAILURE(ClearDirectory(tmp_dir.c_str()));

            
            }


            void DexoptTest::ReserveImageSpace() {

            
              MemMap::Init();


              // Ensure a chunk of memory is reserved for the image space.

            
              uint64_t reservation_start = ART_BASE_ADDRESS;

            
              uint64_t reservation_end = ART_BASE_ADDRESS + 384 * MB;


              std::vector<android::procinfo::MapInfo> maps;

            
              ASSERT_TRUE(android::procinfo::ReadProcessMaps(getpid(), &maps));

            
              for (const android::procinfo::MapInfo& map_info : maps) {

            
                ReserveImageSpaceChunk(reservation_start, std::min(map_info.start, reservation_end));

            
                reservation_start = std::max(reservation_start, map_info.end);

            
                if (reservation_start >= reservation_end) {

            
                  break;

            
                }

            
              }

            
              ReserveImageSpaceChunk(reservation_start, reservation_end);

            
            }


            void DexoptTest::ReserveImageSpaceChunk(uintptr_t start, uintptr_t end) {

            
              if (start < end) {

            
                std::string error_msg;

            
                image_reservation_.push_back(MemMap::MapAnonymous("image reservation",

            
                                                                  reinterpret_cast<uint8_t*>(start),

            
                                                                  end - start,

            
                                                                  PROT_NONE,

            
                                                                  /*low_4gb=*/false,

            
                                                                  /*reuse=*/false,

            
                                                                  /*reservation=*/nullptr,

            
                                                                  &error_msg));

            
                ASSERT_TRUE(image_reservation_.back().IsValid()) << error_msg;

            
                LOG(INFO) << "Reserved space for image "

            
                          << reinterpret_cast<void*>(image_reservation_.back().Begin()) << "-"

            
                          << reinterpret_cast<void*>(image_reservation_.back().End());

            
              }

            
            }


            void DexoptTest::UnreserveImageSpace() { image_reservation_.clear(); }


            }  // namespace art
	/*
	* 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 "dexopt_test.h"

	#include <gtest/gtest.h>
	#include <procinfo/process_map.h>

	#include <string>
	#include <vector>

	#include "android-base/stringprintf.h"
	#include "android-base/strings.h"
	#include "arch/instruction_set.h"
	#include "base/file_utils.h"
	#include "base/mem_map.h"
	#include "common_runtime_test.h"
	#include "compiler_callbacks.h"
	#include "dex/art_dex_file_loader.h"
	#include "dex/dex_file_loader.h"
	#include "dex2oat_environment_test.h"
	#include "gc/space/image_space.h"
	#include "hidden_api.h"
	#include "oat/oat.h"
	#include "oat/oat_file_assistant.h"
	#include "profile/profile_compilation_info.h"

	namespace art HIDDEN {
	void DexoptTest::SetUp() {
	ReserveImageSpace();
	Dex2oatEnvironmentTest::SetUp();
	}

	void DexoptTest::PreRuntimeCreate() {
	std::string error_msg;
	UnreserveImageSpace();
	}

	void DexoptTest::PostRuntimeCreate() { ReserveImageSpace(); }

	bool DexoptTest::Dex2Oat(const std::vector<std::string>& args, std::string* error_msg) {
	std::vector<std::string> argv;
	if (!CommonRuntimeTest::StartDex2OatCommandLine(&argv, error_msg)) {
	return false;
	}

	Runtime* runtime = Runtime::Current();
	if (runtime->GetHiddenApiEnforcementPolicy() == hiddenapi::EnforcementPolicy::kEnabled) {
	argv.push_back("--runtime-arg");
	argv.push_back("-Xhidden-api-policy:enabled");
	}

	if (!kIsTargetBuild) {
	argv.push_back("--host");
	}

	argv.insert(argv.end(), args.begin(), args.end());

	std::string command_line(android::base::Join(argv, ' '));
	return Exec(argv, error_msg);
	}

	std::string DexoptTest::GenerateAlternateImage(const std::string& scratch_dir) {
	std::vector<std::string> libcore_dex_files = GetLibCoreDexFileNames();
	std::vector<std::string> libcore_dex_locations = GetLibCoreDexLocations();

	std::string image_dir = scratch_dir + GetInstructionSetString(kRuntimeISA);
	int mkdir_result = mkdir(image_dir.c_str(), 0700);
	CHECK_EQ(0, mkdir_result) << image_dir.c_str();

	std::vector<std::string> extra_args{
	"--compiler-filter=verify",
	android::base::StringPrintf("--base=0x%08x", ART_BASE_ADDRESS),
	};
	std::string filename_prefix = image_dir + "/boot-interpreter";
	ArrayRef<const std::string> dex_files(libcore_dex_files);
	ArrayRef<const std::string> dex_locations(libcore_dex_locations);
	std::string error_msg;
	bool ok = CompileBootImage(extra_args, filename_prefix, dex_files, dex_locations, &error_msg);
	EXPECT_TRUE(ok) << error_msg;

	return scratch_dir + "boot-interpreter.art";
	}

	void DexoptTest::GenerateOatForTest(const std::string& dex_location,
	const std::string& oat_location,
	CompilerFilter::Filter filter,
	bool with_alternate_image,
	const char* compilation_reason,
	const std::vector<std::string>& extra_args) {
	std::vector<std::string> args;
	args.push_back("--dex-file=" + dex_location);
	args.push_back("--oat-file=" + oat_location);
	args.push_back("--compiler-filter=" + CompilerFilter::NameOfFilter(filter));
	args.push_back("--runtime-arg");

	// Use -Xnorelocate regardless of the relocate argument.
	// We control relocation by redirecting the dalvik cache when needed
	// rather than use this flag.
	args.push_back("-Xnorelocate");

	ScratchFile profile_file;
	if (CompilerFilter::DependsOnProfile(filter)) {
	// Create a profile with some basic content so that dex2oat
	// doesn't get an empty profile and changes the filter to verify.
	std::string error_msg;
	std::vector<std::unique_ptr<const DexFile>> dex_files;
	ArtDexFileLoader dex_file_loader(dex_location);
	ASSERT_TRUE(dex_file_loader.Open(
	/verify=/false, /verify_checksum=/false, &error_msg, &dex_files));
	EXPECT_GE(dex_files.size(), 1U);
	std::unique_ptr<const DexFile>& dex_file = dex_files[0];
	ProfileCompilationInfo info;

	info.AddClass(*dex_file, dex::TypeIndex(0));

	ASSERT_TRUE(info.Save(profile_file.GetFd()));
	ASSERT_EQ(0, profile_file.GetFile()->Flush());

	// Set the argument
	args.push_back("--profile-file=" + profile_file.GetFilename());
	}

	std::string image_location = GetImageLocation();
	std::optional<ScratchDir> scratch;
	if (with_alternate_image) {
	scratch.emplace(); // Create the scratch directory for the generated boot image.
	std::string alternate_image_location = GenerateAlternateImage(scratch->GetPath());
	args.push_back("--boot-image=" + alternate_image_location);
	}

	if (compilation_reason != nullptr) {
	args.push_back("--compilation-reason=" + std::string(compilation_reason));
	}

	args.insert(args.end(), extra_args.begin(), extra_args.end());

	std::string error_msg;
	ASSERT_TRUE(Dex2Oat(args, &error_msg)) << error_msg;

	// Verify the odex file was generated as expected.
	std::unique_ptr<OatFile> odex_file(OatFile::Open(/zip_fd=/-1,
	oat_location,
	oat_location,
	/executable=/false,
	/low_4gb=/false,
	dex_location,
	&error_msg));
	ASSERT_TRUE(odex_file.get() != nullptr) << error_msg;
	EXPECT_EQ(filter, odex_file->GetCompilerFilter());

	if (CompilerFilter::DependsOnImageChecksum(filter)) {
	std::unique_ptr<ClassLoaderContext> context = ClassLoaderContext::Create(/spec=/"");
	OatFileAssistant oat_file_assistant(dex_location.c_str(),
	kRuntimeISA,
	context.get(),
	/load_executable=/false);

	bool match = oat_file_assistant.ValidateBootClassPathChecksums(*odex_file, &error_msg);
	ASSERT_EQ(!with_alternate_image, match) << error_msg;
	}
	}

	void DexoptTest::GenerateOdexForTest(const std::string& dex_location,
	const std::string& odex_location,
	CompilerFilter::Filter filter,
	const char* compilation_reason,
	const std::vector<std::string>& extra_args) {
	GenerateOatForTest(dex_location,
	odex_location,
	filter,
	/with_alternate_image=/false,
	compilation_reason,
	extra_args);
	}

	void DexoptTest::GenerateOatForTest(const char* dex_location,
	CompilerFilter::Filter filter,
	bool with_alternate_image) {
	std::string oat_location;
	std::string error_msg;
	ASSERT_TRUE(OatFileAssistant::DexLocationToOatFilename(
	dex_location, kRuntimeISA, &oat_location, &error_msg))
	<< error_msg;
	GenerateOatForTest(dex_location, oat_location, filter, with_alternate_image);
	}

	void DexoptTest::GenerateOatForTest(const char* dex_location, CompilerFilter::Filter filter) {
	GenerateOatForTest(dex_location, filter, /with_alternate_image=/false);
	}

	void DexoptTest::GenerateSdmDmForTest(const std::string& dex_location,
	const std::string& sdm_location,
	const std::string& dm_location,
	CompilerFilter::Filter filter,
	bool include_app_image,
	const char* compilation_reason,
	const std::vector<std::string>& extra_args) {
	std::string tmp_dir = GetScratchDir() + "/sdm_tmp";
	ASSERT_EQ(0, mkdir(tmp_dir.c_str(), 0700));

	std::string odex_location = tmp_dir + "/TestDex.odex";
	std::string vdex_location = tmp_dir + "/TestDex.vdex";
	std::string art_location;

	std::vector<std::string> extra_args_with_app_image = extra_args;
	if (include_app_image) {
	art_location = tmp_dir + "/TestDex.art";
	extra_args_with_app_image.push_back("--app-image-file=" + art_location);
	}

	// Generate temporary ODEX, VDEX, and ART files in order to create the SDM and DM files from.
	ASSERT_NO_FATAL_FAILURE(GenerateOdexForTest(
	dex_location, odex_location, filter, compilation_reason, extra_args_with_app_image));

	// Create the SDM and DM files.
	ASSERT_NO_FATAL_FAILURE(CreateSecureDexMetadata(odex_location, art_location, sdm_location));
	ASSERT_NO_FATAL_FAILURE(CreateDexMetadata(vdex_location, dm_location, /page_aligned=/true));

	// Cleanup the temporary files.
	ASSERT_NO_FATAL_FAILURE(ClearDirectory(tmp_dir.c_str()));
	}

	void DexoptTest::ReserveImageSpace() {
	MemMap::Init();

	// Ensure a chunk of memory is reserved for the image space.
	uint64_t reservation_start = ART_BASE_ADDRESS;
	uint64_t reservation_end = ART_BASE_ADDRESS + 384 * MB;

	std::vector<android::procinfo::MapInfo> maps;
	ASSERT_TRUE(android::procinfo::ReadProcessMaps(getpid(), &maps));
	for (const android::procinfo::MapInfo& map_info : maps) {
	ReserveImageSpaceChunk(reservation_start, std::min(map_info.start, reservation_end));
	reservation_start = std::max(reservation_start, map_info.end);
	if (reservation_start >= reservation_end) {
	break;
	}
	}
	ReserveImageSpaceChunk(reservation_start, reservation_end);
	}

	void DexoptTest::ReserveImageSpaceChunk(uintptr_t start, uintptr_t end) {
	if (start < end) {
	std::string error_msg;
	image_reservation_.push_back(MemMap::MapAnonymous("image reservation",
	reinterpret_cast<uint8_t*>(start),
	end - start,
	PROT_NONE,
	/low_4gb=/false,
	/reuse=/false,
	/reservation=/nullptr,
	&error_msg));
	ASSERT_TRUE(image_reservation_.back().IsValid()) << error_msg;
	LOG(INFO) << "Reserved space for image "
	<< reinterpret_cast<void*>(image_reservation_.back().Begin()) << "-"
	<< reinterpret_cast<void*>(image_reservation_.back().End());
	}
	}

	void DexoptTest::UnreserveImageSpace() { image_reservation_.clear(); }

	} // namespace art