This is an archive of the discontinued LLVM Phabricator instance.

Differential D26343

[RFC] Refactor TargetParserTests
ClosedPublic

Authored by jojo on Nov 6 2016, 10:25 PM.

Details

Reviewers
rengolin
compnerd
t.p.northover
jmolloy
Summary

The target parser tests are a bit redundant. Refactor the tests hard-coding the expectations in the test themselves.
For example, given a CPU, what's the expcted arch, fpu, flags, etc.

Refact part of tests first, if this could be accepted ,then change all the other tests in this patttern later.

Diff Detail

Event Timeline

jojo updated this revision to Diff 77007.Nov 6 2016, 10:25 PM
jojo retitled this revision from to [RFC] Refactor TargetParserTests.
jojo updated this object.
jojo added reviewers: compnerd, jmolloy, t.p.northover, rengolin.
jojo added a subscriber: llvm-commits.
rengolin edited edge metadata.Nov 6 2016, 10:36 PM

Hi Jojo,

Thanks for the patch. Other checks we could do here:

  • for each arch, what's the default CPU.
  • given some arch/CPU, make sure some extensions are *not* accepted. For these, one each or even less would be fine.
jojo updated this revision to Diff 77011.Nov 6 2016, 10:37 PM
jojo edited edge metadata.
jojo updated this revision to Diff 77306.Nov 8 2016, 7:55 PM

Done the refactoring.

rengolin added a comment.Nov 9 2016, 3:25 AM

Thanks Jojo,

It's looking much better. A new round of comments.

cheers,
--renato

unittests/Support/TargetParserTest.cpp
19–20

"cpu" -> "CPUName"

29

nit: curly brackets to help identifying the if with the else.

30

I think this could also work if any one flag was set by itself, so:

if (ExtKind <= 1 || isPowerOfTwo(ExtKind)) {

could be a more optimal solution, to avoid the long path.

32

I have the impression that the string representation is redundant.

Instead of generating the string representation of the default extensions, then comparing to the given string, I think you should just pass the values as unsigned ex. (CRC | DSP), then compare with the result from getDefaultExtensions.

142

formatting: move all lines to the same style.

Pass clang-format on the patch, and then make sure that the alignment is the same, even if not needed.

Example, if one call needs the ARMBuildAttrs to be on a new line (>80 cols), then all of them should.

This makes it easier to "see" what's going on.

206

I like these tests, but would be good to make them check for a feature that is close enough, but not implemented.

For example, vfp on pre-v5, vfpv3 on pre-v7, vfpv4 on cortex-a8, etc.

Also, the v7M cores are redundant, you only need to test one v6M (M0) and one v7M (M3).

574–678

The same comments for the ARM implementation apply here.

647

We now have v8M and v8R.

669

I think v8.2A has FP by default. If this test returns FALSE, then there's something wrong with the code. :)

jojo updated this revision to Diff 79365.Nov 27 2016, 7:10 PM

Inline comments.

unittests/Support/TargetParserTest.cpp
32

Good idea! This make the code more simple.Thanks.

206

Indeed. Make sense.
I don't know enough on ARM architecture. So I have to make them as close as possible according to information collected from the net.
There may still be a lot of inappropriate,please let me know.

647

AFAIK, both of them are 32bit.
And v8R has been supported in ARMTargetParser.
There is still no support in ARM backend for v8M,
Should we add it to targetparser after it is actually
supported in the backend?

669

Yes,indeed. There is a incorrect index problem in this test.
No errors printed make me missed the wrong flags here.

rengolin added a comment.Dec 1 2016, 2:40 AM

Sorry for the delay, I'm wondering if the &= is the reason why you're getting the wrong expectation on the tests...

unittests/Support/TargetParserTest.cpp
40

Shouldn't this be ret |=?

582

Same here.

647

Yes, because this tests the parser, not the target support.

jojo added a comment.Dec 2 2016, 1:17 AM

I'm wondering if the &= is the reason why you're getting the wrong expectation on the tests...

The reason why a wrong flag for v8.2 was not exposed is I misused enums of ARM for ArchKind
there in the last diff.

unittests/Support/TargetParserTest.cpp
40

It will return "true" here, only when all the items are the values that we expect.
So it should return a value after "&=".

582

Same as above.

rengolin accepted this revision.Dec 2 2016, 2:07 AM
rengolin edited edge metadata.

Ok, I think this looks much better than what we had, and it's a more meaningful testing strategy.

The repetitiveness will help other people adding tests whenever they add a new core/extension, too.

With the small change I proposed in the inline comment, LGTM.

Thanks!
--renato

unittests/Support/TargetParserTest.cpp
40

Right, my mind was in the "true if it fails" which is pervasive throughout the back-end, mainly because you initialised it as "false". :)

Since the first ret will override, I think you can declare ret at the same time:

bool ret = ARM::getArchName(ArchKind).equals(ExpectedArch);
...

Maybe even call it pass, so it's clearer what it means.

This revision is now accepted and ready to land.Dec 2 2016, 2:07 AM
jojo closed this revision.Dec 5 2016, 7:38 PM

Committed r288758

Revision Contents

PathSize
unittests/
Support/
848 lines

Diff 79365

unittests/Support/TargetParserTest.cpp

Show All 10 Lines
#include "llvm/Support/ARMBuildAttributes.h" #include "llvm/Support/ARMBuildAttributes.h"
#include "llvm/Support/TargetParser.h" #include "llvm/Support/TargetParser.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include <string> #include <string>
using namespace llvm; using namespace llvm;
namespace { namespace {
static const unsigned kAArch64ArchExtKinds[] = {
#define AARCH64_ARCH_EXT_NAME(NAME, ID, FEATURE, NEGFEATURE) ID,
#include "llvm/Support/AArch64TargetParser.def"
#undef AARCH64_ARCH_EXT_NAME
};
template <typename T> struct ArchNames {
const char *Name;
unsigned DefaultFPU;
unsigned ArchBaseExtensions;
T ID;
ARMBuildAttrs::CPUArch ArchAttr;
};
ArchNames<AArch64::ArchKind> kAArch64ARCHNames[] = {
#define AARCH64_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU, \
ARCH_BASE_EXT) \
{NAME, ARM::ARCH_FPU, ARCH_BASE_EXT, AArch64::ArchKind::ID, ARCH_ATTR},
#include "llvm/Support/AArch64TargetParser.def"
#undef AARCH64_ARCH
};
ArchNames<ARM::ArchKind> kARMARCHNames[] = {
#define ARM_ARCH(NAME, ID, CPU_ATTR, SUB_ARCH, ARCH_ATTR, ARCH_FPU, \
ARCH_BASE_EXT) \
{NAME, ARM::ARCH_FPU, ARCH_BASE_EXT, ARM::ID, ARCH_ATTR},
#include "llvm/Support/ARMTargetParser.def"
#undef ARM_ARCH
};
template <typename T> struct CpuNames {
const char *Name;
T ID;
unsigned DefaultFPU;
unsigned DefaultExt;
};
CpuNames<AArch64::ArchKind> kAArch64CPUNames[] = {
#define AARCH64_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT) \
{NAME, AArch64::ArchKind::ID, ARM::DEFAULT_FPU, DEFAULT_EXT},
#include "llvm/Support/AArch64TargetParser.def"
#undef AARCH64_CPU_NAME
};
CpuNames<ARM::ArchKind> kARMCPUNames[] = {
#define ARM_CPU_NAME(NAME, ID, DEFAULT_FPU, IS_DEFAULT, DEFAULT_EXT) \
{NAME, ARM::ID, ARM::DEFAULT_FPU, DEFAULT_EXT},
#include "llvm/Support/ARMTargetParser.def"
#undef ARM_CPU_NAME
};
const char *ARMArch[] = { const char *ARMArch[] = {
"armv2", "armv2a", "armv3", "armv3m", "armv4", "armv2", "armv2a", "armv3", "armv3m", "armv4",
rengolinUnsubmitted
Not Done
ReplyInline Actions

"cpu" -> "CPUName"

rengolin: "cpu" -> "CPUName"
"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", "armv7hl", "armv7l", "armv7-r", "armv7r", "armv7a", "armv7hl", "armv7l", "armv7-r", "armv7r",
"armv7-m", "armv7m", "armv7k", "armv7s", "armv7e-m", "armv7-m", "armv7m", "armv7k", "armv7s", "armv7e-m",
"armv7em", "armv8-a", "armv8", "armv8a", "armv8.1-a", "armv7em", "armv8-a", "armv8", "armv8a", "armv8.1-a",
"armv8.1a", "armv8.2-a", "armv8.2a", "armv8-m.base", "armv8m.base", "armv8.1a", "armv8.2-a", "armv8.2a", "armv8-r", "armv8r",
"armv8-m.main", "armv8m.main", "iwmmxt", "iwmmxt2", "xscale"}; "armv8-m.base", "armv8m.base", "armv8-m.main", "armv8m.main", "iwmmxt",
rengolinUnsubmitted
Not Done
ReplyInline Actions

nit: curly brackets to help identifying the if with the else.

rengolin: nit: curly brackets to help identifying the if with the else.
"iwmmxt2", "xscale"};
rengolinUnsubmitted
Not Done
ReplyInline Actions

