This is an archive of the discontinued LLVM Phabricator instance.

Differential D93392

[llvm][ARM/AArch64] Convert Target Parser CPU tests to fixtures
ClosedPublic

Authored by DavidSpickett on Dec 16 2020, 4:59 AM.

Details

Reviewers
a.sidorin
MarkMurrayARM
Commits
rGa6783cd7b65d: [llvm][ARM/AArch64] Convert Target Parser CPU tests to fixtures
Summary

Also convert the test function to use EXPECT_EQ and
remove the special case for the AEK_NONE extension.

This means that each test is marked as failing separatley
and the accumultated EXPECT failures are printed next
to that test, with its parameters.

Before they would be hidden by the "pass &=" pattern
and failures would print in one block since it was a
"single" test.

Example of the new failure messages:

ARMCPUTestsPart1/ARMCPUTestFixture.ARMCPUTests/6
[==========] Running 1 test from 1 test case.
[----------] Global test environment set-up.
[----------] 1 test from ARMCPUTestsPart1/ARMCPUTestFixture
[ RUN      ] ARMCPUTestsPart1/ARMCPUTestFixture.ARMCPUTests/6
/work/open_source/nightly-llvm/llvm-project/llvm/unittests/Support/TargetParserTest.cpp:66:
Failure
      Expected: params.ExpectedFlags
      Which is: 3405705229
To be equal to: default_extensions
      Which is: 1
[  FAILED  ] ARMCPUTestsPart1/ARMCPUTestFixture.ARMCPUTests/6, where
GetParam() = "arm8", "armv4", "none", 0xcafef00d, "4" (0 ms)

Diff Detail

Unit TestsFailed

TimeTest
16,149 msx64 debian > LLVM.Bindings/Go::go.test
60 msx64 windows > LLVM.CodeGen/XCore::threads.ll

Event Timeline

DavidSpickett created this revision.Dec 16 2020, 4:59 AM
Herald added a reviewer: a.sidorin. · View Herald TranscriptDec 16 2020, 4:59 AM
Herald added subscribers: danielkiss, kristof.beyls. · View Herald Transcript
DavidSpickett requested review of this revision.Dec 16 2020, 4:59 AM
Herald added a project: Restricted Project. · View Herald TranscriptDec 16 2020, 4:59 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
Harbormaster completed remote builds in B82625: Diff 312178.Dec 16 2020, 5:00 AM
DavidSpickett added a parent revision: D93387: [llvm][AArch64] Actually check expected FPU for CPUs.Dec 16 2020, 5:01 AM
DavidSpickett added a reviewer: MarkMurrayARM.

I will add a better expect printer for the extension bitfields in a future change, just reorganising the tests here.

fhahn added a subscriber: fhahn.Dec 16 2020, 5:06 AM
fhahn added inline comments.
llvm/unittests/Support/TargetParserTest.cpp
35–36

Can a struct be used instead here? That would make things much more readable IMO/

DavidSpickett updated this revision to Diff 312179.Dec 16 2020, 5:06 AM
  • replace const char* with StringRef in test params
DavidSpickett added inline comments.Dec 16 2020, 5:07 AM
llvm/unittests/Support/TargetParserTest.cpp
35–36

Will do.

DavidSpickett updated this revision to Diff 312184.Dec 16 2020, 5:17 AM

Change test params to a structure.

DavidSpickett marked an inline comment as done.Dec 16 2020, 5:17 AM
DavidSpickett updated this revision to Diff 312185.Dec 16 2020, 5:18 AM
  • clang format
DavidSpickett added inline comments.Dec 16 2020, 5:19 AM
llvm/unittests/Support/TargetParserTest.cpp
933

This is an example where the CPU has AEK_NONE for its additional extensions and the tests had a special path for that.

I don't think there's much merit to that so I've just added AEK_NONE for those CPUs that don't extend the base arch.

Harbormaster completed remote builds in B82626: Diff 312179.Dec 16 2020, 5:40 AM
Harbormaster completed remote builds in B82629: Diff 312185.Dec 16 2020, 5:51 AM
Harbormaster completed remote builds in B82628: Diff 312184.Dec 16 2020, 5:59 AM
MarkMurrayARM accepted this revision.Dec 16 2020, 6:09 AM

The proposed output contains the exact information I needed with my naive attempt. Also, it does not introduce the technical debt that my hack would have.

This revision is now accepted and ready to land.Dec 16 2020, 6:09 AM
DavidSpickett edited the summary of this revision. (Show Details)Dec 16 2020, 6:33 AM
DavidSpickett updated this revision to Diff 312217.Dec 16 2020, 7:59 AM

Added a custom formatter for the params struct.
(the default is to print the bytes of the struct)

DavidSpickett edited the summary of this revision. (Show Details)Dec 16 2020, 8:00 AM
Harbormaster completed remote builds in B82646: Diff 312217.Dec 16 2020, 8:37 AM
DavidSpickett added a child revision: D93448: [llvm][Arm/AArch64] Format extension flags in CPU test failures.Dec 17 2020, 3:05 AM
DavidSpickett added a comment.Dec 17 2020, 3:08 AM

@MarkMurrayARM Just updated to properly format the struct, the example in the summary is updated to what you'll get.

Also posted https://reviews.llvm.org/D93448 for printing the extensions, please take a look.

DavidSpickett updated this revision to Diff 312807.Dec 18 2020, 8:13 AM
  • Remove unused includes
Harbormaster completed remote builds in B82973: Diff 312807.Dec 18 2020, 8:56 AM
DavidSpickett updated this revision to Diff 313055.Dec 21 2020, 2:49 AM
  • Remove double AEK_NONE in arm1136jf-s test
Harbormaster completed remote builds in B83119: Diff 313055.Dec 21 2020, 3:25 AM
This revision was landed with ongoing or failed builds.Dec 22 2020, 1:07 AM
Closed by commit rGa6783cd7b65d: [llvm][ARM/AArch64] Convert Target Parser CPU tests to fixtures (authored by DavidSpickett). · Explain Why
This revision was automatically updated to reflect the committed changes.
DavidSpickett added a commit: rGa6783cd7b65d: [llvm][ARM/AArch64] Convert Target Parser CPU tests to fixtures.
MarkMurrayARM added a comment.Dec 22 2020, 1:14 AM

I remain content.

Revision Contents

PathSize
llvm/
unittests/
Support/
1061 lines

Diff 312185

llvm/unittests/Support/TargetParserTest.cpp

//===----------- TargetParser.cpp - Target Parser -------------------------===// //===----------- TargetParser.cpp - Target Parser -------------------------===//
Lint: Lint
Inline Actions

clang-format not found in user's PATH; not linting file.

