diff options
31 files changed, 973 insertions, 1142 deletions
diff --git a/CPPLINT.cfg b/CPPLINT.cfg index 83288421e2..71a5a26b0e 100644 --- a/CPPLINT.cfg +++ b/CPPLINT.cfg @@ -31,3 +31,4 @@ filter=-readability/function,-readability/streams,-readability/todo filter=-runtime/printf,-runtime/references,-runtime/sizeof,-runtime/threadsafe_fn # TODO: this should be re-enabled. filter=-whitespace/line_length +filter=-whitespace/braces diff --git a/build/Android.bp b/build/Android.bp index a6f8661740..dd9be5c559 100644 --- a/build/Android.bp +++ b/build/Android.bp @@ -48,6 +48,7 @@ art_clang_tidy_errors = [ "performance-noexcept-move-constructor", "performance-unnecessary-copy-initialization", "performance-unnecessary-value-param", + "readability-redundant-string-cstr", ] art_clang_tidy_disabled = [ diff --git a/compiler/utils/assembler_test_base.h b/compiler/utils/assembler_test_base.h index 8c18e07033..73f3657413 100644 --- a/compiler/utils/assembler_test_base.h +++ b/compiler/utils/assembler_test_base.h @@ -85,7 +85,7 @@ class AssemblerTestBase : public testing::Test { // Assemble reference object file. std::string ref_obj_file = test_path(".ref.o"); - ASSERT_TRUE(Assemble(ref_asm_file.c_str(), ref_obj_file.c_str())); + ASSERT_TRUE(Assemble(ref_asm_file, ref_obj_file)); // Read the code produced by assembler from the ELF file. std::vector<uint8_t> ref_code; diff --git a/dex2oat/dex2oat.cc b/dex2oat/dex2oat.cc index a0b860f465..6c713721d8 100644 --- a/dex2oat/dex2oat.cc +++ b/dex2oat/dex2oat.cc @@ -1906,7 +1906,7 @@ class Dex2Oat final { } } - if (android::base::StartsWith(dex_location, filter.c_str())) { + if (android::base::StartsWith(dex_location, filter)) { VLOG(compiler) << "Disabling inlining from " << dex_file->GetLocation(); no_inline_from_dex_files.push_back(dex_file); break; diff --git a/dex2oat/dex2oat_test.cc b/dex2oat/dex2oat_test.cc index e444071e9c..ca76254fc1 100644 --- a/dex2oat/dex2oat_test.cc +++ b/dex2oat/dex2oat_test.cc @@ -104,14 +104,13 @@ class Dex2oatTest : public Dex2oatEnvironmentTest { return status; } - ::testing::AssertionResult GenerateOdexForTest( - const std::string& dex_location, - const std::string& odex_location, - CompilerFilter::Filter filter, - const std::vector<std::string>& extra_args = {}, - bool expect_success = true, - bool use_fd = false, - bool use_zip_fd = false) WARN_UNUSED { + ::testing::AssertionResult GenerateOdexForTest(const std::string& dex_location, + const std::string& odex_location, + CompilerFilter::Filter filter, + const std::vector<std::string>& extra_args = {}, + bool expect_success = true, + bool use_fd = false, + bool use_zip_fd = false) WARN_UNUSED { return GenerateOdexForTest(dex_location, odex_location, filter, @@ -125,47 +124,42 @@ class Dex2oatTest : public Dex2oatEnvironmentTest { bool test_accepts_odex_file_on_failure = false; template <typename T> - ::testing::AssertionResult GenerateOdexForTest( - const std::string& dex_location, - const std::string& odex_location, - CompilerFilter::Filter filter, - const std::vector<std::string>& extra_args, - bool expect_success, - bool use_fd, - bool use_zip_fd, - T check_oat) WARN_UNUSED { + ::testing::AssertionResult GenerateOdexForTest(const std::string& dex_location, + const std::string& odex_location, + CompilerFilter::Filter filter, + const std::vector<std::string>& extra_args, + bool expect_success, + bool use_fd, + bool use_zip_fd, + T check_oat) WARN_UNUSED { std::vector<std::string> dex_locations; if (use_zip_fd) { std::string loc_arg = "--zip-location=" + dex_location; - CHECK(std::any_of(extra_args.begin(), - extra_args.end(), - [&](const std::string& s) { return s == loc_arg; })); - CHECK(std::any_of(extra_args.begin(), - extra_args.end(), - [](const std::string& s) { return StartsWith(s, "--zip-fd="); })); + CHECK(std::any_of(extra_args.begin(), extra_args.end(), [&](const std::string& s) { + return s == loc_arg; + })); + CHECK(std::any_of(extra_args.begin(), extra_args.end(), [](const std::string& s) { + return StartsWith(s, "--zip-fd="); + })); } else { dex_locations.push_back(dex_location); } std::string error_msg; - int status = GenerateOdexForTestWithStatus(dex_locations, - odex_location, - filter, - &error_msg, - extra_args, - use_fd); + int status = GenerateOdexForTestWithStatus( + dex_locations, odex_location, filter, &error_msg, extra_args, use_fd); bool success = (WIFEXITED(status) && WEXITSTATUS(status) == 0); if (expect_success) { if (!success) { - return ::testing::AssertionFailure() - << "Failed to compile odex: " << error_msg << std::endl << output_; + return ::testing::AssertionFailure() << "Failed to compile odex: " << error_msg << std::endl + << output_; } // Verify the odex file was generated as expected. - std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/ -1, - odex_location.c_str(), - odex_location.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/-1, + odex_location, + odex_location, + /*executable=*/false, + /*low_4gb=*/false, dex_location, &error_msg)); if (odex_file == nullptr) { @@ -183,11 +177,11 @@ class Dex2oatTest : public Dex2oatEnvironmentTest { if (!test_accepts_odex_file_on_failure) { // Verify there's no loadable odex file. - std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/ -1, - odex_location.c_str(), - odex_location.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/-1, + odex_location, + odex_location, + /*executable=*/false, + /*low_4gb=*/false, dex_location, &error_msg)); if (odex_file != nullptr) { @@ -213,9 +207,8 @@ class Dex2oatTest : public Dex2oatEnvironmentTest { // to what's already huge test methods). class Dex2oatWithExpectedFilterTest : public Dex2oatTest { protected: - void CheckFilter( - CompilerFilter::Filter expected ATTRIBUTE_UNUSED, - CompilerFilter::Filter actual) override { + void CheckFilter(CompilerFilter::Filter expected ATTRIBUTE_UNUSED, + CompilerFilter::Filter actual) override { EXPECT_EQ(expected_filter_, actual); } @@ -298,27 +291,27 @@ class Dex2oatSwapTest : public Dex2oatTest { }; TEST_F(Dex2oatSwapTest, DoNotUseSwapDefaultSingleSmall) { - RunTest(/*use_fd=*/ false, /*expect_use=*/ false); - RunTest(/*use_fd=*/ true, /*expect_use=*/ false); + RunTest(/*use_fd=*/false, /*expect_use=*/false); + RunTest(/*use_fd=*/true, /*expect_use=*/false); } TEST_F(Dex2oatSwapTest, DoNotUseSwapSingle) { - RunTest(/*use_fd=*/ false, /*expect_use=*/ false, { "--swap-dex-size-threshold=0" }); - RunTest(/*use_fd=*/ true, /*expect_use=*/ false, { "--swap-dex-size-threshold=0" }); + RunTest(/*use_fd=*/false, /*expect_use=*/false, {"--swap-dex-size-threshold=0"}); + RunTest(/*use_fd=*/true, /*expect_use=*/false, {"--swap-dex-size-threshold=0"}); } TEST_F(Dex2oatSwapTest, DoNotUseSwapSmall) { - RunTest(/*use_fd=*/ false, /*expect_use=*/ false, { "--swap-dex-count-threshold=0" }); - RunTest(/*use_fd=*/ true, /*expect_use=*/ false, { "--swap-dex-count-threshold=0" }); + RunTest(/*use_fd=*/false, /*expect_use=*/false, {"--swap-dex-count-threshold=0"}); + RunTest(/*use_fd=*/true, /*expect_use=*/false, {"--swap-dex-count-threshold=0"}); } TEST_F(Dex2oatSwapTest, DoUseSwapSingleSmall) { - RunTest(/*use_fd=*/ false, - /*expect_use=*/ true, - { "--swap-dex-size-threshold=0", "--swap-dex-count-threshold=0" }); - RunTest(/*use_fd=*/ true, - /*expect_use=*/ true, - { "--swap-dex-size-threshold=0", "--swap-dex-count-threshold=0" }); + RunTest(/*use_fd=*/false, + /*expect_use=*/true, + {"--swap-dex-size-threshold=0", "--swap-dex-count-threshold=0"}); + RunTest(/*use_fd=*/true, + /*expect_use=*/true, + {"--swap-dex-size-threshold=0", "--swap-dex-count-threshold=0"}); } class Dex2oatSwapUseTest : public Dex2oatSwapTest { @@ -343,7 +336,7 @@ class Dex2oatSwapUseTest : public Dex2oatSwapTest { void GrabResult1() { if (!kIsTargetBuild) { native_alloc_1_ = ParseNativeAlloc(); - swap_1_ = ParseSwap(/*expected=*/ false); + swap_1_ = ParseSwap(/*expected=*/false); } else { native_alloc_1_ = std::numeric_limits<size_t>::max(); swap_1_ = 0; @@ -353,7 +346,7 @@ class Dex2oatSwapUseTest : public Dex2oatSwapTest { void GrabResult2() { if (!kIsTargetBuild) { native_alloc_2_ = ParseNativeAlloc(); - swap_2_ = ParseSwap(/*expected=*/ true); + swap_2_ = ParseSwap(/*expected=*/true); } else { native_alloc_2_ = 0; swap_2_ = std::numeric_limits<size_t>::max(); @@ -424,16 +417,16 @@ TEST_F(Dex2oatSwapUseTest, CheckSwapUsage) { TEST_DISABLED_FOR_X86(); TEST_DISABLED_FOR_X86_64(); - RunTest(/*use_fd=*/ false, - /*expect_use=*/ false); + RunTest(/*use_fd=*/false, + /*expect_use=*/false); GrabResult1(); std::string output_1 = output_; output_ = ""; - RunTest(/*use_fd=*/ false, - /*expect_use=*/ true, - { "--swap-dex-size-threshold=0", "--swap-dex-count-threshold=0" }); + RunTest(/*use_fd=*/false, + /*expect_use=*/true, + {"--swap-dex-size-threshold=0", "--swap-dex-count-threshold=0"}); GrabResult2(); std::string output_2 = output_; @@ -495,11 +488,11 @@ class Dex2oatVeryLargeTest : public Dex2oatTest { } // Host/target independent checks. std::string error_msg; - std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/ -1, - odex_location.c_str(), - odex_location.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/-1, + odex_location, + odex_location, + /*executable=*/false, + /*low_4gb=*/false, dex_location, &error_msg)); ASSERT_TRUE(odex_file.get() != nullptr) << error_msg; @@ -581,13 +574,13 @@ TEST_F(Dex2oatVeryLargeTest, DontUseVeryLarge) { RunTest(CompilerFilter::kAssumeVerified, false, false); RunTest(CompilerFilter::kSpeed, false, false); - RunTest(CompilerFilter::kAssumeVerified, false, false, { "--very-large-app-threshold=10000000" }); - RunTest(CompilerFilter::kSpeed, false, false, { "--very-large-app-threshold=10000000" }); + RunTest(CompilerFilter::kAssumeVerified, false, false, {"--very-large-app-threshold=10000000"}); + RunTest(CompilerFilter::kSpeed, false, false, {"--very-large-app-threshold=10000000"}); } TEST_F(Dex2oatVeryLargeTest, UseVeryLarge) { - RunTest(CompilerFilter::kAssumeVerified, true, false, { "--very-large-app-threshold=100" }); - RunTest(CompilerFilter::kSpeed, true, true, { "--very-large-app-threshold=100" }); + RunTest(CompilerFilter::kAssumeVerified, true, false, {"--very-large-app-threshold=100"}); + RunTest(CompilerFilter::kSpeed, true, true, {"--very-large-app-threshold=100"}); } // Regressin test for b/35665292. @@ -618,13 +611,12 @@ class Dex2oatLayoutTest : public Dex2oatTest { EXPECT_EQ(dex_files.size(), 1U); std::unique_ptr<const DexFile>& dex_file = dex_files[0]; - int profile_test_fd = open(test_profile.c_str(), - O_CREAT | O_TRUNC | O_WRONLY | O_CLOEXEC, - 0644); + int profile_test_fd = + open(test_profile.c_str(), O_CREAT | O_TRUNC | O_WRONLY | O_CLOEXEC, 0644); CHECK_GE(profile_test_fd, 0); ProfileCompilationInfo info; - std::vector<dex::TypeIndex> classes;; + std::vector<dex::TypeIndex> classes; for (size_t i = 0; i < num_classes; ++i) { classes.push_back(dex::TypeIndex(class_offset + 1 + i)); } @@ -655,12 +647,8 @@ class Dex2oatLayoutTest : public Dex2oatTest { copy.push_back("--app-image-file=" + app_image_file_name); } } - ASSERT_TRUE(GenerateOdexForTest(dex_location, - odex_location, - CompilerFilter::kSpeedProfile, - copy, - expect_success, - use_fd)); + ASSERT_TRUE(GenerateOdexForTest( + dex_location, odex_location, CompilerFilter::kSpeedProfile, copy, expect_success, use_fd)); if (app_image_file != nullptr) { ASSERT_EQ(app_image_file->FlushCloseOrErase(), 0) << "Could not flush and close art file"; } @@ -701,7 +689,7 @@ class Dex2oatLayoutTest : public Dex2oatTest { void RunTest(bool app_image) { std::string dex_location = GetScratchDir() + "/DexNoOat.jar"; std::string odex_location = GetOdexDir() + "/DexOdexNoOat.odex"; - std::string app_image_file = app_image ? (GetOdexDir() + "/DexOdexNoOat.art"): ""; + std::string app_image_file = app_image ? (GetOdexDir() + "/DexOdexNoOat.art") : ""; Copy(GetDexSrc2(), dex_location); uint32_t image_file_empty_profile = 0; @@ -709,8 +697,8 @@ class Dex2oatLayoutTest : public Dex2oatTest { CompileProfileOdex(dex_location, odex_location, app_image_file, - /*use_fd=*/ false, - /*num_profile_classes=*/ 0); + /*use_fd=*/false, + /*num_profile_classes=*/0); CheckValidity(); // Don't check the result since CheckResult relies on the class being in the profile. image_file_empty_profile = GetImageObjectSectionSize(app_image_file); @@ -722,8 +710,8 @@ class Dex2oatLayoutTest : public Dex2oatTest { CompileProfileOdex(dex_location, odex_location, app_image_file, - /*use_fd=*/ false, - /*num_profile_classes=*/ 1); + /*use_fd=*/false, + /*num_profile_classes=*/1); CheckValidity(); CheckResult(dex_location, odex_location, app_image_file); CheckCompilerFilter(dex_location, odex_location, CompilerFilter::Filter::kSpeedProfile); @@ -735,16 +723,15 @@ class Dex2oatLayoutTest : public Dex2oatTest { } } - void CheckCompilerFilter( - const std::string& dex_location, - const std::string& odex_location, - CompilerFilter::Filter expected_filter) { + void CheckCompilerFilter(const std::string& dex_location, + const std::string& odex_location, + CompilerFilter::Filter expected_filter) { std::string error_msg; - std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/ -1, - odex_location.c_str(), - odex_location.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/-1, + odex_location, + odex_location, + /*executable=*/false, + /*low_4gb=*/false, dex_location, &error_msg)); EXPECT_EQ(odex_file->GetCompilerFilter(), expected_filter); @@ -766,9 +753,9 @@ class Dex2oatLayoutTest : public Dex2oatTest { CompileProfileOdex(dex_location, odex_location, app_image_file_name, - /*use_fd=*/ true, - /*num_profile_classes=*/ 1, - { input_vdex, output_vdex }); + /*use_fd=*/true, + /*num_profile_classes=*/1, + {input_vdex, output_vdex}); EXPECT_GT(vdex_file1->GetLength(), 0u); } { @@ -778,10 +765,10 @@ class Dex2oatLayoutTest : public Dex2oatTest { CompileProfileOdex(dex_location, odex_location, app_image_file_name, - /*use_fd=*/ true, - /*num_profile_classes=*/ 1, - { input_vdex, output_vdex }, - /*expect_success=*/ true); + /*use_fd=*/true, + /*num_profile_classes=*/1, + {input_vdex, output_vdex}, + /*expect_success=*/true); EXPECT_GT(vdex_file2.GetFile()->GetLength(), 0u); } ASSERT_EQ(vdex_file1->FlushCloseOrErase(), 0) << "Could not flush and close vdex file"; @@ -793,11 +780,11 @@ class Dex2oatLayoutTest : public Dex2oatTest { const std::string& app_image_file_name) { // Host/target independent checks. std::string error_msg; - std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/ -1, - odex_location.c_str(), - odex_location.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/-1, + odex_location, + odex_location, + /*executable=*/false, + /*low_4gb=*/false, dex_location, &error_msg)); ASSERT_TRUE(odex_file.get() != nullptr) << error_msg; @@ -858,13 +845,9 @@ class Dex2oatLayoutTest : public Dex2oatTest { } }; -TEST_F(Dex2oatLayoutTest, TestLayout) { - RunTest(/*app_image=*/ false); -} +TEST_F(Dex2oatLayoutTest, TestLayout) { RunTest(/*app_image=*/false); } -TEST_F(Dex2oatLayoutTest, TestLayoutAppImage) { - RunTest(/*app_image=*/ true); -} +TEST_F(Dex2oatLayoutTest, TestLayoutAppImage) { RunTest(/*app_image=*/true); } TEST_F(Dex2oatLayoutTest, TestLayoutAppImageMissingBootImage) { std::string dex_location = GetScratchDir() + "/DexNoOat.jar"; @@ -875,18 +858,18 @@ TEST_F(Dex2oatLayoutTest, TestLayoutAppImageMissingBootImage) { CompileProfileOdex(dex_location, odex_location, app_image_file, - /*use_fd=*/ false, - /*num_profile_classes=*/ 1, - /*extra_args=*/ {"--boot-image=/nonx/boot.art"}, - /*expect_success=*/ true); + /*use_fd=*/false, + /*num_profile_classes=*/1, + /*extra_args=*/{"--boot-image=/nonx/boot.art"}, + /*expect_success=*/true); // Verify the odex file does not require an image. std::string error_msg; - std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/ -1, - odex_location.c_str(), - odex_location.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/-1, + odex_location, + odex_location, + /*executable=*/false, + /*low_4gb=*/false, dex_location, &error_msg)); ASSERT_TRUE(odex_file != nullptr) << "Could not open odex file: " << error_msg; @@ -984,9 +967,7 @@ TEST_F(Dex2oatLayoutTest, TestLayoutMultipleProfilesChecksumMismatch) { EXPECT_EQ(image_size_wrong_checksum, image_size_empty); } -TEST_F(Dex2oatLayoutTest, TestVdexLayout) { - RunTestVDex(); -} +TEST_F(Dex2oatLayoutTest, TestVdexLayout) { RunTestVDex(); } class Dex2oatWatchdogTest : public Dex2oatTest { protected: @@ -1001,16 +982,11 @@ class Dex2oatWatchdogTest : public Dex2oatTest { std::string swap_location = GetOdexDir() + "/Dex2OatSwapTest.odex.swap"; copy.push_back("--swap-file=" + swap_location); copy.push_back("-j512"); // Excessive idle threads just slow down dex2oat. - ASSERT_TRUE(GenerateOdexForTest(dex_location, - odex_location, - CompilerFilter::kSpeed, - copy, - expect_success)); + ASSERT_TRUE(GenerateOdexForTest( + dex_location, odex_location, CompilerFilter::kSpeed, copy, expect_success)); } - std::string GetTestDexFileName() { - return GetDexSrc1(); - } + std::string GetTestDexFileName() { return GetDexSrc1(); } }; TEST_F(Dex2oatWatchdogTest, TestWatchdogOK) { @@ -1018,7 +994,7 @@ TEST_F(Dex2oatWatchdogTest, TestWatchdogOK) { RunTest(true); // Check with ten minutes. - RunTest(true, { "--watchdog-timeout=600000" }); + RunTest(true, {"--watchdog-timeout=600000"}); } TEST_F(Dex2oatWatchdogTest, TestWatchdogTrigger) { @@ -1032,7 +1008,7 @@ TEST_F(Dex2oatWatchdogTest, TestWatchdogTrigger) { test_accepts_odex_file_on_failure = true; // Check with ten milliseconds. - RunTest(false, { "--watchdog-timeout=10" }); + RunTest(false, {"--watchdog-timeout=10"}); } class Dex2oatReturnCodeTest : public Dex2oatTest { @@ -1044,16 +1020,11 @@ class Dex2oatReturnCodeTest : public Dex2oatTest { Copy(GetTestDexFileName(), dex_location); std::string error_msg; - return GenerateOdexForTestWithStatus({dex_location}, - odex_location, - CompilerFilter::kSpeed, - &error_msg, - extra_args); + return GenerateOdexForTestWithStatus( + {dex_location}, odex_location, CompilerFilter::kSpeed, &error_msg, extra_args); } - std::string GetTestDexFileName() { - return GetDexSrc1(); - } + std::string GetTestDexFileName() { return GetDexSrc1(); } }; class Dex2oatClassLoaderContextTest : public Dex2oatTest { @@ -1088,22 +1059,16 @@ class Dex2oatClassLoaderContextTest : public Dex2oatTest { CompilerFilter::kVerify, extra_args, expected_success, - /*use_fd=*/ false, - /*use_zip_fd=*/ false, + /*use_fd=*/false, + /*use_zip_fd=*/false, check_oat)); } - std::string GetUsedDexLocation() { - return GetScratchDir() + "/Context.jar"; - } + std::string GetUsedDexLocation() { return GetScratchDir() + "/Context.jar"; } - std::string GetUsedOatLocation() { - return GetOdexDir() + "/Context.odex"; - } + std::string GetUsedOatLocation() { return GetOdexDir() + "/Context.odex"; } - std::string GetUsedImageLocation() { - return GetOdexDir() + "/Context.art"; - } + std::string GetUsedImageLocation() { return GetOdexDir() + "/Context.art"; } const char* kEmptyClassPathKey = "PCL[]"; }; @@ -1125,8 +1090,8 @@ TEST_F(Dex2oatClassLoaderContextTest, ContextWithOtherDexFiles) { std::vector<std::unique_ptr<const DexFile>> dex_files = OpenTestDexFiles("Nested"); std::string context = "PCL[" + dex_files[0]->GetLocation() + "]"; - std::string expected_classpath_key = "PCL[" + - dex_files[0]->GetLocation() + "*" + std::to_string(dex_files[0]->GetLocationChecksum()) + "]"; + std::string expected_classpath_key = "PCL[" + dex_files[0]->GetLocation() + "*" + + std::to_string(dex_files[0]->GetLocationChecksum()) + "]"; RunTest(context.c_str(), expected_classpath_key.c_str(), true); } @@ -1136,7 +1101,7 @@ TEST_F(Dex2oatClassLoaderContextTest, ContextWithResourceOnlyDexFiles) { std::string context = "PCL[" + resource_only_classpath + "]"; // Expect an empty context because resource only dex files cannot be open. - RunTest(context.c_str(), kEmptyClassPathKey , /*expected_success*/ true); + RunTest(context.c_str(), kEmptyClassPathKey, /*expected_success*/ true); } TEST_F(Dex2oatClassLoaderContextTest, ContextWithNotExistentDexFiles) { @@ -1149,10 +1114,10 @@ TEST_F(Dex2oatClassLoaderContextTest, ChainContext) { std::vector<std::unique_ptr<const DexFile>> dex_files1 = OpenTestDexFiles("Nested"); std::vector<std::unique_ptr<const DexFile>> dex_files2 = OpenTestDexFiles("MultiDex"); - std::string context = "PCL[" + GetTestDexFileName("Nested") + "];" + - "DLC[" + GetTestDexFileName("MultiDex") + "]"; + std::string context = + "PCL[" + GetTestDexFileName("Nested") + "];" + "DLC[" + GetTestDexFileName("MultiDex") + "]"; std::string expected_classpath_key = "PCL[" + CreateClassPathWithChecksums(dex_files1) + "];" + - "DLC[" + CreateClassPathWithChecksums(dex_files2) + "]"; + "DLC[" + CreateClassPathWithChecksums(dex_files2) + "]"; RunTest(context.c_str(), expected_classpath_key.c_str(), true); } @@ -1161,10 +1126,10 @@ TEST_F(Dex2oatClassLoaderContextTest, ContextWithSharedLibrary) { std::vector<std::unique_ptr<const DexFile>> dex_files1 = OpenTestDexFiles("Nested"); std::vector<std::unique_ptr<const DexFile>> dex_files2 = OpenTestDexFiles("MultiDex"); - std::string context = "PCL[" + GetTestDexFileName("Nested") + "]" + - "{PCL[" + GetTestDexFileName("MultiDex") + "]}"; + std::string context = + "PCL[" + GetTestDexFileName("Nested") + "]" + "{PCL[" + GetTestDexFileName("MultiDex") + "]}"; std::string expected_classpath_key = "PCL[" + CreateClassPathWithChecksums(dex_files1) + "]" + - "{PCL[" + CreateClassPathWithChecksums(dex_files2) + "]}"; + "{PCL[" + CreateClassPathWithChecksums(dex_files2) + "]}"; RunTest(context.c_str(), expected_classpath_key.c_str(), true); } @@ -1172,49 +1137,49 @@ TEST_F(Dex2oatClassLoaderContextTest, ContextWithSharedLibraryAndImage) { std::vector<std::unique_ptr<const DexFile>> dex_files1 = OpenTestDexFiles("Nested"); std::vector<std::unique_ptr<const DexFile>> dex_files2 = OpenTestDexFiles("MultiDex"); - std::string context = "PCL[" + GetTestDexFileName("Nested") + "]" + - "{PCL[" + GetTestDexFileName("MultiDex") + "]}"; + std::string context = + "PCL[" + GetTestDexFileName("Nested") + "]" + "{PCL[" + GetTestDexFileName("MultiDex") + "]}"; std::string expected_classpath_key = "PCL[" + CreateClassPathWithChecksums(dex_files1) + "]" + - "{PCL[" + CreateClassPathWithChecksums(dex_files2) + "]}"; + "{PCL[" + CreateClassPathWithChecksums(dex_files2) + "]}"; RunTest(context.c_str(), expected_classpath_key.c_str(), - /*expected_success=*/ true, - /*use_second_source=*/ false, - /*generate_image=*/ true); + /*expected_success=*/true, + /*use_second_source=*/false, + /*generate_image=*/true); } TEST_F(Dex2oatClassLoaderContextTest, ContextWithSameSharedLibrariesAndImage) { std::vector<std::unique_ptr<const DexFile>> dex_files1 = OpenTestDexFiles("Nested"); std::vector<std::unique_ptr<const DexFile>> dex_files2 = OpenTestDexFiles("MultiDex"); - std::string context = "PCL[" + GetTestDexFileName("Nested") + "]" + - "{PCL[" + GetTestDexFileName("MultiDex") + "]" + - "#PCL[" + GetTestDexFileName("MultiDex") + "]}"; + std::string context = "PCL[" + GetTestDexFileName("Nested") + "]" + "{PCL[" + + GetTestDexFileName("MultiDex") + "]" + "#PCL[" + + GetTestDexFileName("MultiDex") + "]}"; std::string expected_classpath_key = "PCL[" + CreateClassPathWithChecksums(dex_files1) + "]" + - "{PCL[" + CreateClassPathWithChecksums(dex_files2) + "]" + - "#PCL[" + CreateClassPathWithChecksums(dex_files2) + "]}"; + "{PCL[" + CreateClassPathWithChecksums(dex_files2) + "]" + + "#PCL[" + CreateClassPathWithChecksums(dex_files2) + "]}"; RunTest(context.c_str(), expected_classpath_key.c_str(), - /*expected_success=*/ true, - /*use_second_source=*/ false, - /*generate_image=*/ true); + /*expected_success=*/true, + /*use_second_source=*/false, + /*generate_image=*/true); } TEST_F(Dex2oatClassLoaderContextTest, ContextWithSharedLibrariesDependenciesAndImage) { std::vector<std::unique_ptr<const DexFile>> dex_files1 = OpenTestDexFiles("Nested"); std::vector<std::unique_ptr<const DexFile>> dex_files2 = OpenTestDexFiles("MultiDex"); - std::string context = "PCL[" + GetTestDexFileName("Nested") + "]" + - "{PCL[" + GetTestDexFileName("MultiDex") + "]" + - "{PCL[" + GetTestDexFileName("Nested") + "]}}"; + std::string context = "PCL[" + GetTestDexFileName("Nested") + "]" + "{PCL[" + + GetTestDexFileName("MultiDex") + "]" + "{PCL[" + + GetTestDexFileName("Nested") + "]}}"; std::string expected_classpath_key = "PCL[" + CreateClassPathWithChecksums(dex_files1) + "]" + - "{PCL[" + CreateClassPathWithChecksums(dex_files2) + "]" + - "{PCL[" + CreateClassPathWithChecksums(dex_files1) + "]}}"; + "{PCL[" + CreateClassPathWithChecksums(dex_files2) + "]" + + "{PCL[" + CreateClassPathWithChecksums(dex_files1) + "]}}"; RunTest(context.c_str(), expected_classpath_key.c_str(), - /*expected_success=*/ true, - /*use_second_source=*/ false, - /*generate_image=*/ true); + /*expected_success=*/true, + /*use_second_source=*/false, + /*generate_image=*/true); } class Dex2oatDeterminism : public Dex2oatTest {}; @@ -1233,12 +1198,12 @@ TEST_F(Dex2oatDeterminism, UnloadCompile) { ASSERT_GT(spaces.size(), 0u); const std::string image_location = spaces[0]->GetImageLocation(); // Without passing in an app image, it will unload in between compilations. - const int res = GenerateOdexForTestWithStatus( - GetLibCoreDexFileNames(), - base_oat_name, - CompilerFilter::Filter::kVerify, - &error_msg, - {"--force-determinism", "--avoid-storing-invocation"}); + const int res = + GenerateOdexForTestWithStatus(GetLibCoreDexFileNames(), + base_oat_name, + CompilerFilter::Filter::kVerify, + &error_msg, + {"--force-determinism", "--avoid-storing-invocation"}); ASSERT_EQ(res, 0); Copy(base_oat_name, unload_oat_name); Copy(base_vdex_name, unload_vdex_name); @@ -1303,21 +1268,14 @@ TEST_F(Dex2oatTest, LayoutSections) { std::vector<uint16_t> post_methods = {methods[0], methods[2], methods[6]}; // Here, we build the profile from the method lists. ProfileCompilationInfo info; + info.AddMethodsForDex(static_cast<Hotness::Flag>(Hotness::kFlagHot | Hotness::kFlagStartup), + dex.get(), + hot_methods.begin(), + hot_methods.end()); info.AddMethodsForDex( - static_cast<Hotness::Flag>(Hotness::kFlagHot | Hotness::kFlagStartup), - dex.get(), - hot_methods.begin(), - hot_methods.end()); - info.AddMethodsForDex( - Hotness::kFlagStartup, - dex.get(), - startup_methods.begin(), - startup_methods.end()); + Hotness::kFlagStartup, dex.get(), startup_methods.begin(), startup_methods.end()); info.AddMethodsForDex( - Hotness::kFlagPostStartup, - dex.get(), - post_methods.begin(), - post_methods.end()); + Hotness::kFlagPostStartup, dex.get(), post_methods.begin(), post_methods.end()); for (uint16_t id : hot_methods) { EXPECT_TRUE(info.GetMethodHotness(MethodReference(dex.get(), id)).IsHot()); EXPECT_TRUE(info.GetMethodHotness(MethodReference(dex.get(), id)).IsStartup()); @@ -1340,16 +1298,15 @@ TEST_F(Dex2oatTest, LayoutSections) { oat_filename, CompilerFilter::Filter::kVerify, &error_msg, - {"--profile-file=" + profile_file.GetFilename(), - "--compact-dex-level=fast"}); + {"--profile-file=" + profile_file.GetFilename(), "--compact-dex-level=fast"}); EXPECT_EQ(res, 0); // Open our generated oat file. - std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/ -1, - oat_filename.c_str(), - oat_filename.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/-1, + oat_filename, + oat_filename, + /*executable=*/false, + /*low_4gb=*/false, dex->GetLocation(), &error_msg)); ASSERT_TRUE(odex_file != nullptr); @@ -1445,19 +1402,18 @@ TEST_F(Dex2oatTest, GenerateCompactDex) { const std::string vdex_filename = dir + "/base.vdex"; const std::string dex_location = GetTestDexFileName("MultiDex"); std::string error_msg; - const int res = GenerateOdexForTestWithStatus( - { dex_location }, - oat_filename, - CompilerFilter::Filter::kVerify, - &error_msg, - {"--compact-dex-level=fast"}); + const int res = GenerateOdexForTestWithStatus({dex_location}, + oat_filename, + CompilerFilter::Filter::kVerify, + &error_msg, + {"--compact-dex-level=fast"}); EXPECT_EQ(res, 0); // Open our generated oat file. - std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/ -1, - oat_filename.c_str(), - oat_filename.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/-1, + oat_filename, + oat_filename, + /*executable=*/false, + /*low_4gb=*/false, dex_location, &error_msg)); ASSERT_TRUE(odex_file != nullptr); @@ -1505,20 +1461,18 @@ TEST_F(Dex2oatVerifierAbort, HardFail) { std::string out_dir = GetScratchDir(); const std::string base_oat_name = out_dir + "/base.oat"; std::string error_msg; - const int res_fail = GenerateOdexForTestWithStatus( - {dex->GetLocation()}, - base_oat_name, - CompilerFilter::Filter::kVerify, - &error_msg, - {"--abort-on-hard-verifier-error"}); + const int res_fail = GenerateOdexForTestWithStatus({dex->GetLocation()}, + base_oat_name, + CompilerFilter::Filter::kVerify, + &error_msg, + {"--abort-on-hard-verifier-error"}); EXPECT_NE(0, res_fail); - const int res_no_fail = GenerateOdexForTestWithStatus( - {dex->GetLocation()}, - base_oat_name, - CompilerFilter::Filter::kVerify, - &error_msg, - {"--no-abort-on-hard-verifier-error"}); + const int res_no_fail = GenerateOdexForTestWithStatus({dex->GetLocation()}, + base_oat_name, + CompilerFilter::Filter::kVerify, + &error_msg, + {"--no-abort-on-hard-verifier-error"}); EXPECT_EQ(0, res_no_fail); } @@ -1530,28 +1484,25 @@ TEST_F(Dex2oatDedupeCode, DedupeTest) { std::string out_dir = GetScratchDir(); const std::string base_oat_name = out_dir + "/base.oat"; size_t no_dedupe_size = 0; - ASSERT_TRUE(GenerateOdexForTest(dex->GetLocation(), - base_oat_name, - CompilerFilter::Filter::kSpeed, - { "--deduplicate-code=false" }, - /*expect_success=*/ true, - /*use_fd=*/ false, - /*use_zip_fd=*/ false, - [&no_dedupe_size](const OatFile& o) { - no_dedupe_size = o.Size(); - })); + ASSERT_TRUE( + GenerateOdexForTest(dex->GetLocation(), + base_oat_name, + CompilerFilter::Filter::kSpeed, + {"--deduplicate-code=false"}, + /*expect_success=*/true, + /*use_fd=*/false, + /*use_zip_fd=*/false, + [&no_dedupe_size](const OatFile& o) { no_dedupe_size = o.Size(); })); size_t dedupe_size = 0; ASSERT_TRUE(GenerateOdexForTest(dex->GetLocation(), base_oat_name, CompilerFilter::Filter::kSpeed, - { "--deduplicate-code=true" }, - /*expect_success=*/ true, - /*use_fd=*/ false, - /*use_zip_fd=*/ false, - [&dedupe_size](const OatFile& o) { - dedupe_size = o.Size(); - })); + {"--deduplicate-code=true"}, + /*expect_success=*/true, + /*use_fd=*/false, + /*use_zip_fd=*/false, + [&dedupe_size](const OatFile& o) { dedupe_size = o.Size(); })); EXPECT_LT(dedupe_size, no_dedupe_size); } @@ -1563,13 +1514,11 @@ TEST_F(Dex2oatTest, UncompressedTest) { ASSERT_TRUE(GenerateOdexForTest(dex->GetLocation(), base_oat_name, CompilerFilter::Filter::kVerify, - { }, - /*expect_success=*/ true, - /*use_fd=*/ false, - /*use_zip_fd=*/ false, - [](const OatFile& o) { - CHECK(!o.ContainsDexCode()); - })); + {}, + /*expect_success=*/true, + /*use_fd=*/false, + /*use_zip_fd=*/false, + [](const OatFile& o) { CHECK(!o.ContainsDexCode()); })); } TEST_F(Dex2oatTest, MissingBootImageTest) { @@ -1588,13 +1537,12 @@ TEST_F(Dex2oatTest, EmptyUncompressedDexTest) { std::string out_dir = GetScratchDir(); const std::string base_oat_name = out_dir + "/base.oat"; std::string error_msg; - int status = GenerateOdexForTestWithStatus( - { GetTestDexFileName("MainEmptyUncompressed") }, - base_oat_name, - CompilerFilter::Filter::kVerify, - &error_msg, - { }, - /*use_fd*/ false); + int status = GenerateOdexForTestWithStatus({GetTestDexFileName("MainEmptyUncompressed")}, + base_oat_name, + CompilerFilter::Filter::kVerify, + &error_msg, + {}, + /*use_fd*/ false); // Expect to fail with code 1 and not SIGSEGV or SIGABRT. ASSERT_TRUE(WIFEXITED(status)); ASSERT_EQ(WEXITSTATUS(status), 1) << error_msg; @@ -1604,13 +1552,12 @@ TEST_F(Dex2oatTest, EmptyUncompressedAlignedDexTest) { std::string out_dir = GetScratchDir(); const std::string base_oat_name = out_dir + "/base.oat"; std::string error_msg; - int status = GenerateOdexForTestWithStatus( - { GetTestDexFileName("MainEmptyUncompressedAligned") }, - base_oat_name, - CompilerFilter::Filter::kVerify, - &error_msg, - { }, - /*use_fd*/ false); + int status = GenerateOdexForTestWithStatus({GetTestDexFileName("MainEmptyUncompressedAligned")}, + base_oat_name, + CompilerFilter::Filter::kVerify, + &error_msg, + {}, + /*use_fd*/ false); // Expect to fail with code 1 and not SIGSEGV or SIGABRT. ASSERT_TRUE(WIFEXITED(status)); ASSERT_EQ(WEXITSTATUS(status), 1) << error_msg; @@ -1696,20 +1643,18 @@ TEST_F(Dex2oatTest, CompactDexGenerationFailure) { ASSERT_TRUE(GenerateOdexForTest(temp_dex.GetFilename(), oat_filename, CompilerFilter::Filter::kVerify, - { }, - /*expect_success=*/ true, - /*use_fd=*/ false, - /*use_zip_fd=*/ false, - [](const OatFile& o) { - CHECK(o.ContainsDexCode()); - })); + {}, + /*expect_success=*/true, + /*use_fd=*/false, + /*use_zip_fd=*/false, + [](const OatFile& o) { CHECK(o.ContainsDexCode()); })); // Open our generated oat file. std::string error_msg; - std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/ -1, - oat_filename.c_str(), - oat_filename.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/-1, + oat_filename, + oat_filename, + /*executable=*/false, + /*low_4gb=*/false, temp_dex.GetFilename(), &error_msg)); ASSERT_TRUE(odex_file != nullptr); @@ -1744,11 +1689,8 @@ TEST_F(Dex2oatTest, CompactDexGenerationFailureMultiDex) { } const std::string& dex_location = apk_file.GetFilename(); const std::string odex_location = GetOdexDir() + "/output.odex"; - ASSERT_TRUE(GenerateOdexForTest(dex_location, - odex_location, - CompilerFilter::kVerify, - { "--compact-dex-level=fast" }, - true)); + ASSERT_TRUE(GenerateOdexForTest( + dex_location, odex_location, CompilerFilter::kVerify, {"--compact-dex-level=fast"}, true)); } TEST_F(Dex2oatTest, StderrLoggerOutput) { @@ -1761,7 +1703,7 @@ TEST_F(Dex2oatTest, StderrLoggerOutput) { ASSERT_TRUE(GenerateOdexForTest(dex_location, odex_location, CompilerFilter::kVerify, - { "--runtime-arg", "-Xuse-stderr-logger" }, + {"--runtime-arg", "-Xuse-stderr-logger"}, true)); // Look for some random part of dex2oat logging. With the stderr logger this should be captured, // even on device. @@ -1778,14 +1720,14 @@ TEST_F(Dex2oatTest, VerifyCompilationReason) { ASSERT_TRUE(GenerateOdexForTest(dex_location, odex_location, CompilerFilter::kVerify, - { "--compilation-reason=install" }, + {"--compilation-reason=install"}, true)); std::string error_msg; - std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/ -1, - odex_location.c_str(), - odex_location.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/-1, + odex_location, + odex_location, + /*executable=*/false, + /*low_4gb=*/false, dex_location, &error_msg)); ASSERT_TRUE(odex_file != nullptr); @@ -1799,17 +1741,13 @@ TEST_F(Dex2oatTest, VerifyNoCompilationReason) { // Test file doesn't matter. Copy(GetDexSrc1(), dex_location); - ASSERT_TRUE(GenerateOdexForTest(dex_location, - odex_location, - CompilerFilter::kVerify, - {}, - true)); + ASSERT_TRUE(GenerateOdexForTest(dex_location, odex_location, CompilerFilter::kVerify, {}, true)); std::string error_msg; - std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/ -1, - odex_location.c_str(), - odex_location.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/-1, + odex_location, + odex_location, + /*executable=*/false, + /*low_4gb=*/false, dex_location, &error_msg)); ASSERT_TRUE(odex_file != nullptr); @@ -1826,25 +1764,25 @@ TEST_F(Dex2oatTest, DontExtract) { ASSERT_TRUE(GenerateOdexForTest(dex_location, odex_location, CompilerFilter::Filter::kVerify, - { "--copy-dex-files=false" }, - /*expect_success=*/ true, - /*use_fd=*/ false, - /*use_zip_fd=*/ false, + {"--copy-dex-files=false"}, + /*expect_success=*/true, + /*use_fd=*/false, + /*use_zip_fd=*/false, [](const OatFile&) {})); { // Check the vdex doesn't have dex. - std::unique_ptr<VdexFile> vdex(VdexFile::Open(vdex_location.c_str(), - /*writable=*/ false, - /*low_4gb=*/ false, + std::unique_ptr<VdexFile> vdex(VdexFile::Open(vdex_location, + /*writable=*/false, + /*low_4gb=*/false, &error_msg)); ASSERT_TRUE(vdex != nullptr); EXPECT_FALSE(vdex->HasDexSection()) << output_; } - std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/ -1, - odex_location.c_str(), - odex_location.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/-1, + odex_location, + odex_location, + /*executable=*/false, + /*low_4gb=*/false, dex_location, &error_msg)); ASSERT_TRUE(odex_file != nullptr) << dex_location; @@ -1882,18 +1820,16 @@ TEST_F(Dex2oatTest, DontExtract) { ASSERT_TRUE(GenerateOdexForTest(dex_location, odex_location, filter, - { "--dump-timings", - "--dm-file=" + dm_file.GetFilename(), - // Pass -Xuse-stderr-logger have dex2oat output in output_ on - // target. - "--runtime-arg", - "-Xuse-stderr-logger" }, - /*expect_success=*/ true, - /*use_fd=*/ false, - /*use_zip_fd=*/ false, - [](const OatFile& o) { - CHECK(o.ContainsDexCode()); - })); + {"--dump-timings", + "--dm-file=" + dm_file.GetFilename(), + // Pass -Xuse-stderr-logger have dex2oat output in output_ on + // target. + "--runtime-arg", + "-Xuse-stderr-logger"}, + /*expect_success=*/true, + /*use_fd=*/false, + /*use_zip_fd=*/false, + [](const OatFile& o) { CHECK(o.ContainsDexCode()); })); // Check the output for "Fast verify", this is printed from --dump-timings. std::istringstream iss(output_); std::string line; @@ -1933,12 +1869,11 @@ TEST_F(Dex2oatTest, CompactDexInvalidSource) { const std::string& dex_location = invalid_dex.GetFilename(); const std::string odex_location = GetOdexDir() + "/output.odex"; std::string error_msg; - int status = GenerateOdexForTestWithStatus( - {dex_location}, - odex_location, - CompilerFilter::kVerify, - &error_msg, - { "--compact-dex-level=fast" }); + int status = GenerateOdexForTestWithStatus({dex_location}, + odex_location, + CompilerFilter::kVerify, + &error_msg, + {"--compact-dex-level=fast"}); ASSERT_TRUE(WIFEXITED(status) && WEXITSTATUS(status) != 0) << status << " " << output_; } @@ -1972,20 +1907,18 @@ TEST_F(Dex2oatTest, CompactDexInZip) { std::string error_msg; int status = 0u; - status = GenerateOdexForTestWithStatus( - { invalid_dex_zip.GetFilename() }, - GetOdexDir() + "/output_apk.odex", - CompilerFilter::kVerify, - &error_msg, - { "--compact-dex-level=fast" }); + status = GenerateOdexForTestWithStatus({invalid_dex_zip.GetFilename()}, + GetOdexDir() + "/output_apk.odex", + CompilerFilter::kVerify, + &error_msg, + {"--compact-dex-level=fast"}); ASSERT_TRUE(WIFEXITED(status) && WEXITSTATUS(status) != 0) << status << " " << output_; - status = GenerateOdexForTestWithStatus( - { invalid_dex.GetFilename() }, - GetOdexDir() + "/output.odex", - CompilerFilter::kVerify, - &error_msg, - { "--compact-dex-level=fast" }); + status = GenerateOdexForTestWithStatus({invalid_dex.GetFilename()}, + GetOdexDir() + "/output.odex", + CompilerFilter::kVerify, + &error_msg, + {"--compact-dex-level=fast"}); ASSERT_TRUE(WIFEXITED(status) && WEXITSTATUS(status) != 0) << status << " " << output_; } @@ -1999,25 +1932,25 @@ TEST_F(Dex2oatWithExpectedFilterTest, AppImageNoProfile) { ASSERT_TRUE(GenerateOdexForTest(GetTestDexFileName("ManyMethods"), odex_location, CompilerFilter::Filter::kSpeedProfile, - { "--app-image-fd=" + std::to_string(app_image_file.GetFd()) }, - /*expect_success=*/ true, - /*use_fd=*/ false, - /*use_zip_fd=*/ false, + {"--app-image-fd=" + std::to_string(app_image_file.GetFd())}, + /*expect_success=*/true, + /*use_fd=*/false, + /*use_zip_fd=*/false, [](const OatFile&) {})); // Open our generated oat file. std::string error_msg; - std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/ -1, - odex_location.c_str(), - odex_location.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/-1, + odex_location, + odex_location, + /*executable=*/false, + /*low_4gb=*/false, &error_msg)); ASSERT_TRUE(odex_file != nullptr); ImageHeader header = {}; - ASSERT_TRUE(app_image_file.GetFile()->PreadFully( - reinterpret_cast<void*>(&header), - sizeof(header), - /*offset*/ 0u)) << app_image_file.GetFile()->GetLength(); + ASSERT_TRUE(app_image_file.GetFile()->PreadFully(reinterpret_cast<void*>(&header), + sizeof(header), + /*offset*/ 0u)) + << app_image_file.GetFile()->GetLength(); EXPECT_GT(header.GetImageSection(ImageHeader::kSectionObjects).Size(), 0u); EXPECT_EQ(header.GetImageSection(ImageHeader::kSectionArtMethods).Size(), 0u); EXPECT_EQ(header.GetImageSection(ImageHeader::kSectionArtFields).Size(), 0u); @@ -2036,9 +1969,9 @@ TEST_F(Dex2oatTest, ZipFd) { base_oat_name, CompilerFilter::Filter::kVerify, extra_args, - /*expect_success=*/ true, - /*use_fd=*/ false, - /*use_zip_fd=*/ true)); + /*expect_success=*/true, + /*use_fd=*/false, + /*use_zip_fd=*/true)); } TEST_F(Dex2oatWithExpectedFilterTest, AppImageEmptyDex) { @@ -2052,7 +1985,7 @@ TEST_F(Dex2oatWithExpectedFilterTest, AppImageEmptyDex) { std::vector<uint16_t> methods; std::vector<dex::TypeIndex> classes; { - MutateDexFile(temp_dex.GetFile(), GetTestDexFileName("StringLiterals"), [&] (DexFile* dex) { + MutateDexFile(temp_dex.GetFile(), GetTestDexFileName("StringLiterals"), [&](DexFile* dex) { // Modify the header to make the dex file valid but empty. DexFile::Header* header = const_cast<DexFile::Header*>(&dex->GetHeader()); header->string_ids_size_ = 0; @@ -2090,20 +2023,20 @@ TEST_F(Dex2oatWithExpectedFilterTest, AppImageEmptyDex) { ASSERT_TRUE(GenerateOdexForTest(dex_location, odex_location, CompilerFilter::Filter::kSpeedProfile, - { "--app-image-file=" + app_image_location, - "--resolve-startup-const-strings=true", - "--profile-file=" + profile_file.GetFilename()}, - /*expect_success=*/ true, - /*use_fd=*/ false, - /*use_zip_fd=*/ false, + {"--app-image-file=" + app_image_location, + "--resolve-startup-const-strings=true", + "--profile-file=" + profile_file.GetFilename()}, + /*expect_success=*/true, + /*use_fd=*/false, + /*use_zip_fd=*/false, [](const OatFile&) {})); // Open our generated oat file. std::string error_msg; - std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/ -1, - odex_location.c_str(), - odex_location.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/-1, + odex_location, + odex_location, + /*executable=*/false, + /*low_4gb=*/false, &error_msg)); ASSERT_TRUE(odex_file != nullptr); } @@ -2138,9 +2071,9 @@ TEST_F(Dex2oatTest, DexFileFd) { base_oat_name, CompilerFilter::Filter::kVerify, extra_args, - /*expect_success=*/ true, - /*use_fd=*/ false, - /*use_zip_fd=*/ true)); + /*expect_success=*/true, + /*use_fd=*/false, + /*use_zip_fd=*/true)); } TEST_F(Dex2oatTest, AppImageResolveStrings) { @@ -2152,46 +2085,47 @@ TEST_F(Dex2oatTest, AppImageResolveStrings) { std::vector<uint16_t> methods; std::vector<dex::TypeIndex> classes; { - MutateDexFile(temp_dex.GetFile(), GetTestDexFileName("StringLiterals"), [&] (DexFile* dex) { - bool mutated_successfully = false; - // Change the dex instructions to make an opcode that spans past the end of the code item. - for (ClassAccessor accessor : dex->GetClasses()) { - if (accessor.GetDescriptor() == std::string("LStringLiterals$StartupClass;")) { - classes.push_back(accessor.GetClassIdx()); - } - for (const ClassAccessor::Method& method : accessor.GetMethods()) { - std::string method_name(dex->GetMethodName(dex->GetMethodId(method.GetIndex()))); - CodeItemInstructionAccessor instructions = method.GetInstructions(); - if (method_name == "startUpMethod2") { - // Make an instruction that runs past the end of the code item and verify that it - // doesn't cause dex2oat to crash. - ASSERT_TRUE(instructions.begin() != instructions.end()); - DexInstructionIterator last_instruction = instructions.begin(); - for (auto dex_it = instructions.begin(); dex_it != instructions.end(); ++dex_it) { - last_instruction = dex_it; + MutateDexFile( + temp_dex.GetFile(), GetTestDexFileName("StringLiterals"), [&](DexFile* dex) { + bool mutated_successfully = false; + // Change the dex instructions to make an opcode that spans past the end of the code item. + for (ClassAccessor accessor : dex->GetClasses()) { + if (accessor.GetDescriptor() == std::string("LStringLiterals$StartupClass;")) { + classes.push_back(accessor.GetClassIdx()); } - ASSERT_EQ(last_instruction->SizeInCodeUnits(), 1u); - // Set the opcode to something that will go past the end of the code item. - const_cast<Instruction&>(last_instruction.Inst()).SetOpcode( - Instruction::CONST_STRING_JUMBO); - mutated_successfully = true; - // Test that the safe iterator doesn't go past the end. - SafeDexInstructionIterator it2(instructions.begin(), instructions.end()); - while (!it2.IsErrorState()) { - ++it2; + for (const ClassAccessor::Method& method : accessor.GetMethods()) { + std::string method_name(dex->GetMethodName(dex->GetMethodId(method.GetIndex()))); + CodeItemInstructionAccessor instructions = method.GetInstructions(); + if (method_name == "startUpMethod2") { + // Make an instruction that runs past the end of the code item and verify that it + // doesn't cause dex2oat to crash. + ASSERT_TRUE(instructions.begin() != instructions.end()); + DexInstructionIterator last_instruction = instructions.begin(); + for (auto dex_it = instructions.begin(); dex_it != instructions.end(); ++dex_it) { + last_instruction = dex_it; + } + ASSERT_EQ(last_instruction->SizeInCodeUnits(), 1u); + // Set the opcode to something that will go past the end of the code item. + const_cast<Instruction&>(last_instruction.Inst()) + .SetOpcode(Instruction::CONST_STRING_JUMBO); + mutated_successfully = true; + // Test that the safe iterator doesn't go past the end. + SafeDexInstructionIterator it2(instructions.begin(), instructions.end()); + while (!it2.IsErrorState()) { + ++it2; + } + EXPECT_TRUE(it2 == last_instruction); + EXPECT_TRUE(it2 < instructions.end()); + methods.push_back(method.GetIndex()); + mutated_successfully = true; + } else if (method_name == "startUpMethod") { + methods.push_back(method.GetIndex()); + } } - EXPECT_TRUE(it2 == last_instruction); - EXPECT_TRUE(it2 < instructions.end()); - methods.push_back(method.GetIndex()); - mutated_successfully = true; - } else if (method_name == "startUpMethod") { - methods.push_back(method.GetIndex()); } - } - } - CHECK(mutated_successfully) - << "Failed to find candidate code item with only one code unit in last instruction."; - }); + CHECK(mutated_successfully) + << "Failed to find candidate code item with only one code unit in last instruction."; + }); } std::unique_ptr<const DexFile> dex_file(OpenDexFile(temp_dex.GetFilename().c_str())); { @@ -2210,38 +2144,36 @@ TEST_F(Dex2oatTest, AppImageResolveStrings) { ASSERT_TRUE(GenerateOdexForTest(dex_location, odex_location, CompilerFilter::Filter::kSpeedProfile, - { "--app-image-file=" + app_image_location, - "--resolve-startup-const-strings=true", - "--profile-file=" + profile_file.GetFilename()}, - /*expect_success=*/ true, - /*use_fd=*/ false, - /*use_zip_fd=*/ false, + {"--app-image-file=" + app_image_location, + "--resolve-startup-const-strings=true", + "--profile-file=" + profile_file.GetFilename()}, + /*expect_success=*/true, + /*use_fd=*/false, + /*use_zip_fd=*/false, [](const OatFile&) {})); // Open our generated oat file. std::string error_msg; - std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/ -1, - odex_location.c_str(), - odex_location.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/-1, + odex_location, + odex_location, + /*executable=*/false, + /*low_4gb=*/false, &error_msg)); ASSERT_TRUE(odex_file != nullptr); // Check the strings in the app image intern table only contain the "startup" strigs. { ScopedObjectAccess soa(Thread::Current()); - std::unique_ptr<gc::space::ImageSpace> space = - gc::space::ImageSpace::CreateFromAppImage(app_image_location.c_str(), - odex_file.get(), - &error_msg); + std::unique_ptr<gc::space::ImageSpace> space = gc::space::ImageSpace::CreateFromAppImage( + app_image_location.c_str(), odex_file.get(), &error_msg); ASSERT_TRUE(space != nullptr) << error_msg; std::set<std::string> seen; InternTable intern_table; - intern_table.AddImageStringsToTable(space.get(), [&](InternTable::UnorderedSet& interns) - REQUIRES_SHARED(Locks::mutator_lock_) { - for (const GcRoot<mirror::String>& str : interns) { - seen.insert(str.Read()->ToModifiedUtf8()); - } - }); + intern_table.AddImageStringsToTable( + space.get(), [&](InternTable::UnorderedSet& interns) REQUIRES_SHARED(Locks::mutator_lock_) { + for (const GcRoot<mirror::String>& str : interns) { + seen.insert(str.Read()->ToModifiedUtf8()); + } + }); // Normal methods EXPECT_TRUE(seen.find("Loading ") != seen.end()); EXPECT_TRUE(seen.find("Starting up") != seen.end()); @@ -2259,20 +2191,23 @@ TEST_F(Dex2oatTest, AppImageResolveStrings) { std::set<std::string> app_image_strings; MutexLock mu(Thread::Current(), *Locks::intern_table_lock_); - intern_table.VisitInterns([&](const GcRoot<mirror::String>& root) - REQUIRES_SHARED(Locks::mutator_lock_) { - boot_image_strings.insert(root.Read()->ToModifiedUtf8()); - }, /*visit_boot_images=*/true, /*visit_non_boot_images=*/false); - intern_table.VisitInterns([&](const GcRoot<mirror::String>& root) - REQUIRES_SHARED(Locks::mutator_lock_) { - app_image_strings.insert(root.Read()->ToModifiedUtf8()); - }, /*visit_boot_images=*/false, /*visit_non_boot_images=*/true); + intern_table.VisitInterns( + [&](const GcRoot<mirror::String>& root) REQUIRES_SHARED(Locks::mutator_lock_) { + boot_image_strings.insert(root.Read()->ToModifiedUtf8()); + }, + /*visit_boot_images=*/true, + /*visit_non_boot_images=*/false); + intern_table.VisitInterns( + [&](const GcRoot<mirror::String>& root) REQUIRES_SHARED(Locks::mutator_lock_) { + app_image_strings.insert(root.Read()->ToModifiedUtf8()); + }, + /*visit_boot_images=*/false, + /*visit_non_boot_images=*/true); EXPECT_EQ(boot_image_strings.size(), 0u); EXPECT_TRUE(app_image_strings == seen); } } - TEST_F(Dex2oatClassLoaderContextTest, StoredClassLoaderContext) { std::vector<std::unique_ptr<const DexFile>> dex_files = OpenTestDexFiles("MultiDex"); const std::string out_dir = GetScratchDir(); @@ -2293,31 +2228,34 @@ TEST_F(Dex2oatClassLoaderContextTest, StoredClassLoaderContext) { expected_stored_context += "*" + std::to_string(dex_file->GetLocationChecksum()); ++index; } - expected_stored_context += + "]"; + expected_stored_context += "]"; // The class path should not be valid and should fail being stored. EXPECT_TRUE(GenerateOdexForTest(GetTestDexFileName("ManyMethods"), odex_location, CompilerFilter::Filter::kVerify, - { "--class-loader-context=" + stored_context }, - /*expect_success=*/ true, - /*use_fd=*/ false, - /*use_zip_fd=*/ false, + {"--class-loader-context=" + stored_context}, + /*expect_success=*/true, + /*use_fd=*/false, + /*use_zip_fd=*/false, [&](const OatFile& oat_file) { - EXPECT_NE(oat_file.GetClassLoaderContext(), stored_context) << output_; - EXPECT_NE(oat_file.GetClassLoaderContext(), valid_context) << output_; - })); + EXPECT_NE(oat_file.GetClassLoaderContext(), stored_context) + << output_; + EXPECT_NE(oat_file.GetClassLoaderContext(), valid_context) + << output_; + })); // The stored context should match what we expect even though it's invalid. - EXPECT_TRUE(GenerateOdexForTest(GetTestDexFileName("ManyMethods"), - odex_location, - CompilerFilter::Filter::kVerify, - { "--class-loader-context=" + valid_context, - "--stored-class-loader-context=" + stored_context }, - /*expect_success=*/ true, - /*use_fd=*/ false, - /*use_zip_fd=*/ false, - [&](const OatFile& oat_file) { - EXPECT_EQ(oat_file.GetClassLoaderContext(), expected_stored_context) << output_; - })); + EXPECT_TRUE(GenerateOdexForTest( + GetTestDexFileName("ManyMethods"), + odex_location, + CompilerFilter::Filter::kVerify, + {"--class-loader-context=" + valid_context, + "--stored-class-loader-context=" + stored_context}, + /*expect_success=*/true, + /*use_fd=*/false, + /*use_zip_fd=*/false, + [&](const OatFile& oat_file) { + EXPECT_EQ(oat_file.GetClassLoaderContext(), expected_stored_context) << output_; + })); } class Dex2oatISAFeaturesRuntimeDetectionTest : public Dex2oatTest { @@ -2328,15 +2266,11 @@ class Dex2oatISAFeaturesRuntimeDetectionTest : public Dex2oatTest { Copy(GetTestDexFileName(), dex_location); - ASSERT_TRUE(GenerateOdexForTest(dex_location, - odex_location, - CompilerFilter::kSpeed, - extra_args)); + ASSERT_TRUE( + GenerateOdexForTest(dex_location, odex_location, CompilerFilter::kSpeed, extra_args)); } - std::string GetTestDexFileName() { - return GetDexSrc1(); - } + std::string GetTestDexFileName() { return GetDexSrc1(); } }; TEST_F(Dex2oatISAFeaturesRuntimeDetectionTest, TestCurrentRuntimeFeaturesAsDex2OatArguments) { @@ -2362,20 +2296,19 @@ TEST_F(LinkageTest, LinkageEnabled) { std::string out_dir = GetScratchDir(); const std::string base_oat_name = out_dir + "/base.oat"; std::string error_msg; - const int res_fail = GenerateOdexForTestWithStatus( - {dex->GetLocation()}, - base_oat_name, - CompilerFilter::Filter::kSpeed, - &error_msg, - {"--check-linkage-conditions", "--crash-on-linkage-violation"}); + const int res_fail = + GenerateOdexForTestWithStatus({dex->GetLocation()}, + base_oat_name, + CompilerFilter::Filter::kSpeed, + &error_msg, + {"--check-linkage-conditions", "--crash-on-linkage-violation"}); EXPECT_NE(0, res_fail); - const int res_no_fail = GenerateOdexForTestWithStatus( - {dex->GetLocation()}, - base_oat_name, - CompilerFilter::Filter::kSpeed, - &error_msg, - {"--check-linkage-conditions"}); + const int res_no_fail = GenerateOdexForTestWithStatus({dex->GetLocation()}, + base_oat_name, + CompilerFilter::Filter::kSpeed, + &error_msg, + {"--check-linkage-conditions"}); EXPECT_EQ(0, res_no_fail); } @@ -2387,19 +2320,19 @@ TEST_F(Dex2oatTest, LoadOutOfDateOatFile) { ASSERT_TRUE(GenerateOdexForTest(dex->GetLocation(), base_oat_name, CompilerFilter::Filter::kSpeed, - { "--deduplicate-code=false" }, - /*expect_success=*/ true, - /*use_fd=*/ false, - /*use_zip_fd=*/ false)); + {"--deduplicate-code=false"}, + /*expect_success=*/true, + /*use_fd=*/false, + /*use_zip_fd=*/false)); // Check that we can open the oat file as executable. { std::string error_msg; - std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/ -1, - base_oat_name.c_str(), - base_oat_name.c_str(), - /*executable=*/ true, - /*low_4gb=*/ false, + std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/-1, + base_oat_name, + base_oat_name, + /*executable=*/true, + /*low_4gb=*/false, dex->GetLocation(), &error_msg)); ASSERT_TRUE(odex_file != nullptr) << error_msg; @@ -2415,19 +2348,19 @@ TEST_F(Dex2oatTest, LoadOutOfDateOatFile) { { std::string error_msg; std::unique_ptr<ElfFile> elf_file(ElfFile::Open(file.get(), - /*writable=*/ false, - /*program_header_only=*/ true, - /*low_4gb=*/ false, + /*writable=*/false, + /*program_header_only=*/true, + /*low_4gb=*/false, &error_msg)); ASSERT_TRUE(elf_file != nullptr) << error_msg; ASSERT_TRUE(elf_file->Load(file.get(), - /*executable=*/ false, - /*low_4gb=*/ false, - /*reservation=*/ nullptr, - &error_msg)) << error_msg; - const uint8_t* base_address = elf_file->Is64Bit() - ? elf_file->GetImpl64()->GetBaseAddress() - : elf_file->GetImpl32()->GetBaseAddress(); + /*executable=*/false, + /*low_4gb=*/false, + /*reservation=*/nullptr, + &error_msg)) + << error_msg; + const uint8_t* base_address = elf_file->Is64Bit() ? elf_file->GetImpl64()->GetBaseAddress() : + elf_file->GetImpl32()->GetBaseAddress(); const uint8_t* oatdata = elf_file->FindDynamicSymbolAddress("oatdata"); ASSERT_TRUE(oatdata != nullptr); ASSERT_TRUE(oatdata > base_address); @@ -2472,11 +2405,11 @@ TEST_F(Dex2oatTest, LoadOutOfDateOatFile) { // Check that we reject the oat file without crashing. { std::string error_msg; - std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/ -1, - base_oat_name.c_str(), - base_oat_name.c_str(), - /*executable=*/ true, - /*low_4gb=*/ false, + std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/-1, + base_oat_name, + base_oat_name, + /*executable=*/true, + /*low_4gb=*/false, dex->GetLocation(), &error_msg)); ASSERT_FALSE(odex_file != nullptr); diff --git a/dex2oat/dex2oat_vdex_test.cc b/dex2oat/dex2oat_vdex_test.cc index df76d58980..27fcc180a5 100644 --- a/dex2oat/dex2oat_vdex_test.cc +++ b/dex2oat/dex2oat_vdex_test.cc @@ -49,7 +49,7 @@ class Dex2oatVdexTest : public Dex2oatEnvironmentTest { args.push_back("--public-sdk=" + *public_sdk); } args.push_back("--compiler-filter=" + - CompilerFilter::NameOfFilter(CompilerFilter::Filter::kVerify)); + CompilerFilter::NameOfFilter(CompilerFilter::Filter::kVerify)); args.push_back("--runtime-arg"); args.push_back("-Xnorelocate"); if (!copy_dex_files) { @@ -65,12 +65,12 @@ class Dex2oatVdexTest : public Dex2oatEnvironmentTest { return Dex2Oat(args, &output_, &error_msg_) == 0; } - std::unique_ptr<VerifierDeps> GetVerifierDeps( - const std::string& vdex_location, const DexFile* dex_file) { + std::unique_ptr<VerifierDeps> GetVerifierDeps(const std::string& vdex_location, + const DexFile* dex_file) { // Verify the vdex file content: only the classes using public APIs should be verified. - std::unique_ptr<VdexFile> vdex(VdexFile::Open(vdex_location.c_str(), - /*writable=*/ false, - /*low_4gb=*/ false, + std::unique_ptr<VdexFile> vdex(VdexFile::Open(vdex_location, + /*writable=*/false, + /*low_4gb=*/false, &error_msg_)); // Check the vdex doesn't have dex. if (vdex->HasDexSection()) { @@ -85,7 +85,7 @@ class Dex2oatVdexTest : public Dex2oatEnvironmentTest { std::vector<const DexFile*> dex_files; dex_files.push_back(dex_file); - std::unique_ptr<VerifierDeps> deps(new VerifierDeps(dex_files, /*output_only=*/ false)); + std::unique_ptr<VerifierDeps> deps(new VerifierDeps(dex_files, /*output_only=*/false)); if (!deps->ParseStoredData(dex_files, vdex->GetVerifierDepsData())) { ::testing::AssertionFailure() << error_msg_; @@ -200,11 +200,10 @@ TEST_F(Dex2oatVdexTest, VerifyPublicSdkStubsWithDexFiles) { std::unique_ptr<const DexFile> dex_file(OpenTestDexFile("Dex2oatVdexTestDex")); // Compile the subject app using the predefined API-stubs - ASSERT_TRUE(RunDex2oat( - dex_file->GetLocation(), - GetOdex(dex_file), - /*public_sdk=*/ nullptr, - /*copy_dex_files=*/ true)); + ASSERT_TRUE(RunDex2oat(dex_file->GetLocation(), + GetOdex(dex_file), + /*public_sdk=*/nullptr, + /*copy_dex_files=*/true)); // Create the .dm file with the output. std::string dm_file = GetScratchDir() + "/base.dm"; @@ -214,12 +213,11 @@ TEST_F(Dex2oatVdexTest, VerifyPublicSdkStubsWithDexFiles) { // Recompile again with the .dm file which contains a vdex with code. // The compilation will pass, but dex2oat will not use the vdex file. - ASSERT_TRUE(RunDex2oat( - dex_file->GetLocation(), - GetOdex(dex_file, "v2"), - /*public_sdk=*/ nullptr, - /*copy_dex_files=*/ true, - extra_args)); + ASSERT_TRUE(RunDex2oat(dex_file->GetLocation(), + GetOdex(dex_file, "v2"), + /*public_sdk=*/nullptr, + /*copy_dex_files=*/true, + extra_args)); } // Check that corrupt vdex files from .dm archives are ignored. @@ -238,12 +236,12 @@ TEST_F(Dex2oatVdexTest, VerifyCorruptVdexFile) { extra_args.push_back("--dm-file=" + dm_file); // Compile the dex file. Despite having a corrupt input .vdex, we should not crash. - ASSERT_TRUE(RunDex2oat( - dex_file->GetLocation(), - GetOdex(dex_file), - /*public_sdk=*/ nullptr, - /*copy_dex_files=*/ true, - extra_args)) << output_; + ASSERT_TRUE(RunDex2oat(dex_file->GetLocation(), + GetOdex(dex_file), + /*public_sdk=*/nullptr, + /*copy_dex_files=*/true, + extra_args)) + << output_; } // Check that if the input dm a vdex with mismatching checksums the compilation fails @@ -253,11 +251,10 @@ TEST_F(Dex2oatVdexTest, VerifyInputDmWithMismatchedChecksums) { // Generate a vdex file for Dex2oatVdexTestDex. std::unique_ptr<const DexFile> dex_file(OpenTestDexFile("Dex2oatVdexTestDex")); - ASSERT_TRUE(RunDex2oat( - dex_file->GetLocation(), - GetOdex(dex_file), - /*public_sdk=*/ nullptr, - /*copy_dex_files=*/ false)); + ASSERT_TRUE(RunDex2oat(dex_file->GetLocation(), + GetOdex(dex_file), + /*public_sdk=*/nullptr, + /*copy_dex_files=*/false)); // Create the .dm file with the output. std::string dm_file = GetScratchDir() + "/base.dm"; @@ -268,12 +265,12 @@ TEST_F(Dex2oatVdexTest, VerifyInputDmWithMismatchedChecksums) { // Try to compile Main using an input dm which contains the vdex for // Dex2oatVdexTestDex. It should fail. std::unique_ptr<const DexFile> dex_file2(OpenTestDexFile("Main")); - ASSERT_FALSE(RunDex2oat( - dex_file2->GetLocation(), - GetOdex(dex_file2, "v2"), - /*public_sdk=*/ nullptr, - /*copy_dex_files=*/ false, - extra_args)) << output_; + ASSERT_FALSE(RunDex2oat(dex_file2->GetLocation(), + GetOdex(dex_file2, "v2"), + /*public_sdk=*/nullptr, + /*copy_dex_files=*/false, + extra_args)) + << output_; } } // namespace art diff --git a/dexlayout/dexdiag_test.cc b/dexlayout/dexdiag_test.cc index 27ac402120..3cd80b409f 100644 --- a/dexlayout/dexdiag_test.cc +++ b/dexlayout/dexdiag_test.cc @@ -33,9 +33,7 @@ static const char* kDexDiagBinaryName = "dexdiag"; class DexDiagTest : public CommonArtTest { protected: - void SetUp() override { - CommonArtTest::SetUp(); - } + void SetUp() override { CommonArtTest::SetUp(); } // Path to the dexdiag(d?)[32|64] binary. std::string GetDexDiagFilePath() { @@ -63,11 +61,11 @@ class DexDiagTest : public CommonArtTest { EXPECT_TRUE(!oat_location.empty()); std::cout << "==" << oat_location << std::endl; std::string error_msg; - std::unique_ptr<OatFile> oat(OatFile::Open(/*zip_fd=*/ -1, - oat_location.c_str(), - oat_location.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + std::unique_ptr<OatFile> oat(OatFile::Open(/*zip_fd=*/-1, + oat_location, + oat_location, + /*executable=*/false, + /*low_4gb=*/false, &error_msg)); EXPECT_TRUE(oat != nullptr) << error_msg; return oat; @@ -82,8 +80,8 @@ class DexDiagTest : public CommonArtTest { // Build the command line "dexdiag <args> this_pid". std::string executable_path = GetDexDiagFilePath(); - EXPECT_TRUE(OS::FileExists(executable_path.c_str())) << executable_path - << " should be a valid file path"; + EXPECT_TRUE(OS::FileExists(executable_path.c_str())) + << executable_path << " should be a valid file path"; exec_argv.push_back(executable_path); for (const auto& arg : args) { exec_argv.push_back(arg); @@ -102,11 +100,11 @@ class DexDiagTest : public CommonArtTest { TEST_F(DexDiagTest, DexDiagHelpTest) { // TODO: test the resulting output. std::string error_msg; - ASSERT_TRUE(Exec(getpid(), { kDexDiagHelp }, &error_msg)) << "Failed to execute -- because: " - << error_msg; + ASSERT_TRUE(Exec(getpid(), {kDexDiagHelp}, &error_msg)) + << "Failed to execute -- because: " << error_msg; } -#if defined (ART_TARGET) +#if defined(ART_TARGET) TEST_F(DexDiagTest, DexDiagContainsTest) { #else TEST_F(DexDiagTest, DISABLED_DexDiagContainsTest) { @@ -114,11 +112,11 @@ TEST_F(DexDiagTest, DISABLED_DexDiagContainsTest) { std::unique_ptr<OatFile> oat = OpenOatAndVdexFiles(); // TODO: test the resulting output. std::string error_msg; - ASSERT_TRUE(Exec(getpid(), { kDexDiagContains }, &error_msg)) << "Failed to execute -- because: " - << error_msg; + ASSERT_TRUE(Exec(getpid(), {kDexDiagContains}, &error_msg)) + << "Failed to execute -- because: " << error_msg; } -#if defined (ART_TARGET) +#if defined(ART_TARGET) TEST_F(DexDiagTest, DexDiagContainsFailsTest) { #else TEST_F(DexDiagTest, DISABLED_DexDiagContainsFailsTest) { @@ -126,12 +124,11 @@ TEST_F(DexDiagTest, DISABLED_DexDiagContainsFailsTest) { std::unique_ptr<OatFile> oat = OpenOatAndVdexFiles(); // TODO: test the resulting output. std::string error_msg; - ASSERT_FALSE(Exec(getpid(), { kDexDiagContainsFails }, &error_msg)) - << "Failed to execute -- because: " - << error_msg; + ASSERT_FALSE(Exec(getpid(), {kDexDiagContainsFails}, &error_msg)) + << "Failed to execute -- because: " << error_msg; } -#if defined (ART_TARGET) +#if defined(ART_TARGET) TEST_F(DexDiagTest, DexDiagVerboseTest) { #else TEST_F(DexDiagTest, DISABLED_DexDiagVerboseTest) { @@ -139,8 +136,8 @@ TEST_F(DexDiagTest, DISABLED_DexDiagVerboseTest) { // TODO: test the resulting output. std::unique_ptr<OatFile> oat = OpenOatAndVdexFiles(); std::string error_msg; - ASSERT_TRUE(Exec(getpid(), { kDexDiagVerbose }, &error_msg)) << "Failed to execute -- because: " - << error_msg; + ASSERT_TRUE(Exec(getpid(), {kDexDiagVerbose}, &error_msg)) + << "Failed to execute -- because: " << error_msg; } } // namespace art diff --git a/dexoptanalyzer/dexoptanalyzer_test.cc b/dexoptanalyzer/dexoptanalyzer_test.cc index b6b26dbdda..15f71e8fa1 100644 --- a/dexoptanalyzer/dexoptanalyzer_test.cc +++ b/dexoptanalyzer/dexoptanalyzer_test.cc @@ -129,7 +129,7 @@ TEST_F(DexoptAnalyzerTest, OatUpToDate) { std::string dex_location = GetScratchDir() + "/OatUpToDate.jar"; std::string odex_location = GetOdexDir() + "/OatUpToDate.odex"; Copy(GetDexSrc1(), dex_location); - GenerateOdexForTest(dex_location.c_str(), odex_location.c_str(), CompilerFilter::kSpeed); + GenerateOdexForTest(dex_location, odex_location, CompilerFilter::kSpeed); Verify(dex_location, CompilerFilter::kSpeed); Verify(dex_location, CompilerFilter::kVerify); @@ -143,7 +143,7 @@ TEST_F(DexoptAnalyzerTest, ProfileOatUpToDate) { std::string dex_location = GetScratchDir() + "/ProfileOatUpToDate.jar"; std::string odex_location = GetOdexDir() + "/ProfileOatUpToDate.odex"; Copy(GetDexSrc1(), dex_location); - GenerateOdexForTest(dex_location.c_str(), odex_location.c_str(), CompilerFilter::kSpeedProfile); + GenerateOdexForTest(dex_location, odex_location, CompilerFilter::kSpeedProfile); Verify(dex_location, CompilerFilter::kSpeedProfile, ProfileAnalysisResult::kDontOptimizeSmallDelta); @@ -159,7 +159,7 @@ TEST_F(DexoptAnalyzerTest, VerifyAndEmptyProfiles) { std::string odex_location = GetOdexDir() + "/VerifyAndEmptyProfiles.odex"; Copy(GetDexSrc1(), dex_location); - GenerateOdexForTest(dex_location.c_str(), odex_location.c_str(), CompilerFilter::kVerify); + GenerateOdexForTest(dex_location, odex_location, CompilerFilter::kVerify); // If we want to speed-profile something that was verified, do it even if // the profile analysis returns kDontOptimizeSmallDelta (it means that we do have profile data, @@ -186,7 +186,7 @@ TEST_F(DexoptAnalyzerTest, Downgrade) { std::string dex_location = GetScratchDir() + "/Downgrade.jar"; std::string odex_location = GetOdexDir() + "/Downgrade.odex"; Copy(GetDexSrc1(), dex_location); - GenerateOdexForTest(dex_location.c_str(), odex_location.c_str(), CompilerFilter::kVerify); + GenerateOdexForTest(dex_location, odex_location, CompilerFilter::kVerify); Verify(dex_location, CompilerFilter::kSpeedProfile, ProfileAnalysisResult::kDontOptimizeSmallDelta, true); @@ -200,7 +200,7 @@ TEST_F(DexoptAnalyzerTest, MultiDexOatUpToDate) { std::string odex_location = GetOdexDir() + "/MultiDexOatUpToDate.odex"; Copy(GetMultiDexSrc1(), dex_location); - GenerateOdexForTest(dex_location.c_str(), odex_location.c_str(), CompilerFilter::kSpeed); + GenerateOdexForTest(dex_location, odex_location, CompilerFilter::kSpeed); Verify(dex_location, CompilerFilter::kSpeed, ProfileAnalysisResult::kDontOptimizeSmallDelta); } @@ -212,7 +212,7 @@ TEST_F(DexoptAnalyzerTest, MultiDexSecondaryOutOfDate) { // Compile code for GetMultiDexSrc1. Copy(GetMultiDexSrc1(), dex_location); - GenerateOdexForTest(dex_location.c_str(), odex_location.c_str(), CompilerFilter::kSpeed); + GenerateOdexForTest(dex_location, odex_location, CompilerFilter::kSpeed); // Now overwrite the dex file with GetMultiDexSrc2 so the secondary checksum // is out of date. @@ -230,7 +230,7 @@ TEST_F(DexoptAnalyzerTest, OatDexOutOfDate) { // We create a dex, generate an oat for it, then overwrite the dex with a // different dex to make the oat out of date. Copy(GetDexSrc1(), dex_location); - GenerateOdexForTest(dex_location.c_str(), odex_location.c_str(), CompilerFilter::kSpeed); + GenerateOdexForTest(dex_location, odex_location, CompilerFilter::kSpeed); Copy(GetDexSrc2(), dex_location); Verify(dex_location, CompilerFilter::kSpeed); @@ -243,8 +243,8 @@ TEST_F(DexoptAnalyzerTest, OatImageOutOfDate) { std::string odex_location = GetOdexDir() + "/OatImageOutOfDate.odex"; Copy(GetDexSrc1(), dex_location); - GenerateOatForTest(dex_location.c_str(), - odex_location.c_str(), + GenerateOatForTest(dex_location, + odex_location, CompilerFilter::kSpeed, /*with_alternate_image=*/true); diff --git a/libartbase/base/common_art_test.cc b/libartbase/base/common_art_test.cc index 02bfe6fd81..db0e1c157f 100644 --- a/libartbase/base/common_art_test.cc +++ b/libartbase/base/common_art_test.cc @@ -266,7 +266,7 @@ void CommonArtTestImpl::SetUpAndroidRootEnvVars() { const char* android_i18n_root_from_env = getenv("ANDROID_I18N_ROOT"); if (android_i18n_root_from_env == nullptr) { // Use ${ANDROID_I18N_OUT}/com.android.i18n for ANDROID_I18N_ROOT. - std::string android_i18n_root = android_host_out.c_str(); + std::string android_i18n_root = android_host_out; android_i18n_root += "/com.android.i18n"; setenv("ANDROID_I18N_ROOT", android_i18n_root.c_str(), 1); } @@ -277,7 +277,7 @@ void CommonArtTestImpl::SetUpAndroidRootEnvVars() { const char* android_art_root_from_env = getenv("ANDROID_ART_ROOT"); if (android_art_root_from_env == nullptr) { // Use ${ANDROID_HOST_OUT}/com.android.art for ANDROID_ART_ROOT. - std::string android_art_root = android_host_out.c_str(); + std::string android_art_root = android_host_out; android_art_root += "/com.android.art"; setenv("ANDROID_ART_ROOT", android_art_root.c_str(), 1); } @@ -288,7 +288,7 @@ void CommonArtTestImpl::SetUpAndroidRootEnvVars() { const char* android_tzdata_root_from_env = getenv("ANDROID_TZDATA_ROOT"); if (android_tzdata_root_from_env == nullptr) { // Use ${ANDROID_HOST_OUT}/com.android.tzdata for ANDROID_TZDATA_ROOT. - std::string android_tzdata_root = android_host_out.c_str(); + std::string android_tzdata_root = android_host_out; android_tzdata_root += "/com.android.tzdata"; setenv("ANDROID_TZDATA_ROOT", android_tzdata_root.c_str(), 1); } @@ -328,7 +328,7 @@ void CommonArtTestImpl::SetUp() { SetUpAndroidDataDir(android_data_); // Re-use the data temporary directory for /system_ext tests - android_system_ext_.append(android_data_.c_str()); + android_system_ext_.append(android_data_); android_system_ext_.append("/system_ext"); int mkdir_result = mkdir(android_system_ext_.c_str(), 0700); ASSERT_EQ(mkdir_result, 0); @@ -338,7 +338,7 @@ void CommonArtTestImpl::SetUp() { mkdir_result = mkdir(system_ext_framework.c_str(), 0700); ASSERT_EQ(mkdir_result, 0); - dalvik_cache_.append(android_data_.c_str()); + dalvik_cache_.append(android_data_); dalvik_cache_.append("/dalvik-cache"); mkdir_result = mkdir(dalvik_cache_.c_str(), 0700); ASSERT_EQ(mkdir_result, 0); diff --git a/libartbase/base/file_utils.cc b/libartbase/base/file_utils.cc index d2afbcc009..c337d114b7 100644 --- a/libartbase/base/file_utils.cc +++ b/libartbase/base/file_utils.cc @@ -771,7 +771,7 @@ bool LocationIsOnSystem(const std::string& location) { LOG(FATAL) << "LocationIsOnSystem is unsupported on Windows."; return false; #else - return android::base::StartsWith(location, GetAndroidRoot().c_str()); + return android::base::StartsWith(location, GetAndroidRoot()); #endif } diff --git a/libartbase/base/file_utils_test.cc b/libartbase/base/file_utils_test.cc index dff4478549..e660f35d94 100644 --- a/libartbase/base/file_utils_test.cc +++ b/libartbase/base/file_utils_test.cc @@ -36,9 +36,8 @@ class ScopedOverrideDalvikCacheSubDirectory { OverrideDalvikCacheSubDirectory(override); } - ~ScopedOverrideDalvikCacheSubDirectory() { - OverrideDalvikCacheSubDirectory("dalvik-cache"); - } + ~ScopedOverrideDalvikCacheSubDirectory() { OverrideDalvikCacheSubDirectory("dalvik-cache"); } + private: DISALLOW_COPY_AND_ASSIGN(ScopedOverrideDalvikCacheSubDirectory); }; @@ -104,7 +103,7 @@ TEST_F(FileUtilsTest, DISABLED_GetAndroidRootSafe) { // broken. On non-bionic. On bionic we can be running with a different libartbase that lives // outside of ANDROID_ROOT. UniqueCPtr<char> real_root3(realpath(android_root3.c_str(), nullptr)); -#if !defined(__BIONIC__ ) || defined(__ANDROID__) +#if !defined(__BIONIC__) || defined(__ANDROID__) UniqueCPtr<char> real_root(realpath(android_root.c_str(), nullptr)); EXPECT_STREQ(real_root.get(), real_root3.get()) << error_msg; #else @@ -158,7 +157,7 @@ TEST_F(FileUtilsTest, GetArtRootSafe) { // the test setup is broken. On non-bionic. On bionic we can be running // with a different libartbase that lives outside of ANDROID_ART_ROOT. UniqueCPtr<char> real_root3(realpath(android_art_root3.c_str(), nullptr)); -#if !defined(__BIONIC__ ) || defined(__ANDROID__) +#if !defined(__BIONIC__) || defined(__ANDROID__) UniqueCPtr<char> real_root(realpath(android_art_root.c_str(), nullptr)); EXPECT_STREQ(real_root.get(), real_root3.get()) << error_msg; #else @@ -195,11 +194,10 @@ TEST_F(FileUtilsTest, GetApexDataOatFilename) { GetApexDataOatFilename("/product/javalib/beep.jar", InstructionSet::kArm)); const std::string art_apex_jar = std::string {kAndroidArtApexDefaultPath} + "/javalib/some.jar"; - EXPECT_EQ(std::string {}, GetApexDataOatFilename(art_apex_jar.c_str(), InstructionSet::kArm)); + EXPECT_EQ(std::string{}, GetApexDataOatFilename(art_apex_jar, InstructionSet::kArm)); - const std::string i18n_jar = - std::string {kAndroidI18nApexDefaultPath} + "/javalib/core-icu4j.jar"; - EXPECT_EQ(std::string {}, GetApexDataOatFilename(i18n_jar, InstructionSet::kArm)); + const std::string i18n_jar = std::string{kAndroidI18nApexDefaultPath} + "/javalib/core-icu4j.jar"; + EXPECT_EQ(std::string{}, GetApexDataOatFilename(i18n_jar, InstructionSet::kArm)); const std::string system_jar_apexdata_oat = GetArtApexData() + "/dalvik-cache/x86/boot-lace.oat"; EXPECT_EQ(system_jar_apexdata_oat, @@ -216,13 +214,12 @@ TEST_F(FileUtilsTest, GetApexDataOdexFilename) { const std::string art_apex_jar = std::string {kAndroidArtApexDefaultPath} + "/javalib/some.jar"; EXPECT_EQ( GetArtApexData() + "/dalvik-cache/arm/apex@com.android.art@javalib@some.jar@classes.odex", - GetApexDataOdexFilename(art_apex_jar.c_str(), InstructionSet::kArm)); + GetApexDataOdexFilename(art_apex_jar, InstructionSet::kArm)); - const std::string i18n_jar = - std::string {kAndroidI18nApexDefaultPath} + "/javalib/core-icu4j.jar"; + const std::string i18n_jar = std::string{kAndroidI18nApexDefaultPath} + "/javalib/core-icu4j.jar"; EXPECT_EQ(GetArtApexData() + "/dalvik-cache/arm/apex@com.android.i18n@javalib@core-icu4j.jar@classes.odex", - GetApexDataOdexFilename(i18n_jar.c_str(), InstructionSet::kArm)); + GetApexDataOdexFilename(i18n_jar, InstructionSet::kArm)); const std::string system_jar_apexdata_odex = GetArtApexData() + "/dalvik-cache/x86/system@framework@cookie.jar@classes.odex"; @@ -234,20 +231,20 @@ TEST_F(FileUtilsTest, GetApexDataBootImage) { ScopedUnsetEnvironmentVariable android_root("ANDROID_ROOT"); ScopedUnsetEnvironmentVariable art_apex_data("ART_APEX_DATA"); - EXPECT_EQ(std::string {}, - GetApexDataBootImage(std::string {kAndroidI18nApexDefaultPath} + "/javalib/bar.jar")); + EXPECT_EQ(std::string{}, + GetApexDataBootImage(std::string{kAndroidI18nApexDefaultPath} + "/javalib/bar.jar")); // Check image location has the prefix "boot-" in front of the basename of dex location and // that image suffix is .art. const std::string system_jar = "/system/framework/disk.jar"; - const std::string boot_image = GetApexDataBootImage(system_jar.c_str()); + const std::string boot_image = GetApexDataBootImage(system_jar); EXPECT_EQ(GetArtApexData() + "/dalvik-cache/boot-disk.art", boot_image); // Check the image filename corresponds to the oat file for the same system jar. const InstructionSet isa = InstructionSet::kArm64; const std::string boot_image_filename = GetSystemImageFilename(boot_image.c_str(), isa); const std::string accompanying_oat_file = ReplaceFileExtension(boot_image_filename, "oat"); - EXPECT_EQ(accompanying_oat_file, GetApexDataOatFilename(system_jar.c_str(), isa)); + EXPECT_EQ(accompanying_oat_file, GetApexDataOatFilename(system_jar, isa)); } TEST_F(FileUtilsTest, GetApexDataImage) { @@ -308,7 +305,7 @@ TEST_F(FileUtilsTest, OverrideDalvikCacheSubDirectory) { GetApexDataOdexFilename("/data/some/code.dex", InstructionSet::kArm)); const std::string system_jar = "/system/framework/disk.jar"; - const std::string boot_image = GetApexDataBootImage(system_jar.c_str()); + const std::string boot_image = GetApexDataBootImage(system_jar); EXPECT_EQ(GetArtApexData() + "/overridden-cache/boot-disk.art", boot_image); EXPECT_EQ( @@ -327,7 +324,7 @@ TEST_F(FileUtilsTest, GetSystemOdexFilenameForApex) { const std::string apex_jar = std::string {kAndroidArtApexDefaultPath} + "/javalib/some.jar"; EXPECT_EQ( GetAndroidRoot() + "/framework/oat/arm/apex@com.android.art@javalib@some.jar@classes.odex", - GetSystemOdexFilenameForApex(apex_jar.c_str(), InstructionSet::kArm)); + GetSystemOdexFilenameForApex(apex_jar, InstructionSet::kArm)); } TEST_F(FileUtilsTest, ApexNameFromLocation) { diff --git a/oatdump/oatdump.cc b/oatdump/oatdump.cc index 6f75fbd9d5..9dd704aa06 100644 --- a/oatdump/oatdump.cc +++ b/oatdump/oatdump.cc @@ -3020,7 +3020,7 @@ class IMTDumper { table_index++; std::string p_name = ptr2->PrettyMethod(true); - if (android::base::StartsWith(p_name, method.c_str())) { + if (android::base::StartsWith(p_name, method)) { std::cerr << " Slot " << index << " (" @@ -3033,7 +3033,7 @@ class IMTDumper { } } else { std::string p_name = ptr->PrettyMethod(true); - if (android::base::StartsWith(p_name, method.c_str())) { + if (android::base::StartsWith(p_name, method)) { std::cerr << " Slot " << index << " (1)" << std::endl; std::cerr << " " << p_name << std::endl; } else { @@ -3046,7 +3046,7 @@ class IMTDumper { for (ArtMethod& iface_method : iface->GetMethods(pointer_size)) { if (ImTable::GetImtIndex(&iface_method) == index) { std::string i_name = iface_method.PrettyMethod(true); - if (android::base::StartsWith(i_name, method.c_str())) { + if (android::base::StartsWith(i_name, method)) { std::cerr << " Slot " << index << " (1)" << std::endl; std::cerr << " " << p_name << " (" << i_name << ")" << std::endl; } diff --git a/odrefresh/odr_fs_utils_test.cc b/odrefresh/odr_fs_utils_test.cc index d460be28a0..0adc1d1635 100644 --- a/odrefresh/odr_fs_utils_test.cc +++ b/odrefresh/odr_fs_utils_test.cc @@ -136,12 +136,12 @@ TEST_F(OdrFsUtilsTest, DISABLED_GetUsedSpace) { ASSERT_EQ(kFirstFileBytes, static_cast<decltype(kFirstFileBytes)>(sb.st_size)); uint64_t bytes_used = 0; - ASSERT_TRUE(GetUsedSpace(scratch_dir.GetPath().c_str(), &bytes_used)); + ASSERT_TRUE(GetUsedSpace(scratch_dir.GetPath(), &bytes_used)); const std::string second_file_path = scratch_dir.GetPath() + "/2.dat"; ASSERT_TRUE(CreateFile(second_file_path.c_str(), kSecondFileBytes)); - ASSERT_TRUE(GetUsedSpace(scratch_dir.GetPath().c_str(), &bytes_used)); + ASSERT_TRUE(GetUsedSpace(scratch_dir.GetPath(), &bytes_used)); uint64_t expected_bytes_used = RoundUp(kFirstFileBytes, sb.st_blocks * kBytesPerBlock) + RoundUp(kSecondFileBytes, sb.st_blocks * kBytesPerBlock); ASSERT_EQ(expected_bytes_used, bytes_used); @@ -152,7 +152,7 @@ TEST_F(OdrFsUtilsTest, DISABLED_GetUsedSpace) { const std::string path = android::base::StringPrintf("%s/%zu", sub_dir_path.c_str(), i); ASSERT_TRUE(CreateFile(path.c_str(), i)); expected_bytes_used += RoundUp(i, sb.st_blocks * kBytesPerBlock); - ASSERT_TRUE(GetUsedSpace(scratch_dir.GetPath().c_str(), &bytes_used)); + ASSERT_TRUE(GetUsedSpace(scratch_dir.GetPath(), &bytes_used)); ASSERT_EQ(expected_bytes_used, bytes_used); } } diff --git a/odrefresh/odrefresh.cc b/odrefresh/odrefresh.cc index 346313eb1e..86921d98b0 100644 --- a/odrefresh/odrefresh.cc +++ b/odrefresh/odrefresh.cc @@ -825,7 +825,7 @@ std::string OnDeviceRefresh::GetSystemServerImagePath(bool on_system, } else { // Typically // "/data/misc/apexdata/.../dalvik-cache/<isa>/system@framework@services.jar@classes.art". - const std::string image = GetApexDataImage(jar_path.c_str()); + const std::string image = GetApexDataImage(jar_path); return GetSystemImageFilename(image.c_str(), config_.GetSystemServerIsa()); } } @@ -1653,7 +1653,7 @@ WARN_UNUSED bool OnDeviceRefresh::CompileSystemServerArtifacts( } OdrArtifacts artifacts = OdrArtifacts::ForSystemServer(image_location); - CHECK_EQ(artifacts.OatPath(), GetApexDataOdexFilename(jar.c_str(), isa)); + CHECK_EQ(artifacts.OatPath(), GetApexDataOdexFilename(jar, isa)); const std::pair<const std::string, const char*> location_kind_pairs[] = { std::make_pair(artifacts.ImagePath(), "app-image"), diff --git a/runtime/art_method_test.cc b/runtime/art_method_test.cc index b71f8a39e4..b1e9ed3879 100644 --- a/runtime/art_method_test.cc +++ b/runtime/art_method_test.cc @@ -51,7 +51,7 @@ class ArtMethodTest : public CommonRuntimeTest { ASSERT_STREQ(value_of->GetName(), "valueOf"); std::string unbox_signature = std::string("()") + kPrimitive; ArtMethod* unbox_method = value_of->GetDeclaringClass()->FindClassMethod( - unbox_name, unbox_signature.c_str(), kRuntimePointerSize); + unbox_name, unbox_signature, kRuntimePointerSize); ASSERT_TRUE(unbox_method != nullptr); ASSERT_FALSE(unbox_method->IsStatic()); ASSERT_TRUE(value_of->GetDeclaringClass()->IsFinal()); diff --git a/runtime/class_loader_context.cc b/runtime/class_loader_context.cc index 074a819d0a..2f34f04f5b 100644 --- a/runtime/class_loader_context.cc +++ b/runtime/class_loader_context.cc @@ -63,8 +63,7 @@ static constexpr char kDexFileChecksumSeparator = '*'; static constexpr char kInMemoryDexClassLoaderDexLocationMagic[] = "<unknown>"; ClassLoaderContext::ClassLoaderContext() - : dex_files_state_(ContextDexFilesState::kDexFilesNotOpened), - owns_the_dex_files_(true) {} + : dex_files_state_(ContextDexFilesState::kDexFilesNotOpened), owns_the_dex_files_(true) {} ClassLoaderContext::ClassLoaderContext(bool owns_the_dex_files) : dex_files_state_(ContextDexFilesState::kDexFilesOpened), @@ -72,9 +71,8 @@ ClassLoaderContext::ClassLoaderContext(bool owns_the_dex_files) // Utility method to add parent and shared libraries of `info` into // the `work_list`. -static void AddToWorkList( - ClassLoaderContext::ClassLoaderInfo* info, - std::vector<ClassLoaderContext::ClassLoaderInfo*>& work_list) { +static void AddToWorkList(ClassLoaderContext::ClassLoaderInfo* info, + std::vector<ClassLoaderContext::ClassLoaderInfo*>& work_list) { if (info->parent != nullptr) { work_list.push_back(info->parent.get()); } @@ -106,9 +104,7 @@ ClassLoaderContext::~ClassLoaderContext() { } } -std::unique_ptr<ClassLoaderContext> ClassLoaderContext::Default() { - return Create(""); -} +std::unique_ptr<ClassLoaderContext> ClassLoaderContext::Default() { return Create(""); } std::unique_ptr<ClassLoaderContext> ClassLoaderContext::Create(const std::string& spec) { std::unique_ptr<ClassLoaderContext> result(new ClassLoaderContext()); @@ -127,8 +123,7 @@ static size_t FindMatchingSharedLibraryCloseMarker(const std::string& spec, uint32_t string_index = shared_library_open_index + 1; size_t shared_library_close = std::string::npos; while (counter != 0) { - shared_library_close = - spec.find_first_of(kClassLoaderSharedLibraryClosingMark, string_index); + shared_library_close = spec.find_first_of(kClassLoaderSharedLibraryClosingMark, string_index); size_t shared_library_open = spec.find_first_of(kClassLoaderSharedLibraryOpeningMark, string_index); if (shared_library_close == std::string::npos) { @@ -156,8 +151,7 @@ static size_t FindMatchingSharedLibraryCloseMarker(const std::string& spec, // "ClassLoaderType1[ClasspathElem1*Checksum1:ClasspathElem2*Checksum2...]{ClassLoaderType2[...]}". // The checksum part of the format is expected only if parse_cheksums is true. std::unique_ptr<ClassLoaderContext::ClassLoaderInfo> ClassLoaderContext::ParseClassLoaderSpec( - const std::string& class_loader_spec, - bool parse_checksums) { + const std::string& class_loader_spec, bool parse_checksums) { ClassLoaderType class_loader_type = ExtractClassLoaderType(class_loader_spec); if (class_loader_type == kInvalidClassLoader) { return nullptr; @@ -200,8 +194,8 @@ std::unique_ptr<ClassLoaderContext::ClassLoaderInfo> ClassLoaderContext::ParseCl // At this point we know the format is ok; continue and extract the classpath. // Note that class loaders with an empty class path are allowed. - std::string classpath = class_loader_spec.substr(type_str_size + 1, - closing_index - type_str_size - 1); + std::string classpath = + class_loader_spec.substr(type_str_size + 1, closing_index - type_str_size - 1); std::unique_ptr<ClassLoaderInfo> info(new ClassLoaderInfo(class_loader_type)); @@ -299,7 +293,7 @@ std::unique_ptr<ClassLoaderContext::ClassLoaderInfo> ClassLoaderContext::ParseCl } std::unique_ptr<ClassLoaderInfo> shared_library_info( - ParseInternal(shared_library_spec, parse_checksums)); + ParseInternal(shared_library_spec, parse_checksums)); if (shared_library_info == nullptr) { return nullptr; } @@ -317,11 +311,10 @@ std::unique_ptr<ClassLoaderContext::ClassLoaderInfo> ClassLoaderContext::ParseCl // Extracts the class loader type from the given spec. // Return ClassLoaderContext::kInvalidClassLoader if the class loader type is not // recognized. -ClassLoaderContext::ClassLoaderType -ClassLoaderContext::ExtractClassLoaderType(const std::string& class_loader_spec) { - const ClassLoaderType kValidTypes[] = { kPathClassLoader, - kDelegateLastClassLoader, - kInMemoryDexClassLoader }; +ClassLoaderContext::ClassLoaderType ClassLoaderContext::ExtractClassLoaderType( + const std::string& class_loader_spec) { + const ClassLoaderType kValidTypes[] = { + kPathClassLoader, kDelegateLastClassLoader, kInMemoryDexClassLoader}; for (const ClassLoaderType& type : kValidTypes) { const char* type_str = GetClassLoaderTypeName(type); if (class_loader_spec.compare(0, strlen(type_str), type_str) == 0) { @@ -348,8 +341,8 @@ bool ClassLoaderContext::Parse(const std::string& spec, bool parse_checksums) { return class_loader_chain_ != nullptr; } -ClassLoaderContext::ClassLoaderInfo* ClassLoaderContext::ParseInternal( - const std::string& spec, bool parse_checksums) { +ClassLoaderContext::ClassLoaderInfo* ClassLoaderContext::ParseInternal(const std::string& spec, + bool parse_checksums) { CHECK(!spec.empty()); std::string remaining = spec; std::unique_ptr<ClassLoaderInfo> first(nullptr); @@ -391,8 +384,8 @@ ClassLoaderContext::ClassLoaderInfo* ClassLoaderContext::ParseInternal( LOG(ERROR) << "Invalid class loader spec: " << class_loader_spec; return nullptr; } else { - remaining = remaining.substr(shared_library_close + 2, - remaining.size() - shared_library_close - 2); + remaining = + remaining.substr(shared_library_close + 2, remaining.size() - shared_library_close - 2); } } @@ -420,9 +413,12 @@ bool ClassLoaderContext::OpenDexFiles(const std::string& classpath_dir, const std::vector<int>& fds, bool only_read_checksums) { switch (dex_files_state_) { - case kDexFilesNotOpened: break; // files not opened, continue. - case kDexFilesOpenFailed: return false; // previous attempt failed. - case kDexFilesOpened: return true; // previous attempt succeed. + case kDexFilesNotOpened: + break; // files not opened, continue. + case kDexFilesOpenFailed: + return false; // previous attempt failed. + case kDexFilesOpened: + return true; // previous attempt succeed. case kDexFilesChecksumsRead: if (only_read_checksums) { return true; // we already read the checksums. @@ -531,7 +527,7 @@ bool ClassLoaderContext::OpenDexFiles(const std::string& classpath_dir, // as we have encountered while iterating over this class loader context. if (dex_file_index != fds.size()) { LOG(WARNING) << fds.size() << " FDs provided but only " << dex_file_index - << " dex files are in the class loader context"; + << " dex files are in the class loader context"; dex_files_state_ = kDexFilesOpenFailed; } @@ -558,13 +554,13 @@ bool ClassLoaderContext::RemoveLocationsFromClassPaths( ClassLoaderInfo* info = work_list.back(); work_list.pop_back(); size_t initial_size = info->classpath.size(); - auto kept_it = std::remove_if( - info->classpath.begin(), - info->classpath.end(), - [canonical_locations](const std::string& location) { - return ContainsElement(canonical_locations, - DexFileLoader::GetDexCanonicalLocation(location.c_str())); - }); + auto kept_it = std::remove_if(info->classpath.begin(), + info->classpath.end(), + [canonical_locations](const std::string& location) { + return ContainsElement( + canonical_locations, + DexFileLoader::GetDexCanonicalLocation(location.c_str())); + }); info->classpath.erase(kept_it, info->classpath.end()); if (initial_size != info->classpath.size()) { removed_locations = true; @@ -575,16 +571,16 @@ bool ClassLoaderContext::RemoveLocationsFromClassPaths( } std::string ClassLoaderContext::EncodeContextForDex2oat(const std::string& base_dir) const { - return EncodeContext(base_dir, /*for_dex2oat=*/ true, /*stored_context=*/ nullptr); + return EncodeContext(base_dir, /*for_dex2oat=*/true, /*stored_context=*/nullptr); } std::string ClassLoaderContext::EncodeContextForOatFile(const std::string& base_dir, ClassLoaderContext* stored_context) const { - return EncodeContext(base_dir, /*for_dex2oat=*/ false, stored_context); + return EncodeContext(base_dir, /*for_dex2oat=*/false, stored_context); } -std::map<std::string, std::string> -ClassLoaderContext::EncodeClassPathContexts(const std::string& base_dir) const { +std::map<std::string, std::string> ClassLoaderContext::EncodeClassPathContexts( + const std::string& base_dir) const { CheckDexFilesOpened("EncodeClassPathContexts"); if (class_loader_chain_ == nullptr) { return std::map<std::string, std::string>{}; @@ -636,8 +632,7 @@ std::string ClassLoaderContext::EncodeContext(const std::string& base_dir, if (class_loader_chain_ == nullptr) { // We can get in this situation if the context was created with a class path containing the // source dex files which were later removed (happens during run-tests). - out << GetClassLoaderTypeName(kPathClassLoader) - << kClassLoaderOpeningMark + out << GetClassLoaderTypeName(kPathClassLoader) << kClassLoaderOpeningMark << kClassLoaderClosingMark; return out.str(); } @@ -667,8 +662,7 @@ void ClassLoaderContext::EncodeClassPath(const std::string& base_dir, } if (type == kInMemoryDexClassLoader) { out << kInMemoryDexClassLoaderDexLocationMagic; - } else if (!base_dir.empty() - && location.substr(0, base_dir.length()) == base_dir) { + } else if (!base_dir.empty() && location.substr(0, base_dir.length()) == base_dir) { // Find paths that were relative and convert them back from absolute. out << location.substr(base_dir.length() + 1).c_str(); } else { @@ -703,8 +697,8 @@ void ClassLoaderContext::EncodeContextInternal(const ClassLoaderInfo& info, if (for_dex2oat) { // dex2oat only needs the base location. It cannot accept multidex locations. // So ensure we only add each file once. - bool new_insert = seen_locations.insert( - DexFileLoader::GetBaseLocation(dex_file->GetLocation())).second; + bool new_insert = + seen_locations.insert(DexFileLoader::GetBaseLocation(dex_file->GetLocation())).second; if (!new_insert) { continue; } @@ -765,12 +759,11 @@ void ClassLoaderContext::EncodeSharedLibAndParent(const ClassLoaderInfo& info, } if (info.parent != nullptr) { out << kClassLoaderSeparator; - EncodeContextInternal( - *info.parent.get(), - base_dir, - for_dex2oat, - (stored_info == nullptr ? nullptr : stored_info->parent.get()), - out); + EncodeContextInternal(*info.parent.get(), + base_dir, + for_dex2oat, + (stored_info == nullptr ? nullptr : stored_info->parent.get()), + out); } } @@ -784,7 +777,8 @@ static ObjPtr<mirror::Class> GetClassLoaderClass(ClassLoaderContext::ClassLoader return WellKnownClasses::dalvik_system_DelegateLastClassLoader.Get(); case ClassLoaderContext::kInMemoryDexClassLoader: return WellKnownClasses::dalvik_system_InMemoryDexClassLoader.Get(); - case ClassLoaderContext::kInvalidClassLoader: break; // will fail after the switch. + case ClassLoaderContext::kInvalidClassLoader: + break; // will fail after the switch. } LOG(FATAL) << "Invalid class loader type " << type; UNREACHABLE(); @@ -802,8 +796,7 @@ static ObjPtr<mirror::ClassLoader> CreateClassLoaderInternal( VariableSizedHandleScope& map_scope, std::map<std::string, Handle<mirror::ClassLoader>>& canonicalized_libraries, bool add_compilation_sources, - const std::vector<const DexFile*>& compilation_sources) - REQUIRES_SHARED(Locks::mutator_lock_) { + const std::vector<const DexFile*>& compilation_sources) REQUIRES_SHARED(Locks::mutator_lock_) { if (for_shared_library) { // Check if the shared library has already been created. auto search = canonicalized_libraries.find(FlattenClasspath(info.classpath)); @@ -816,7 +809,7 @@ static ObjPtr<mirror::ClassLoader> CreateClassLoaderInternal( MutableHandle<mirror::ObjectArray<mirror::ClassLoader>> libraries( hs.NewHandle<mirror::ObjectArray<mirror::ClassLoader>>(nullptr)); MutableHandle<mirror::ObjectArray<mirror::ClassLoader>> libraries_after( - hs.NewHandle<mirror::ObjectArray<mirror::ClassLoader>>(nullptr)); + hs.NewHandle<mirror::ObjectArray<mirror::ClassLoader>>(nullptr)); if (!info.shared_libraries.empty()) { libraries.Assign(mirror::ObjectArray<mirror::ClassLoader>::Alloc( @@ -826,15 +819,14 @@ static ObjPtr<mirror::ClassLoader> CreateClassLoaderInternal( for (uint32_t i = 0; i < info.shared_libraries.size(); ++i) { // We should only add the compilation sources to the first class loader. libraries->Set(i, - CreateClassLoaderInternal( - self, - soa, - *info.shared_libraries[i].get(), - /* for_shared_library= */ true, - map_scope, - canonicalized_libraries, - /* add_compilation_sources= */ false, - compilation_sources)); + CreateClassLoaderInternal(self, + soa, + *info.shared_libraries[i].get(), + /* for_shared_library= */ true, + map_scope, + canonicalized_libraries, + /* add_compilation_sources= */ false, + compilation_sources)); } } @@ -846,50 +838,41 @@ static ObjPtr<mirror::ClassLoader> CreateClassLoaderInternal( for (uint32_t i = 0; i < info.shared_libraries_after.size(); ++i) { // We should only add the compilation sources to the first class loader. libraries_after->Set(i, - CreateClassLoaderInternal( - self, - soa, - *info.shared_libraries_after[i].get(), - /* for_shared_library= */ true, - map_scope, - canonicalized_libraries, - /* add_compilation_sources= */ false, - compilation_sources)); + CreateClassLoaderInternal(self, + soa, + *info.shared_libraries_after[i].get(), + /* for_shared_library= */ true, + map_scope, + canonicalized_libraries, + /* add_compilation_sources= */ false, + compilation_sources)); } } MutableHandle<mirror::ClassLoader> parent = hs.NewHandle<mirror::ClassLoader>(nullptr); if (info.parent != nullptr) { // We should only add the compilation sources to the first class loader. - parent.Assign(CreateClassLoaderInternal( - self, - soa, - *info.parent.get(), - /* for_shared_library= */ false, - map_scope, - canonicalized_libraries, - /* add_compilation_sources= */ false, - compilation_sources)); - } - std::vector<const DexFile*> class_path_files = MakeNonOwningPointerVector( - info.opened_dex_files); + parent.Assign(CreateClassLoaderInternal(self, + soa, + *info.parent.get(), + /* for_shared_library= */ false, + map_scope, + canonicalized_libraries, + /* add_compilation_sources= */ false, + compilation_sources)); + } + std::vector<const DexFile*> class_path_files = MakeNonOwningPointerVector(info.opened_dex_files); if (add_compilation_sources) { // For the first class loader, its classpath comes first, followed by compilation sources. // This ensures that whenever we need to resolve classes from it the classpath elements // come first. - class_path_files.insert(class_path_files.end(), - compilation_sources.begin(), - compilation_sources.end()); + class_path_files.insert( + class_path_files.end(), compilation_sources.begin(), compilation_sources.end()); } Handle<mirror::Class> loader_class = hs.NewHandle<mirror::Class>(GetClassLoaderClass(info.type)); ObjPtr<mirror::ClassLoader> loader = Runtime::Current()->GetClassLinker()->CreateWellKnownClassLoader( - self, - class_path_files, - loader_class, - parent, - libraries, - libraries_after); + self, class_path_files, loader_class, parent, libraries, libraries_after); if (for_shared_library) { canonicalized_libraries[FlattenClasspath(info.classpath)] = map_scope.NewHandle<mirror::ClassLoader>(loader); @@ -922,8 +905,7 @@ jobject ClassLoaderContext::CreateClassLoader( /* add_compilation_sources= */ true, compilation_sources); // Make it a global ref and return. - ScopedLocalRef<jobject> local_ref( - soa.Env(), soa.Env()->AddLocalReference<jobject>(loader)); + ScopedLocalRef<jobject> local_ref(soa.Env(), soa.Env()->AddLocalReference<jobject>(loader)); return soa.Env()->NewGlobalRef(local_ref.get()); } @@ -969,9 +951,12 @@ std::vector<std::string> ClassLoaderContext::FlattenDexPaths() const { const char* ClassLoaderContext::GetClassLoaderTypeName(ClassLoaderType type) { switch (type) { - case kPathClassLoader: return kPathClassLoaderString; - case kDelegateLastClassLoader: return kDelegateLastClassLoaderString; - case kInMemoryDexClassLoader: return kInMemoryDexClassLoaderString; + case kPathClassLoader: + return kPathClassLoaderString; + case kDelegateLastClassLoader: + return kDelegateLastClassLoaderString; + case kInMemoryDexClassLoader: + return kInMemoryDexClassLoaderString; default: LOG(FATAL) << "Invalid class loader type " << type; UNREACHABLE(); @@ -989,7 +974,7 @@ void ClassLoaderContext::CheckDexFilesOpened(const std::string& calling_method) static bool CollectDexFilesFromJavaDexFile(ObjPtr<mirror::Object> java_dex_file, ArtField* const cookie_field, std::vector<const DexFile*>* out_dex_files) - REQUIRES_SHARED(Locks::mutator_lock_) { + REQUIRES_SHARED(Locks::mutator_lock_) { if (java_dex_file == nullptr) { return true; } @@ -1020,7 +1005,7 @@ static bool CollectDexFilesFromJavaDexFile(ObjPtr<mirror::Object> java_dex_file, static bool CollectDexFilesFromSupportedClassLoader(Thread* self, Handle<mirror::ClassLoader> class_loader, std::vector<const DexFile*>* out_dex_files) - REQUIRES_SHARED(Locks::mutator_lock_) { + REQUIRES_SHARED(Locks::mutator_lock_) { CHECK(IsInstanceOfBaseDexClassLoader(class_loader)); // All supported class loaders inherit from BaseDexClassLoader. @@ -1114,13 +1099,12 @@ static bool GetDexFilesFromDexElementsArray( // This method is recursive (w.r.t. the class loader parent) and will stop once it reaches the // BootClassLoader. Note that the class loader chain is expected to be short. bool ClassLoaderContext::CreateInfoFromClassLoader( - ScopedObjectAccessAlreadyRunnable& soa, - Handle<mirror::ClassLoader> class_loader, - Handle<mirror::ObjectArray<mirror::Object>> dex_elements, - ClassLoaderInfo* child_info, - bool is_shared_library, - bool is_after) - REQUIRES_SHARED(Locks::mutator_lock_) { + ScopedObjectAccessAlreadyRunnable& soa, + Handle<mirror::ClassLoader> class_loader, + Handle<mirror::ObjectArray<mirror::Object>> dex_elements, + ClassLoaderInfo* child_info, + bool is_shared_library, + bool is_after) REQUIRES_SHARED(Locks::mutator_lock_) { if (ClassLinker::IsBootClassLoader(class_loader.Get())) { // Nothing to do for the boot class loader as we don't add its dex files to the context. return true; @@ -1174,9 +1158,9 @@ bool ClassLoaderContext::CreateInfoFromClassLoader( for (const DexFile* dex_file : dex_files_loaded) { // Dex location of dex files loaded with InMemoryDexClassLoader is always bogus. // Use a magic value for the classpath instead. - info->classpath.push_back((type == kInMemoryDexClassLoader) - ? kInMemoryDexClassLoaderDexLocationMagic - : dex_file->GetLocation()); + info->classpath.push_back((type == kInMemoryDexClassLoader) ? + kInMemoryDexClassLoaderDexLocationMagic : + dex_file->GetLocation()); info->checksums.push_back(dex_file->GetLocationChecksum()); info->opened_dex_files.emplace_back(dex_file); } @@ -1199,8 +1183,8 @@ bool ClassLoaderContext::CreateInfoFromClassLoader( temp_loader, null_dex_elements, info, - /*is_shared_library=*/ true, - /*is_after=*/ false)) { + /*is_shared_library=*/true, + /*is_after=*/false)) { return false; } } @@ -1217,8 +1201,8 @@ bool ClassLoaderContext::CreateInfoFromClassLoader( temp_loader, null_dex_elements, info, - /*is_shared_library=*/ true, - /*is_after=*/ true)) { + /*is_shared_library=*/true, + /*is_after=*/true)) { return false; } } @@ -1230,16 +1214,15 @@ bool ClassLoaderContext::CreateInfoFromClassLoader( parent, null_dex_elements, info, - /*is_shared_library=*/ false, - /*is_after=*/ false)) { + /*is_shared_library=*/false, + /*is_after=*/false)) { return false; } return true; } std::unique_ptr<ClassLoaderContext> ClassLoaderContext::CreateContextForClassLoader( - jobject class_loader, - jobjectArray dex_elements) { + jobject class_loader, jobjectArray dex_elements) { ScopedTrace trace(__FUNCTION__); if (class_loader == nullptr) { @@ -1251,20 +1234,20 @@ std::unique_ptr<ClassLoaderContext> ClassLoaderContext::CreateContextForClassLoa hs.NewHandle(soa.Decode<mirror::ClassLoader>(class_loader)); Handle<mirror::ObjectArray<mirror::Object>> h_dex_elements = hs.NewHandle(soa.Decode<mirror::ObjectArray<mirror::Object>>(dex_elements)); - std::unique_ptr<ClassLoaderContext> result(new ClassLoaderContext(/*owns_the_dex_files=*/ false)); + std::unique_ptr<ClassLoaderContext> result(new ClassLoaderContext(/*owns_the_dex_files=*/false)); if (!result->CreateInfoFromClassLoader(soa, h_class_loader, h_dex_elements, nullptr, - /*is_shared_library=*/ false, - /*is_after=*/ false)) { + /*is_shared_library=*/false, + /*is_after=*/false)) { return nullptr; } return result; } -std::map<std::string, std::string> -ClassLoaderContext::EncodeClassPathContextsForClassLoader(jobject class_loader) { +std::map<std::string, std::string> ClassLoaderContext::EncodeClassPathContextsForClassLoader( + jobject class_loader) { std::unique_ptr<ClassLoaderContext> clc = ClassLoaderContext::CreateContextForClassLoader(class_loader, nullptr); if (clc != nullptr) { @@ -1291,14 +1274,12 @@ ClassLoaderContext::EncodeClassPathContextsForClassLoader(jobject class_loader) } bool ClassLoaderContext::IsValidEncoding(const std::string& possible_encoded_class_loader_context) { - return ClassLoaderContext::Create(possible_encoded_class_loader_context.c_str()) != nullptr - || possible_encoded_class_loader_context == kUnsupportedClassLoaderContextEncoding; + return ClassLoaderContext::Create(possible_encoded_class_loader_context) != nullptr || + possible_encoded_class_loader_context == kUnsupportedClassLoaderContextEncoding; } ClassLoaderContext::VerificationResult ClassLoaderContext::VerifyClassLoaderContextMatch( - const std::string& context_spec, - bool verify_names, - bool verify_checksums) const { + const std::string& context_spec, bool verify_names, bool verify_checksums) const { ScopedTrace trace(__FUNCTION__); if (verify_names || verify_checksums) { DCHECK(dex_files_state_ == kDexFilesChecksumsRead || dex_files_state_ == kDexFilesOpened) @@ -1328,8 +1309,7 @@ static inline bool AbsolutePathHasRelativeSuffix(const std::string& path, const std::string& suffix) { DCHECK(IsAbsoluteLocation(path)); DCHECK(!IsAbsoluteLocation(suffix)); - return (path.size() > suffix.size()) && - (path[path.size() - suffix.size() - 1u] == '/') && + return (path.size() > suffix.size()) && (path[path.size() - suffix.size() - 1u] == '/') && (std::string_view(path).substr(/*pos*/ path.size() - suffix.size()) == suffix); } @@ -1394,24 +1374,23 @@ static bool AreDexNameMatching(const std::string& actual_dex_name, return dex_names_match; } -bool ClassLoaderContext::ClassLoaderInfoMatch( - const ClassLoaderInfo& info, - const ClassLoaderInfo& expected_info, - const std::string& context_spec, - bool verify_names, - bool verify_checksums) const { +bool ClassLoaderContext::ClassLoaderInfoMatch(const ClassLoaderInfo& info, + const ClassLoaderInfo& expected_info, + const std::string& context_spec, + bool verify_names, + bool verify_checksums) const { if (info.type != expected_info.type) { LOG(WARNING) << "ClassLoaderContext type mismatch" - << ". expected=" << GetClassLoaderTypeName(expected_info.type) - << ", found=" << GetClassLoaderTypeName(info.type) - << " (" << context_spec << " | " << EncodeContextForOatFile("") << ")"; + << ". expected=" << GetClassLoaderTypeName(expected_info.type) + << ", found=" << GetClassLoaderTypeName(info.type) << " (" << context_spec << " | " + << EncodeContextForOatFile("") << ")"; return false; } if (info.classpath.size() != expected_info.classpath.size()) { LOG(WARNING) << "ClassLoaderContext classpath size mismatch" - << ". expected=" << expected_info.classpath.size() - << ", found=" << info.classpath.size() - << " (" << context_spec << " | " << EncodeContextForOatFile("") << ")"; + << ". expected=" << expected_info.classpath.size() + << ", found=" << info.classpath.size() << " (" << context_spec << " | " + << EncodeContextForOatFile("") << ")"; return false; } @@ -1427,9 +1406,9 @@ bool ClassLoaderContext::ClassLoaderInfoMatch( // Compare the locations. if (!dex_names_match) { LOG(WARNING) << "ClassLoaderContext classpath element mismatch" - << ". expected=" << expected_info.classpath[k] - << ", found=" << info.classpath[k] - << " (" << context_spec << " | " << EncodeContextForOatFile("") << ")"; + << ". expected=" << expected_info.classpath[k] + << ", found=" << info.classpath[k] << " (" << context_spec << " | " + << EncodeContextForOatFile("") << ")"; return false; } @@ -1437,8 +1416,8 @@ bool ClassLoaderContext::ClassLoaderInfoMatch( if (info.checksums[k] != expected_info.checksums[k]) { LOG(WARNING) << "ClassLoaderContext classpath element checksum mismatch" << ". expected=" << expected_info.checksums[k] - << ", found=" << info.checksums[k] - << " (" << context_spec << " | " << EncodeContextForOatFile("") << ")"; + << ", found=" << info.checksums[k] << " (" << context_spec << " | " + << EncodeContextForOatFile("") << ")"; return false; } } @@ -1446,9 +1425,9 @@ bool ClassLoaderContext::ClassLoaderInfoMatch( if (info.shared_libraries.size() != expected_info.shared_libraries.size()) { LOG(WARNING) << "ClassLoaderContext shared library size mismatch. " - << "Expected=" << expected_info.shared_libraries.size() - << ", found=" << info.shared_libraries.size() - << " (" << context_spec << " | " << EncodeContextForOatFile("") << ")"; + << "Expected=" << expected_info.shared_libraries.size() + << ", found=" << info.shared_libraries.size() << " (" << context_spec << " | " + << EncodeContextForOatFile("") << ")"; return false; } for (size_t i = 0; i < info.shared_libraries.size(); ++i) { @@ -1463,13 +1442,13 @@ bool ClassLoaderContext::ClassLoaderInfoMatch( if (info.parent.get() == nullptr) { if (expected_info.parent.get() != nullptr) { LOG(WARNING) << "ClassLoaderContext parent mismatch. " - << " (" << context_spec << " | " << EncodeContextForOatFile("") << ")"; + << " (" << context_spec << " | " << EncodeContextForOatFile("") << ")"; return false; } return true; } else if (expected_info.parent.get() == nullptr) { LOG(WARNING) << "ClassLoaderContext parent mismatch. " - << " (" << context_spec << " | " << EncodeContextForOatFile("") << ")"; + << " (" << context_spec << " | " << EncodeContextForOatFile("") << ")"; return false; } else { return ClassLoaderInfoMatch(*info.parent.get(), @@ -1499,8 +1478,8 @@ std::set<const DexFile*> ClassLoaderContext::CheckForDuplicateDexFiles( ClassLoaderInfo* info = class_loader_chain_.get(); for (size_t k = 0; k < info->classpath.size(); k++) { for (const DexFile* dex_file : dex_files_to_check) { - if (info->checksums[k] == dex_file->GetLocationChecksum() - && AreDexNameMatching(info->classpath[k], dex_file->GetLocation())) { + if (info->checksums[k] == dex_file->GetLocationChecksum() && + AreDexNameMatching(info->classpath[k], dex_file->GetLocation())) { result.insert(dex_file); } } diff --git a/runtime/dexopt_test.cc b/runtime/dexopt_test.cc index 6ba75737f5..3eee9e03e0 100644 --- a/runtime/dexopt_test.cc +++ b/runtime/dexopt_test.cc @@ -49,9 +49,7 @@ void DexoptTest::PreRuntimeCreate() { UnreserveImageSpace(); } -void DexoptTest::PostRuntimeCreate() { - ReserveImageSpace(); -} +void DexoptTest::PostRuntimeCreate() { ReserveImageSpace(); } bool DexoptTest::Dex2Oat(const std::vector<std::string>& args, std::string* error_msg) { std::vector<std::string> argv; @@ -83,9 +81,9 @@ std::string DexoptTest::GenerateAlternateImage(const std::string& scratch_dir) { 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::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); @@ -154,11 +152,11 @@ void DexoptTest::GenerateOatForTest(const std::string& dex_location, 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.c_str(), - oat_location.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + 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; @@ -184,7 +182,7 @@ void DexoptTest::GenerateOdexForTest(const std::string& dex_location, GenerateOatForTest(dex_location, odex_location, filter, - /*with_alternate_image=*/ false, + /*with_alternate_image=*/false, compilation_reason, extra_args); } @@ -195,15 +193,13 @@ void DexoptTest::GenerateOatForTest(const char* dex_location, 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); + 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); + GenerateOatForTest(dex_location, filter, /*with_alternate_image=*/false); } void DexoptTest::ReserveImageSpace() { @@ -232,19 +228,17 @@ void DexoptTest::ReserveImageSpaceChunk(uintptr_t start, uintptr_t end) { reinterpret_cast<uint8_t*>(start), end - start, PROT_NONE, - /*low_4gb=*/ false, - /*reuse=*/ false, - /*reservation=*/ nullptr, + /*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()); + 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(); -} +void DexoptTest::UnreserveImageSpace() { image_reservation_.clear(); } } // namespace art diff --git a/runtime/gc/space/image_space_test.cc b/runtime/gc/space/image_space_test.cc index b85560caad..d6bb86b11b 100644 --- a/runtime/gc/space/image_space_test.cc +++ b/runtime/gc/space/image_space_test.cc @@ -50,7 +50,7 @@ class ImageSpaceTest : public CommonRuntimeTest { }; TEST_F(ImageSpaceTest, StringDeduplication) { - const char* const kBaseNames[] = { "Extension1", "Extension2" }; + const char* const kBaseNames[] = {"Extension1", "Extension2"}; ScratchDir scratch; const std::string& scratch_dir = scratch.GetPath(); @@ -77,7 +77,7 @@ TEST_F(ImageSpaceTest, StringDeduplication) { std::vector<std::string> extension_image_locations; for (const char* base_name : kBaseNames) { std::string jar_name = GetTestDexFileName(base_name); - ArrayRef<const std::string> dex_files(&jar_name, /*size=*/ 1u); + ArrayRef<const std::string> dex_files(&jar_name, /*size=*/1u); ScratchFile profile_file; GenerateBootProfile(dex_files, profile_file.GetFile()); std::vector<std::string> extra_args = { @@ -94,8 +94,8 @@ TEST_F(ImageSpaceTest, StringDeduplication) { ASSERT_TRUE(success) << error_msg; bcp.push_back(jar_name); bcp_locations.push_back(jar_name); - extension_image_locations.push_back( - scratch_dir + prefix + '-' + GetFilenameBase(jar_name) + ".art"); + extension_image_locations.push_back(scratch_dir + prefix + '-' + GetFilenameBase(jar_name) + + ".art"); } // Also compile the second extension as an app with app image. @@ -104,26 +104,27 @@ TEST_F(ImageSpaceTest, StringDeduplication) { std::string app_odex_name = scratch_dir + app_base_name + ".odex"; std::string app_image_name = scratch_dir + app_base_name + ".art"; { - ArrayRef<const std::string> dex_files(&app_jar_name, /*size=*/ 1u); + ArrayRef<const std::string> dex_files(&app_jar_name, /*size=*/1u); ScratchFile profile_file; GenerateProfile(dex_files, profile_file.GetFile()); std::vector<std::string> argv; std::string error_msg; - bool success = StartDex2OatCommandLine(&argv, &error_msg, /*use_runtime_bcp_and_image=*/ false); + bool success = StartDex2OatCommandLine(&argv, &error_msg, /*use_runtime_bcp_and_image=*/false); ASSERT_TRUE(success) << error_msg; - argv.insert(argv.end(), { - "--profile-file=" + profile_file.GetFilename(), - "--runtime-arg", - "-Xbootclasspath:" + base_bcp_string, - "--runtime-arg", - "-Xbootclasspath-locations:" + base_bcp_locations_string, - "--boot-image=" + base_image_location, - "--dex-file=" + app_jar_name, - "--dex-location=" + app_jar_name, - "--oat-file=" + app_odex_name, - "--app-image-file=" + app_image_name, - "--initialize-app-image-classes=true", - }); + argv.insert(argv.end(), + { + "--profile-file=" + profile_file.GetFilename(), + "--runtime-arg", + "-Xbootclasspath:" + base_bcp_string, + "--runtime-arg", + "-Xbootclasspath-locations:" + base_bcp_locations_string, + "--boot-image=" + base_image_location, + "--dex-file=" + app_jar_name, + "--dex-location=" + app_jar_name, + "--oat-file=" + app_odex_name, + "--app-image-file=" + app_image_name, + "--initialize-app-image-classes=true", + }); success = RunDex2Oat(argv, &error_msg); ASSERT_TRUE(success) << error_msg; } @@ -136,16 +137,16 @@ TEST_F(ImageSpaceTest, StringDeduplication) { extra_reservation = MemMap::Invalid(); return ImageSpace::LoadBootImage(bcp, bcp_locations, - /*boot_class_path_fds=*/ std::vector<int>(), - /*boot_class_path_image_fds=*/ std::vector<int>(), - /*boot_class_path_vdex_fds=*/ std::vector<int>(), - /*boot_class_path_oat_fds=*/ std::vector<int>(), + /*boot_class_path_fds=*/std::vector<int>(), + /*boot_class_path_image_fds=*/std::vector<int>(), + /*boot_class_path_vdex_fds=*/std::vector<int>(), + /*boot_class_path_oat_fds=*/std::vector<int>(), full_image_locations, kRuntimeISA, - /*relocate=*/ false, - /*executable=*/ true, - /*extra_reservation_size=*/ 0u, - /*allow_in_memory_compilation=*/ false, + /*relocate=*/false, + /*executable=*/true, + /*extra_reservation_size=*/0u, + /*allow_in_memory_compilation=*/false, &boot_image_spaces, &extra_reservation); }; @@ -154,13 +155,13 @@ TEST_F(ImageSpaceTest, StringDeduplication) { size_t test_string_length = std::size(test_string) - 1u; // Equals UTF-16 length. uint32_t hash = InternTable::Utf8String::Hash(test_string_length, test_string); InternTable::Utf8String utf8_test_string(test_string_length, test_string); - auto contains_test_string = [utf8_test_string, hash](ImageSpace* space) - REQUIRES_SHARED(Locks::mutator_lock_) { + auto contains_test_string = [utf8_test_string, + hash](ImageSpace* space) REQUIRES_SHARED(Locks::mutator_lock_) { const ImageHeader& image_header = space->GetImageHeader(); if (image_header.GetInternedStringsSection().Size() != 0u) { const uint8_t* data = space->Begin() + image_header.GetInternedStringsSection().Offset(); size_t read_count; - InternTable::UnorderedSet temp_set(data, /*make_copy_of_data=*/ false, &read_count); + InternTable::UnorderedSet temp_set(data, /*make_copy_of_data=*/false, &read_count); return temp_set.FindWithHash(utf8_test_string, hash) != temp_set.end(); } else { return false; @@ -171,8 +172,7 @@ TEST_F(ImageSpaceTest, StringDeduplication) { ScopedObjectAccess soa(Thread::Current()); ASSERT_EQ(2u, extension_image_locations.size()); full_image_locations = { - base_image_location, extension_image_locations[0], extension_image_locations[1] - }; + base_image_location, extension_image_locations[0], extension_image_locations[1]}; bool success = load_boot_image(); ASSERT_TRUE(success); ASSERT_EQ(bcp.size(), boot_image_spaces.size()); @@ -184,8 +184,7 @@ TEST_F(ImageSpaceTest, StringDeduplication) { std::swap(bcp[bcp.size() - 2u], bcp[bcp.size() - 1u]); std::swap(bcp_locations[bcp_locations.size() - 2u], bcp_locations[bcp_locations.size() - 1u]); full_image_locations = { - base_image_location, extension_image_locations[1], extension_image_locations[0] - }; + base_image_location, extension_image_locations[1], extension_image_locations[0]}; success = load_boot_image(); ASSERT_TRUE(success); ASSERT_EQ(bcp.size(), boot_image_spaces.size()); @@ -204,21 +203,21 @@ TEST_F(ImageSpaceTest, StringDeduplication) { // Load the app odex file and app image. std::string error_msg; - std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/ -1, - app_odex_name.c_str(), - app_odex_name.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/-1, + app_odex_name, + app_odex_name, + /*executable=*/false, + /*low_4gb=*/false, app_jar_name, &error_msg)); ASSERT_TRUE(odex_file != nullptr) << error_msg; std::vector<ImageSpace*> non_owning_boot_image_spaces = MakeNonOwningPointerVector(boot_image_spaces); - std::unique_ptr<ImageSpace> app_image_space = ImageSpace::CreateFromAppImage( - app_image_name.c_str(), - odex_file.get(), - ArrayRef<ImageSpace* const>(non_owning_boot_image_spaces), - &error_msg); + std::unique_ptr<ImageSpace> app_image_space = + ImageSpace::CreateFromAppImage(app_image_name.c_str(), + odex_file.get(), + ArrayRef<ImageSpace* const>(non_owning_boot_image_spaces), + &error_msg); ASSERT_TRUE(app_image_space != nullptr) << error_msg; // The string in the app image should be replaced and removed from interned string section. @@ -243,25 +242,25 @@ TEST_F(DexoptTest, ValidateOatFile) { args.push_back("--oat-file=" + oat_location); ASSERT_TRUE(Dex2Oat(args, &error_msg)) << error_msg; - std::unique_ptr<OatFile> oat(OatFile::Open(/*zip_fd=*/ -1, - oat_location.c_str(), - oat_location.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + std::unique_ptr<OatFile> oat(OatFile::Open(/*zip_fd=*/-1, + oat_location, + oat_location, + /*executable=*/false, + /*low_4gb=*/false, &error_msg)); ASSERT_TRUE(oat != nullptr) << error_msg; { // Test opening the oat file also with explicit dex filenames. - std::vector<std::string> dex_filenames{ dex1, multidex1, dex2 }; - std::unique_ptr<OatFile> oat2(OatFile::Open(/*zip_fd=*/ -1, - oat_location.c_str(), - oat_location.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + std::vector<std::string> dex_filenames{dex1, multidex1, dex2}; + std::unique_ptr<OatFile> oat2(OatFile::Open(/*zip_fd=*/-1, + oat_location, + oat_location, + /*executable=*/false, + /*low_4gb=*/false, ArrayRef<const std::string>(dex_filenames), - /*dex_fds=*/ ArrayRef<const int>(), - /*reservation=*/ nullptr, + /*dex_fds=*/ArrayRef<const int>(), + /*reservation=*/nullptr, &error_msg)); ASSERT_TRUE(oat2 != nullptr) << error_msg; } diff --git a/runtime/hidden_api.cc b/runtime/hidden_api.cc index 6acbe51add..9d32e51ba6 100644 --- a/runtime/hidden_api.cc +++ b/runtime/hidden_api.cc @@ -16,19 +16,19 @@ #include "hidden_api.h" -#include <nativehelper/scoped_local_ref.h> #include <atomic> #include "art_field-inl.h" #include "art_method-inl.h" -#include "class_root-inl.h" -#include "compat_framework.h" #include "base/dumpable.h" #include "base/file_utils.h" +#include "class_root-inl.h" +#include "compat_framework.h" #include "dex/class_accessor-inl.h" #include "dex/dex_file_loader.h" #include "mirror/class_ext.h" #include "mirror/proxy.h" +#include "nativehelper/scoped_local_ref.h" #include "oat_file.h" #include "scoped_thread_state_change.h" #include "stack.h" @@ -105,22 +105,21 @@ static Domain DetermineDomainFromLocation(const std::string& dex_location, // These checks will be skipped on target buildbots where ANDROID_ART_ROOT // is set to "/system". if (ArtModuleRootDistinctFromAndroidRoot()) { - if (LocationIsOnArtModule(dex_location.c_str()) || - LocationIsOnConscryptModule(dex_location.c_str()) || - LocationIsOnI18nModule(dex_location.c_str())) { + if (LocationIsOnArtModule(dex_location) || LocationIsOnConscryptModule(dex_location) || + LocationIsOnI18nModule(dex_location)) { return Domain::kCorePlatform; } - if (LocationIsOnApex(dex_location.c_str())) { + if (LocationIsOnApex(dex_location)) { return Domain::kPlatform; } } - if (LocationIsOnSystemFramework(dex_location.c_str())) { + if (LocationIsOnSystemFramework(dex_location)) { return Domain::kPlatform; } - if (LocationIsOnSystemExtFramework(dex_location.c_str())) { + if (LocationIsOnSystemExtFramework(dex_location)) { return Domain::kPlatform; } @@ -128,7 +127,7 @@ static Domain DetermineDomainFromLocation(const std::string& dex_location, if (kIsTargetBuild && !kIsTargetLinux) { // This is unexpected only when running on Android. LOG(WARNING) << "DexFile " << dex_location - << " is in boot class path but is not in a known location"; + << " is in boot class path but is not in a known location"; } return Domain::kPlatform; } @@ -150,11 +149,11 @@ void InitializeCorePlatformApiPrivateFields() { // The following fields in WellKnownClasses correspond to private fields in the Core Platform // API that cannot be otherwise expressed and propagated through tooling (b/144502743). ArtField* private_core_platform_api_fields[] = { - WellKnownClasses::java_io_FileDescriptor_descriptor, - WellKnownClasses::java_nio_Buffer_address, - WellKnownClasses::java_nio_Buffer_elementSizeShift, - WellKnownClasses::java_nio_Buffer_limit, - WellKnownClasses::java_nio_Buffer_position, + WellKnownClasses::java_io_FileDescriptor_descriptor, + WellKnownClasses::java_nio_Buffer_address, + WellKnownClasses::java_nio_Buffer_elementSizeShift, + WellKnownClasses::java_nio_Buffer_limit, + WellKnownClasses::java_nio_Buffer_position, }; ScopedObjectAccess soa(Thread::Current()); @@ -174,11 +173,10 @@ hiddenapi::AccessContext GetReflectionCallerAccessContext(Thread* self) struct FirstExternalCallerVisitor : public StackVisitor { explicit FirstExternalCallerVisitor(Thread* thread) : StackVisitor(thread, nullptr, StackVisitor::StackWalkKind::kIncludeInlinedFrames), - caller(nullptr) { - } + caller(nullptr) {} bool VisitFrame() override REQUIRES_SHARED(Locks::mutator_lock_) { - ArtMethod *m = GetMethod(); + ArtMethod* m = GetMethod(); if (m == nullptr) { // Attached native thread. Assume this is *not* boot class path. caller = nullptr; @@ -199,8 +197,8 @@ hiddenapi::AccessContext GetReflectionCallerAccessContext(Thread* self) // NB Static initializers within java.lang.invoke are permitted and do not // need further stack inspection. ObjPtr<mirror::Class> lookup_class = GetClassRoot<mirror::MethodHandlesLookup>(); - if ((declaring_class == lookup_class || declaring_class->IsInSamePackage(lookup_class)) - && !m->IsClassInitializer()) { + if ((declaring_class == lookup_class || declaring_class->IsInSamePackage(lookup_class)) && + !m->IsClassInitializer()) { return true; } // Check for classes in the java.lang.reflect package, except for java.lang.reflect.Proxy. @@ -229,10 +227,9 @@ hiddenapi::AccessContext GetReflectionCallerAccessContext(Thread* self) // Construct AccessContext from the calling class found on the stack. // If the calling class cannot be determined, e.g. unattached threads, // we conservatively assume the caller is trusted. - ObjPtr<mirror::Class> caller = (visitor.caller == nullptr) - ? nullptr : visitor.caller->GetDeclaringClass(); - return caller.IsNull() ? AccessContext(/* is_trusted= */ true) - : AccessContext(caller); + ObjPtr<mirror::Class> caller = + (visitor.caller == nullptr) ? nullptr : visitor.caller->GetDeclaringClass(); + return caller.IsNull() ? AccessContext(/* is_trusted= */ true) : AccessContext(caller); } namespace detail { @@ -243,7 +240,7 @@ enum AccessContextFlags { // Accessed member is a field if this bit is set, else a method kMemberIsField = 1 << 0, // Indicates if access was denied to the member, instead of just printing a warning. - kAccessDenied = 1 << 1, + kAccessDenied = 1 << 1, }; MemberSignature::MemberSignature(ArtField* field) { @@ -282,10 +279,10 @@ MemberSignature::MemberSignature(const ClassAccessor::Method& method) { inline std::vector<const char*> MemberSignature::GetSignatureParts() const { if (type_ == kField) { - return { class_name_.c_str(), "->", member_name_.c_str(), ":", type_signature_.c_str() }; + return {class_name_.c_str(), "->", member_name_.c_str(), ":", type_signature_.c_str()}; } else { DCHECK_EQ(type_, kMethod); - return { class_name_.c_str(), "->", member_name_.c_str(), type_signature_.c_str() }; + return {class_name_.c_str(), "->", member_name_.c_str(), type_signature_.c_str()}; } } @@ -341,10 +338,8 @@ void MemberSignature::WarnAboutAccess(AccessMethod access_method, } bool MemberSignature::Equals(const MemberSignature& other) { - return type_ == other.type_ && - class_name_ == other.class_name_ && - member_name_ == other.member_name_ && - type_signature_ == other.type_signature_; + return type_ == other.type_ && class_name_ == other.class_name_ && + member_name_ == other.member_name_ && type_signature_ == other.type_signature_; } bool MemberSignature::MemberNameAndTypeMatch(const MemberSignature& other) { @@ -373,26 +368,25 @@ void MemberSignature::LogAccessToEventLog(uint32_t sampled_value, ScopedObjectAccess soa(Thread::Current()); StackHandleScope<2u> hs(soa.Self()); - Handle<mirror::String> package_str = hs.NewHandle( - mirror::String::AllocFromModifiedUtf8(soa.Self(), package_name.c_str())); + Handle<mirror::String> package_str = + hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), package_name.c_str())); if (soa.Self()->IsExceptionPending()) { soa.Self()->ClearException(); LOG(ERROR) << "Unable to allocate string for package name which called hidden api"; } - Handle<mirror::String> signature_jstr = hs.NewHandle( - mirror::String::AllocFromModifiedUtf8(soa.Self(), signature_str.str().c_str())); + Handle<mirror::String> signature_jstr = + hs.NewHandle(mirror::String::AllocFromModifiedUtf8(soa.Self(), signature_str.str().c_str())); if (soa.Self()->IsExceptionPending()) { soa.Self()->ClearException(); LOG(ERROR) << "Unable to allocate string for hidden api method signature"; } WellKnownClasses::dalvik_system_VMRuntime_hiddenApiUsed - ->InvokeStatic<'V', 'I', 'L', 'L', 'I', 'Z'>( - soa.Self(), - static_cast<jint>(sampled_value), - package_str.Get(), - signature_jstr.Get(), - static_cast<jint>(access_method), - access_denied); + ->InvokeStatic<'V', 'I', 'L', 'L', 'I', 'Z'>(soa.Self(), + static_cast<jint>(sampled_value), + package_str.Get(), + signature_jstr.Get(), + static_cast<jint>(access_method), + access_denied); if (soa.Self()->IsExceptionPending()) { soa.Self()->ClearException(); LOG(ERROR) << "Unable to report hidden api usage"; @@ -438,23 +432,20 @@ void MemberSignature::NotifyHiddenApiListener(AccessMethod access_method) { } } -static ALWAYS_INLINE bool CanUpdateRuntimeFlags(ArtField*) { - return true; -} +static ALWAYS_INLINE bool CanUpdateRuntimeFlags(ArtField*) { return true; } static ALWAYS_INLINE bool CanUpdateRuntimeFlags(ArtMethod* method) { return !method->IsIntrinsic(); } -template<typename T> +template <typename T> static ALWAYS_INLINE void MaybeUpdateAccessFlags(Runtime* runtime, T* member, uint32_t flag) REQUIRES_SHARED(Locks::mutator_lock_) { // Update the access flags unless: // (a) `member` is an intrinsic // (b) this is AOT compiler, as we do not want the updated access flags in the boot/app image // (c) deduping warnings has been explicitly switched off. - if (CanUpdateRuntimeFlags(member) && - !runtime->IsAotCompiler() && + if (CanUpdateRuntimeFlags(member) && !runtime->IsAotCompiler() && runtime->ShouldDedupeHiddenApiWarnings()) { member->SetAccessFlags(member->GetAccessFlags() | flag); } @@ -485,12 +476,13 @@ static void VisitMembers(const DexFile& dex_file, accessor.VisitMethods(fn_visit, fn_visit); } -template<typename T> +template <typename T> uint32_t GetDexFlags(T* member) REQUIRES_SHARED(Locks::mutator_lock_) { static_assert(std::is_same<T, ArtField>::value || std::is_same<T, ArtMethod>::value); constexpr bool kMemberIsField = std::is_same<T, ArtField>::value; using AccessorType = typename std::conditional<std::is_same<T, ArtField>::value, - ClassAccessor::Field, ClassAccessor::Method>::type; + ClassAccessor::Field, + ClassAccessor::Method>::type; ObjPtr<mirror::Class> declaring_class = member->GetDeclaringClass(); DCHECK(!declaring_class.IsNull()) << "Attempting to access a runtime method"; @@ -545,11 +537,11 @@ uint32_t GetDexFlags(T* member) REQUIRES_SHARED(Locks::mutator_lock_) { } CHECK(flags.IsValid()) << "Could not find hiddenapi flags for " - << Dumpable<MemberSignature>(MemberSignature(member)); + << Dumpable<MemberSignature>(MemberSignature(member)); return flags.GetDexFlags(); } -template<typename T> +template <typename T> bool HandleCorePlatformApiViolation(T* member, const AccessContext& caller_context, AccessMethod access_method, @@ -559,8 +551,8 @@ bool HandleCorePlatformApiViolation(T* member, if (access_method != AccessMethod::kNone) { LOG(WARNING) << "Core platform API violation: " - << Dumpable<MemberSignature>(MemberSignature(member)) - << " from " << caller_context << " using " << access_method; + << Dumpable<MemberSignature>(MemberSignature(member)) << " from " << caller_context + << " using " << access_method; // If policy is set to just warn, add kAccCorePlatformApi to access flags of // `member` to avoid reporting the violation again next time. @@ -573,7 +565,7 @@ bool HandleCorePlatformApiViolation(T* member, return policy == EnforcementPolicy::kEnabled; } -template<typename T> +template <typename T> bool ShouldDenyAccessToMemberImpl(T* member, ApiList api_list, AccessMethod access_method) { DCHECK(member != nullptr); Runtime* runtime = Runtime::Current(); @@ -598,9 +590,8 @@ bool ShouldDenyAccessToMemberImpl(T* member, ApiList api_list, AccessMethod acce bool deny_access = false; if (hiddenApiPolicy == EnforcementPolicy::kEnabled) { - if (api_list.IsTestApi() && - (testApiPolicy == EnforcementPolicy::kDisabled || - compatFramework.IsChangeEnabled(kAllowTestApiAccess))) { + if (api_list.IsTestApi() && (testApiPolicy == EnforcementPolicy::kDisabled || + compatFramework.IsChangeEnabled(kAllowTestApiAccess))) { deny_access = false; } else { switch (api_list.GetMaxAllowedSdkVersion()) { @@ -673,7 +664,7 @@ template bool ShouldDenyAccessToMemberImpl<ArtMethod>(ArtMethod* member, AccessMethod access_method); } // namespace detail -template<typename T> +template <typename T> bool ShouldDenyAccessToMember(T* member, const std::function<AccessContext()>& fn_get_access_context, AccessMethod access_method) { @@ -766,10 +757,7 @@ bool ShouldDenyAccessToMember(T* member, // Access checks are not disabled, report the violation. // This may also add kAccCorePlatformApi to the access flags of `member` // so as to not warn again on next access. - return detail::HandleCorePlatformApiViolation(member, - caller_context, - access_method, - policy); + return detail::HandleCorePlatformApiViolation(member, caller_context, access_method, policy); } case Domain::kCorePlatform: { diff --git a/runtime/hidden_api_test.cc b/runtime/hidden_api_test.cc index c2c40c5af3..3fb447afc9 100644 --- a/runtime/hidden_api_test.cc +++ b/runtime/hidden_api_test.cc @@ -638,14 +638,14 @@ TEST_F(HiddenApiTest, CheckMemberSignatureForProxyClass) { TEST_F(HiddenApiTest, DexDomain_DataDir) { // Load file from a non-system directory and check that it is not flagged as framework. std::string data_location_path = android_data_ + "/foo.jar"; - ASSERT_FALSE(LocationIsOnSystemFramework(data_location_path.c_str())); + ASSERT_FALSE(LocationIsOnSystemFramework(data_location_path)); TestLocation(data_location_path, hiddenapi::Domain::kApplication); } TEST_F(HiddenApiTest, DexDomain_SystemDir) { // Load file from a system, non-framework directory and check that it is not flagged as framework. std::string system_location_path = GetAndroidRoot() + "/foo.jar"; - ASSERT_FALSE(LocationIsOnSystemFramework(system_location_path.c_str())); + ASSERT_FALSE(LocationIsOnSystemFramework(system_location_path)); TestLocation(system_location_path, hiddenapi::Domain::kApplication); } @@ -653,7 +653,7 @@ TEST_F(HiddenApiTest, DexDomain_SystemExtDir) { // Load file from a system_ext, non-framework directory and check that it is not flagged as // framework. std::string system_ext_location_path = android_system_ext_ + "/foo.jar"; - ASSERT_FALSE(LocationIsOnSystemExtFramework(system_ext_location_path.c_str())); + ASSERT_FALSE(LocationIsOnSystemExtFramework(system_ext_location_path)); TestLocation(system_ext_location_path, hiddenapi::Domain::kApplication); } @@ -662,7 +662,7 @@ TEST_F(HiddenApiTest, DexDomain_SystemSystemExtDir) { // framework. std::filesystem::create_directory(GetAndroidRoot() + "/system_ext"); std::string system_ext_location_path = GetAndroidRoot() + "/system_ext/foo.jar"; - ASSERT_FALSE(LocationIsOnSystemExtFramework(system_ext_location_path.c_str())); + ASSERT_FALSE(LocationIsOnSystemExtFramework(system_ext_location_path)); TestLocation(system_ext_location_path, hiddenapi::Domain::kApplication); } @@ -670,7 +670,7 @@ TEST_F(HiddenApiTest, DexDomain_SystemFrameworkDir) { // Load file from a system/framework directory and check that it is flagged as a framework dex. std::filesystem::create_directory(GetAndroidRoot() + "/framework"); std::string system_framework_location_path = GetAndroidRoot() + "/framework/foo.jar"; - ASSERT_TRUE(LocationIsOnSystemFramework(system_framework_location_path.c_str())); + ASSERT_TRUE(LocationIsOnSystemFramework(system_framework_location_path)); TestLocation(system_framework_location_path, hiddenapi::Domain::kPlatform); } @@ -678,7 +678,7 @@ TEST_F(HiddenApiTest, DexDomain_SystemExtFrameworkDir) { // Load file from a system_ext/framework directory and check that it is flagged as a framework dex. std::filesystem::create_directory(android_system_ext_ + "/framework"); std::string system_ext_framework_location_path = android_system_ext_ + "/framework/foo.jar"; - ASSERT_TRUE(LocationIsOnSystemExtFramework(system_ext_framework_location_path.c_str())); + ASSERT_TRUE(LocationIsOnSystemExtFramework(system_ext_framework_location_path)); TestLocation(system_ext_framework_location_path, hiddenapi::Domain::kPlatform); } @@ -689,14 +689,14 @@ TEST_F(HiddenApiTest, DexDomain_SystemSystemExtFrameworkDir) { std::filesystem::create_directory(GetAndroidRoot() + "/system_ext/framework"); std::string system_ext_framework_location_path = GetAndroidRoot() + "/system_ext/framework/foo.jar"; - ASSERT_TRUE(LocationIsOnSystemExtFramework(system_ext_framework_location_path.c_str())); + ASSERT_TRUE(LocationIsOnSystemExtFramework(system_ext_framework_location_path)); TestLocation(system_ext_framework_location_path, hiddenapi::Domain::kPlatform); } TEST_F(HiddenApiTest, DexDomain_DataDir_MultiDex) { // Load multidex file from a non-system directory and check that it is not flagged as framework. std::string data_multi_location_path = android_data_ + "/multifoo.jar"; - ASSERT_FALSE(LocationIsOnSystemFramework(data_multi_location_path.c_str())); + ASSERT_FALSE(LocationIsOnSystemFramework(data_multi_location_path)); TestLocation(data_multi_location_path, hiddenapi::Domain::kApplication); } @@ -704,7 +704,7 @@ TEST_F(HiddenApiTest, DexDomain_SystemDir_MultiDex) { // Load multidex file from a system, non-framework directory and check that it is not flagged // as framework. std::string system_multi_location_path = GetAndroidRoot() + "/multifoo.jar"; - ASSERT_FALSE(LocationIsOnSystemFramework(system_multi_location_path.c_str())); + ASSERT_FALSE(LocationIsOnSystemFramework(system_multi_location_path)); TestLocation(system_multi_location_path, hiddenapi::Domain::kApplication); } @@ -712,7 +712,7 @@ TEST_F(HiddenApiTest, DexDomain_SystemExtDir_MultiDex) { // Load multidex file from a system_ext, non-framework directory and check that it is not flagged // as framework. std::string system_ext_multi_location_path = android_system_ext_ + "/multifoo.jar"; - ASSERT_FALSE(LocationIsOnSystemExtFramework(system_ext_multi_location_path.c_str())); + ASSERT_FALSE(LocationIsOnSystemExtFramework(system_ext_multi_location_path)); TestLocation(system_ext_multi_location_path, hiddenapi::Domain::kApplication); } @@ -722,7 +722,7 @@ TEST_F(HiddenApiTest, DexDomain_SystemSystemExtDir_MultiDex) { std::filesystem::create_directory(GetAndroidRoot() + "/system_ext"); std::string system_ext_multi_location_path = GetAndroidRoot() + "/system_ext/multifoo.jar"; - ASSERT_FALSE(LocationIsOnSystemExtFramework(system_ext_multi_location_path.c_str())); + ASSERT_FALSE(LocationIsOnSystemExtFramework(system_ext_multi_location_path)); TestLocation(system_ext_multi_location_path, hiddenapi::Domain::kApplication); } @@ -731,7 +731,7 @@ TEST_F(HiddenApiTest, DexDomain_SystemFrameworkDir_MultiDex) { // framework dex. std::filesystem::create_directory(GetAndroidRoot() + "/framework"); std::string system_framework_multi_location_path = GetAndroidRoot() + "/framework/multifoo.jar"; - ASSERT_TRUE(LocationIsOnSystemFramework(system_framework_multi_location_path.c_str())); + ASSERT_TRUE(LocationIsOnSystemFramework(system_framework_multi_location_path)); TestLocation(system_framework_multi_location_path, hiddenapi::Domain::kPlatform); } @@ -741,7 +741,7 @@ TEST_F(HiddenApiTest, DexDomain_SystemExtFrameworkDir_MultiDex) { std::filesystem::create_directory(android_system_ext_ + "/framework"); std::string system_ext_framework_multi_location_path = android_system_ext_ + "/framework/multifoo.jar"; - ASSERT_TRUE(LocationIsOnSystemExtFramework(system_ext_framework_multi_location_path.c_str())); + ASSERT_TRUE(LocationIsOnSystemExtFramework(system_ext_framework_multi_location_path)); TestLocation(system_ext_framework_multi_location_path, hiddenapi::Domain::kPlatform); } @@ -752,7 +752,7 @@ TEST_F(HiddenApiTest, DexDomain_SystemSystemExtFrameworkDir_MultiDex) { std::filesystem::create_directory(GetAndroidRoot() + "/system_ext/framework"); std::string system_ext_framework_multi_location_path = GetAndroidRoot() + "/system_ext/framework/multifoo.jar"; - ASSERT_TRUE(LocationIsOnSystemExtFramework(system_ext_framework_multi_location_path.c_str())); + ASSERT_TRUE(LocationIsOnSystemExtFramework(system_ext_framework_multi_location_path)); TestLocation(system_ext_framework_multi_location_path, hiddenapi::Domain::kPlatform); } diff --git a/runtime/interpreter/unstarted_runtime.cc b/runtime/interpreter/unstarted_runtime.cc index cafd7c456c..32ed4300b7 100644 --- a/runtime/interpreter/unstarted_runtime.cc +++ b/runtime/interpreter/unstarted_runtime.cc @@ -1276,7 +1276,7 @@ static void UnstartedMemoryPeekArray( if (offset < 0 || offset + count > array->GetLength()) { std::string error_msg(StringPrintf("Array out of bounds in peekArray: %d/%d vs %d", offset, count, array->GetLength())); - Runtime::Current()->AbortTransactionAndThrowAbortError(self, error_msg.c_str()); + Runtime::Current()->AbortTransactionAndThrowAbortError(self, error_msg); return; } diff --git a/runtime/jit/jit.cc b/runtime/jit/jit.cc index fda5affd16..b231cce0bc 100644 --- a/runtime/jit/jit.cc +++ b/runtime/jit/jit.cc @@ -1403,7 +1403,7 @@ uint32_t Jit::CompileMethodsFromBootProfile( const std::string& profile_file, Handle<mirror::ClassLoader> class_loader, bool add_to_queue) { - unix_file::FdFile profile(profile_file.c_str(), O_RDONLY, true); + unix_file::FdFile profile(profile_file, O_RDONLY, true); if (profile.Fd() == -1) { PLOG(WARNING) << "No boot profile: " << profile_file; @@ -1453,7 +1453,7 @@ uint32_t Jit::CompileMethodsFromProfile( // We don't generate boot profiles on device, therefore we don't // need to lock the file. - unix_file::FdFile profile(profile_file.c_str(), O_RDONLY, true); + unix_file::FdFile profile(profile_file, O_RDONLY, true); if (profile.Fd() == -1) { PLOG(WARNING) << "No profile: " << profile_file; diff --git a/runtime/jit/profile_saver.cc b/runtime/jit/profile_saver.cc index e1a10b89e5..cdc4bdb5f1 100644 --- a/runtime/jit/profile_saver.cc +++ b/runtime/jit/profile_saver.cc @@ -876,7 +876,7 @@ bool ProfileSaver::ProcessProfilingInfo( } } else { // Create a file if it doesn't exist. - unix_file::FdFile file(filename.c_str(), + unix_file::FdFile file(filename, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR, /*check_usage=*/false); diff --git a/runtime/native/java_lang_Class.cc b/runtime/native/java_lang_Class.cc index 2506ca8610..5e54f85b9d 100644 --- a/runtime/native/java_lang_Class.cc +++ b/runtime/native/java_lang_Class.cc @@ -395,7 +395,7 @@ static jobject Class_getDeclaredField(JNIEnv* env, jobject javaThis, jstring nam } // We may have a pending exception if we failed to resolve. if (!soa.Self()->IsExceptionPending()) { - ThrowNoSuchFieldException(h_klass.Get(), name_str.c_str()); + ThrowNoSuchFieldException(h_klass.Get(), name_str); } return nullptr; } diff --git a/runtime/oat_file_assistant.cc b/runtime/oat_file_assistant.cc index d324a241b7..6014409c78 100644 --- a/runtime/oat_file_assistant.cc +++ b/runtime/oat_file_assistant.cc @@ -63,7 +63,7 @@ static constexpr const char* kAnonymousDexPrefix = "Anonymous-DexFile@"; static constexpr const char* kVdexExtension = ".vdex"; static constexpr const char* kDmExtension = ".dm"; -std::ostream& operator << (std::ostream& stream, const OatFileAssistant::OatStatus status) { +std::ostream& operator<<(std::ostream& stream, const OatFileAssistant::OatStatus status) { switch (status) { case OatFileAssistant::kOatCannotOpen: stream << "kOatCannotOpen"; @@ -126,9 +126,9 @@ OatFileAssistant::OatFileAssistant(const char* dex_location, if (zip_fd < 0) { CHECK_LE(oat_fd, 0) << "zip_fd must be provided with valid oat_fd. zip_fd=" << zip_fd - << " oat_fd=" << oat_fd; + << " oat_fd=" << oat_fd; CHECK_LE(vdex_fd, 0) << "zip_fd must be provided with valid vdex_fd. zip_fd=" << zip_fd - << " vdex_fd=" << vdex_fd;; + << " vdex_fd=" << vdex_fd; CHECK(!UseFdToReadFiles()); } else { CHECK(UseFdToReadFiles()); @@ -146,7 +146,7 @@ OatFileAssistant::OatFileAssistant(const char* dex_location, if (load_executable_ && isa != kRuntimeISA) { LOG(WARNING) << "OatFileAssistant: Load executable specified, " - << "but isa is not kRuntimeISA. Will not attempt to load executable."; + << "but isa is not kRuntimeISA. Will not attempt to load executable."; load_executable_ = false; } @@ -194,14 +194,14 @@ OatFileAssistant::OatFileAssistant(const char* dex_location, GetRuntimeOptions().deny_art_apex_data_files, &oat_file_name, &error_msg)) { - oat_.Reset(oat_file_name, /*use_fd=*/ false); + oat_.Reset(oat_file_name, /*use_fd=*/false); std::string vdex_file_name = GetVdexFilename(oat_file_name); vdex_for_oat_.Reset(vdex_file_name, UseFdToReadFiles(), zip_fd, vdex_fd, oat_fd); std::string dm_file_name = GetDmFilename(dex_location); dm_for_oat_.Reset(dm_file_name, UseFdToReadFiles(), zip_fd, vdex_fd, oat_fd); } else { - LOG(WARNING) << "Failed to determine oat file name for dex location " - << dex_location_ << ": " << error_msg; + LOG(WARNING) << "Failed to determine oat file name for dex location " << dex_location_ << ": " + << error_msg; } } @@ -241,13 +241,13 @@ std::unique_ptr<OatFileAssistant> OatFileAssistant::Create( std::unique_ptr<ClassLoaderContext> tmp_context = nullptr; if (context_str.has_value()) { - tmp_context = ClassLoaderContext::Create(context_str->c_str()); + tmp_context = ClassLoaderContext::Create(context_str.value()); if (tmp_context == nullptr) { *error_msg = StringPrintf("Class loader context '%s' is invalid", context_str->c_str()); return nullptr; } - if (!tmp_context->OpenDexFiles(android::base::Dirname(filename.c_str()), + if (!tmp_context->OpenDexFiles(android::base::Dirname(filename), /*context_fds=*/{}, /*only_read_checksums=*/true)) { *error_msg = @@ -269,9 +269,7 @@ std::unique_ptr<OatFileAssistant> OatFileAssistant::Create( return assistant; } -bool OatFileAssistant::UseFdToReadFiles() { - return zip_fd_ >= 0; -} +bool OatFileAssistant::UseFdToReadFiles() { return zip_fd_ >= 0; } bool OatFileAssistant::IsInBootClassPath() { // Note: We check the current boot class path, regardless of the ISA @@ -344,9 +342,7 @@ bool OatFileAssistant::GetDexOptNeeded(CompilerFilter::Filter target_compiler_fi return dexopt_needed != kNoDexOptNeeded; } -bool OatFileAssistant::IsUpToDate() { - return GetBestInfo().Status() == kOatUpToDate; -} +bool OatFileAssistant::IsUpToDate() { return GetBestInfo().Status() == kOatUpToDate; } std::unique_ptr<OatFile> OatFileAssistant::GetBestOatFile() { return GetBestInfo().ReleaseFileForUse(); @@ -400,7 +396,7 @@ std::string OatFileAssistant::GetStatusDump() { } std::vector<std::unique_ptr<const DexFile>> OatFileAssistant::LoadDexFiles( - const OatFile &oat_file, const char *dex_location) { + const OatFile& oat_file, const char* dex_location) { std::vector<std::unique_ptr<const DexFile>> dex_files; if (LoadDexFiles(oat_file, dex_location, &dex_files)) { return dex_files; @@ -409,14 +405,13 @@ std::vector<std::unique_ptr<const DexFile>> OatFileAssistant::LoadDexFiles( } } -bool OatFileAssistant::LoadDexFiles( - const OatFile &oat_file, - const std::string& dex_location, - std::vector<std::unique_ptr<const DexFile>>* out_dex_files) { +bool OatFileAssistant::LoadDexFiles(const OatFile& oat_file, + const std::string& dex_location, + std::vector<std::unique_ptr<const DexFile>>* out_dex_files) { // Load the main dex file. std::string error_msg; - const OatDexFile* oat_dex_file = oat_file.GetOatDexFile( - dex_location.c_str(), nullptr, &error_msg); + const OatDexFile* oat_dex_file = + oat_file.GetOatDexFile(dex_location.c_str(), nullptr, &error_msg); if (oat_dex_file == nullptr) { LOG(WARNING) << error_msg; return false; @@ -457,13 +452,9 @@ std::optional<bool> OatFileAssistant::HasDexFiles(std::string* error_msg) { return !checksums->empty(); } -OatFileAssistant::OatStatus OatFileAssistant::OdexFileStatus() { - return odex_.Status(); -} +OatFileAssistant::OatStatus OatFileAssistant::OdexFileStatus() { return odex_.Status(); } -OatFileAssistant::OatStatus OatFileAssistant::OatFileStatus() { - return oat_.Status(); -} +OatFileAssistant::OatStatus OatFileAssistant::OatFileStatus() { return oat_.Status(); } bool OatFileAssistant::DexChecksumUpToDate(const OatFile& file, std::string* error_msg) { if (!file.ContainsDexCode()) { @@ -483,9 +474,8 @@ bool OatFileAssistant::DexChecksumUpToDate(const OatFile& file, std::string* err uint32_t number_of_dex_files = file.GetOatHeader().GetDexFileCount(); if (required_dex_checksums->size() != number_of_dex_files) { - *error_msg = StringPrintf("expected %zu dex files but found %u", - required_dex_checksums->size(), - number_of_dex_files); + *error_msg = StringPrintf( + "expected %zu dex files but found %u", required_dex_checksums->size(), number_of_dex_files); return false; } @@ -500,8 +490,7 @@ bool OatFileAssistant::DexChecksumUpToDate(const OatFile& file, std::string* err uint32_t actual_checksum = oat_dex_file->GetDexFileLocationChecksum(); if (expected_checksum != actual_checksum) { VLOG(oat) << "Dex checksum does not match for dex: " << dex - << ". Expected: " << expected_checksum - << ", Actual: " << actual_checksum; + << ". Expected: " << expected_checksum << ", Actual: " << actual_checksum; return false; } } @@ -574,9 +563,8 @@ bool OatFileAssistant::AnonymousDexVdexLocation(const std::vector<const DexFile: uint32_t checksum = adler32(0L, Z_NULL, 0); for (const DexFile::Header* header : headers) { - checksum = adler32_combine(checksum, - header->checksum_, - header->file_size_ - DexFile::kNumNonChecksumBytes); + checksum = adler32_combine( + checksum, header->checksum_, header->file_size_ - DexFile::kNumNonChecksumBytes); } const std::string& data_dir = Runtime::Current()->GetProcessDataDirectory(); @@ -601,7 +589,7 @@ bool OatFileAssistant::IsAnonymousVdexBasename(const std::string& basename) { DCHECK(basename.find('/') == std::string::npos); // `basename` must have format: <kAnonymousDexPrefix><checksum><kVdexExtension> if (basename.size() < strlen(kAnonymousDexPrefix) + strlen(kVdexExtension) + 1 || - !android::base::StartsWith(basename.c_str(), kAnonymousDexPrefix) || + !android::base::StartsWith(basename, kAnonymousDexPrefix) || !android::base::EndsWith(basename, kVdexExtension)) { return false; } @@ -645,7 +633,7 @@ bool OatFileAssistant::DexLocationToOdexFilename(const std::string& location, *error_msg = "Dex location " + location + " has no directory."; return false; } - std::string dir = location.substr(0, pos+1); + std::string dir = location.substr(0, pos + 1); // Add the oat directory. dir += "oat"; @@ -653,7 +641,7 @@ bool OatFileAssistant::DexLocationToOdexFilename(const std::string& location, dir += "/" + std::string(GetInstructionSetString(isa)); // Get the base part of the file without the extension. - std::string file = location.substr(pos+1); + std::string file = location.substr(pos + 1); pos = file.rfind('.'); if (pos == std::string::npos) { *error_msg = "Dex location " + location + " has no extension."; @@ -706,11 +694,11 @@ bool OatFileAssistant::DexLocationToOatFilename(const std::string& location, bool dalvik_cache_exists = false; bool is_global_cache = false; GetDalvikCache(GetInstructionSetString(isa), - /*create_if_absent=*/ true, - &dalvik_cache, - &have_android_data, - &dalvik_cache_exists, - &is_global_cache); + /*create_if_absent=*/true, + &dalvik_cache, + &have_android_data, + &dalvik_cache_exists, + &is_global_cache); if (!dalvik_cache_exists) { *error_msg = "Dalvik cache directory does not exist"; return false; @@ -868,7 +856,7 @@ bool OatFileAssistant::ValidateBootClassPathChecksums(const OatFile& oat_file) { &error_msg); if (!result) { VLOG(oat) << "Failed to verify checksums of oat file " << oat_file.GetLocation() - << " error: " << error_msg; + << " error: " << error_msg; return false; } @@ -958,12 +946,9 @@ std::unique_ptr<gc::space::ImageSpace> OatFileAssistant::OpenImageSpace(const Oa OatFileAssistant::OatFileInfo::OatFileInfo(OatFileAssistant* oat_file_assistant, bool is_oat_location) - : oat_file_assistant_(oat_file_assistant), is_oat_location_(is_oat_location) -{} + : oat_file_assistant_(oat_file_assistant), is_oat_location_(is_oat_location) {} -bool OatFileAssistant::OatFileInfo::IsOatLocation() { - return is_oat_location_; -} +bool OatFileAssistant::OatFileInfo::IsOatLocation() { return is_oat_location_; } const std::string* OatFileAssistant::OatFileInfo::Filename() { return filename_provided_ ? &filename_ : nullptr; @@ -975,9 +960,11 @@ bool OatFileAssistant::OatFileInfo::IsUseable() { case kOatCannotOpen: case kOatDexOutOfDate: case kOatContextOutOfDate: - case kOatBootImageOutOfDate: return false; + case kOatBootImageOutOfDate: + return false; - case kOatUpToDate: return true; + case kOatUpToDate: + return true; } UNREACHABLE(); } @@ -991,8 +978,8 @@ OatFileAssistant::OatStatus OatFileAssistant::OatFileInfo::Status() { status_ = kOatCannotOpen; } else { status_ = oat_file_assistant_->GivenOatFileStatus(*file); - VLOG(oat) << file->GetLocation() << " is " << status_ - << " with filter " << file->GetCompilerFilter(); + VLOG(oat) << file->GetLocation() << " is " << status_ << " with filter " + << file->GetCompilerFilter(); } } return status_; @@ -1064,15 +1051,15 @@ const OatFile* OatFileAssistant::OatFileInfo::GetFile() { vdex = VdexFile::Open(vdex_fd_, s.st_size, filename_, - /*writable=*/ false, - /*low_4gb=*/ false, + /*writable=*/false, + /*low_4gb=*/false, &error_msg); } } } else { vdex = VdexFile::Open(filename_, - /*writable=*/ false, - /*low_4gb=*/ false, + /*writable=*/false, + /*low_4gb=*/false, &error_msg); } if (vdex == nullptr) { @@ -1100,38 +1087,36 @@ const OatFile* OatFileAssistant::OatFileInfo::GetFile() { } } else { if (executable && oat_file_assistant_->only_load_trusted_executable_) { - executable = LocationIsTrusted(filename_, /*trust_art_apex_data_files=*/ true); + executable = LocationIsTrusted(filename_, /*trust_art_apex_data_files=*/true); } VLOG(oat) << "Loading " << filename_ << " with executable: " << executable; if (use_fd_) { if (oat_fd_ >= 0 && vdex_fd_ >= 0) { ArrayRef<const std::string> dex_locations(&oat_file_assistant_->dex_location_, - /*size=*/ 1u); + /*size=*/1u); file_.reset(OatFile::Open(zip_fd_, vdex_fd_, oat_fd_, - filename_.c_str(), + filename_, executable, - /*low_4gb=*/ false, + /*low_4gb=*/false, dex_locations, - /*dex_fds=*/ ArrayRef<const int>(), - /*reservation=*/ nullptr, + /*dex_fds=*/ArrayRef<const int>(), + /*reservation=*/nullptr, &error_msg)); } } else { - file_.reset(OatFile::Open(/*zip_fd=*/ -1, - filename_.c_str(), - filename_.c_str(), + file_.reset(OatFile::Open(/*zip_fd=*/-1, + filename_, + filename_, executable, - /*low_4gb=*/ false, + /*low_4gb=*/false, oat_file_assistant_->dex_location_, &error_msg)); } } if (file_.get() == nullptr) { - VLOG(oat) << "OatFileAssistant test for existing oat file " - << filename_ - << ": " << error_msg; + VLOG(oat) << "OatFileAssistant test for existing oat file " << filename_ << ": " << error_msg; } else { VLOG(oat) << "Successfully loaded " << filename_ << " with executable: " << executable; } @@ -1195,13 +1180,12 @@ bool OatFileAssistant::ClassLoaderContextIsOkay(const OatFile& oat_file) const { return true; } - ClassLoaderContext::VerificationResult matches = context_->VerifyClassLoaderContextMatch( - oat_file.GetClassLoaderContext(), - /*verify_names=*/ true, - /*verify_checksums=*/ true); + ClassLoaderContext::VerificationResult matches = + context_->VerifyClassLoaderContextMatch(oat_file.GetClassLoaderContext(), + /*verify_names=*/true, + /*verify_checksums=*/true); if (matches == ClassLoaderContext::VerificationResult::kMismatch) { - VLOG(oat) << "ClassLoaderContext check failed. Context was " - << oat_file.GetClassLoaderContext() + VLOG(oat) << "ClassLoaderContext check failed. Context was " << oat_file.GetClassLoaderContext() << ". The expected context is " << context_->EncodeContextForOatFile(android::base::Dirname(dex_location_)); return false; @@ -1220,11 +1204,8 @@ void OatFileAssistant::OatFileInfo::Reset() { status_attempted_ = false; } -void OatFileAssistant::OatFileInfo::Reset(const std::string& filename, - bool use_fd, - int zip_fd, - int vdex_fd, - int oat_fd) { +void OatFileAssistant::OatFileInfo::Reset( + const std::string& filename, bool use_fd, int zip_fd, int vdex_fd, int oat_fd) { filename_provided_ = true; filename_ = filename; use_fd_ = use_fd; @@ -1265,19 +1246,15 @@ void OatFileAssistant::GetOptimizationStatus(const std::string& filename, /*only_load_trusted_executable=*/false, ofa_context); std::string out_odex_location; // unused - std::string out_odex_status; // unused + std::string out_odex_status; // unused oat_file_assistant.GetOptimizationStatus( - &out_odex_location, - out_compilation_filter, - out_compilation_reason, - &out_odex_status); + &out_odex_location, out_compilation_filter, out_compilation_reason, &out_odex_status); } -void OatFileAssistant::GetOptimizationStatus( - std::string* out_odex_location, - std::string* out_compilation_filter, - std::string* out_compilation_reason, - std::string* out_odex_status) { +void OatFileAssistant::GetOptimizationStatus(std::string* out_odex_location, + std::string* out_compilation_filter, + std::string* out_compilation_reason, + std::string* out_odex_status) { OatFileInfo& oat_file_info = GetBestInfo(); const OatFile* oat_file = GetBestInfo().GetFile(); diff --git a/runtime/oat_file_assistant_test.cc b/runtime/oat_file_assistant_test.cc index d34e6a7555..42350dc9f8 100644 --- a/runtime/oat_file_assistant_test.cc +++ b/runtime/oat_file_assistant_test.cc @@ -618,8 +618,8 @@ TEST_P(OatFileAssistantTest, GetDexOptNeededWithFd) { std::string vdex_location = GetScratchDir() + "/OatUpToDate.vdex"; Copy(GetDexSrc1(), dex_location); - GenerateOatForTest(dex_location.c_str(), - odex_location.c_str(), + GenerateOatForTest(dex_location, + odex_location, CompilerFilter::kSpeed, /* with_alternate_image= */ false); @@ -668,8 +668,8 @@ TEST_P(OatFileAssistantTest, GetDexOptNeededWithInvalidOdexFd) { std::string vdex_location = GetScratchDir() + "/OatUpToDate.vdex"; Copy(GetDexSrc1(), dex_location); - GenerateOatForTest(dex_location.c_str(), - odex_location.c_str(), + GenerateOatForTest(dex_location, + odex_location, CompilerFilter::kSpeed, /* with_alternate_image= */ false); @@ -716,8 +716,8 @@ TEST_P(OatFileAssistantTest, GetDexOptNeededWithInvalidVdexFd) { std::string odex_location = GetScratchDir() + "/OatUpToDate.odex"; Copy(GetDexSrc1(), dex_location); - GenerateOatForTest(dex_location.c_str(), - odex_location.c_str(), + GenerateOatForTest(dex_location, + odex_location, CompilerFilter::kSpeed, /* with_alternate_image= */ false); @@ -816,8 +816,8 @@ TEST_P(OatFileAssistantTest, EmptyVdexOdex) { std::string vdex_location = GetOdexDir() + "/EmptyVdexOdex.vdex"; Copy(GetDexSrc1(), dex_location); - ScratchFile vdex_file(vdex_location.c_str()); - ScratchFile odex_file(odex_location.c_str()); + ScratchFile vdex_file(vdex_location); + ScratchFile odex_file(odex_location); auto scoped_maybe_without_runtime = ScopedMaybeWithoutRuntime(); @@ -1163,7 +1163,7 @@ TEST_P(OatFileAssistantTest, OatContextOutOfDate) { auto scoped_maybe_without_runtime = ScopedMaybeWithoutRuntime(); VerifyOptimizationStatus( - dex_location.c_str(), context.get(), "verify", "vdex", "up-to-date", /*check_context=*/true); + dex_location, context.get(), "verify", "vdex", "up-to-date", /*check_context=*/true); } // Case: We have a DEX file and an ODEX file, but no OAT file. diff --git a/runtime/oat_file_test.cc b/runtime/oat_file_test.cc index f33235732a..80265f77f5 100644 --- a/runtime/oat_file_test.cc +++ b/runtime/oat_file_test.cc @@ -18,17 +18,15 @@ #include <string> -#include <gtest/gtest.h> - #include "common_runtime_test.h" #include "dexopt_test.h" +#include "gtest/gtest.h" #include "scoped_thread_state_change-inl.h" #include "vdex_file.h" namespace art { -class OatFileTest : public DexoptTest { -}; +class OatFileTest : public DexoptTest {}; TEST_F(OatFileTest, LoadOat) { std::string dex_location = GetScratchDir() + "/LoadOat.jar"; @@ -39,12 +37,13 @@ TEST_F(OatFileTest, LoadOat) { std::string oat_location; std::string error_msg; ASSERT_TRUE(OatFileAssistant::DexLocationToOatFilename( - dex_location, kRuntimeISA, &oat_location, &error_msg)) << error_msg; - std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/ -1, - oat_location.c_str(), - oat_location.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + dex_location, kRuntimeISA, &oat_location, &error_msg)) + << error_msg; + 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); @@ -62,15 +61,16 @@ TEST_F(OatFileTest, ChangingMultiDexUncompressed) { std::string oat_location; std::string error_msg; ASSERT_TRUE(OatFileAssistant::DexLocationToOatFilename( - dex_location, kRuntimeISA, &oat_location, &error_msg)) << error_msg; + dex_location, kRuntimeISA, &oat_location, &error_msg)) + << error_msg; // Ensure we can load that file. Just a precondition. { - std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/ -1, - oat_location.c_str(), - oat_location.c_str(), - /*executable=*/ false, - /*low_4gb=*/ false, + 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 != nullptr); @@ -81,11 +81,11 @@ TEST_F(OatFileTest, ChangingMultiDexUncompressed) { Copy(GetTestDexFileName("MainUncompressedAligned"), dex_location); // And try to load again. - std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/ -1, + std::unique_ptr<OatFile> odex_file(OatFile::Open(/*zip_fd=*/-1, oat_location, oat_location, - /*executable=*/ false, - /*low_4gb=*/ false, + /*executable=*/false, + /*low_4gb=*/false, dex_location, &error_msg)); EXPECT_TRUE(odex_file == nullptr); diff --git a/runtime/sdk_checker.cc b/runtime/sdk_checker.cc index 9097dc62a2..95023829a5 100644 --- a/runtime/sdk_checker.cc +++ b/runtime/sdk_checker.cc @@ -25,8 +25,7 @@ namespace art { SdkChecker::SdkChecker() : enabled_(true) {} -SdkChecker* SdkChecker::Create( - const std::string& public_sdk, std::string* error_msg) { +SdkChecker* SdkChecker::Create(const std::string& public_sdk, std::string* error_msg) { std::vector<std::string> dex_file_paths; Split(public_sdk, ':', &dex_file_paths); @@ -63,9 +62,7 @@ bool SdkChecker::ShouldDenyAccess(ArtMethod* art_method) const { dex::TypeIndex return_type_idx; std::vector<dex::TypeIndex> param_type_idxs; if (!dex_file->CreateTypeList( - art_method->GetSignature().ToString().c_str(), - &return_type_idx, - ¶m_type_idxs)) { + art_method->GetSignature().ToString(), &return_type_idx, ¶m_type_idxs)) { continue; } const dex::ProtoId* proto_id = dex_file->FindProtoId(return_type_idx, param_type_idxs); @@ -98,8 +95,8 @@ bool SdkChecker::ShouldDenyAccess(ArtField* art_field) const { for (const std::unique_ptr<const DexFile>& dex_file : sdk_dex_files_) { std::string declaring_class; - const dex::TypeId* declaring_type_id = dex_file->FindTypeId( - art_field->GetDeclaringClass()->GetDescriptor(&declaring_class)); + const dex::TypeId* declaring_type_id = + dex_file->FindTypeId(art_field->GetDeclaringClass()->GetDescriptor(&declaring_class)); if (declaring_type_id == nullptr) { continue; } diff --git a/runtime/verifier/verifier_deps.cc b/runtime/verifier/verifier_deps.cc index 781cf7bb79..e9e488b2f4 100644 --- a/runtime/verifier/verifier_deps.cc +++ b/runtime/verifier/verifier_deps.cc @@ -52,11 +52,8 @@ VerifierDeps::VerifierDeps(const std::vector<const DexFile*>& dex_files, bool ou // Size of `other` must be equal to size of `to_update`. static inline void BitVectorOr(std::vector<bool>& to_update, const std::vector<bool>& other) { DCHECK_EQ(to_update.size(), other.size()); - std::transform(other.begin(), - other.end(), - to_update.begin(), - to_update.begin(), - std::logical_or<bool>()); + std::transform( + other.begin(), other.end(), to_update.begin(), to_update.begin(), std::logical_or<bool>()); } void VerifierDeps::MergeWith(std::unique_ptr<VerifierDeps> other, @@ -175,8 +172,8 @@ dex::StringIndex VerifierDeps::GetIdFromString(const DexFile& dex_file, const st } } -std::string VerifierDeps::GetStringFromId(const DexFile& dex_file, dex::StringIndex string_id) - const { +std::string VerifierDeps::GetStringFromId(const DexFile& dex_file, + dex::StringIndex string_id) const { uint32_t num_ids_in_dex = dex_file.NumStringIds(); if (string_id.index_ < num_ids_in_dex) { return std::string(dex_file.StringDataByIdx(string_id)); @@ -224,10 +221,7 @@ void VerifierDeps::AddAssignability(const DexFile& dex_file, // Only perform the optimization if both types are resolved which guarantees // that they linked successfully, as required at the top of this method. if (destination_component->IsResolved() && source_component->IsResolved()) { - AddAssignability(dex_file, - class_def, - destination_component, - source_component); + AddAssignability(dex_file, class_def, destination_component, source_component); return; } } @@ -337,25 +331,29 @@ void VerifierDeps::MaybeRecordAssignability(VerifierDeps* verifier_deps, namespace { -template<typename T> inline uint32_t Encode(T in); +template <typename T> +inline uint32_t Encode(T in); -template<> inline uint32_t Encode<dex::StringIndex>(dex::StringIndex in) { +template <> +inline uint32_t Encode<dex::StringIndex>(dex::StringIndex in) { return in.index_; } -template<typename T> inline T Decode(uint32_t in); +template <typename T> +inline T Decode(uint32_t in); -template<> inline dex::StringIndex Decode<dex::StringIndex>(uint32_t in) { +template <> +inline dex::StringIndex Decode<dex::StringIndex>(uint32_t in) { return dex::StringIndex(in); } -template<typename T1, typename T2> +template <typename T1, typename T2> static inline void EncodeTuple(std::vector<uint8_t>* out, const std::tuple<T1, T2>& t) { EncodeUnsignedLeb128(out, Encode(std::get<0>(t))); EncodeUnsignedLeb128(out, Encode(std::get<1>(t))); } -template<typename T1, typename T2> +template <typename T1, typename T2> static inline bool DecodeTuple(const uint8_t** in, const uint8_t* end, std::tuple<T1, T2>* t) { uint32_t v1, v2; if (UNLIKELY(!DecodeUnsignedLeb128Checked(in, end, &v1)) || @@ -366,14 +364,14 @@ static inline bool DecodeTuple(const uint8_t** in, const uint8_t* end, std::tupl return true; } -template<typename T1, typename T2, typename T3> +template <typename T1, typename T2, typename T3> static inline void EncodeTuple(std::vector<uint8_t>* out, const std::tuple<T1, T2, T3>& t) { EncodeUnsignedLeb128(out, Encode(std::get<0>(t))); EncodeUnsignedLeb128(out, Encode(std::get<1>(t))); EncodeUnsignedLeb128(out, Encode(std::get<2>(t))); } -template<typename T1, typename T2, typename T3> +template <typename T1, typename T2, typename T3> static inline bool DecodeTuple(const uint8_t** in, const uint8_t* end, std::tuple<T1, T2, T3>* t) { uint32_t v1, v2, v3; if (UNLIKELY(!DecodeUnsignedLeb128Checked(in, end, &v1)) || @@ -393,7 +391,7 @@ static void SetUint32InUint8Array(std::vector<uint8_t>* out, (reinterpret_cast<uint32_t*>(out->data() + uint8_offset))[uint32_offset] = value; } -template<typename T> +template <typename T> static void EncodeSetVector(std::vector<uint8_t>* out, const std::vector<std::set<T>>& vector, const std::vector<bool>& verified_classes) { @@ -417,7 +415,7 @@ static void EncodeSetVector(std::vector<uint8_t>* out, SetUint32InUint8Array(out, offsets_index, class_def_index, out->size()); } -template<bool kFillSet, typename T> +template <bool kFillSet, typename T> static bool DecodeSetVector(const uint8_t** cursor, const uint8_t* start, const uint8_t* end, @@ -468,7 +466,7 @@ static inline void EncodeStringVector(std::vector<uint8_t>* out, uint32_t offsets_index = out->size(); // Make room for offsets for each string, +1 for putting the number of // strings. - out->resize(out->size() + (strings.size() + 1 ) * sizeof(uint32_t)); + out->resize(out->size() + (strings.size() + 1) * sizeof(uint32_t)); (reinterpret_cast<uint32_t*>(out->data() + offsets_index))[0] = strings.size(); uint32_t string_index = 1; for (const std::string& str : strings) { @@ -483,7 +481,7 @@ static inline void EncodeStringVector(std::vector<uint8_t>* out, } } -template<bool kFillVector> +template <bool kFillVector> static inline bool DecodeStringVector(const uint8_t** cursor, const uint8_t* start, const uint8_t* end, @@ -498,8 +496,8 @@ static inline bool DecodeStringVector(const uint8_t** cursor, for (uint32_t i = 0; i < num_strings; ++i) { uint32_t string_offset = reinterpret_cast<const uint32_t*>(offsets)[i + 1]; const char* string_start = reinterpret_cast<const char*>(start + string_offset); - const char* string_end = reinterpret_cast<const char*>( - memchr(string_start, 0, end - start - string_offset)); + const char* string_end = + reinterpret_cast<const char*>(memchr(string_start, 0, end - start - string_offset)); if (UNLIKELY(string_end == nullptr)) { return false; } @@ -537,16 +535,14 @@ bool VerifierDeps::DecodeDexFileDeps(DexFileDeps& deps, const uint8_t* data_start, const uint8_t* data_end, size_t num_class_defs) { - return - DecodeSetVector</*kFillSet=*/ !kOnlyVerifiedClasses>( - cursor, - data_start, - data_end, - &deps.assignable_types_, - &deps.verified_classes_, - num_class_defs) && - DecodeStringVector</*kFillVector=*/ !kOnlyVerifiedClasses>( - cursor, data_start, data_end, &deps.strings_); + return DecodeSetVector</*kFillSet=*/!kOnlyVerifiedClasses>(cursor, + data_start, + data_end, + &deps.assignable_types_, + &deps.verified_classes_, + num_class_defs) && + DecodeStringVector</*kFillVector=*/!kOnlyVerifiedClasses>( + cursor, data_start, data_end, &deps.strings_); } bool VerifierDeps::ParseStoredData(const std::vector<const DexFile*>& dex_files, @@ -566,11 +562,8 @@ bool VerifierDeps::ParseStoredData(const std::vector<const DexFile*>& dex_files, // Fetch the offset of this dex file's verifier data. cursor = data_start + reinterpret_cast<const uint32_t*>(data_start)[dex_file_index++]; size_t num_class_defs = dex_file->NumClassDefs(); - if (UNLIKELY(!DecodeDexFileDeps</*kOnlyVerifiedClasses=*/ false>(*deps, - &cursor, - data_start, - data_end, - num_class_defs))) { + if (UNLIKELY(!DecodeDexFileDeps</*kOnlyVerifiedClasses=*/false>( + *deps, &cursor, data_start, data_end, num_class_defs))) { LOG(ERROR) << "Failed to parse dex file dependencies for " << dex_file->GetLocation(); return false; } @@ -582,7 +575,7 @@ bool VerifierDeps::ParseStoredData(const std::vector<const DexFile*>& dex_files, bool VerifierDeps::ParseVerifiedClasses( const std::vector<const DexFile*>& dex_files, ArrayRef<const uint8_t> data, - /*out*/std::vector<std::vector<bool>>* verified_classes_per_dex) { + /*out*/ std::vector<std::vector<bool>>* verified_classes_per_dex) { DCHECK(!data.empty()); DCHECK(!dex_files.empty()); DCHECK(verified_classes_per_dex->empty()); @@ -594,16 +587,13 @@ bool VerifierDeps::ParseVerifiedClasses( const uint8_t* cursor = data_start; uint32_t dex_file_index = 0; for (const DexFile* dex_file : dex_files) { - DexFileDeps deps(/*num_class_defs=*/ 0u); // Do not initialize vectors. + DexFileDeps deps(/*num_class_defs=*/0u); // Do not initialize vectors. // Fetch the offset of this dex file's verifier data. cursor = data_start + reinterpret_cast<const uint32_t*>(data_start)[dex_file_index++]; size_t num_class_defs = dex_file->NumClassDefs(); deps.verified_classes_.resize(num_class_defs); - if (UNLIKELY(!DecodeDexFileDeps</*kOnlyVerifiedClasses=*/ true>(deps, - &cursor, - data_start, - data_end, - num_class_defs))) { + if (UNLIKELY(!DecodeDexFileDeps</*kOnlyVerifiedClasses=*/true>( + deps, &cursor, data_start, data_end, num_class_defs))) { LOG(ERROR) << "Failed to parse dex file dependencies for " << dex_file->GetLocation(); return false; } @@ -640,8 +630,7 @@ bool VerifierDeps::Equals(const VerifierDeps& rhs) const { } bool VerifierDeps::DexFileDeps::Equals(const VerifierDeps::DexFileDeps& rhs) const { - return (strings_ == rhs.strings_) && - (assignable_types_ == rhs.assignable_types_) && + return (strings_ == rhs.strings_) && (assignable_types_ == rhs.assignable_types_) && (verified_classes_ == rhs.verified_classes_); } @@ -653,18 +642,12 @@ void VerifierDeps::Dump(VariableIndentationOutputStream* vios) const { for (const auto& dep : dex_deps_) { dex_deps.emplace_back(dep.first, dep.second.get()); } - std::sort( - dex_deps.begin(), - dex_deps.end(), - [](const DepsEntry& lhs, const DepsEntry& rhs) { - return lhs.first->GetLocation() < rhs.first->GetLocation(); - }); + std::sort(dex_deps.begin(), dex_deps.end(), [](const DepsEntry& lhs, const DepsEntry& rhs) { + return lhs.first->GetLocation() < rhs.first->GetLocation(); + }); for (const auto& dep : dex_deps) { const DexFile& dex_file = *dep.first; - vios->Stream() - << "Dependencies of " - << dex_file.GetLocation() - << ":\n"; + vios->Stream() << "Dependencies of " << dex_file.GetLocation() << ":\n"; ScopedIndentation indent(vios); @@ -673,24 +656,18 @@ void VerifierDeps::Dump(VariableIndentationOutputStream* vios) const { } for (size_t idx = 0; idx < dep.second->assignable_types_.size(); idx++) { - vios->Stream() - << "Dependencies of " - << dex_file.GetClassDescriptor(dex_file.GetClassDef(idx)) - << ":\n"; + vios->Stream() << "Dependencies of " << dex_file.GetClassDescriptor(dex_file.GetClassDef(idx)) + << ":\n"; for (const TypeAssignability& entry : dep.second->assignable_types_[idx]) { - vios->Stream() - << GetStringFromId(dex_file, entry.GetSource()) - << " must be assignable to " - << GetStringFromId(dex_file, entry.GetDestination()) - << "\n"; + vios->Stream() << GetStringFromId(dex_file, entry.GetSource()) << " must be assignable to " + << GetStringFromId(dex_file, entry.GetDestination()) << "\n"; } } for (size_t idx = 0; idx < dep.second->verified_classes_.size(); idx++) { if (!dep.second->verified_classes_[idx]) { - vios->Stream() - << dex_file.GetClassDescriptor(dex_file.GetClassDef(idx)) - << " will be verified at runtime\n"; + vios->Stream() << dex_file.GetClassDescriptor(dex_file.GetClassDef(idx)) + << " will be verified at runtime\n"; } } } @@ -738,10 +715,9 @@ bool VerifierDeps::VerifyAssignability(Handle<mirror::ClassLoader> class_loader, for (const auto& entry : vec) { const std::string& destination_desc = GetStringFromId(dex_file, entry.GetDestination()); destination.Assign( - FindClassAndClearException(class_linker, self, destination_desc.c_str(), class_loader)); + FindClassAndClearException(class_linker, self, destination_desc, class_loader)); const std::string& source_desc = GetStringFromId(dex_file, entry.GetSource()); - source.Assign( - FindClassAndClearException(class_linker, self, source_desc.c_str(), class_loader)); + source.Assign(FindClassAndClearException(class_linker, self, source_desc, class_loader)); if (destination == nullptr || source == nullptr) { // We currently don't use assignability information for unresolved @@ -771,17 +747,12 @@ void VerifierDeps::ClearData(const std::vector<const DexFile*>& dex_files) { } } - bool VerifierDeps::VerifyDexFile(Handle<mirror::ClassLoader> class_loader, const DexFile& dex_file, const DexFileDeps& deps, Thread* self, /* out */ std::string* error_msg) const { - return VerifyAssignability(class_loader, - dex_file, - deps.assignable_types_, - self, - error_msg); + return VerifyAssignability(class_loader, dex_file, deps.assignable_types_, self, error_msg); } } // namespace verifier diff --git a/tools/dexanalyze/dexanalyze.cc b/tools/dexanalyze/dexanalyze.cc index 0a3cd8c8a8..79602aacbc 100644 --- a/tools/dexanalyze/dexanalyze.cc +++ b/tools/dexanalyze/dexanalyze.cc @@ -203,7 +203,7 @@ class DexAnalyze { for (const std::string& filename : options.filenames_) { std::string content; // TODO: once added, use an API to android::base to read a std::vector<uint8_t>. - if (!android::base::ReadFileToString(filename.c_str(), &content)) { + if (!android::base::ReadFileToString(filename, &content)) { LOG(ERROR) << "ReadFileToString failed for " + filename << std::endl; return kExitCodeFailedToOpenFile; } diff --git a/tools/veridex/veridex.cc b/tools/veridex/veridex.cc index 2ef236d70e..d2a32e6db1 100644 --- a/tools/veridex/veridex.cc +++ b/tools/veridex/veridex.cc @@ -297,7 +297,7 @@ class Veridex { } // TODO: once added, use an api to android::base to read a std::vector<uint8_t>. - if (!android::base::ReadFileToString(filename.c_str(), &content)) { + if (!android::base::ReadFileToString(filename, &content)) { *error_msg = "ReadFileToString failed for " + filename; return false; } @@ -306,7 +306,7 @@ class Veridex { static constexpr bool kVerifyChecksum = true; static constexpr bool kRunDexFileVerifier = true; DexFileLoader dex_file_loader( - reinterpret_cast<const uint8_t*>(content.data()), content.size(), filename.c_str()); + reinterpret_cast<const uint8_t*>(content.data()), content.size(), filename); if (!dex_file_loader.Open( kRunDexFileVerifier, kVerifyChecksum, &error_code, error_msg, dex_files)) { if (error_code == DexFileLoaderErrorCode::kEntryNotFound) { |