I think this could also work if any one flag was set by itself, so:

if (ExtKind <= 1 || isPowerOfTwo(ExtKind)) {

could be a more optimal solution, to avoid the long path.

rengolin: I think this could also work if any one flag was set by itself, so: if (ExtKind <= 1 ||…
bool testARMCPU(StringRef CPUName, StringRef ExpectedArch,
rengolinUnsubmitted
Not Done
ReplyInline Actions

I have the impression that the string representation is redundant.

Instead of generating the string representation of the default extensions, then comparing to the given string, I think you should just pass the values as unsigned ex. (CRC | DSP), then compare with the result from getDefaultExtensions.

rengolin: I have the impression that the string representation is redundant. Instead of generating the…
jojoAuthorUnsubmitted
Not Done
ReplyInline Actions

Good idea! This make the code more simple.Thanks.

jojo: Good idea! This make the code more simple.Thanks.
StringRef ExpectedFPU, unsigned ExpectedFlags,
StringRef CPUAttr) {
bool ret = false;
unsigned ArchKind = ARM::parseCPUArch(CPUName);
ret = ARM::getArchName(ArchKind).equals(ExpectedArch);
unsigned FPUKind = ARM::getDefaultFPU(CPUName, ArchKind);
ret &= ARM::getFPUName(FPUKind).equals(ExpectedFPU);
rengolinUnsubmitted
Not Done
ReplyInline Actions

Shouldn't this be ret |=?

rengolin: Shouldn't this be `ret |=`?
jojoAuthorUnsubmitted
Not Done
ReplyInline Actions

It will return "true" here, only when all the items are the values that we expect.
So it should return a value after "&=".

jojo: It will return "true" here, only when all the items are the values that we expect. So it should…
rengolinUnsubmitted
Not Done
ReplyInline Actions

Right, my mind was in the "true if it fails" which is pervasive throughout the back-end, mainly because you initialised it as "false". :)

Since the first ret will override, I think you can declare ret at the same time:

bool ret = ARM::getArchName(ArchKind).equals(ExpectedArch);
...

Maybe even call it pass, so it's clearer what it means.

rengolin: Right, my mind was in the "true if it fails" which is pervasive throughout the back-end, mainly…
unsigned ExtKind = ARM::getDefaultExtensions(CPUName, ArchKind);
if (ExtKind > 1 && (ExtKind & ARM::AEK_NONE))
ret &= ((ExtKind ^ ARM::AEK_NONE) == ExpectedFlags);
else
ret &= (ExtKind == ExpectedFlags);
ret &= ARM::getCPUAttr(ArchKind).equals(CPUAttr);
template <typename T, size_t N> return ret;
bool contains(const T (&array)[N], const T element) {
return std::find(std::begin(array), std::end(array), element) !=
std::end(array);
}
template <size_t N>
bool contains(const char *(&array)[N], const char *element) {
return std::find_if(std::begin(array), std::end(array), [&](const char *S) {
return ::strcmp(S, element) == 0;
}) != std::end(array);
}
TEST(TargetParserTest, ARMArchName) {
for (ARM::ArchKind AK = static_cast<ARM::ArchKind>(0);
AK <= ARM::ArchKind::AK_LAST;
AK = static_cast<ARM::ArchKind>(static_cast<unsigned>(AK) + 1))
EXPECT_TRUE(AK == ARM::AK_LAST ? ARM::getArchName(AK).empty()
: !ARM::getArchName(AK).empty());
}
TEST(TargetParserTest, ARMCPUAttr) {
for (ARM::ArchKind AK = static_cast<ARM::ArchKind>(0);
AK <= ARM::ArchKind::AK_LAST;
AK = static_cast<ARM::ArchKind>(static_cast<unsigned>(AK) + 1))
EXPECT_TRUE((AK == ARM::AK_INVALID || AK == ARM::AK_LAST)
? ARM::getCPUAttr(AK).empty()
: !ARM::getCPUAttr(AK).empty());
}
TEST(TargetParserTest, ARMSubArch) {
for (ARM::ArchKind AK = static_cast<ARM::ArchKind>(0);
AK <= ARM::ArchKind::AK_LAST;
AK = static_cast<ARM::ArchKind>(static_cast<unsigned>(AK) + 1))
EXPECT_TRUE((AK == ARM::AK_INVALID || AK == ARM::AK_IWMMXT ||
AK == ARM::AK_IWMMXT2 || AK == ARM::AK_LAST)
? ARM::getSubArch(AK).empty()
: !ARM::getSubArch(AK).empty());
} }
TEST(TargetParserTest, ARMFPUName) { TEST(TargetParserTest, testARMCPU) {
for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0); EXPECT_TRUE(testARMCPU("invalid", "invalid", "invalid",
FK <= ARM::FPUKind::FK_LAST; ARM::AEK_NONE, ""));
FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1)) EXPECT_TRUE(testARMCPU("generic", "invalid", "none",
EXPECT_TRUE(FK == ARM::FK_LAST ? ARM::getFPUName(FK).empty() ARM::AEK_NONE, ""));
: !ARM::getFPUName(FK).empty());
EXPECT_TRUE(testARMCPU("arm2", "armv2", "none",
ARM::AEK_NONE, "2"));
EXPECT_TRUE(testARMCPU("arm3", "armv2a", "none",
ARM::AEK_NONE, "2A"));
EXPECT_TRUE(testARMCPU("arm6", "armv3", "none",
ARM::AEK_NONE, "3"));
EXPECT_TRUE(testARMCPU("arm7m", "armv3m", "none",
ARM::AEK_NONE, "3M"));
EXPECT_TRUE(testARMCPU("arm8", "armv4", "none",
ARM::AEK_NONE, "4"));
EXPECT_TRUE(testARMCPU("arm810", "armv4", "none",
ARM::AEK_NONE, "4"));
EXPECT_TRUE(testARMCPU("strongarm", "armv4", "none",
ARM::AEK_NONE, "4"));
EXPECT_TRUE(testARMCPU("strongarm110", "armv4", "none",
ARM::AEK_NONE, "4"));
EXPECT_TRUE(testARMCPU("strongarm1100", "armv4", "none",
ARM::AEK_NONE, "4"));
EXPECT_TRUE(testARMCPU("strongarm1110", "armv4", "none",
ARM::AEK_NONE, "4"));
EXPECT_TRUE(testARMCPU("arm7tdmi", "armv4t", "none",
ARM::AEK_NONE, "4T"));
EXPECT_TRUE(testARMCPU("arm7tdmi-s", "armv4t", "none",
ARM::AEK_NONE, "4T"));
EXPECT_TRUE(testARMCPU("arm710t", "armv4t", "none",
ARM::AEK_NONE, "4T"));
EXPECT_TRUE(testARMCPU("arm720t", "armv4t", "none",
ARM::AEK_NONE, "4T"));
EXPECT_TRUE(testARMCPU("arm9", "armv4t", "none",
ARM::AEK_NONE, "4T"));
EXPECT_TRUE(testARMCPU("arm9tdmi", "armv4t", "none",
ARM::AEK_NONE, "4T"));
EXPECT_TRUE(testARMCPU("arm920", "armv4t", "none",
ARM::AEK_NONE, "4T"));
EXPECT_TRUE(testARMCPU("arm920t", "armv4t", "none",
ARM::AEK_NONE, "4T"));
EXPECT_TRUE(testARMCPU("arm922t", "armv4t", "none",
ARM::AEK_NONE, "4T"));
EXPECT_TRUE(testARMCPU("arm9312", "armv4t", "none",
ARM::AEK_NONE, "4T"));
EXPECT_TRUE(testARMCPU("arm940t", "armv4t", "none",
ARM::AEK_NONE, "4T"));
EXPECT_TRUE(testARMCPU("ep9312", "armv4t", "none",
ARM::AEK_NONE, "4T"));
EXPECT_TRUE(testARMCPU("arm10tdmi", "armv5t", "none",
ARM::AEK_NONE, "5T"));
EXPECT_TRUE(testARMCPU("arm1020t", "armv5t", "none",
ARM::AEK_NONE, "5T"));
EXPECT_TRUE(testARMCPU("arm9e", "armv5te", "none",
ARM::AEK_DSP, "5TE"));
EXPECT_TRUE(testARMCPU("arm946e-s", "armv5te", "none",
ARM::AEK_DSP, "5TE"));
EXPECT_TRUE(testARMCPU("arm966e-s", "armv5te", "none",
ARM::AEK_DSP, "5TE"));
EXPECT_TRUE(testARMCPU("arm968e-s", "armv5te", "none",
ARM::AEK_DSP, "5TE"));
EXPECT_TRUE(testARMCPU("arm10e", "armv5te", "none",
ARM::AEK_DSP, "5TE"));
EXPECT_TRUE(testARMCPU("arm1020e", "armv5te", "none",
ARM::AEK_DSP, "5TE"));
EXPECT_TRUE(testARMCPU("arm1022e", "armv5te", "none",
ARM::AEK_DSP, "5TE"));
EXPECT_TRUE(testARMCPU("arm926ej-s", "armv5tej", "none",
ARM::AEK_DSP, "5TEJ"));
EXPECT_TRUE(testARMCPU("arm1136j-s", "armv6", "none",
ARM::AEK_DSP, "6"));
EXPECT_TRUE(testARMCPU("arm1136jf-s", "armv6", "vfpv2",
ARM::AEK_DSP, "6"));
EXPECT_TRUE(testARMCPU("arm1136jz-s", "armv6", "none",
ARM::AEK_DSP, "6"));
EXPECT_TRUE(testARMCPU("arm1176j-s", "armv6k", "none",
ARM::AEK_DSP, "6K"));
EXPECT_TRUE(testARMCPU("arm1176jz-s", "armv6kz", "none",
ARM::AEK_SEC | ARM::AEK_DSP, "6KZ"));
EXPECT_TRUE(testARMCPU("mpcore", "armv6k", "vfpv2",
ARM::AEK_DSP, "6K"));
EXPECT_TRUE(testARMCPU("mpcorenovfp", "armv6k", "none",
ARM::AEK_DSP, "6K"));
EXPECT_TRUE(testARMCPU("arm1176jzf-s", "armv6kz", "vfpv2",
ARM::AEK_SEC | ARM::AEK_DSP, "6KZ"));
EXPECT_TRUE(testARMCPU("arm1156t2-s", "armv6t2", "none",
ARM::AEK_DSP, "6T2"));
EXPECT_TRUE(testARMCPU("arm1156t2f-s", "armv6t2", "vfpv2",
ARM::AEK_DSP, "6T2"));
rengolinUnsubmitted
Not Done
ReplyInline Actions