Lint: Lint: clang-format not found in user's PATH; not linting file.
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/Support/TargetParser.h" #include "llvm/Support/TargetParser.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/Support/ARMBuildAttributes.h" #include "llvm/Support/ARMBuildAttributes.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include <string> #include <string>
#include <tuple>
using namespace llvm; using namespace llvm;
namespace { namespace {
const char *ARMArch[] = { const char *ARMArch[] = {
"armv2", "armv2a", "armv3", "armv3m", "armv4", "armv2", "armv2a", "armv3", "armv3m", "armv4",
"armv4t", "armv5", "armv5t", "armv5e", "armv5te", "armv4t", "armv5", "armv5t", "armv5e", "armv5te",
"armv5tej", "armv6", "armv6j", "armv6k", "armv6hl", "armv5tej", "armv6", "armv6j", "armv6k", "armv6hl",
"armv6t2", "armv6kz", "armv6z", "armv6zk", "armv6-m", "armv6t2", "armv6kz", "armv6z", "armv6zk", "armv6-m",
"armv6m", "armv6sm", "armv6s-m", "armv7-a", "armv7", "armv6m", "armv6sm", "armv6s-m", "armv7-a", "armv7",
"armv7a", "armv7ve", "armv7hl", "armv7l", "armv7-r", "armv7a", "armv7ve", "armv7hl", "armv7l", "armv7-r",
"armv7r", "armv7-m", "armv7m", "armv7k", "armv7s", "armv7r", "armv7-m", "armv7m", "armv7k", "armv7s",
"armv7e-m", "armv7em", "armv8-a", "armv8", "armv8a", "armv7e-m", "armv7em", "armv8-a", "armv8", "armv8a",
"armv8l", "armv8.1-a", "armv8.1a", "armv8.2-a", "armv8.2a", "armv8l", "armv8.1-a", "armv8.1a", "armv8.2-a", "armv8.2a",
"armv8.3-a", "armv8.3a", "armv8.4-a", "armv8.4a", "armv8.5-a", "armv8.3-a", "armv8.3a", "armv8.4-a", "armv8.4a", "armv8.5-a",
"armv8.5a", "armv8.6-a", "armv8.6a", "armv8-r", "armv8r", "armv8.5a", "armv8.6-a", "armv8.6a", "armv8-r", "armv8r",
"armv8-m.base", "armv8m.base", "armv8-m.main", "armv8m.main", "iwmmxt", "armv8-m.base", "armv8m.base", "armv8-m.main", "armv8m.main", "iwmmxt",
"iwmmxt2", "xscale", "armv8.1-m.main", "iwmmxt2", "xscale", "armv8.1-m.main",
}; };
bool testARMCPU(StringRef CPUName, StringRef ExpectedArch, struct ARMCPUTestParams {
fhahnUnsubmitted
Done
ReplyInline Actions

Can a struct be used instead here? That would make things much more readable IMO/

fhahn: Can a struct be used instead here? That would make things much more readable IMO/
DavidSpickettAuthorUnsubmitted
Done
ReplyInline Actions

Will do.

DavidSpickett: Will do.
ARMCPUTestParams(StringRef CPUName, StringRef ExpectedArch,
StringRef ExpectedFPU, uint64_t ExpectedFlags, StringRef ExpectedFPU, uint64_t ExpectedFlags,
StringRef CPUAttr) { StringRef CPUAttr)
ARM::ArchKind AK = ARM::parseCPUArch(CPUName); : CPUName(CPUName), ExpectedArch(ExpectedArch), ExpectedFPU(ExpectedFPU),
bool pass = ARM::getArchName(AK).equals(ExpectedArch); ExpectedFlags(ExpectedFlags), CPUAttr(CPUAttr) {}
unsigned FPUKind = ARM::getDefaultFPU(CPUName, AK);
pass &= ARM::getFPUName(FPUKind).equals(ExpectedFPU); StringRef CPUName;
StringRef ExpectedArch;
uint64_t ExtKind = ARM::getDefaultExtensions(CPUName, AK); StringRef ExpectedFPU;
if (ExtKind > 1 && (ExtKind & ARM::AEK_NONE)) uint64_t ExpectedFlags;
pass &= ((ExtKind ^ ARM::AEK_NONE) == ExpectedFlags); StringRef CPUAttr;
else };
pass &= (ExtKind == ExpectedFlags);
pass &= ARM::getCPUAttr(AK).equals(CPUAttr);
return pass; class ARMCPUTestFixture : public ::testing::TestWithParam<ARMCPUTestParams> {};
}
TEST_P(ARMCPUTestFixture, ARMCPUTests) {
auto params = GetParam();
Lint: Pre-merge checks
Inline Actions

clang-tidy: warning: invalid case style for variable 'params' [readability-identifier-naming]
not useful

Lint: Pre-merge checks: clang-tidy: warning: invalid case style for variable 'params' [readability-identifier-naming]…
ARM::ArchKind AK = ARM::parseCPUArch(params.CPUName);
EXPECT_EQ(params.ExpectedArch, ARM::getArchName(AK));
TEST(TargetParserTest, testARMCPU) { unsigned FPUKind = ARM::getDefaultFPU(params.CPUName, AK);
EXPECT_TRUE(testARMCPU("invalid", "invalid", "invalid", EXPECT_EQ(params.ExpectedFPU, ARM::getFPUName(FPUKind));
ARM::AEK_NONE, ""));
EXPECT_TRUE(testARMCPU("generic", "invalid", "none", uint64_t default_extensions = ARM::getDefaultExtensions(params.CPUName, AK);
Lint: Pre-merge checks
Inline Actions

clang-tidy: warning: invalid case style for variable 'default_extensions' [readability-identifier-naming]
not useful

Lint: Pre-merge checks: clang-tidy: warning: invalid case style for variable 'default_extensions' [readability…
ARM::AEK_NONE, "")); EXPECT_EQ(params.ExpectedFlags, default_extensions);
EXPECT_TRUE(testARMCPU("arm2", "armv2", "none", EXPECT_EQ(params.CPUAttr, ARM::getCPUAttr(AK));
ARM::AEK_NONE, "2")); }
EXPECT_TRUE(testARMCPU("arm3", "armv2a", "none",
ARM::AEK_NONE, "2A")); // Note that we include ARM::AEK_NONE even when there are other extensions
EXPECT_TRUE(testARMCPU("arm6", "armv3", "none", // we expect. This is because the default extensions for a CPU are the sum
ARM::AEK_NONE, "3")); // of the default extensions for its architecture and for the CPU.
EXPECT_TRUE(testARMCPU("arm7m", "armv3m", "none", // So if a CPU has no extra extensions, it adds AEK_NONE.
ARM::AEK_NONE, "3M")); INSTANTIATE_TEST_CASE_P(
EXPECT_TRUE(testARMCPU("arm8", "armv4", "none", ARMCPUTestsPart1, ARMCPUTestFixture,
ARM::AEK_NONE, "4")); ::testing::Values(
EXPECT_TRUE(testARMCPU("arm810", "armv4", "none", ARMCPUTestParams("invalid", "invalid", "invalid", ARM::AEK_NONE, ""),
ARM::AEK_NONE, "4")); ARMCPUTestParams("generic", "invalid", "none", ARM::AEK_NONE, ""),
EXPECT_TRUE(testARMCPU("strongarm", "armv4", "none",
ARM::AEK_NONE, "4")); ARMCPUTestParams("arm2", "armv2", "none", ARM::AEK_NONE, "2"),
EXPECT_TRUE(testARMCPU("strongarm110", "armv4", "none", ARMCPUTestParams("arm3", "armv2a", "none", ARM::AEK_NONE, "2A"),
ARM::AEK_NONE, "4")); ARMCPUTestParams("arm6", "armv3", "none", ARM::AEK_NONE, "3"),
EXPECT_TRUE(testARMCPU("strongarm1100", "armv4", "none", ARMCPUTestParams("arm7m", "armv3m", "none", ARM::AEK_NONE, "3M"),
ARM::AEK_NONE, "4")); ARMCPUTestParams("arm8", "armv4", "none", ARM::AEK_NONE, "4"),
EXPECT_TRUE(testARMCPU("strongarm1110", "armv4", "none", ARMCPUTestParams("arm810", "armv4", "none", ARM::AEK_NONE, "4"),
ARM::AEK_NONE, "4")); ARMCPUTestParams("strongarm", "armv4", "none", ARM::AEK_NONE, "4"),
EXPECT_TRUE(testARMCPU("arm7tdmi", "armv4t", "none", ARMCPUTestParams("strongarm110", "armv4", "none", ARM::AEK_NONE, "4"),
ARM::AEK_NONE, "4T")); ARMCPUTestParams("strongarm1100", "armv4", "none", ARM::AEK_NONE, "4"),
EXPECT_TRUE(testARMCPU("arm7tdmi-s", "armv4t", "none", ARMCPUTestParams("strongarm1110", "armv4", "none", ARM::AEK_NONE, "4"),
ARM::AEK_NONE, "4T")); ARMCPUTestParams("arm7tdmi", "armv4t", "none", ARM::AEK_NONE, "4T"),
EXPECT_TRUE(testARMCPU("arm710t", "armv4t", "none", ARMCPUTestParams("arm7tdmi-s", "armv4t", "none", ARM::AEK_NONE, "4T"),
ARM::AEK_NONE, "4T")); ARMCPUTestParams("arm710t", "armv4t", "none", ARM::AEK_NONE, "4T"),
EXPECT_TRUE(testARMCPU("arm720t", "armv4t", "none", ARMCPUTestParams("arm720t", "armv4t", "none", ARM::AEK_NONE, "4T"),
ARM::AEK_NONE, "4T")); ARMCPUTestParams("arm9", "armv4t", "none", ARM::AEK_NONE, "4T"),
EXPECT_TRUE(testARMCPU("arm9", "armv4t", "none", ARMCPUTestParams("arm9tdmi", "armv4t", "none", ARM::AEK_NONE, "4T"),
ARM::AEK_NONE, "4T")); ARMCPUTestParams("arm920", "armv4t", "none", ARM::AEK_NONE, "4T"),
EXPECT_TRUE(testARMCPU("arm9tdmi", "armv4t", "none", ARMCPUTestParams("arm920t", "armv4t", "none", ARM::AEK_NONE, "4T"),
ARM::AEK_NONE, "4T")); ARMCPUTestParams("arm922t", "armv4t", "none", ARM::AEK_NONE, "4T"),
EXPECT_TRUE(testARMCPU("arm920", "armv4t", "none", ARMCPUTestParams("arm9312", "armv4t", "none", ARM::AEK_NONE, "4T"),
ARM::AEK_NONE, "4T")); ARMCPUTestParams("arm940t", "armv4t", "none", ARM::AEK_NONE, "4T"),
EXPECT_TRUE(testARMCPU("arm920t", "armv4t", "none", ARMCPUTestParams("ep9312", "armv4t", "none", ARM::AEK_NONE, "4T"),
ARM::AEK_NONE, "4T")); ARMCPUTestParams("arm10tdmi", "armv5t", "none", ARM::AEK_NONE, "5T"),
EXPECT_TRUE(testARMCPU("arm922t", "armv4t", "none", ARMCPUTestParams("arm1020t", "armv5t", "none", ARM::AEK_NONE, "5T"),
ARM::AEK_NONE, "4T")); ARMCPUTestParams("arm9e", "armv5te", "none",
EXPECT_TRUE(testARMCPU("arm9312", "armv4t", "none", ARM::AEK_NONE | ARM::AEK_DSP, "5TE"),
ARM::AEK_NONE, "4T")); ARMCPUTestParams("arm946e-s", "armv5te", "none",
EXPECT_TRUE(testARMCPU("arm940t", "armv4t", "none", ARM::AEK_NONE | ARM::AEK_DSP, "5TE"),
ARM::AEK_NONE, "4T")); ARMCPUTestParams("arm966e-s", "armv5te", "none",
EXPECT_TRUE(testARMCPU("ep9312", "armv4t", "none", ARM::AEK_NONE | ARM::AEK_DSP, "5TE"),
ARM::AEK_NONE, "4T")); ARMCPUTestParams("arm968e-s", "armv5te", "none",
EXPECT_TRUE(testARMCPU("arm10tdmi", "armv5t", "none", ARM::AEK_NONE | ARM::AEK_DSP, "5TE"),
ARM::AEK_NONE, "5T")); ARMCPUTestParams("arm10e", "armv5te", "none",
EXPECT_TRUE(testARMCPU("arm1020t", "armv5t", "none", ARM::AEK_NONE | ARM::AEK_DSP, "5TE"),
ARM::AEK_NONE, "5T")); ARMCPUTestParams("arm1020e", "armv5te", "none",
EXPECT_TRUE(testARMCPU("arm9e", "armv5te", "none", ARM::AEK_NONE | ARM::AEK_DSP, "5TE"),
ARM::AEK_DSP, "5TE")); ARMCPUTestParams("arm1022e", "armv5te", "none",
EXPECT_TRUE(testARMCPU("arm946e-s", "armv5te", "none", ARM::AEK_NONE | ARM::AEK_DSP, "5TE"),
ARM::AEK_DSP, "5TE")); ARMCPUTestParams("arm926ej-s", "armv5tej", "none",
EXPECT_TRUE(testARMCPU("arm966e-s", "armv5te", "none", ARM::AEK_NONE | ARM::AEK_DSP, "5TEJ"),
ARM::AEK_DSP, "5TE")); ARMCPUTestParams("arm1136j-s", "armv6", "none",
EXPECT_TRUE(testARMCPU("arm968e-s", "armv5te", "none", ARM::AEK_NONE | ARM::AEK_DSP, "6"),
ARM::AEK_DSP, "5TE")); ARMCPUTestParams("arm1136jf-s", "armv6", "vfpv2",
EXPECT_TRUE(testARMCPU("arm10e", "armv5te", "none", ARM::AEK_NONE | ARM::AEK_NONE | ARM::AEK_DSP, "6"),
ARM::AEK_DSP, "5TE")); ARMCPUTestParams("arm1136jz-s", "armv6", "none",
EXPECT_TRUE(testARMCPU("arm1020e", "armv5te", "none", ARM::AEK_NONE | ARM::AEK_DSP, "6"),
ARM::AEK_DSP, "5TE")); ARMCPUTestParams("arm1176jz-s", "armv6kz", "none",
EXPECT_TRUE(testARMCPU("arm1022e", "armv5te", "none", ARM::AEK_NONE | ARM::AEK_SEC | ARM::AEK_DSP, "6KZ"),
ARM::AEK_DSP, "5TE")); ARMCPUTestParams("mpcore", "armv6k", "vfpv2",
EXPECT_TRUE(testARMCPU("arm926ej-s", "armv5tej", "none", ARM::AEK_NONE | ARM::AEK_DSP, "6K"),
ARM::AEK_DSP, "5TEJ")); ARMCPUTestParams("mpcorenovfp", "armv6k", "none",
EXPECT_TRUE(testARMCPU("arm1136j-s", "armv6", "none", ARM::AEK_NONE | ARM::AEK_DSP, "6K"),
ARM::AEK_DSP, "6")); ARMCPUTestParams("arm1176jzf-s", "armv6kz", "vfpv2",
EXPECT_TRUE(testARMCPU("arm1136jf-s", "armv6", "vfpv2", ARM::AEK_NONE | ARM::AEK_SEC | ARM::AEK_DSP, "6KZ"),
ARM::AEK_DSP, "6")); ARMCPUTestParams("arm1156t2-s", "armv6t2", "none",
EXPECT_TRUE(testARMCPU("arm1136jz-s", "armv6", "none", ARM::AEK_NONE | ARM::AEK_DSP, "6T2"),
ARM::AEK_DSP, "6")); ARMCPUTestParams("arm1156t2f-s", "armv6t2", "vfpv2",
EXPECT_TRUE(testARMCPU("arm1176jz-s", "armv6kz", "none", ARM::AEK_NONE | ARM::AEK_DSP, "6T2"),
ARM::AEK_SEC | ARM::AEK_DSP, "6KZ")); ARMCPUTestParams("cortex-m0", "armv6-m", "none", ARM::AEK_NONE, "6-M"),
EXPECT_TRUE(testARMCPU("mpcore", "armv6k", "vfpv2", ARMCPUTestParams("cortex-m0plus", "armv6-m", "none", ARM::AEK_NONE,
ARM::AEK_DSP, "6K")); "6-M"),
EXPECT_TRUE(testARMCPU("mpcorenovfp", "armv6k", "none", ARMCPUTestParams("cortex-m1", "armv6-m", "none", ARM::AEK_NONE, "6-M"),
ARM::AEK_DSP, "6K")); ARMCPUTestParams("sc000", "armv6-m", "none", ARM::AEK_NONE, "6-M"),
EXPECT_TRUE(testARMCPU("arm1176jzf-s", "armv6kz", "vfpv2", ARMCPUTestParams("cortex-a5", "armv7-a", "neon-vfpv4",
ARM::AEK_SEC | ARM::AEK_DSP, "6KZ")); ARM::AEK_MP | ARM::AEK_SEC | ARM::AEK_DSP, "7-A"),
EXPECT_TRUE(testARMCPU("arm1156t2-s", "armv6t2", "none", ARMCPUTestParams("cortex-a7", "armv7-a", "neon-vfpv4",
ARM::AEK_DSP, "6T2"));
EXPECT_TRUE(testARMCPU("arm1156t2f-s", "armv6t2", "vfpv2",
ARM::AEK_DSP, "6T2"));
EXPECT_TRUE(testARMCPU("cortex-m0", "armv6-m", "none",
ARM::AEK_NONE, "6-M"));
EXPECT_TRUE(testARMCPU("cortex-m0plus", "armv6-m", "none",
ARM::AEK_NONE, "6-M"));
EXPECT_TRUE(testARMCPU("cortex-m1", "armv6-m", "none",
ARM::AEK_NONE, "6-M"));
EXPECT_TRUE(testARMCPU("sc000", "armv6-m", "none",
ARM::AEK_NONE, "6-M"));
EXPECT_TRUE(testARMCPU("cortex-a5", "armv7-a", "neon-vfpv4",
ARM::AEK_MP | ARM::AEK_SEC | ARM::AEK_DSP, "7-A"));
EXPECT_TRUE(testARMCPU("cortex-a7", "armv7-a", "neon-vfpv4",
ARM::AEK_HWDIVTHUMB | ARM::AEK_HWDIVARM | ARM::AEK_MP | ARM::AEK_HWDIVTHUMB | ARM::AEK_HWDIVARM | ARM::AEK_MP |
ARM::AEK_SEC | ARM::AEK_VIRT | ARM::AEK_DSP, ARM::AEK_SEC | ARM::AEK_VIRT | ARM::AEK_DSP,
"7-A")); "7-A"),
EXPECT_TRUE(testARMCPU("cortex-a8", "armv7-a", "neon", ARMCPUTestParams("cortex-a8", "armv7-a", "neon",
ARM::AEK_SEC | ARM::AEK_DSP, "7-A")); ARM::AEK_SEC | ARM::AEK_DSP, "7-A")), );
EXPECT_TRUE(testARMCPU("cortex-a9", "armv7-a", "neon-fp16",
ARM::AEK_MP | ARM::AEK_SEC | ARM::AEK_DSP, "7-A")); // gtest in llvm has a limit of 50 test cases when using ::Values so we split
EXPECT_TRUE(testARMCPU("cortex-a12", "armv7-a", "neon-vfpv4", // them into 2 blocks
INSTANTIATE_TEST_CASE_P(
ARMCPUTestsPart2, ARMCPUTestFixture,
::testing::Values(
ARMCPUTestParams("cortex-a9", "armv7-a", "neon-fp16",
ARM::AEK_MP | ARM::AEK_SEC | ARM::AEK_DSP, "7-A"),
ARMCPUTestParams("cortex-a12", "armv7-a", "neon-vfpv4",
ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT | ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
ARM::AEK_DSP, ARM::AEK_DSP,
"7-A")); "7-A"),
EXPECT_TRUE(testARMCPU("cortex-a15", "armv7-a", "neon-vfpv4", ARMCPUTestParams("cortex-a15", "armv7-a", "neon-vfpv4",
ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT | ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
ARM::AEK_DSP, ARM::AEK_DSP,
"7-A")); "7-A"),
EXPECT_TRUE(testARMCPU("cortex-a17", "armv7-a", "neon-vfpv4", ARMCPUTestParams("cortex-a17", "armv7-a", "neon-vfpv4",
ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT | ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
ARM::AEK_DSP, ARM::AEK_DSP,
"7-A")); "7-A"),
EXPECT_TRUE(testARMCPU("krait", "armv7-a", "neon-vfpv4", ARMCPUTestParams("krait", "armv7-a", "neon-vfpv4",
ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
"7-A")); "7-A"),
EXPECT_TRUE(testARMCPU("cortex-r4", "armv7-r", "none", ARMCPUTestParams("cortex-r4", "armv7-r", "none",
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, "7-R")); ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
EXPECT_TRUE(testARMCPU("cortex-r4f", "armv7-r", "vfpv3-d16", "7-R"),
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, "7-R")); ARMCPUTestParams("cortex-r4f", "armv7-r", "vfpv3-d16",
EXPECT_TRUE(testARMCPU("cortex-r5", "armv7-r", "vfpv3-d16", ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
"7-R"),
ARMCPUTestParams("cortex-r5", "armv7-r", "vfpv3-d16",
ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
ARM::AEK_DSP, ARM::AEK_DSP,
"7-R")); "7-R"),
EXPECT_TRUE(testARMCPU("cortex-r7", "armv7-r", "vfpv3-d16-fp16", ARMCPUTestParams("cortex-r7", "armv7-r", "vfpv3-d16-fp16",
ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
ARM::AEK_DSP, ARM::AEK_DSP,
"7-R")); "7-R"),
EXPECT_TRUE(testARMCPU("cortex-r8", "armv7-r", "vfpv3-d16-fp16", ARMCPUTestParams("cortex-r8", "armv7-r", "vfpv3-d16-fp16",
ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
ARM::AEK_DSP, ARM::AEK_DSP,
"7-R")); "7-R"),
EXPECT_TRUE(testARMCPU("cortex-r52", "armv8-r", "neon-fp-armv8", ARMCPUTestParams("cortex-r52", "armv8-r", "neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_MP | ARM::AEK_VIRT | ARM::AEK_NONE | ARM::AEK_CRC | ARM::AEK_MP |
ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_DSP, ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
"8-R")); "8-R"),
EXPECT_TRUE( ARMCPUTestParams("sc300", "armv7-m", "none",
testARMCPU("sc300", "armv7-m", "none", ARM::AEK_HWDIVTHUMB, "7-M")); ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB, "7-M"),
EXPECT_TRUE( ARMCPUTestParams("cortex-m3", "armv7-m", "none",
testARMCPU("cortex-m3", "armv7-m", "none", ARM::AEK_HWDIVTHUMB, "7-M")); ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB, "7-M"),
EXPECT_TRUE(testARMCPU("cortex-m4", "armv7e-m", "fpv4-sp-d16", ARMCPUTestParams("cortex-m4", "armv7e-m", "fpv4-sp-d16",
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, "7E-M")); ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
EXPECT_TRUE(testARMCPU("cortex-m7", "armv7e-m", "fpv5-d16", "7E-M"),
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, "7E-M")); ARMCPUTestParams("cortex-m7", "armv7e-m", "fpv5-d16",
EXPECT_TRUE(testARMCPU("cortex-a32", "armv8-a", "crypto-neon-fp-armv8", ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
"7E-M"),
ARMCPUTestParams("cortex-a32", "armv8-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
"8-A")); "8-A"),
EXPECT_TRUE(testARMCPU("cortex-a35", "armv8-a", "crypto-neon-fp-armv8", ARMCPUTestParams("cortex-a35", "armv8-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
"8-A")); "8-A"),
EXPECT_TRUE(testARMCPU("cortex-a53", "armv8-a", "crypto-neon-fp-armv8", ARMCPUTestParams("cortex-a53", "armv8-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
"8-A")); "8-A"),
EXPECT_TRUE(testARMCPU("cortex-a55", "armv8.2-a", "crypto-neon-fp-armv8", ARMCPUTestParams("cortex-a55", "armv8.2-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | ARM::AEK_FP16 | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
ARM::AEK_RAS | ARM::AEK_DOTPROD, ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD,
"8.2-A")); "8.2-A"),
EXPECT_TRUE(testARMCPU("cortex-a57", "armv8-a", "crypto-neon-fp-armv8", ARMCPUTestParams("cortex-a57", "armv8-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
"8-A")); "8-A"),
EXPECT_TRUE(testARMCPU("cortex-a72", "armv8-a", "crypto-neon-fp-armv8", ARMCPUTestParams("cortex-a72", "armv8-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
"8-A")); "8-A"),
EXPECT_TRUE(testARMCPU("cortex-a73", "armv8-a", "crypto-neon-fp-armv8", ARMCPUTestParams("cortex-a73", "armv8-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
"8-A")); "8-A"),
EXPECT_TRUE(testARMCPU("cortex-a75", "armv8.2-a", "crypto-neon-fp-armv8", ARMCPUTestParams("cortex-a75", "armv8.2-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | ARM::AEK_FP16 | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
ARM::AEK_RAS | ARM::AEK_DOTPROD, ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD,
"8.2-A")); "8.2-A"),
EXPECT_TRUE(testARMCPU("cortex-a76", "armv8.2-a", "crypto-neon-fp-armv8", ARMCPUTestParams("cortex-a76", "armv8.2-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | ARM::AEK_FP16 | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
ARM::AEK_RAS | ARM::AEK_DOTPROD, ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD,
"8.2-A")); "8.2-A"),
EXPECT_TRUE(testARMCPU("cortex-a76ae", "armv8.2-a", "crypto-neon-fp-armv8", ARMCPUTestParams("cortex-a76ae", "armv8.2-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | ARM::AEK_FP16 | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
ARM::AEK_RAS | ARM::AEK_DOTPROD, ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD,
"8.2-A")); "8.2-A"),
EXPECT_TRUE(testARMCPU("cortex-a77", "armv8.2-a", "crypto-neon-fp-armv8", ARMCPUTestParams("cortex-a77", "armv8.2-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | ARM::AEK_FP16 | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
ARM::AEK_RAS | ARM::AEK_DOTPROD, ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD,
"8.2-A")); "8.2-A"),
EXPECT_TRUE(testARMCPU("cortex-a78", "armv8.2-a", "crypto-neon-fp-armv8", ARMCPUTestParams("cortex-a78", "armv8.2-a", "crypto-neon-fp-armv8",
ARM::AEK_DOTPROD | ARM::AEK_FP16 | ARM::AEK_DOTPROD | ARM::AEK_FP16 | ARM::AEK_SEC |
ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT | ARM::AEK_MP | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | ARM::AEK_CRC |
ARM::AEK_DSP | ARM::AEK_CRC | ARM::AEK_RAS, ARM::AEK_RAS,
"8.2-A")); "8.2-A"),
EXPECT_TRUE(testARMCPU("cortex-x1", "armv8.2-a", "crypto-neon-fp-armv8", ARMCPUTestParams("cortex-x1", "armv8.2-a", "crypto-neon-fp-armv8",
ARM::AEK_RAS | ARM::AEK_FP16 | ARM::AEK_DOTPROD | ARM::AEK_RAS | ARM::AEK_FP16 | ARM::AEK_DOTPROD |
ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT | ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
ARM::AEK_DSP | ARM::AEK_CRC | ARM::AEK_RAS, ARM::AEK_DSP | ARM::AEK_CRC | ARM::AEK_RAS,
"8.2-A")); "8.2-A"),
EXPECT_TRUE(testARMCPU("neoverse-n1", "armv8.2-a", "crypto-neon-fp-armv8", ARMCPUTestParams("neoverse-n1", "armv8.2-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | ARM::AEK_FP16 | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
ARM::AEK_RAS | ARM::AEK_DOTPROD, ARM::AEK_FP16 | ARM::AEK_RAS | ARM::AEK_DOTPROD,
"8.2-A")); "8.2-A"),
EXPECT_TRUE(testARMCPU("neoverse-n2", "armv8.5-a", "crypto-neon-fp-armv8", ARMCPUTestParams("neoverse-n2", "armv8.5-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_HWDIVTHUMB | ARM::AEK_HWDIVARM | ARM::AEK_CRC | ARM::AEK_HWDIVTHUMB |
ARM::AEK_MP | ARM::AEK_SEC | ARM::AEK_VIRT | ARM::AEK_HWDIVARM | ARM::AEK_MP | ARM::AEK_SEC |
ARM::AEK_DSP | ARM::AEK_BF16 | ARM::AEK_DOTPROD | ARM::AEK_VIRT | ARM::AEK_DSP | ARM::AEK_BF16 |
ARM::AEK_RAS | ARM::AEK_I8MM | ARM::AEK_SB, ARM::AEK_DOTPROD | ARM::AEK_RAS | ARM::AEK_I8MM |
"8.5-A")); ARM::AEK_SB,
EXPECT_TRUE(testARMCPU("neoverse-v1", "armv8.4-a", "crypto-neon-fp-armv8", "8.5-A"),
ARMCPUTestParams("neoverse-v1", "armv8.4-a", "crypto-neon-fp-armv8",
ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT | ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB |
ARM::AEK_DSP | ARM::AEK_CRC | ARM::AEK_RAS | ARM::AEK_DSP | ARM::AEK_CRC | ARM::AEK_RAS |
ARM::AEK_FP16 | ARM::AEK_BF16 | ARM::AEK_DOTPROD, ARM::AEK_FP16 | ARM::AEK_BF16 | ARM::AEK_DOTPROD,
"8.4-A")); "8.4-A"),
EXPECT_TRUE(testARMCPU("cyclone", "armv8-a", "crypto-neon-fp-armv8", ARMCPUTestParams("cyclone", "armv8-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
"8-A")); "8-A"),
EXPECT_TRUE(testARMCPU("exynos-m3", "armv8-a", "crypto-neon-fp-armv8", ARMCPUTestParams("exynos-m3", "armv8-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
"8-A")); "8-A"),
EXPECT_TRUE(testARMCPU("exynos-m4", "armv8.2-a", "crypto-neon-fp-armv8", ARMCPUTestParams("exynos-m4", "armv8.2-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | ARM::AEK_DOTPROD | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
ARM::AEK_FP16 | ARM::AEK_RAS, ARM::AEK_DOTPROD | ARM::AEK_FP16 | ARM::AEK_RAS,
"8.2-A")); "8.2-A"),
EXPECT_TRUE(testARMCPU("exynos-m5", "armv8.2-a", "crypto-neon-fp-armv8", ARMCPUTestParams("exynos-m5", "armv8.2-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM | ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | ARM::AEK_DOTPROD | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP |
ARM::AEK_FP16 | ARM::AEK_RAS, ARM::AEK_DOTPROD | ARM::AEK_FP16 | ARM::AEK_RAS,
"8.2-A")); "8.2-A"),
EXPECT_TRUE(testARMCPU("cortex-m23", "armv8-m.base", "none", ARMCPUTestParams("cortex-m23", "armv8-m.base", "none",
ARM::AEK_HWDIVTHUMB, "8-M.Baseline")); ARM::AEK_NONE | ARM::AEK_HWDIVTHUMB, "8-M.Baseline"),
EXPECT_TRUE(testARMCPU("cortex-m33", "armv8-m.main", "fpv5-sp-d16", ARMCPUTestParams("cortex-m33", "armv8-m.main", "fpv5-sp-d16",
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, "8-M.Mainline")); ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, "8-M.Mainline"),
EXPECT_TRUE(testARMCPU("cortex-m35p", "armv8-m.main", "fpv5-sp-d16", ARMCPUTestParams("cortex-m35p", "armv8-m.main", "fpv5-sp-d16",
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, "8-M.Mainline")); ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, "8-M.Mainline"),
EXPECT_TRUE(testARMCPU("cortex-m55", "armv8.1-m.main", "fp-armv8-fullfp16-d16", ARMCPUTestParams("cortex-m55", "armv8.1-m.main",
"fp-armv8-fullfp16-d16",
ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | ARM::AEK_SIMD | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP | ARM::AEK_SIMD |
ARM::AEK_FP | ARM::AEK_RAS | ARM::AEK_LOB | ARM::AEK_FP | ARM::AEK_RAS | ARM::AEK_LOB |
ARM::AEK_FP16, ARM::AEK_FP16,
"8.1-M.Mainline")); "8.1-M.Mainline"),
EXPECT_TRUE(testARMCPU("iwmmxt", "iwmmxt", "none", ARMCPUTestParams("iwmmxt", "iwmmxt", "none", ARM::AEK_NONE, "iwmmxt"),
ARM::AEK_NONE, "iwmmxt")); ARMCPUTestParams("xscale", "xscale", "none", ARM::AEK_NONE, "xscale"),
EXPECT_TRUE(testARMCPU("xscale", "xscale", "none", ARMCPUTestParams("swift", "armv7s", "neon-vfpv4",
ARM::AEK_NONE, "xscale"));
EXPECT_TRUE(testARMCPU("swift", "armv7s", "neon-vfpv4",
ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP, ARM::AEK_HWDIVARM | ARM::AEK_HWDIVTHUMB | ARM::AEK_DSP,
"7-S")); "7-S")), );
}
static constexpr unsigned NumARMCPUArchs = 91; static constexpr unsigned NumARMCPUArchs = 91;
TEST(TargetParserTest, testARMCPUArchList) { TEST(TargetParserTest, testARMCPUArchList) {
SmallVector<StringRef, NumARMCPUArchs> List; SmallVector<StringRef, NumARMCPUArchs> List;
ARM::fillValidCPUArchList(List); ARM::fillValidCPUArchList(List);
// No list exists for these in this test suite, so ensure all are // No list exists for these in this test suite, so ensure all are
▲ Show 20 Lines • Show All 444 Lines • ▼ Show 20 Lines
TEST(TargetParserTest, ARMparseArchVersion) { TEST(TargetParserTest, ARMparseArchVersion) {
for (unsigned i = 0; i < array_lengthof(ARMArch); i++) for (unsigned i = 0; i < array_lengthof(ARMArch); i++)
if (((std::string)ARMArch[i]).substr(0, 4) == "armv") if (((std::string)ARMArch[i]).substr(0, 4) == "armv")
EXPECT_EQ((ARMArch[i][4] - 48u), ARM::parseArchVersion(ARMArch[i])); EXPECT_EQ((ARMArch[i][4] - 48u), ARM::parseArchVersion(ARMArch[i]));
else else
EXPECT_EQ(5u, ARM::parseArchVersion(ARMArch[i])); EXPECT_EQ(5u, ARM::parseArchVersion(ARMArch[i]));
} }
bool testAArch64CPU(StringRef CPUName, StringRef ExpectedArch, class AArch64CPUTestFixture
StringRef ExpectedFPU, uint64_t ExpectedFlags, : public ::testing::TestWithParam<ARMCPUTestParams> {};
StringRef CPUAttr) {
AArch64::ArchKind AK = AArch64::parseCPUArch(CPUName); TEST_P(AArch64CPUTestFixture, testAArch64CPU) {
bool pass = AArch64::getArchName(AK).equals(ExpectedArch); ARMCPUTestParams params = GetParam();
Lint: Pre-merge checks
Inline Actions

clang-tidy: warning: invalid case style for variable 'params' [readability-identifier-naming]
not useful

Lint: Pre-merge checks: clang-tidy: warning: invalid case style for variable 'params' [readability-identifier-naming]…
uint64_t ExtKind = AArch64::getDefaultExtensions(CPUName, AK);
if (ExtKind > 1 && (ExtKind & AArch64::AEK_NONE))
pass &= ((ExtKind ^ AArch64::AEK_NONE) == ExpectedFlags);
else
pass &= (ExtKind == ExpectedFlags);
unsigned FPUKind = AArch64::getDefaultFPU(CPUName, AK); AArch64::ArchKind AK = AArch64::parseCPUArch(params.CPUName);
pass &= ARM::getFPUName(FPUKind).equals(ExpectedFPU); EXPECT_EQ(params.ExpectedArch, AArch64::getArchName(AK));
pass &= AArch64::getCPUAttr(AK).equals(CPUAttr); uint64_t default_extensions =
Lint: Pre-merge checks
Inline Actions

clang-tidy: warning: invalid case style for variable 'default_extensions' [readability-identifier-naming]
not useful

Lint: Pre-merge checks: clang-tidy: warning: invalid case style for variable 'default_extensions' [readability…
AArch64::getDefaultExtensions(params.CPUName, AK);
EXPECT_EQ(params.ExpectedFlags, default_extensions);
return pass; unsigned FPUKind = AArch64::getDefaultFPU(params.CPUName, AK);
EXPECT_EQ(params.ExpectedFPU, ARM::getFPUName(FPUKind));
EXPECT_EQ(params.CPUAttr, AArch64::getCPUAttr(AK));
} }
TEST(TargetParserTest, testAArch64CPU) { INSTANTIATE_TEST_CASE_P(
EXPECT_TRUE(testAArch64CPU( AArch64CPUTests, AArch64CPUTestFixture,
"invalid", "invalid", "invalid", ::testing::Values(
AArch64::AEK_NONE, "")); ARMCPUTestParams("invalid", "invalid", "invalid", AArch64::AEK_NONE,
EXPECT_TRUE(testAArch64CPU( ""),
"generic", "invalid", "none", ARMCPUTestParams("generic", "invalid", "none", AArch64::AEK_NONE, ""),
AArch64::AEK_NONE, ""));
ARMCPUTestParams("cortex-a34", "armv8-a", "crypto-neon-fp-armv8",
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
"cortex-a34", "armv8-a", "crypto-neon-fp-armv8", AArch64::AEK_FP | AArch64::AEK_SIMD,
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | "8-A"),
AArch64::AEK_SIMD, "8-A")); ARMCPUTestParams("cortex-a35", "armv8-a", "crypto-neon-fp-armv8",
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
"cortex-a35", "armv8-a", "crypto-neon-fp-armv8", AArch64::AEK_FP | AArch64::AEK_SIMD,
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | "8-A"),
AArch64::AEK_SIMD, "8-A")); ARMCPUTestParams("cortex-a53", "armv8-a", "crypto-neon-fp-armv8",
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
"cortex-a53", "armv8-a", "crypto-neon-fp-armv8", AArch64::AEK_FP | AArch64::AEK_SIMD,
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | "8-A"),
AArch64::AEK_SIMD, "8-A")); ARMCPUTestParams("cortex-a55", "armv8.2-a", "crypto-neon-fp-armv8",
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
"cortex-a55", "armv8.2-a", "crypto-neon-fp-armv8", AArch64::AEK_FP | AArch64::AEK_SIMD |
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | AArch64::AEK_RAS | AArch64::AEK_LSE |
AArch64::AEK_SIMD | AArch64::AEK_RAS | AArch64::AEK_LSE | AArch64::AEK_RDM | AArch64::AEK_FP16 |
AArch64::AEK_RDM | AArch64::AEK_FP16 | AArch64::AEK_DOTPROD | AArch64::AEK_DOTPROD | AArch64::AEK_RCPC,
AArch64::AEK_RCPC, "8.2-A")); "8.2-A"),
EXPECT_TRUE(testAArch64CPU( ARMCPUTestParams("cortex-a57", "armv8-a", "crypto-neon-fp-armv8",
"cortex-a57", "armv8-a", "crypto-neon-fp-armv8", AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | AArch64::AEK_FP | AArch64::AEK_SIMD,
AArch64::AEK_SIMD, "8-A")); "8-A"),
EXPECT_TRUE(testAArch64CPU( ARMCPUTestParams("cortex-a65", "armv8.2-a", "crypto-neon-fp-armv8",
"cortex-a65", "armv8.2-a", "crypto-neon-fp-armv8", AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_DOTPROD | AArch64::AEK_DOTPROD | AArch64::AEK_FP |
AArch64::AEK_FP | AArch64::AEK_FP16 | AArch64::AEK_LSE | AArch64::AEK_FP16 | AArch64::AEK_LSE |
AArch64::AEK_RAS | AArch64::AEK_RCPC | AArch64::AEK_RDM | AArch64::AEK_RAS | AArch64::AEK_RCPC |
AArch64::AEK_SIMD | AArch64::AEK_SSBS, AArch64::AEK_RDM | AArch64::AEK_SIMD |
"8.2-A")); AArch64::AEK_SSBS,
EXPECT_TRUE(testAArch64CPU( "8.2-A"),
"cortex-a65ae", "armv8.2-a", "crypto-neon-fp-armv8", ARMCPUTestParams("cortex-a65ae", "armv8.2-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_DOTPROD | AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_FP | AArch64::AEK_FP16 | AArch64::AEK_LSE | AArch64::AEK_DOTPROD | AArch64::AEK_FP |
AArch64::AEK_RAS | AArch64::AEK_RCPC | AArch64::AEK_RDM | AArch64::AEK_FP16 | AArch64::AEK_LSE |
AArch64::AEK_SIMD | AArch64::AEK_SSBS, AArch64::AEK_RAS | AArch64::AEK_RCPC |
"8.2-A")); AArch64::AEK_RDM | AArch64::AEK_SIMD |
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_SSBS,
"cortex-a72", "armv8-a", "crypto-neon-fp-armv8", "8.2-A"),
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | ARMCPUTestParams("cortex-a72", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_SIMD, "8-A")); AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_FP | AArch64::AEK_SIMD,
"cortex-a73", "armv8-a", "crypto-neon-fp-armv8", "8-A"),
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | ARMCPUTestParams("cortex-a73", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_SIMD, "8-A")); AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_FP | AArch64::AEK_SIMD,
"cortex-a75", "armv8.2-a", "crypto-neon-fp-armv8", "8-A"),
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | ARMCPUTestParams("cortex-a75", "armv8.2-a", "crypto-neon-fp-armv8",
AArch64::AEK_SIMD | AArch64::AEK_RAS | AArch64::AEK_LSE | AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_RDM | AArch64::AEK_FP16 | AArch64::AEK_DOTPROD | AArch64::AEK_FP | AArch64::AEK_SIMD |
AArch64::AEK_RCPC, "8.2-A")); AArch64::AEK_RAS | AArch64::AEK_LSE |
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_RDM | AArch64::AEK_FP16 |
"cortex-a76", "armv8.2-a", "crypto-neon-fp-armv8", AArch64::AEK_DOTPROD | AArch64::AEK_RCPC,
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | "8.2-A"),
AArch64::AEK_RDM | AArch64::AEK_SIMD | AArch64::AEK_RAS | ARMCPUTestParams("cortex-a76", "armv8.2-a", "crypto-neon-fp-armv8",
AArch64::AEK_LSE | AArch64::AEK_FP16 | AArch64::AEK_DOTPROD | AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_RCPC| AArch64::AEK_SSBS, "8.2-A")); AArch64::AEK_FP | AArch64::AEK_RDM |
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_SIMD | AArch64::AEK_RAS |
"cortex-a76ae", "armv8.2-a", "crypto-neon-fp-armv8", AArch64::AEK_LSE | AArch64::AEK_FP16 |
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
AArch64::AEK_RDM | AArch64::AEK_SIMD | AArch64::AEK_RAS | AArch64::AEK_SSBS,
AArch64::AEK_LSE | AArch64::AEK_FP16 | AArch64::AEK_DOTPROD | "8.2-A"),
AArch64::AEK_RCPC| AArch64::AEK_SSBS, "8.2-A")); ARMCPUTestParams("cortex-a76ae", "armv8.2-a", "crypto-neon-fp-armv8",
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
"cortex-a77", "armv8.2-a", "crypto-neon-fp-armv8", AArch64::AEK_FP | AArch64::AEK_RDM |
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | AArch64::AEK_SIMD | AArch64::AEK_RAS |
AArch64::AEK_RDM | AArch64::AEK_SIMD | AArch64::AEK_RAS | AArch64::AEK_LSE | AArch64::AEK_FP16 |
AArch64::AEK_LSE | AArch64::AEK_FP16 | AArch64::AEK_DOTPROD | AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
AArch64::AEK_RCPC | AArch64::AEK_SSBS, "8.2-A")); AArch64::AEK_SSBS,
EXPECT_TRUE(testAArch64CPU( "8.2-A"),
"cortex-a78", "armv8.2-a", "crypto-neon-fp-armv8", ARMCPUTestParams("cortex-a77", "armv8.2-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_RDM | AArch64::AEK_SIMD | AArch64::AEK_RAS | AArch64::AEK_FP | AArch64::AEK_RDM |
AArch64::AEK_LSE | AArch64::AEK_FP16 | AArch64::AEK_DOTPROD | AArch64::AEK_SIMD | AArch64::AEK_RAS |
AArch64::AEK_RCPC | AArch64::AEK_SSBS, AArch64::AEK_LSE | AArch64::AEK_FP16 |
"8.2-A")); AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_SSBS,
"8.2-A"),
ARMCPUTestParams("cortex-a78", "armv8.2-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_FP | AArch64::AEK_RDM |
AArch64::AEK_SIMD | AArch64::AEK_RAS |
AArch64::AEK_LSE | AArch64::AEK_FP16 |
AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
AArch64::AEK_SSBS,
"8.2-A"),
ARMCPUTestParams(
"neoverse-v1", "armv8.4-a", "crypto-neon-fp-armv8", "neoverse-v1", "armv8.4-a", "crypto-neon-fp-armv8",
AArch64::AEK_RAS | AArch64::AEK_SVE | AArch64::AEK_SSBS | AArch64::AEK_RAS | AArch64::AEK_SVE | AArch64::AEK_SSBS |
AArch64::AEK_RCPC | AArch64::AEK_CRC | AArch64::AEK_FP | AArch64::AEK_RCPC | AArch64::AEK_CRC | AArch64::AEK_FP |
AArch64::AEK_SIMD | AArch64::AEK_RAS | AArch64::AEK_LSE | AArch64::AEK_SIMD | AArch64::AEK_RAS | AArch64::AEK_LSE |
AArch64::AEK_RDM | AArch64::AEK_RCPC | AArch64::AEK_DOTPROD | AArch64::AEK_RDM | AArch64::AEK_RCPC | AArch64::AEK_DOTPROD |
AArch64::AEK_CRYPTO | AArch64::AEK_FP16 | AArch64::AEK_BF16, AArch64::AEK_CRYPTO | AArch64::AEK_FP16 | AArch64::AEK_BF16,
"8.4-A")); "8.4-A"),
EXPECT_TRUE(testAArch64CPU( ARMCPUTestParams("cortex-r82", "armv8-r", "crypto-neon-fp-armv8",
"cortex-r82", "armv8-r", "crypto-neon-fp-armv8", AArch64::AEK_CRC | AArch64::AEK_RDM |
AArch64::AEK_CRC | AArch64::AEK_RDM | AArch64::AEK_SSBS | AArch64::AEK_SSBS | AArch64::AEK_DOTPROD |
AArch64::AEK_DOTPROD | AArch64::AEK_FP | AArch64::AEK_SIMD | AArch64::AEK_FP | AArch64::AEK_SIMD |
AArch64::AEK_FP16 | AArch64::AEK_FP16FML | AArch64::AEK_RAS | AArch64::AEK_FP16 | AArch64::AEK_FP16FML |
AArch64::AEK_RCPC | AArch64::AEK_LSE | AArch64::AEK_SB, AArch64::AEK_RAS | AArch64::AEK_RCPC |
"8-R")); AArch64::AEK_LSE | AArch64::AEK_SB,
EXPECT_TRUE(testAArch64CPU( "8-R"),
"cortex-x1", "armv8.2-a", "crypto-neon-fp-armv8", ARMCPUTestParams("cortex-x1", "armv8.2-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_RDM | AArch64::AEK_SIMD | AArch64::AEK_RAS | AArch64::AEK_FP | AArch64::AEK_RDM |
AArch64::AEK_LSE | AArch64::AEK_FP16 | AArch64::AEK_DOTPROD | AArch64::AEK_SIMD | AArch64::AEK_RAS |
AArch64::AEK_RCPC | AArch64::AEK_SSBS, AArch64::AEK_LSE | AArch64::AEK_FP16 |
"8.2-A")); AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_SSBS,
"cyclone", "armv8-a", "crypto-neon-fp-armv8", "8.2-A"),
AArch64::AEK_CRYPTO | AArch64::AEK_FP | AArch64::AEK_SIMD, "8-A")); ARMCPUTestParams("cyclone", "armv8-a", "crypto-neon-fp-armv8",
DavidSpickettAuthorUnsubmitted
Done
ReplyInline Actions

This is an example where the CPU has AEK_NONE for its additional extensions and the tests had a special path for that.

I don't think there's much merit to that so I've just added AEK_NONE for those CPUs that don't extend the base arch.

DavidSpickett: This is an example where the CPU has AEK_NONE for its additional extensions and the tests had a…
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_NONE | AArch64::AEK_CRYPTO |
"apple-a7", "armv8-a", "crypto-neon-fp-armv8", AArch64::AEK_FP | AArch64::AEK_SIMD,
AArch64::AEK_CRYPTO | AArch64::AEK_FP | AArch64::AEK_SIMD, "8-A")); "8-A"),
EXPECT_TRUE(testAArch64CPU( ARMCPUTestParams("apple-a7", "armv8-a", "crypto-neon-fp-armv8",
"apple-a8", "armv8-a", "crypto-neon-fp-armv8", AArch64::AEK_NONE | AArch64::AEK_CRYPTO |
AArch64::AEK_CRYPTO | AArch64::AEK_FP | AArch64::AEK_SIMD, "8-A")); AArch64::AEK_FP | AArch64::AEK_SIMD,
EXPECT_TRUE(testAArch64CPU( "8-A"),
"apple-a9", "armv8-a", "crypto-neon-fp-armv8", ARMCPUTestParams("apple-a8", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRYPTO | AArch64::AEK_FP | AArch64::AEK_SIMD, "8-A")); AArch64::AEK_NONE | AArch64::AEK_CRYPTO |
EXPECT_TRUE(testAArch64CPU("apple-a10", "armv8-a", "crypto-neon-fp-armv8", AArch64::AEK_FP | AArch64::AEK_SIMD,
"8-A"),
ARMCPUTestParams("apple-a9", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_NONE | AArch64::AEK_CRYPTO |
AArch64::AEK_FP | AArch64::AEK_SIMD,
"8-A"),
ARMCPUTestParams("apple-a10", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_FP | AArch64::AEK_RDM | AArch64::AEK_FP | AArch64::AEK_RDM |
AArch64::AEK_SIMD, AArch64::AEK_SIMD,
"8-A")); "8-A"),
EXPECT_TRUE(testAArch64CPU("apple-a11", "armv8.2-a", "crypto-neon-fp-armv8", ARMCPUTestParams("apple-a11", "armv8.2-a", "crypto-neon-fp-armv8",
AArch64::AEK_NONE | AArch64::AEK_CRC |
AArch64::AEK_CRYPTO | AArch64::AEK_FP |
AArch64::AEK_LSE | AArch64::AEK_RAS |
AArch64::AEK_RDM | AArch64::AEK_SIMD,
"8.2-A"),
ARMCPUTestParams("apple-a12", "armv8.3-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_FP | AArch64::AEK_SIMD |
AArch64::AEK_LSE | AArch64::AEK_RAS |
AArch64::AEK_RDM | AArch64::AEK_RCPC |
AArch64::AEK_FP16,
"8.3-A"),
ARMCPUTestParams("apple-a13", "armv8.4-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_FP | AArch64::AEK_SIMD |
AArch64::AEK_LSE | AArch64::AEK_RAS |
AArch64::AEK_RDM | AArch64::AEK_RCPC |
AArch64::AEK_DOTPROD | AArch64::AEK_FP16 |
AArch64::AEK_FP16FML,
"8.4-A"),
ARMCPUTestParams("apple-s4", "armv8.3-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_FP | AArch64::AEK_SIMD |
AArch64::AEK_LSE | AArch64::AEK_RAS |
AArch64::AEK_RDM | AArch64::AEK_RCPC |
AArch64::AEK_FP16,
"8.3-A"),
ARMCPUTestParams("apple-s5", "armv8.3-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_FP | AArch64::AEK_SIMD |
AArch64::AEK_LSE | AArch64::AEK_RAS |
AArch64::AEK_RDM | AArch64::AEK_RCPC |
AArch64::AEK_FP16,
"8.3-A"),
ARMCPUTestParams("exynos-m3", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_FP | AArch64::AEK_SIMD,
"8-A"),
ARMCPUTestParams("exynos-m4", "armv8.2-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_DOTPROD | AArch64::AEK_FP |
AArch64::AEK_FP16 | AArch64::AEK_LSE |
AArch64::AEK_RAS | AArch64::AEK_RDM |
AArch64::AEK_SIMD,
"8.2-A"),
ARMCPUTestParams("exynos-m5", "armv8.2-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_FP | AArch64::AEK_LSE | AArch64::AEK_DOTPROD | AArch64::AEK_FP |
AArch64::AEK_FP16 | AArch64::AEK_LSE |
AArch64::AEK_RAS | AArch64::AEK_RDM | AArch64::AEK_RAS | AArch64::AEK_RDM |
AArch64::AEK_SIMD, AArch64::AEK_SIMD,
"8.2-A")); "8.2-A"),
EXPECT_TRUE(testAArch64CPU( ARMCPUTestParams("falkor", "armv8-a", "crypto-neon-fp-armv8",
"apple-a12", "armv8.3-a", "crypto-neon-fp-armv8", AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | AArch64::AEK_FP | AArch64::AEK_SIMD |
AArch64::AEK_SIMD | AArch64::AEK_LSE | AArch64::AEK_RAS | AArch64::AEK_RDM,
AArch64::AEK_RDM | AArch64::AEK_RCPC | AArch64::AEK_FP16, "8-A"),
"8.3-A")); ARMCPUTestParams("kryo", "armv8-a", "crypto-neon-fp-armv8",
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
"apple-a13", "armv8.4-a", "crypto-neon-fp-armv8", AArch64::AEK_FP | AArch64::AEK_SIMD,
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | "8-A"),
AArch64::AEK_SIMD | AArch64::AEK_LSE | AArch64::AEK_RAS | ARMCPUTestParams("neoverse-e1", "armv8.2-a", "crypto-neon-fp-armv8",
AArch64::AEK_RDM | AArch64::AEK_RCPC | AArch64::AEK_DOTPROD | AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_FP16 | AArch64::AEK_FP16FML, AArch64::AEK_DOTPROD | AArch64::AEK_FP |
"8.4-A")); AArch64::AEK_FP16 | AArch64::AEK_LSE |
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_RAS | AArch64::AEK_RCPC |
"apple-s4", "armv8.3-a", "crypto-neon-fp-armv8", AArch64::AEK_RDM | AArch64::AEK_SIMD |
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | AArch64::AEK_SSBS,
AArch64::AEK_SIMD | AArch64::AEK_LSE | AArch64::AEK_RAS | "8.2-A"),
AArch64::AEK_RDM | AArch64::AEK_RCPC | AArch64::AEK_FP16, ARMCPUTestParams("neoverse-n1", "armv8.2-a", "crypto-neon-fp-armv8",
"8.3-A")); AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_DOTPROD | AArch64::AEK_FP |
"apple-s5", "armv8.3-a", "crypto-neon-fp-armv8", AArch64::AEK_FP16 | AArch64::AEK_LSE |
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | AArch64::AEK_PROFILE | AArch64::AEK_RAS |
AArch64::AEK_SIMD | AArch64::AEK_LSE | AArch64::AEK_RAS | AArch64::AEK_RCPC | AArch64::AEK_RDM |
AArch64::AEK_RDM | AArch64::AEK_RCPC | AArch64::AEK_FP16,
"8.3-A"));
EXPECT_TRUE(testAArch64CPU(
"exynos-m3", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP |
AArch64::AEK_SIMD, "8-A"));
EXPECT_TRUE(testAArch64CPU(
"exynos-m4", "armv8.2-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_DOTPROD | AArch64::AEK_FP | AArch64::AEK_FP16 |
AArch64::AEK_LSE | AArch64::AEK_RAS | AArch64::AEK_RDM |
AArch64::AEK_SIMD, "8.2-A"));
EXPECT_TRUE(testAArch64CPU(
"exynos-m5", "armv8.2-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_DOTPROD | AArch64::AEK_FP | AArch64::AEK_FP16 |
AArch64::AEK_LSE | AArch64::AEK_RAS | AArch64::AEK_RDM |
AArch64::AEK_SIMD, "8.2-A"));
EXPECT_TRUE(testAArch64CPU(
"falkor", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP |
AArch64::AEK_SIMD | AArch64::AEK_RDM, "8-A"));
EXPECT_TRUE(testAArch64CPU(
"kryo", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP |
AArch64::AEK_SIMD, "8-A"));
EXPECT_TRUE(testAArch64CPU(
"neoverse-e1", "armv8.2-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_DOTPROD |
AArch64::AEK_FP | AArch64::AEK_FP16 | AArch64::AEK_LSE |
AArch64::AEK_RAS | AArch64::AEK_RCPC | AArch64::AEK_RDM |
AArch64::AEK_SIMD | AArch64::AEK_SSBS, AArch64::AEK_SIMD | AArch64::AEK_SSBS,
"8.2-A")); "8.2-A"),
EXPECT_TRUE(testAArch64CPU( ARMCPUTestParams("neoverse-n2", "armv8.5-a", "crypto-neon-fp-armv8",
"neoverse-n1", "armv8.2-a", "crypto-neon-fp-armv8", AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_DOTPROD | AArch64::AEK_FP | AArch64::AEK_SIMD |
AArch64::AEK_FP | AArch64::AEK_FP16 | AArch64::AEK_LSE | AArch64::AEK_FP16 | AArch64::AEK_RAS |
AArch64::AEK_PROFILE | AArch64::AEK_RAS | AArch64::AEK_RCPC | AArch64::AEK_LSE | AArch64::AEK_SVE |
AArch64::AEK_RDM | AArch64::AEK_SIMD | AArch64::AEK_SSBS, AArch64::AEK_DOTPROD | AArch64::AEK_RCPC |
"8.2-A")); AArch64::AEK_RDM | AArch64::AEK_MTE |
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_SSBS | AArch64::AEK_SB |
"neoverse-n2", "armv8.5-a", "crypto-neon-fp-armv8", AArch64::AEK_SVE2 | AArch64::AEK_SVE2BITPERM |
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | AArch64::AEK_BF16 | AArch64::AEK_I8MM,
AArch64::AEK_SIMD | AArch64::AEK_FP16 | AArch64::AEK_RAS | "8.5-A"),
AArch64::AEK_LSE | AArch64::AEK_SVE | AArch64::AEK_DOTPROD | ARMCPUTestParams("thunderx2t99", "armv8.1-a", "crypto-neon-fp-armv8",
AArch64::AEK_RCPC | AArch64::AEK_RDM | AArch64::AEK_MTE | AArch64::AEK_NONE | AArch64::AEK_CRC |
AArch64::AEK_SSBS | AArch64::AEK_SB | AArch64::AEK_SVE2 | AArch64::AEK_CRYPTO | AArch64::AEK_LSE |
AArch64::AEK_SVE2BITPERM | AArch64::AEK_BF16 | AArch64::AEK_I8MM, AArch64::AEK_RDM | AArch64::AEK_FP |
"8.5-A")); AArch64::AEK_SIMD,
EXPECT_TRUE(testAArch64CPU( "8.1-A"),
"thunderx2t99", "armv8.1-a", "crypto-neon-fp-armv8", ARMCPUTestParams("thunderx3t110", "armv8.3-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_LSE | AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_RDM | AArch64::AEK_FP | AArch64::AEK_SIMD, "8.1-A")); AArch64::AEK_LSE | AArch64::AEK_RDM |
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_FP | AArch64::AEK_SIMD |
"thunderx3t110", "armv8.3-a", "crypto-neon-fp-armv8", AArch64::AEK_PROFILE | AArch64::AEK_RAS |
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_LSE | AArch64::AEK_RAND | AArch64::AEK_RCPC,
AArch64::AEK_RDM | AArch64::AEK_FP | AArch64::AEK_SIMD | "8.3-A"),
AArch64::AEK_PROFILE | AArch64::AEK_RAS | AArch64::AEK_RAND | ARMCPUTestParams("thunderx", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_RCPC, AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
"8.3-A")); AArch64::AEK_SIMD | AArch64::AEK_FP |
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_PROFILE,
"thunderx", "armv8-a", "crypto-neon-fp-armv8", "8-A"),
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD | ARMCPUTestParams("thunderxt81", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_FP | AArch64::AEK_PROFILE, AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
"8-A")); AArch64::AEK_SIMD | AArch64::AEK_FP |
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_PROFILE,
"thunderxt81", "armv8-a", "crypto-neon-fp-armv8", "8-A"),
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD | ARMCPUTestParams("thunderxt83", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_FP | AArch64::AEK_PROFILE, AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
"8-A")); AArch64::AEK_SIMD | AArch64::AEK_FP |
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_PROFILE,
"thunderxt83", "armv8-a", "crypto-neon-fp-armv8", "8-A"),
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD | ARMCPUTestParams("thunderxt88", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_FP | AArch64::AEK_PROFILE, AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
"8-A")); AArch64::AEK_SIMD | AArch64::AEK_FP |
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_PROFILE,
"thunderxt88", "armv8-a", "crypto-neon-fp-armv8", "8-A"),
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD | ARMCPUTestParams("tsv110", "armv8.2-a", "crypto-neon-fp-armv8",
AArch64::AEK_FP | AArch64::AEK_PROFILE, AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
"8-A")); AArch64::AEK_FP | AArch64::AEK_SIMD |
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_RAS | AArch64::AEK_LSE |
"tsv110", "armv8.2-a", "crypto-neon-fp-armv8", AArch64::AEK_RDM | AArch64::AEK_PROFILE |
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | AArch64::AEK_FP16 | AArch64::AEK_FP16FML |
AArch64::AEK_SIMD | AArch64::AEK_RAS | AArch64::AEK_LSE | AArch64::AEK_DOTPROD,
AArch64::AEK_RDM | AArch64::AEK_PROFILE | AArch64::AEK_FP16 | "8.2-A"),
AArch64::AEK_FP16FML | AArch64::AEK_DOTPROD, ARMCPUTestParams("a64fx", "armv8.2-a", "crypto-neon-fp-armv8",
"8.2-A")); AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_FP | AArch64::AEK_SIMD |
"a64fx", "armv8.2-a", "crypto-neon-fp-armv8", AArch64::AEK_FP16 | AArch64::AEK_RAS |
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | AArch64::AEK_LSE | AArch64::AEK_SVE |
AArch64::AEK_SIMD | AArch64::AEK_FP16 | AArch64::AEK_RAS | AArch64::AEK_RDM,
AArch64::AEK_LSE | AArch64::AEK_SVE | AArch64::AEK_RDM, "8.2-A"),
"8.2-A")); ARMCPUTestParams("carmel", "armv8.2-a", "crypto-neon-fp-armv8",
EXPECT_TRUE(testAArch64CPU( AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
"carmel", "armv8.2-a", "crypto-neon-fp-armv8", AArch64::AEK_FP | AArch64::AEK_SIMD |
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_FP | AArch64::AEK_FP16 | AArch64::AEK_RAS |
AArch64::AEK_SIMD | AArch64::AEK_FP16 | AArch64::AEK_RAS |
AArch64::AEK_LSE | AArch64::AEK_RDM, AArch64::AEK_LSE | AArch64::AEK_RDM,
"8.2-A")); "8.2-A")), );
}
static constexpr unsigned NumAArch64CPUArchs = 45; static constexpr unsigned NumAArch64CPUArchs = 45;
TEST(TargetParserTest, testAArch64CPUArchList) { TEST(TargetParserTest, testAArch64CPUArchList) {
SmallVector<StringRef, NumAArch64CPUArchs> List; SmallVector<StringRef, NumAArch64CPUArchs> List;
AArch64::fillValidCPUArchList(List); AArch64::fillValidCPUArchList(List);
// No list exists for these in this test suite, so ensure all are // No list exists for these in this test suite, so ensure all are
▲ Show 20 Lines • Show All 263 Lines • ▼ Show 20 LinesTEST(TargetParserTest, AArch64ArchExtFeature) {
for (unsigned i = 0; i < array_lengthof(ArchExt); i++) { for (unsigned i = 0; i < array_lengthof(ArchExt); i++) {
EXPECT_EQ(StringRef(ArchExt[i][2]), EXPECT_EQ(StringRef(ArchExt[i][2]),
AArch64::getArchExtFeature(ArchExt[i][0])); AArch64::getArchExtFeature(ArchExt[i][0]));
EXPECT_EQ(StringRef(ArchExt[i][3]), EXPECT_EQ(StringRef(ArchExt[i][3]),
AArch64::getArchExtFeature(ArchExt[i][1])); AArch64::getArchExtFeature(ArchExt[i][1]));
} }
} }
}
} // namespace