From c255d35a1040d049366645016ecd09b789d45586 Mon Sep 17 00:00:00 2001 From: Benjamin Kramer Date: Sun, 1 Mar 2015 21:05:05 +0000 Subject: [PATCH] ArrayRef: Remove the equals helper with many arguments. With initializer lists there is a really neat idiomatic way to write this, 'ArrayRef.equals({1, 2, 3, 4, 5})'. Remove the equal method which always had a hard limit on the number of arguments. I considered rewriting it with variadic templates but that's not really a good fit for a function with homogeneous arguments. 'ArrayRef == {1, 2, 3, 4, 5}' would've been even more awesome, but C++11 doesn't allow init lists with binary operators. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@230907 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/ADT/ArrayRef.h | 55 ------------------------------ lib/Target/X86/X86ISelLowering.cpp | 32 ++++++++--------- unittests/ADT/ArrayRefTest.cpp | 28 +++++++-------- 3 files changed, 28 insertions(+), 87 deletions(-) diff --git a/include/llvm/ADT/ArrayRef.h b/include/llvm/ADT/ArrayRef.h index 5b7ed9cb77d..7f5fa3271ac 100644 --- a/include/llvm/ADT/ArrayRef.h +++ b/include/llvm/ADT/ArrayRef.h @@ -11,7 +11,6 @@ #define LLVM_ADT_ARRAYREF_H #include "llvm/ADT/None.h" -#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallVector.h" #include @@ -44,19 +43,6 @@ namespace llvm { /// The number of elements. size_type Length; - /// \brief A dummy "optional" type that is only created by implicit - /// conversion from a reference to T. - /// - /// This type must *only* be used in a function argument or as a copy of - /// a function argument, as otherwise it will hold a pointer to a temporary - /// past that temporaries' lifetime. - struct TRefOrNothing { - const T *TPtr; - - TRefOrNothing() : TPtr(nullptr) {} - TRefOrNothing(const T &TRef) : TPtr(&TRef) {} - }; - public: /// @name Constructors /// @{ @@ -201,47 +187,6 @@ namespace llvm { return std::vector(Data, Data+Length); } - /// @} - /// @{ - /// @name Convenience methods - - /// @brief Predicate for testing that the array equals the exact sequence of - /// arguments. - /// - /// Will return false if the size is not equal to the exact number of - /// arguments given or if the array elements don't equal the argument - /// elements in order. Currently supports up to 16 arguments, but can - /// easily be extended. - bool equals(TRefOrNothing Arg0 = TRefOrNothing(), - TRefOrNothing Arg1 = TRefOrNothing(), - TRefOrNothing Arg2 = TRefOrNothing(), - TRefOrNothing Arg3 = TRefOrNothing(), - TRefOrNothing Arg4 = TRefOrNothing(), - TRefOrNothing Arg5 = TRefOrNothing(), - TRefOrNothing Arg6 = TRefOrNothing(), - TRefOrNothing Arg7 = TRefOrNothing(), - TRefOrNothing Arg8 = TRefOrNothing(), - TRefOrNothing Arg9 = TRefOrNothing(), - TRefOrNothing Arg10 = TRefOrNothing(), - TRefOrNothing Arg11 = TRefOrNothing(), - TRefOrNothing Arg12 = TRefOrNothing(), - TRefOrNothing Arg13 = TRefOrNothing(), - TRefOrNothing Arg14 = TRefOrNothing(), - TRefOrNothing Arg15 = TRefOrNothing()) { - TRefOrNothing Args[] = {Arg0, Arg1, Arg2, Arg3, Arg4, Arg5, - Arg6, Arg7, Arg8, Arg9, Arg10, Arg11, - Arg12, Arg13, Arg14, Arg15}; - if (size() > array_lengthof(Args)) - return false; - - for (unsigned i = 0, e = size(); i != e; ++i) - if (Args[i].TPtr == nullptr || (*this)[i] != *Args[i].TPtr) - return false; - - // Either the size is exactly as many args, or the next arg must be null. - return size() == array_lengthof(Args) || Args[size()].TPtr == nullptr; - } - /// @} }; diff --git a/lib/Target/X86/X86ISelLowering.cpp b/lib/Target/X86/X86ISelLowering.cpp index fcdc53eabca..67255d8a35f 100644 --- a/lib/Target/X86/X86ISelLowering.cpp +++ b/lib/Target/X86/X86ISelLowering.cpp @@ -19149,8 +19149,8 @@ static bool combineX86ShuffleChain(SDValue Op, SDValue Root, ArrayRef Mask, // // FIXME: Should teach these routines about AVX vector widths. if (FloatDomain && VT.getSizeInBits() == 128) { - if (Mask.equals(0, 0) || Mask.equals(1, 1)) { - bool Lo = Mask.equals(0, 0); + if (Mask.equals({0, 0}) || Mask.equals({1, 1})) { + bool Lo = Mask.equals({0, 0}); unsigned Shuffle; MVT ShuffleVT; // Check if we have SSE3 which will let us use MOVDDUP. That instruction @@ -19179,8 +19179,8 @@ static bool combineX86ShuffleChain(SDValue Op, SDValue Root, ArrayRef Mask, return true; } if (Subtarget->hasSSE3() && - (Mask.equals(0, 0, 2, 2) || Mask.equals(1, 1, 3, 3))) { - bool Lo = Mask.equals(0, 0, 2, 2); + (Mask.equals({0, 0, 2, 2}) || Mask.equals({1, 1, 3, 3}))) { + bool Lo = Mask.equals({0, 0, 2, 2}); unsigned Shuffle = Lo ? X86ISD::MOVSLDUP : X86ISD::MOVSHDUP; MVT ShuffleVT = MVT::v4f32; if (Depth == 1 && Root->getOpcode() == Shuffle) @@ -19193,8 +19193,8 @@ static bool combineX86ShuffleChain(SDValue Op, SDValue Root, ArrayRef Mask, /*AddTo*/ true); return true; } - if (Mask.equals(0, 0, 1, 1) || Mask.equals(2, 2, 3, 3)) { - bool Lo = Mask.equals(0, 0, 1, 1); + if (Mask.equals({0, 0, 1, 1}) || Mask.equals({2, 2, 3, 3})) { + bool Lo = Mask.equals({0, 0, 1, 1}); unsigned Shuffle = Lo ? X86ISD::UNPCKL : X86ISD::UNPCKH; MVT ShuffleVT = MVT::v4f32; if (Depth == 1 && Root->getOpcode() == Shuffle) @@ -19213,11 +19213,11 @@ static bool combineX86ShuffleChain(SDValue Op, SDValue Root, ArrayRef Mask, // variants as none of these have single-instruction variants that are // superior to the UNPCK formulation. if (!FloatDomain && VT.getSizeInBits() == 128 && - (Mask.equals(0, 0, 1, 1, 2, 2, 3, 3) || - Mask.equals(4, 4, 5, 5, 6, 6, 7, 7) || - Mask.equals(0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7) || - Mask.equals(8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, - 15))) { + (Mask.equals({0, 0, 1, 1, 2, 2, 3, 3}) || + Mask.equals({4, 4, 5, 5, 6, 6, 7, 7}) || + Mask.equals({0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7}) || + Mask.equals( + {8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15}))) { bool Lo = Mask[0] == 0; unsigned Shuffle = Lo ? X86ISD::UNPCKL : X86ISD::UNPCKH; if (Depth == 1 && Root->getOpcode() == Shuffle) @@ -19706,7 +19706,7 @@ static SDValue PerformTargetShuffleCombine(SDValue N, SelectionDAG &DAG, // See if this reduces to a PSHUFD which is no more expensive and can // combine with more operations. Note that it has to at least flip the // dwords as otherwise it would have been removed as a no-op. - if (Mask[0] == 2 && Mask[1] == 3 && Mask[2] == 0 && Mask[3] == 1) { + if (makeArrayRef(Mask).equals({2, 3, 0, 1})) { int DMask[] = {0, 1, 2, 3}; int DOffset = N.getOpcode() == X86ISD::PSHUFLW ? 0 : 2; DMask[DOffset + 0] = DOffset + 1; @@ -19745,12 +19745,8 @@ static SDValue PerformTargetShuffleCombine(SDValue N, SelectionDAG &DAG, int MappedMask[8]; for (int i = 0; i < 8; ++i) MappedMask[i] = 2 * DMask[WordMask[i] / 2] + WordMask[i] % 2; - const int UnpackLoMask[] = {0, 0, 1, 1, 2, 2, 3, 3}; - const int UnpackHiMask[] = {4, 4, 5, 5, 6, 6, 7, 7}; - if (std::equal(std::begin(MappedMask), std::end(MappedMask), - std::begin(UnpackLoMask)) || - std::equal(std::begin(MappedMask), std::end(MappedMask), - std::begin(UnpackHiMask))) { + if (makeArrayRef(MappedMask).equals({0, 0, 1, 1, 2, 2, 3, 3}) || + makeArrayRef(MappedMask).equals({4, 4, 5, 5, 6, 6, 7, 7})) { // We can replace all three shuffles with an unpack. V = DAG.getNode(ISD::BITCAST, DL, VT, D.getOperand(0)); DCI.AddToWorklist(V.getNode()); diff --git a/unittests/ADT/ArrayRefTest.cpp b/unittests/ADT/ArrayRefTest.cpp index 70f8208620e..6955036f113 100644 --- a/unittests/ADT/ArrayRefTest.cpp +++ b/unittests/ADT/ArrayRefTest.cpp @@ -57,24 +57,24 @@ TEST(ArrayRefTest, DropBack) { TEST(ArrayRefTest, Equals) { static const int A1[] = {1, 2, 3, 4, 5, 6, 7, 8}; ArrayRef AR1(A1); - EXPECT_TRUE(AR1.equals(1, 2, 3, 4, 5, 6, 7, 8)); - EXPECT_FALSE(AR1.equals(8, 1, 2, 4, 5, 6, 6, 7)); - EXPECT_FALSE(AR1.equals(2, 4, 5, 6, 6, 7, 8, 1)); - EXPECT_FALSE(AR1.equals(0, 1, 2, 4, 5, 6, 6, 7)); - EXPECT_FALSE(AR1.equals(1, 2, 42, 4, 5, 6, 7, 8)); - EXPECT_FALSE(AR1.equals(42, 2, 3, 4, 5, 6, 7, 8)); - EXPECT_FALSE(AR1.equals(1, 2, 3, 4, 5, 6, 7, 42)); - EXPECT_FALSE(AR1.equals(1, 2, 3, 4, 5, 6, 7)); - EXPECT_FALSE(AR1.equals(1, 2, 3, 4, 5, 6, 7, 8, 9)); + EXPECT_TRUE(AR1.equals({1, 2, 3, 4, 5, 6, 7, 8})); + EXPECT_FALSE(AR1.equals({8, 1, 2, 4, 5, 6, 6, 7})); + EXPECT_FALSE(AR1.equals({2, 4, 5, 6, 6, 7, 8, 1})); + EXPECT_FALSE(AR1.equals({0, 1, 2, 4, 5, 6, 6, 7})); + EXPECT_FALSE(AR1.equals({1, 2, 42, 4, 5, 6, 7, 8})); + EXPECT_FALSE(AR1.equals({42, 2, 3, 4, 5, 6, 7, 8})); + EXPECT_FALSE(AR1.equals({1, 2, 3, 4, 5, 6, 7, 42})); + EXPECT_FALSE(AR1.equals({1, 2, 3, 4, 5, 6, 7})); + EXPECT_FALSE(AR1.equals({1, 2, 3, 4, 5, 6, 7, 8, 9})); ArrayRef AR1a = AR1.drop_back(); - EXPECT_TRUE(AR1a.equals(1, 2, 3, 4, 5, 6, 7)); - EXPECT_FALSE(AR1a.equals(1, 2, 3, 4, 5, 6, 7, 8)); + EXPECT_TRUE(AR1a.equals({1, 2, 3, 4, 5, 6, 7})); + EXPECT_FALSE(AR1a.equals({1, 2, 3, 4, 5, 6, 7, 8})); ArrayRef AR1b = AR1a.slice(2, 4); - EXPECT_TRUE(AR1b.equals(3, 4, 5, 6)); - EXPECT_FALSE(AR1b.equals(2, 3, 4, 5, 6)); - EXPECT_FALSE(AR1b.equals(3, 4, 5, 6, 7)); + EXPECT_TRUE(AR1b.equals({3, 4, 5, 6})); + EXPECT_FALSE(AR1b.equals({2, 3, 4, 5, 6})); + EXPECT_FALSE(AR1b.equals({3, 4, 5, 6, 7})); } TEST(ArrayRefTest, EmptyEquals) {