formatting: move all lines to the same style.

Pass clang-format on the patch, and then make sure that the alignment is the same, even if not needed.

Example, if one call needs the ARMBuildAttrs to be on a new line (>80 cols), then all of them should.

This makes it easier to "see" what's going on.

rengolin: formatting: move all lines to the same style. Pass clang-format on the patch, and then make…
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_HWDIV | ARM::AEK_HWDIVARM | ARM::AEK_MP |
ARM::AEK_SEC | ARM::AEK_VIRT | ARM::AEK_DSP,
"7-A"));
EXPECT_TRUE(testARMCPU("cortex-a8", "armv7-a", "neon",
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"));
EXPECT_TRUE(testARMCPU("cortex-a12", "armv7-a", "neon-vfpv4",
ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_DSP,
"7-A"));
EXPECT_TRUE(testARMCPU("cortex-a15", "armv7-a", "neon-vfpv4",
ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_DSP,
"7-A"));
EXPECT_TRUE(testARMCPU("cortex-a17", "armv7-a", "neon-vfpv4",
ARM::AEK_SEC | ARM::AEK_MP | ARM::AEK_VIRT |
ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_DSP,
"7-A"));
EXPECT_TRUE(testARMCPU("krait", "armv7-a", "neon-vfpv4",
ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_DSP,
"7-A"));
EXPECT_TRUE(testARMCPU("cortex-r4", "armv7-r", "none",
ARM::AEK_HWDIV | ARM::AEK_DSP, "7-R"));
EXPECT_TRUE(testARMCPU("cortex-r4f", "armv7-r", "vfpv3-d16",
ARM::AEK_HWDIV | ARM::AEK_DSP, "7-R"));
EXPECT_TRUE(testARMCPU("cortex-r5", "armv7-r", "vfpv3-d16",
ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIV |
ARM::AEK_DSP, "7-R"));
EXPECT_TRUE(testARMCPU("cortex-r7", "armv7-r", "vfpv3-d16-fp16",
ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIV |
ARM::AEK_DSP, "7-R"));
EXPECT_TRUE(testARMCPU("cortex-r8", "armv7-r", "vfpv3-d16-fp16",
ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIV |
ARM::AEK_DSP, "7-R"));
EXPECT_TRUE(testARMCPU("cortex-r52", "armv8-r", "neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_MP | ARM::AEK_VIRT |
ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_DSP,
"8-R"));
EXPECT_TRUE(testARMCPU("sc300", "armv7-m", "none",
ARM::AEK_HWDIV, "7-M"));
EXPECT_TRUE(testARMCPU("cortex-m3", "armv7-m", "none",
ARM::AEK_HWDIV, "7-M"));
EXPECT_TRUE(testARMCPU("cortex-m4", "armv7e-m", "fpv4-sp-d16",
ARM::AEK_HWDIV | ARM::AEK_DSP, "7E-M"));
EXPECT_TRUE(testARMCPU("cortex-m7", "armv7e-m", "fpv5-d16",
ARM::AEK_HWDIV | ARM::AEK_DSP, "7E-M"));
EXPECT_TRUE(testARMCPU("cortex-a32", "armv8-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIV | ARM::AEK_DSP,
"8-A"));
EXPECT_TRUE(testARMCPU("cortex-a35", "armv8-a", "crypto-neon-fp-armv8",
rengolinUnsubmitted
Not Done
ReplyInline Actions

I like these tests, but would be good to make them check for a feature that is close enough, but not implemented.

For example, vfp on pre-v5, vfpv3 on pre-v7, vfpv4 on cortex-a8, etc.

Also, the v7M cores are redundant, you only need to test one v6M (M0) and one v7M (M3).

rengolin: I like these tests, but would be good to make them check for a feature that is close enough…
jojoAuthorUnsubmitted
Not Done
ReplyInline Actions

Indeed. Make sense.
I don't know enough on ARM architecture. So I have to make them as close as possible according to information collected from the net.
There may still be a lot of inappropriate,please let me know.

jojo: Indeed. Make sense. I don't know enough on ARM architecture. So I have to make them as close as…
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIV | ARM::AEK_DSP,
"8-A"));
EXPECT_TRUE(testARMCPU("cortex-a53", "armv8-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIV | ARM::AEK_DSP,
"8-A"));
EXPECT_TRUE(testARMCPU("cortex-a57", "armv8-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIV | ARM::AEK_DSP,
"8-A"));
EXPECT_TRUE(testARMCPU("cortex-a72", "armv8-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIV | ARM::AEK_DSP,
"8-A"));
EXPECT_TRUE(testARMCPU("cortex-a73", "armv8-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIV | ARM::AEK_DSP,
"8-A"));
EXPECT_TRUE(testARMCPU("cyclone", "armv8-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIV | ARM::AEK_DSP,
"8-A"));
EXPECT_TRUE(testARMCPU("exynos-m1", "armv8-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIV | ARM::AEK_DSP,
"8-A"));
EXPECT_TRUE(testARMCPU("exynos-m2", "armv8-a", "crypto-neon-fp-armv8",
ARM::AEK_CRC | ARM::AEK_SEC | ARM::AEK_MP |
ARM::AEK_VIRT | ARM::AEK_HWDIVARM |
ARM::AEK_HWDIV | ARM::AEK_DSP,
"8-A"));
EXPECT_TRUE(testARMCPU("iwmmxt", "iwmmxt", "none",
ARM::AEK_NONE, "iwmmxt"));
EXPECT_TRUE(testARMCPU("xscale", "xscale", "none",
ARM::AEK_NONE, "xscale"));
EXPECT_TRUE(testARMCPU("swift", "armv7s", "neon-vfpv4",
ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_DSP,
"7-S"));
}
bool testARMArch(StringRef Arch, StringRef DefaultCPU, StringRef SubArch,
unsigned ArchAttr) {
unsigned ArchKind = ARM::parseArch(Arch);
return (ArchKind != ARM::AK_INVALID) &
ARM::getDefaultCPU(Arch).equals(DefaultCPU) &
ARM::getSubArch(ArchKind).equals(SubArch) &
(ARM::getArchAttr(ArchKind) == ArchAttr);
}
TEST(TargetParserTest, testARMArch) {
EXPECT_TRUE(
testARMArch("armv2", "arm2", "v2",
ARMBuildAttrs::CPUArch::Pre_v4));
EXPECT_TRUE(
testARMArch("armv2a", "arm3", "v2a",
ARMBuildAttrs::CPUArch::Pre_v4));
EXPECT_TRUE(
testARMArch("armv3", "arm6", "v3",
ARMBuildAttrs::CPUArch::Pre_v4));
EXPECT_TRUE(
testARMArch("armv3m", "arm7m", "v3m",
ARMBuildAttrs::CPUArch::Pre_v4));
EXPECT_TRUE(
testARMArch("armv4", "strongarm", "v4",
ARMBuildAttrs::CPUArch::v4));
EXPECT_TRUE(
testARMArch("armv4t", "arm7tdmi", "v4t",
ARMBuildAttrs::CPUArch::v4T));
EXPECT_TRUE(
testARMArch("armv5t", "arm10tdmi", "v5",
ARMBuildAttrs::CPUArch::v5T));
EXPECT_TRUE(
testARMArch("armv5te", "arm1022e", "v5e",
ARMBuildAttrs::CPUArch::v5TE));
EXPECT_TRUE(
testARMArch("armv5tej", "arm926ej-s", "v5e",
ARMBuildAttrs::CPUArch::v5TEJ));
EXPECT_TRUE(
testARMArch("armv6", "arm1136jf-s", "v6",
ARMBuildAttrs::CPUArch::v6));
EXPECT_TRUE(
testARMArch("armv6k", "arm1176j-s", "v6k",
ARMBuildAttrs::CPUArch::v6K));
EXPECT_TRUE(
testARMArch("armv6t2", "arm1156t2-s", "v6t2",
ARMBuildAttrs::CPUArch::v6T2));
EXPECT_TRUE(
testARMArch("armv6kz", "arm1176jzf-s", "v6kz",
ARMBuildAttrs::CPUArch::v6KZ));
EXPECT_TRUE(
testARMArch("armv6-m", "cortex-m0", "v6m",
ARMBuildAttrs::CPUArch::v6_M));
EXPECT_TRUE(
testARMArch("armv7-a", "cortex-a8", "v7",
ARMBuildAttrs::CPUArch::v7));
EXPECT_TRUE(
testARMArch("armv7-r", "cortex-r4", "v7r",
ARMBuildAttrs::CPUArch::v7));
EXPECT_TRUE(
testARMArch("armv7-m", "cortex-m3", "v7m",
ARMBuildAttrs::CPUArch::v7));
EXPECT_TRUE(
testARMArch("armv7e-m", "cortex-m4", "v7em",
ARMBuildAttrs::CPUArch::v7E_M));
EXPECT_TRUE(
testARMArch("armv8-a", "cortex-a53", "v8",
ARMBuildAttrs::CPUArch::v8_A));
EXPECT_TRUE(
testARMArch("armv8.1-a", "generic", "v8.1a",
ARMBuildAttrs::CPUArch::v8_A));
EXPECT_TRUE(
testARMArch("armv8.2-a", "generic", "v8.2a",
ARMBuildAttrs::CPUArch::v8_A));
EXPECT_TRUE(
testARMArch("armv8-r", "cortex-r52", "v8r",
ARMBuildAttrs::CPUArch::v8_R));
EXPECT_TRUE(
testARMArch("armv8-m.base", "generic", "v8m.base",
ARMBuildAttrs::CPUArch::v8_M_Base));
EXPECT_TRUE(
testARMArch("armv8-m.main", "generic", "v8m.main",
ARMBuildAttrs::CPUArch::v8_M_Main));
EXPECT_TRUE(
testARMArch("iwmmxt", "iwmmxt", "",
ARMBuildAttrs::CPUArch::v5TE));
EXPECT_TRUE(
testARMArch("iwmmxt2", "generic", "",
ARMBuildAttrs::CPUArch::v5TE));
EXPECT_TRUE(
testARMArch("xscale", "xscale", "v5e",
ARMBuildAttrs::CPUArch::v5TE));
EXPECT_TRUE(
testARMArch("armv7s", "swift", "v7s",
ARMBuildAttrs::CPUArch::v7));
EXPECT_TRUE(
testARMArch("armv7k", "generic", "v7k",
ARMBuildAttrs::CPUArch::v7));
}
bool testARMExtension(StringRef CPUName, unsigned ArchKind, StringRef ArchExt) {
return ARM::getDefaultExtensions(CPUName, ArchKind) &
ARM::parseArchExt(ArchExt);
}
TEST(TargetParserTest, testARMExtension) {
EXPECT_FALSE(testARMExtension("arm2", 0, "thumb"));
EXPECT_FALSE(testARMExtension("arm3", 0, "thumb"));
EXPECT_FALSE(testARMExtension("arm6", 0, "thumb"));
EXPECT_FALSE(testARMExtension("arm7m", 0, "thumb"));
EXPECT_FALSE(testARMExtension("strongarm", 0, "dsp"));
EXPECT_FALSE(testARMExtension("arm7tdmi", 0, "dsp"));
EXPECT_FALSE(testARMExtension("arm10tdmi", 0, "simd"));
EXPECT_FALSE(testARMExtension("arm1022e", 0, "simd"));
EXPECT_FALSE(testARMExtension("arm926ej-s", 0, "simd"));
EXPECT_FALSE(testARMExtension("arm1136jf-s", 0, "crypto"));
EXPECT_FALSE(testARMExtension("arm1176j-s", 0, "crypto"));
EXPECT_FALSE(testARMExtension("arm1156t2-s", 0, "crypto"));
EXPECT_FALSE(testARMExtension("arm1176jzf-s", 0, "crypto"));
EXPECT_FALSE(testARMExtension("cortex-m0", 0, "crypto"));
EXPECT_FALSE(testARMExtension("cortex-a8", 0, "crypto"));
EXPECT_FALSE(testARMExtension("cortex-r4", 0, "crypto"));
EXPECT_FALSE(testARMExtension("cortex-m3", 0, "crypto"));
EXPECT_FALSE(testARMExtension("cortex-a53", 0, "ras"));
EXPECT_FALSE(testARMExtension("cortex-r52", 0, "ras"));
EXPECT_FALSE(testARMExtension("iwmmxt", 0, "crc"));
EXPECT_FALSE(testARMExtension("xscale", 0, "crc"));
EXPECT_FALSE(testARMExtension("swift", 0, "crc"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV2, "thumb"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV2A, "thumb"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV3, "thumb"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV3M, "thumb"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV4, "dsp"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV4T, "dsp"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV5T, "simd"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV5TE, "simd"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV5TEJ, "simd"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV6, "crypto"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV6K, "crypto"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV6T2, "crypto"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV6KZ, "crypto"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV6M, "crypto"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7A, "crypto"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7R, "crypto"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7M, "crypto"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7EM, "crypto"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8A, "ras"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8_1A, "ras"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8_2A, "spe"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8R, "ras"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8MBaseline, "crc"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV8MMainline, "crc"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_IWMMXT, "crc"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_IWMMXT2, "crc"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_XSCALE, "crc"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7S, "crypto"));
EXPECT_FALSE(testARMExtension("generic", ARM::AK_ARMV7K, "crypto"));
} }
TEST(TargetParserTest, ARMFPUVersion) { TEST(TargetParserTest, ARMFPUVersion) {
for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0); for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
FK <= ARM::FPUKind::FK_LAST; FK <= ARM::FPUKind::FK_LAST;
FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1)) FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
if (FK == ARM::FK_LAST) if (FK == ARM::FK_LAST)
EXPECT_EQ(0U, ARM::getFPUVersion(FK)); EXPECT_EQ(0U, ARM::getFPUVersion(FK));
Show All 16 Lines for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
FK <= ARM::FPUKind::FK_LAST; FK <= ARM::FPUKind::FK_LAST;
FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1)) FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
if (FK == ARM::FK_LAST) if (FK == ARM::FK_LAST)
EXPECT_EQ(0U, ARM::getFPURestriction(FK)); EXPECT_EQ(0U, ARM::getFPURestriction(FK));
else else
EXPECT_LE(0U, ARM::getFPURestriction(FK)); EXPECT_LE(0U, ARM::getFPURestriction(FK));
} }
TEST(TargetParserTest, ARMDefaultFPU) {
for (ARM::ArchKind AK = static_cast<ARM::ArchKind>(0);
AK < ARM::ArchKind::AK_LAST;
AK = static_cast<ARM::ArchKind>(static_cast<unsigned>(AK) + 1))
EXPECT_EQ(kARMARCHNames[AK].DefaultFPU,
ARM::getDefaultFPU(StringRef("generic"), AK));
for (const auto &ARMCPUName : kARMCPUNames)
EXPECT_EQ(ARMCPUName.DefaultFPU, ARM::getDefaultFPU(ARMCPUName.Name, 0));
}
TEST(TargetParserTest, ARMDefaultExtensions) {
for (ARM::ArchKind AK = static_cast<ARM::ArchKind>(0);
AK < ARM::ArchKind::AK_LAST;
AK = static_cast<ARM::ArchKind>(static_cast<unsigned>(AK) + 1))
EXPECT_EQ(kARMARCHNames[AK].ArchBaseExtensions,
ARM::getDefaultExtensions(StringRef("generic"), AK));
for (const auto &ARMCPUName : kARMCPUNames) {
unsigned DefaultExt =
kARMARCHNames[ARMCPUName.ID].ArchBaseExtensions | ARMCPUName.DefaultExt;
EXPECT_EQ(DefaultExt, ARM::getDefaultExtensions(ARMCPUName.Name, 0));
}
}
TEST(TargetParserTest, ARMExtensionFeatures) { TEST(TargetParserTest, ARMExtensionFeatures) {
std::vector<StringRef> Features; std::vector<StringRef> Features;
unsigned Extensions = ARM::AEK_CRC | ARM::AEK_CRYPTO | ARM::AEK_DSP | unsigned Extensions = ARM::AEK_CRC | ARM::AEK_CRYPTO | ARM::AEK_DSP |
ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_MP | ARM::AEK_HWDIVARM | ARM::AEK_HWDIV | ARM::AEK_MP |
ARM::AEK_SEC | ARM::AEK_VIRT | ARM::AEK_RAS; ARM::AEK_SEC | ARM::AEK_VIRT | ARM::AEK_RAS;
for (unsigned i = 0; i <= Extensions; i++) for (unsigned i = 0; i <= Extensions; i++)
EXPECT_TRUE(i == 0 ? !ARM::getExtensionFeatures(i, Features) EXPECT_TRUE(i == 0 ? !ARM::getExtensionFeatures(i, Features)
: ARM::getExtensionFeatures(i, Features)); : ARM::getExtensionFeatures(i, Features));
} }
TEST(TargetParserTest, ARMFPUFeatures) { TEST(TargetParserTest, ARMFPUFeatures) {
std::vector<StringRef> Features; std::vector<StringRef> Features;
for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0); for (ARM::FPUKind FK = static_cast<ARM::FPUKind>(0);
FK <= ARM::FPUKind::FK_LAST; FK <= ARM::FPUKind::FK_LAST;
FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1)) FK = static_cast<ARM::FPUKind>(static_cast<unsigned>(FK) + 1))
EXPECT_TRUE((FK == ARM::FK_INVALID || FK >= ARM::FK_LAST) EXPECT_TRUE((FK == ARM::FK_INVALID || FK >= ARM::FK_LAST)
? !ARM::getFPUFeatures(FK, Features) ? !ARM::getFPUFeatures(FK, Features)
: ARM::getFPUFeatures(FK, Features)); : ARM::getFPUFeatures(FK, Features));
} }
TEST(TargetParserTest, ARMArchAttr) {
for (ARM::ArchKind AK = static_cast<ARM::ArchKind>(0);
AK <= ARM::ArchKind::AK_LAST;
AK = static_cast<ARM::ArchKind>(static_cast<unsigned>(AK) + 1))
EXPECT_TRUE(AK == ARM::AK_LAST
? (ARMBuildAttrs::CPUArch::Pre_v4 == ARM::getArchAttr(AK))
: (kARMARCHNames[AK].ArchAttr == ARM::getArchAttr(AK)));
}
TEST(TargetParserTest, ARMArchExtFeature) { TEST(TargetParserTest, ARMArchExtFeature) {
const char *ArchExt[][4] = {{"crc", "nocrc", "+crc", "-crc"}, const char *ArchExt[][4] = {{"crc", "nocrc", "+crc", "-crc"},
{"crypto", "nocrypto", "+crypto", "-crypto"}, {"crypto", "nocrypto", "+crypto", "-crypto"},
{"dsp", "nodsp", "+dsp", "-dsp"}, {"dsp", "nodsp", "+dsp", "-dsp"},
{"fp", "nofp", nullptr, nullptr}, {"fp", "nofp", nullptr, nullptr},
{"idiv", "noidiv", nullptr, nullptr}, {"idiv", "noidiv", nullptr, nullptr},
{"mp", "nomp", nullptr, nullptr}, {"mp", "nomp", nullptr, nullptr},
{"simd", "nosimd", nullptr, nullptr}, {"simd", "nosimd", nullptr, nullptr},
{"sec", "nosec", nullptr, nullptr}, {"sec", "nosec", nullptr, nullptr},
{"virt", "novirt", nullptr, nullptr}, {"virt", "novirt", nullptr, nullptr},
{"fp16", "nofp16", "+fullfp16", "-fullfp16"}, {"fp16", "nofp16", "+fullfp16", "-fullfp16"},
{"ras", "noras", "+ras", "-ras"}, {"ras", "noras", "+ras", "-ras"},
{"os", "noos", nullptr, nullptr}, {"os", "noos", nullptr, nullptr},
{"iwmmxt", "noiwmmxt", nullptr, nullptr}, {"iwmmxt", "noiwmmxt", nullptr, nullptr},
{"iwmmxt2", "noiwmmxt2", nullptr, nullptr}, {"iwmmxt2", "noiwmmxt2", nullptr, nullptr},
{"maverick", "maverick", nullptr, nullptr}, {"maverick", "maverick", nullptr, nullptr},
{"xscale", "noxscale", nullptr, nullptr}}; {"xscale", "noxscale", nullptr, nullptr}};
for (unsigned i = 0; i < array_lengthof(ArchExt); i++) { for (unsigned i = 0; i < array_lengthof(ArchExt); i++) {
EXPECT_EQ(StringRef(ArchExt[i][2]), ARM::getArchExtFeature(ArchExt[i][0])); EXPECT_EQ(StringRef(ArchExt[i][2]), ARM::getArchExtFeature(ArchExt[i][0]));
EXPECT_EQ(StringRef(ArchExt[i][3]), ARM::getArchExtFeature(ArchExt[i][1])); EXPECT_EQ(StringRef(ArchExt[i][3]), ARM::getArchExtFeature(ArchExt[i][1]));
} }
} }
TEST(TargetParserTest, ARMDefaultCPU) {
for (unsigned i = 0; i < array_lengthof(ARMArch); i++)
EXPECT_FALSE(ARM::getDefaultCPU(ARMArch[i]).empty());
}
TEST(TargetParserTest, ARMparseHWDiv) { TEST(TargetParserTest, ARMparseHWDiv) {
const char *hwdiv[] = {"thumb", "arm", "arm,thumb", "thumb,arm"}; const char *hwdiv[] = {"thumb", "arm", "arm,thumb", "thumb,arm"};
for (unsigned i = 0; i < array_lengthof(hwdiv); i++) for (unsigned i = 0; i < array_lengthof(hwdiv); i++)
EXPECT_NE(ARM::AEK_INVALID, ARM::parseHWDiv((StringRef)hwdiv[i])); EXPECT_NE(ARM::AEK_INVALID, ARM::parseHWDiv((StringRef)hwdiv[i]));
} }
TEST(TargetParserTest, ARMparseFPU) {
const char *FPU[] = {"vfp",
"vfpv2",
"vfp2",
"vfpv3",
"vfp3",
"vfpv3-fp16",
"vfpv3-d16",
"vfp3-d16",
"vfpv3-d16-fp16",
"vfpv3xd",
"vfpv3xd-fp16",
"vfpv4",
"vfp4",
"vfpv4-d16",
"vfp4-d16",
"fp4-dp-d16",
"fpv4-dp-d16",
"fpv4-sp-d16",
"fp4-sp-d16",
"vfpv4-sp-d16",
"fpv5-d16",
"fp5-dp-d16",
"fpv5-dp-d16",
"fpv5-sp-d16",
"fp5-sp-d16",
"fp-armv8",
"neon",
"neon-vfpv3",
"neon-fp16",
"neon-vfpv4",
"neon-fp-armv8",
"crypto-neon-fp-armv8",
"softvfp"};
for (unsigned i = 0; i < array_lengthof(FPU); i++)
EXPECT_NE(ARM::FK_INVALID, ARM::parseFPU((StringRef)FPU[i]));
}
TEST(TargetParserTest, ARMparseArch) {
for (unsigned i = 0; i < array_lengthof(ARMArch); i++)
EXPECT_NE(ARM::AEK_INVALID, ARM::parseArch(ARMArch[i]));
}
TEST(TargetParserTest, ARMparseArchExt) {
const char *ArchExt[] = {"none", "crc", "crypto", "dsp", "fp",
"idiv", "mp", "simd", "sec", "virt",
"fp16", "ras", "os", "iwmmxt", "iwmmxt2",
"maverick", "xscale"};
for (unsigned i = 0; i < array_lengthof(ArchExt); i++)
EXPECT_NE(ARM::AEK_INVALID, ARM::parseArchExt(ArchExt[i]));
}
TEST(TargetParserTest, ARMparseCPUArch) {
const char *CPU[] = {
"arm2", "arm3", "arm6", "arm7m",
"arm8", "arm810", "strongarm", "strongarm110",
"strongarm1100", "strongarm1110", "arm7tdmi", "arm7tdmi-s",
"arm710t", "arm720t", "arm9", "arm9tdmi",
"arm920", "arm920t", "arm922t", "arm9312",
"arm940t", "ep9312", "arm10tdmi", "arm1020t",
"arm9e", "arm946e-s", "arm966e-s", "arm968e-s",
"arm10e", "arm1020e", "arm1022e", "arm926ej-s",
"arm1136j-s", "arm1136jf-s", "arm1136jz-s", "arm1176j-s",
"arm1176jz-s", "mpcore", "mpcorenovfp", "arm1176jzf-s",
"arm1156t2-s", "arm1156t2f-s", "cortex-m0", "cortex-m0plus",
"cortex-m1", "sc000", "cortex-a5", "cortex-a7",
"cortex-a8", "cortex-a9", "cortex-a12", "cortex-a15",
"cortex-a17", "krait", "cortex-r4", "cortex-r4f",
"cortex-r5", "cortex-r7", "cortex-r8", "sc300",
"cortex-m3", "cortex-m4", "cortex-m7", "cortex-a32",
"cortex-a35", "cortex-a53", "cortex-a57", "cortex-a72",
"cortex-a73", "cyclone", "exynos-m1", "exynos-m2",
"iwmmxt", "xscale", "swift", "cortex-r52"};
for (const auto &ARMCPUName : kARMCPUNames) {
if (contains(CPU, ARMCPUName.Name))
EXPECT_NE(ARM::AK_INVALID, ARM::parseCPUArch(ARMCPUName.Name));
else
EXPECT_EQ(ARM::AK_INVALID, ARM::parseCPUArch(ARMCPUName.Name));
}
}
TEST(TargetParserTest, ARMparseArchEndianAndISA) { TEST(TargetParserTest, ARMparseArchEndianAndISA) {
const char *Arch[] = { const char *Arch[] = {
"v2", "v2a", "v3", "v3m", "v4", "v4t", "v5", "v5t", "v2", "v2a", "v3", "v3m", "v4", "v4t", "v5", "v5t",
"v5e", "v5te", "v5tej", "v6", "v6j", "v6k", "v6hl", "v6t2", "v5e", "v5te", "v5tej", "v6", "v6j", "v6k", "v6hl", "v6t2",
"v6kz", "v6z", "v6zk", "v6-m", "v6m", "v6sm", "v6s-m", "v7-a", "v6kz", "v6z", "v6zk", "v6-m", "v6m", "v6sm", "v6s-m", "v7-a",
"v7", "v7a", "v7hl", "v7l", "v7-r", "v7r", "v7-m", "v7m", "v7", "v7a", "v7hl", "v7l", "v7-r", "v7r", "v7-m", "v7m",
"v7k", "v7s", "v7e-m", "v7em", "v8-a", "v8", "v8a", "v8.1-a", "v7k", "v7s", "v7e-m", "v7em", "v8-a", "v8", "v8a", "v8.1-a",
"v8.1a", "v8.2-a", "v8.2a", "v8-r"}; "v8.1a", "v8.2-a", "v8.2a", "v8-r"};
Show All 39 Lines for (unsigned i = 0; i < array_lengthof(ARMArch); i++) {
case ARM::AK_ARMV6M: case ARM::AK_ARMV6M:
case ARM::AK_ARMV7M: case ARM::AK_ARMV7M:
case ARM::AK_ARMV7EM: case ARM::AK_ARMV7EM:
case ARM::AK_ARMV8MMainline: case ARM::AK_ARMV8MMainline:
case ARM::AK_ARMV8MBaseline: case ARM::AK_ARMV8MBaseline:
EXPECT_EQ(ARM::PK_M, ARM::parseArchProfile(ARMArch[i])); EXPECT_EQ(ARM::PK_M, ARM::parseArchProfile(ARMArch[i]));
continue; continue;
case ARM::AK_ARMV7R: case ARM::AK_ARMV7R:
case ARM::AK_ARMV8R:
EXPECT_EQ(ARM::PK_R, ARM::parseArchProfile(ARMArch[i])); EXPECT_EQ(ARM::PK_R, ARM::parseArchProfile(ARMArch[i]));
continue; continue;
case ARM::AK_ARMV7A: case ARM::AK_ARMV7A:
case ARM::AK_ARMV7K: case ARM::AK_ARMV7K:
case ARM::AK_ARMV8A: case ARM::AK_ARMV8A:
case ARM::AK_ARMV8_1A: case ARM::AK_ARMV8_1A:
case ARM::AK_ARMV8_2A: case ARM::AK_ARMV8_2A:
EXPECT_EQ(ARM::PK_A, ARM::parseArchProfile(ARMArch[i])); EXPECT_EQ(ARM::PK_A, ARM::parseArchProfile(ARMArch[i]));
continue; continue;
} }
EXPECT_EQ(ARM::PK_INVALID, ARM::parseArchProfile(ARMArch[i])); EXPECT_EQ(ARM::PK_INVALID, ARM::parseArchProfile(ARMArch[i]));
} }
} }
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]));
} }
TEST(TargetParserTest, AArch64DefaultFPU) { bool testAArch64CPU(StringRef CPUName, StringRef ExpectedArch,
for (unsigned AK = 0; AK < static_cast<unsigned>(AArch64::ArchKind::AK_LAST); StringRef ExpectedFPU, unsigned ExpectedFlags,
AK++) StringRef CPUAttr) {
EXPECT_EQ(kAArch64ARCHNames[AK].DefaultFPU, bool ret = false;
AArch64::getDefaultFPU(StringRef("generic"), AK));
unsigned ArchKind = AArch64::parseCPUArch(CPUName);
ret = AArch64::getArchName(ArchKind).equals(ExpectedArch);
unsigned FPUKind = AArch64::getDefaultFPU(CPUName, ArchKind);
ret &= AArch64::getFPUName(FPUKind).equals(ExpectedFPU);
rengolinUnsubmitted
Not Done
ReplyInline Actions

Same here.

rengolin: Same here.
jojoAuthorUnsubmitted
Not Done
ReplyInline Actions

Same as above.

jojo: Same as above.
unsigned ExtKind = AArch64::getDefaultExtensions(CPUName, ArchKind);
if (ExtKind > 1 && (ExtKind & AArch64::AEK_NONE))
ret &= ((ExtKind ^ AArch64::AEK_NONE) == ExpectedFlags);
else
ret &= (ExtKind == ExpectedFlags);
for (const auto &AArch64CPUName : kAArch64CPUNames) ret &= AArch64::getCPUAttr(ArchKind).equals(CPUAttr);
EXPECT_EQ(AArch64CPUName.DefaultFPU,
AArch64::getDefaultFPU(AArch64CPUName.Name,
static_cast<unsigned>(AArch64CPUName.ID)));
}
TEST(TargetParserTest, AArch64DefaultExt) { return ret;
for (unsigned AK = 0; AK < static_cast<unsigned>(AArch64::ArchKind::AK_LAST); }
AK++)
EXPECT_EQ(kAArch64ARCHNames[AK].ArchBaseExtensions,
AArch64::getDefaultExtensions(StringRef("generic"), AK));
for (const auto &AArch64CPUName : kAArch64CPUNames) TEST(TargetParserTest, testAArch64CPU) {
EXPECT_EQ( EXPECT_TRUE(testAArch64CPU(
AArch64CPUName.DefaultExt, "invalid", "invalid", "invalid",
AArch64::getDefaultExtensions( AArch64::AEK_INVALID, ""));
AArch64CPUName.Name, static_cast<unsigned>(AArch64CPUName.ID))); EXPECT_TRUE(testAArch64CPU(
"generic", "invalid", "none",
AArch64::AEK_NONE, ""));
EXPECT_TRUE(testAArch64CPU(
"cortex-a35", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
EXPECT_TRUE(testAArch64CPU(
"cortex-a53", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
EXPECT_TRUE(testAArch64CPU(
"cortex-a57", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
EXPECT_TRUE(testAArch64CPU(
"cortex-a72", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
EXPECT_TRUE(testAArch64CPU(
"cortex-a73", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
EXPECT_TRUE(testAArch64CPU(
"cyclone", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
EXPECT_TRUE(testAArch64CPU(
"exynos-m1", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
EXPECT_TRUE(testAArch64CPU(
"exynos-m2", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
EXPECT_TRUE(testAArch64CPU(
"falkor", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
EXPECT_TRUE(testAArch64CPU(
"kryo", "armv8-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8-A"));
EXPECT_TRUE(testAArch64CPU(
"vulcan", "armv8.1-a", "crypto-neon-fp-armv8",
AArch64::AEK_CRC | AArch64::AEK_CRYPTO | AArch64::AEK_SIMD, "8.1-A"));
}
bool testAArch64Arch(StringRef Arch, StringRef DefaultCPU, StringRef SubArch,
unsigned ArchAttr) {
unsigned ArchKind = AArch64::parseArch(Arch);
return (ArchKind != static_cast<unsigned>(AArch64::ArchKind::AK_INVALID)) &
AArch64::getDefaultCPU(Arch).equals(DefaultCPU) &
AArch64::getSubArch(ArchKind).equals(SubArch) &
(AArch64::getArchAttr(ArchKind) == ArchAttr);
}
TEST(TargetParserTest, testAArch64Arch) {
rengolinUnsubmitted
Not Done
ReplyInline Actions

We now have v8M and v8R.

rengolin: We now have v8M and v8R.
jojoAuthorUnsubmitted
Not Done
ReplyInline Actions

AFAIK, both of them are 32bit.
And v8R has been supported in ARMTargetParser.
There is still no support in ARM backend for v8M,
Should we add it to targetparser after it is actually
supported in the backend?

jojo: AFAIK, both of them are 32bit. And v8R has been supported in ARMTargetParser. There is still…
rengolinUnsubmitted
Not Done
ReplyInline Actions

Yes, because this tests the parser, not the target support.

rengolin: Yes, because this tests the parser, not the target support.
EXPECT_TRUE(testAArch64Arch("armv8-a", "cortex-a53", "v8",
ARMBuildAttrs::CPUArch::v8_A));
EXPECT_TRUE(testAArch64Arch("armv8.1-a", "generic", "v8.1a",
ARMBuildAttrs::CPUArch::v8_A));
EXPECT_TRUE(testAArch64Arch("armv8.2-a", "generic", "v8.2a",
ARMBuildAttrs::CPUArch::v8_A));
}
bool testAArch64Extension(StringRef CPUName, unsigned ArchKind,
StringRef ArchExt) {
return AArch64::getDefaultExtensions(CPUName, ArchKind) &
AArch64::parseArchExt(ArchExt);
}
TEST(TargetParserTest, testAArch64Extension) {
EXPECT_FALSE(testAArch64Extension("cortex-a35", 0, "ras"));
EXPECT_FALSE(testAArch64Extension("cortex-a53", 0, "ras"));
EXPECT_FALSE(testAArch64Extension("cortex-a57", 0, "ras"));
EXPECT_FALSE(testAArch64Extension("cortex-a72", 0, "ras"));
EXPECT_FALSE(testAArch64Extension("cortex-a73", 0, "ras"));
EXPECT_FALSE(testAArch64Extension("cyclone", 0, "ras"));
EXPECT_FALSE(testAArch64Extension("exynos-m1", 0, "ras"));
rengolinUnsubmitted
Not Done
ReplyInline Actions

I think v8.2A has FP by default. If this test returns FALSE, then there's something wrong with the code. :)

rengolin: I think v8.2A has FP by default. If this test returns FALSE, then there's something wrong with…
jojoAuthorUnsubmitted
Not Done
ReplyInline Actions

Yes,indeed. There is a incorrect index problem in this test.
No errors printed make me missed the wrong flags here.

jojo: Yes,indeed. There is a incorrect index problem in this test. No errors printed make me missed…
EXPECT_FALSE(testAArch64Extension("kryo", 0, "ras"));
EXPECT_FALSE(testAArch64Extension("vulcan", 0, "ras"));
EXPECT_FALSE(testAArch64Extension(
"generic", static_cast<unsigned>(AArch64::ArchKind::AK_ARMV8A), "ras"));
EXPECT_FALSE(testAArch64Extension(
"generic", static_cast<unsigned>(AArch64::ArchKind::AK_ARMV8_1A), "ras"));
EXPECT_FALSE(testAArch64Extension(
"generic", static_cast<unsigned>(AArch64::ArchKind::AK_ARMV8_2A), "spe"));
rengolinUnsubmitted
Not Done
ReplyInline Actions

The same comments for the ARM implementation apply here.

rengolin: The same comments for the ARM implementation apply here.
} }
TEST(TargetParserTest, AArch64ExtensionFeatures) { TEST(TargetParserTest, AArch64ExtensionFeatures) {
std::vector<StringRef> Features; std::vector<StringRef> Features;
unsigned Extensions = AArch64::AEK_CRC | AArch64::AEK_CRYPTO | unsigned Extensions = AArch64::AEK_CRC | AArch64::AEK_CRYPTO |
AArch64::AEK_FP | AArch64::AEK_SIMD | AArch64::AEK_FP | AArch64::AEK_SIMD |
AArch64::AEK_FP16 | AArch64::AEK_PROFILE | AArch64::AEK_FP16 | AArch64::AEK_PROFILE |
AArch64::AEK_RAS; AArch64::AEK_RAS;
Show All 9 LinesTEST(TargetParserTest, AArch64ArchFeatures) {
for (unsigned AK = 0; AK < static_cast<unsigned>(AArch64::ArchKind::AK_LAST); for (unsigned AK = 0; AK < static_cast<unsigned>(AArch64::ArchKind::AK_LAST);
AK++) AK++)
EXPECT_TRUE((AK == static_cast<unsigned>(AArch64::ArchKind::AK_INVALID) || EXPECT_TRUE((AK == static_cast<unsigned>(AArch64::ArchKind::AK_INVALID) ||
AK == static_cast<unsigned>(AArch64::ArchKind::AK_LAST)) AK == static_cast<unsigned>(AArch64::ArchKind::AK_LAST))
? !AArch64::getArchFeatures(AK, Features) ? !AArch64::getArchFeatures(AK, Features)
: AArch64::getArchFeatures(AK, Features)); : AArch64::getArchFeatures(AK, Features));
} }
TEST(TargetParserTest, AArch64ArchName) {
for (unsigned AK = 0; AK < static_cast<unsigned>(AArch64::ArchKind::AK_LAST);
AK++)
EXPECT_TRUE(AK == static_cast<unsigned>(AArch64::ArchKind::AK_LAST)
? AArch64::getArchName(AK).empty()
: !AArch64::getArchName(AK).empty());
}
TEST(TargetParserTest, AArch64CPUAttr) {
for (unsigned AK = 0; AK < static_cast<unsigned>(AArch64::ArchKind::AK_LAST);
AK++)
EXPECT_TRUE((AK == static_cast<unsigned>(AArch64::ArchKind::AK_INVALID) ||
AK == static_cast<unsigned>(AArch64::ArchKind::AK_LAST))
? AArch64::getCPUAttr(AK).empty()
: !AArch64::getCPUAttr(AK).empty());
}
TEST(TargetParserTest, AArch64SubArch) {
for (unsigned AK = 0; AK < static_cast<unsigned>(AArch64::ArchKind::AK_LAST);
AK++)
EXPECT_TRUE((AK == static_cast<unsigned>(AArch64::ArchKind::AK_INVALID) ||
AK == static_cast<unsigned>(AArch64::ArchKind::AK_LAST))
? AArch64::getSubArch(AK).empty()
: !AArch64::getSubArch(AK).empty());
}
TEST(TargetParserTest, AArch64ArchAttr) {
for (unsigned AK = 0; AK < static_cast<unsigned>(AArch64::ArchKind::AK_LAST);
AK++)
EXPECT_TRUE(
AK == static_cast<unsigned>(AArch64::ArchKind::AK_LAST)
? (ARMBuildAttrs::CPUArch::v8_A == AArch64::getArchAttr(AK))
: (kAArch64ARCHNames[AK].ArchAttr == AArch64::getArchAttr(AK)));
}
TEST(TargetParserTest, AArch64ArchExtName) {
for (AArch64::ArchExtKind AEK = static_cast<AArch64::ArchExtKind>(0);
AEK <= AArch64::ArchExtKind::AEK_RAS;
AEK = static_cast<AArch64::ArchExtKind>(static_cast<unsigned>(AEK) + 1))
EXPECT_TRUE(contains(kAArch64ArchExtKinds, static_cast<unsigned>(AEK))
? !AArch64::getArchExtName(AEK).empty()
: AArch64::getArchExtName(AEK).empty());
}
TEST(TargetParserTest, AArch64ArchExtFeature) { TEST(TargetParserTest, AArch64ArchExtFeature) {
const char *ArchExt[][4] = {{"crc", "nocrc", "+crc", "-crc"}, const char *ArchExt[][4] = {{"crc", "nocrc", "+crc", "-crc"},
{"crypto", "nocrypto", "+crypto", "-crypto"}, {"crypto", "nocrypto", "+crypto", "-crypto"},
{"fp", "nofp", "+fp-armv8", "-fp-armv8"}, {"fp", "nofp", "+fp-armv8", "-fp-armv8"},
{"simd", "nosimd", "+neon", "-neon"}, {"simd", "nosimd", "+neon", "-neon"},
{"fp16", "nofp16", "+fullfp16", "-fullfp16"}, {"fp16", "nofp16", "+fullfp16", "-fullfp16"},
{"profile", "noprofile", "+spe", "-spe"}, {"profile", "noprofile", "+spe", "-spe"},
{"ras", "noras", "+ras", "-ras"}}; {"ras", "noras", "+ras", "-ras"}};
for (unsigned i = 0; i < array_lengthof(ArchExt); i++) { for (unsigned i = 0; i < array_lengthof(ArchExt); i++) {
EXPECT_EQ(StringRef(ArchExt[i][2]), AArch64::getArchExtFeature(ArchExt[i][0])); EXPECT_EQ(StringRef(ArchExt[i][2]),
EXPECT_EQ(StringRef(ArchExt[i][3]), AArch64::getArchExtFeature(ArchExt[i][1])); AArch64::getArchExtFeature(ArchExt[i][0]));
EXPECT_EQ(StringRef(ArchExt[i][3]),
AArch64::getArchExtFeature(ArchExt[i][1]));
} }
} }
TEST(TargetParserTest, AArch64DefaultCPU) {
const char *Arch[] = {"armv8a", "armv8-a", "armv8", "armv8.1a",
"armv8.1-a", "armv8.2a", "armv8.2-a"};
for (unsigned i = 0; i < array_lengthof(Arch); i++)
EXPECT_FALSE(AArch64::getDefaultCPU(Arch[i]).empty());
}
TEST(TargetParserTest, AArch64parseArch) {
const char *Arch[] = {"armv8", "armv8a", "armv8-a", "armv8.1a",
"armv8.1-a", "armv8.2a", "armv8.2-a"};
for (unsigned i = 0; i < array_lengthof(Arch); i++)
EXPECT_NE(static_cast<unsigned>(AArch64::ArchKind::AK_INVALID),
AArch64::parseArch(Arch[i]));
EXPECT_EQ(static_cast<unsigned>(AArch64::ArchKind::AK_INVALID),
AArch64::parseArch("aarch64"));
EXPECT_EQ(static_cast<unsigned>(AArch64::ArchKind::AK_INVALID),
AArch64::parseArch("arm64"));
}
TEST(TargetParserTest, AArch64parseArchExt) {
const char *ArchExt[] = {"none", "crc", "crypto", "fp",
"simd", "fp16", "profile", "ras"};
for (unsigned i = 0; i < array_lengthof(ArchExt); i++)
EXPECT_NE(AArch64::AEK_INVALID, AArch64::parseArchExt(ArchExt[i]));
}
TEST(TargetParserTest, AArch64parseCPUArch) {
const char *CPU[] = {"cortex-a35",
"cortex-a53",
"cortex-a57",
"cortex-a72",
"cortex-a73",
"cyclone",
"exynos-m1",
"exynos-m2",
"falkor",
"kryo",
"vulcan"};
for (const auto &AArch64CPUName : kAArch64CPUNames)
EXPECT_TRUE(contains(CPU, AArch64CPUName.Name)
? (static_cast<unsigned>(AArch64::ArchKind::AK_INVALID) !=
AArch64::parseCPUArch(AArch64CPUName.Name))
: (static_cast<unsigned>(AArch64::ArchKind::AK_INVALID) ==
AArch64::parseCPUArch(AArch64CPUName.Name)));
}
} }