From b8472ee687235ed8e925b6e8bda46798b4b8a7fe Mon Sep 17 00:00:00 2001 From: Serban Constantinescu Date: Wed, 26 Oct 2016 11:15:00 +0100 Subject: [PATCH] ARM: Instruction set features clean-up. Clean-up the instruction set features for ARM. Remove all the CPU variants that are not supported or used with ART. Remove: - Old cpu variants (eg: arm7tdmi - does not have the features needed by ART). - M & R class cpu variants (currently ART only runs on A class cpus). - cpu variants that are unlikely to be used with ART (eg: cyclone). Test: mma test-art-target && mma test-art-host Change-Id: I2b7e5169022ea0a5a943281381b9446c52e17364 --- runtime/arch/arm/instruction_set_features_arm.cc | 77 ++++++++++------------ .../arch/arm/instruction_set_features_arm_test.cc | 44 ++++++------- 2 files changed, 58 insertions(+), 63 deletions(-) diff --git a/runtime/arch/arm/instruction_set_features_arm.cc b/runtime/arch/arm/instruction_set_features_arm.cc index e47aa6752..6c2c81576 100644 --- a/runtime/arch/arm/instruction_set_features_arm.cc +++ b/runtime/arch/arm/instruction_set_features_arm.cc @@ -41,59 +41,54 @@ ArmFeaturesUniquePtr ArmInstructionSetFeatures::FromVariant( const std::string& variant, std::string* error_msg) { // Look for variants that have divide support. static const char* arm_variants_with_div[] = { - "cortex-a7", "cortex-a12", "cortex-a15", "cortex-a17", "cortex-a53", "cortex-a57", - "cortex-a53.a57", "cortex-m3", "cortex-m4", "cortex-r4", "cortex-r5", - "cyclone", "denver", "krait", "swift" }; + "cortex-a7", + "cortex-a12", + "cortex-a15", + "cortex-a17", + "cortex-a53", + "cortex-a53.a57", + "cortex-a57", + "denver", + "krait", + }; - bool has_div = FindVariantInArray(arm_variants_with_div, arraysize(arm_variants_with_div), + bool has_div = FindVariantInArray(arm_variants_with_div, + arraysize(arm_variants_with_div), variant); // Look for variants that have LPAE support. static const char* arm_variants_with_lpae[] = { - "cortex-a7", "cortex-a15", "krait", "denver", "cortex-a53", "cortex-a57", "cortex-a53.a57" + "cortex-a7", + "cortex-a12", + "cortex-a15", + "cortex-a17", + "cortex-a53", + "cortex-a53.a57", + "cortex-a57", + "denver", + "krait", }; - bool has_lpae = FindVariantInArray(arm_variants_with_lpae, arraysize(arm_variants_with_lpae), + bool has_lpae = FindVariantInArray(arm_variants_with_lpae, + arraysize(arm_variants_with_lpae), variant); if (has_div == false && has_lpae == false) { - // Avoid unsupported variants. - static const char* unsupported_arm_variants[] = { - // ARM processors that aren't ARMv7 compatible aren't supported. - "arm2", "arm250", "arm3", "arm6", "arm60", "arm600", "arm610", "arm620", - "cortex-m0", "cortex-m0plus", "cortex-m1", - "fa526", "fa626", "fa606te", "fa626te", "fmp626", "fa726te", - "iwmmxt", "iwmmxt2", - "strongarm", "strongarm110", "strongarm1100", "strongarm1110", - "xscale" - }; - if (FindVariantInArray(unsupported_arm_variants, arraysize(unsupported_arm_variants), - variant)) { - *error_msg = StringPrintf("Attempt to use unsupported ARM variant: %s", variant.c_str()); - return ArmFeaturesUniquePtr(); - } - // Warn if the variant is unknown. - // TODO: some of the variants below may have feature support, but that support is currently - // unknown so we'll choose conservative (sub-optimal) defaults without warning. - // TODO: some of the architectures may not support all features required by ART and should be - // moved to unsupported_arm_variants[] above. - static const char* arm_variants_without_known_features[] = { + static const char* arm_variants_with_default_features[] = { + "cortex-a5", + "cortex-a8", + "cortex-a9", + "cortex-a9-mp", "default", - "arm7", "arm7m", "arm7d", "arm7dm", "arm7di", "arm7dmi", "arm70", "arm700", "arm700i", - "arm710", "arm710c", "arm7100", "arm720", "arm7500", "arm7500fe", "arm7tdmi", "arm7tdmi-s", - "arm710t", "arm720t", "arm740t", - "arm8", "arm810", - "arm9", "arm9e", "arm920", "arm920t", "arm922t", "arm946e-s", "arm966e-s", "arm968e-s", - "arm926ej-s", "arm940t", "arm9tdmi", - "arm10tdmi", "arm1020t", "arm1026ej-s", "arm10e", "arm1020e", "arm1022e", - "arm1136j-s", "arm1136jf-s", - "arm1156t2-s", "arm1156t2f-s", "arm1176jz-s", "arm1176jzf-s", - "cortex-a5", "cortex-a8", "cortex-a9", "cortex-a9-mp", "cortex-r4f", - "marvell-pj4", "mpcore", "mpcorenovfp" + "generic" }; - if (!FindVariantInArray(arm_variants_without_known_features, - arraysize(arm_variants_without_known_features), + if (!FindVariantInArray(arm_variants_with_default_features, + arraysize(arm_variants_with_default_features), variant)) { - LOG(WARNING) << "Unknown instruction set features for ARM CPU variant (" << variant + *error_msg = StringPrintf("Attempt to use unsupported ARM variant: %s", variant.c_str()); + return nullptr; + } else { + // Warn if we use the default features. + LOG(WARNING) << "Using default instruction set features for ARM CPU variant (" << variant << ") using conservative defaults"; } } diff --git a/runtime/arch/arm/instruction_set_features_arm_test.cc b/runtime/arch/arm/instruction_set_features_arm_test.cc index 7abe53c9b..697ca9015 100644 --- a/runtime/arch/arm/instruction_set_features_arm_test.cc +++ b/runtime/arch/arm/instruction_set_features_arm_test.cc @@ -48,17 +48,17 @@ TEST(ArmInstructionSetFeaturesTest, ArmFeaturesFromVariant) { EXPECT_EQ(denver_features->AsBitmap(), 3U); // Build features for a 32-bit ARMv7 processor. - std::unique_ptr arm7_features( - InstructionSetFeatures::FromVariant(kArm, "arm7", &error_msg)); - ASSERT_TRUE(arm7_features.get() != nullptr) << error_msg; - - EXPECT_TRUE(arm7_features->Equals(arm7_features.get())); - EXPECT_FALSE(arm7_features->Equals(krait_features.get())); - EXPECT_FALSE(krait_features->Equals(arm7_features.get())); - EXPECT_FALSE(arm7_features->AsArmInstructionSetFeatures()->HasDivideInstruction()); - EXPECT_FALSE(arm7_features->AsArmInstructionSetFeatures()->HasAtomicLdrdAndStrd()); - EXPECT_STREQ("-div,-atomic_ldrd_strd", arm7_features->GetFeatureString().c_str()); - EXPECT_EQ(arm7_features->AsBitmap(), 0U); + std::unique_ptr generic_features( + InstructionSetFeatures::FromVariant(kArm, "generic", &error_msg)); + ASSERT_TRUE(generic_features.get() != nullptr) << error_msg; + + EXPECT_TRUE(generic_features->Equals(generic_features.get())); + EXPECT_FALSE(generic_features->Equals(krait_features.get())); + EXPECT_FALSE(krait_features->Equals(generic_features.get())); + EXPECT_FALSE(generic_features->AsArmInstructionSetFeatures()->HasDivideInstruction()); + EXPECT_FALSE(generic_features->AsArmInstructionSetFeatures()->HasAtomicLdrdAndStrd()); + EXPECT_STREQ("-div,-atomic_ldrd_strd", generic_features->GetFeatureString().c_str()); + EXPECT_EQ(generic_features->AsBitmap(), 0U); // ARM6 is not a supported architecture variant. std::unique_ptr arm6_features( @@ -70,7 +70,7 @@ TEST(ArmInstructionSetFeaturesTest, ArmFeaturesFromVariant) { TEST(ArmInstructionSetFeaturesTest, ArmAddFeaturesFromString) { std::string error_msg; std::unique_ptr base_features( - InstructionSetFeatures::FromVariant(kArm, "arm7", &error_msg)); + InstructionSetFeatures::FromVariant(kArm, "generic", &error_msg)); ASSERT_TRUE(base_features.get() != nullptr) << error_msg; // Build features for a 32-bit ARM with LPAE and div processor. @@ -99,17 +99,17 @@ TEST(ArmInstructionSetFeaturesTest, ArmAddFeaturesFromString) { EXPECT_EQ(denver_features->AsBitmap(), 3U); // Build features for a 32-bit default ARM processor. - std::unique_ptr arm7_features( + std::unique_ptr generic_features( base_features->AddFeaturesFromString("default", &error_msg)); - ASSERT_TRUE(arm7_features.get() != nullptr) << error_msg; - - EXPECT_TRUE(arm7_features->Equals(arm7_features.get())); - EXPECT_FALSE(arm7_features->Equals(krait_features.get())); - EXPECT_FALSE(krait_features->Equals(arm7_features.get())); - EXPECT_FALSE(arm7_features->AsArmInstructionSetFeatures()->HasDivideInstruction()); - EXPECT_FALSE(arm7_features->AsArmInstructionSetFeatures()->HasAtomicLdrdAndStrd()); - EXPECT_STREQ("-div,-atomic_ldrd_strd", arm7_features->GetFeatureString().c_str()); - EXPECT_EQ(arm7_features->AsBitmap(), 0U); + ASSERT_TRUE(generic_features.get() != nullptr) << error_msg; + + EXPECT_TRUE(generic_features->Equals(generic_features.get())); + EXPECT_FALSE(generic_features->Equals(krait_features.get())); + EXPECT_FALSE(krait_features->Equals(generic_features.get())); + EXPECT_FALSE(generic_features->AsArmInstructionSetFeatures()->HasDivideInstruction()); + EXPECT_FALSE(generic_features->AsArmInstructionSetFeatures()->HasAtomicLdrdAndStrd()); + EXPECT_STREQ("-div,-atomic_ldrd_strd", generic_features->GetFeatureString().c_str()); + EXPECT_EQ(generic_features->AsBitmap(), 0U); } } // namespace art -- 2.11.0