6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-15 05:24:01 +00:00
Code Issues Projects Releases Wiki Activity

ArrayRef: Remove the equals helper with many arguments.

Browse Source 
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
This commit is contained in:
Benjamin Kramer
2015-03-01 21:05:05 +00:00
parent e2557d9bd1
commit c255d35a10
3 changed files with 28 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
include/llvm/ADT/ArrayRef.h
View File

@ -11,7 +11,6 @@
#define LLVM_ADT_ARRAYREF_H #define LLVM_ADT_ARRAYREF_H
#include "llvm/ADT/None.h" #include "llvm/ADT/None.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include <vector> #include <vector>
@ -44,19 +43,6 @@ namespace llvm {
/// The number of elements. /// The number of elements.
size_type Length; 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: public:
/// @name Constructors /// @name Constructors
/// @{ /// @{
@ -201,47 +187,6 @@ namespace llvm {
return std::vector<T>(Data, Data+Length); return std::vector<T>(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;
}
/// @} /// @}
}; };

32
lib/Target/X86/X86ISelLowering.cpp
View File

@ -19149,8 +19149,8 @@ static bool combineX86ShuffleChain(SDValue Op, SDValue Root, ArrayRef<int> Mask,
// //
// FIXME: Should teach these routines about AVX vector widths. // FIXME: Should teach these routines about AVX vector widths.
if (FloatDomain && VT.getSizeInBits() == 128) { if (FloatDomain && VT.getSizeInBits() == 128) {
if (Mask.equals(0, 0) || Mask.equals(1, 1)) { if (Mask.equals({0, 0}) || Mask.equals({1, 1})) {
bool Lo = Mask.equals(0, 0); bool Lo = Mask.equals({0, 0});
unsigned Shuffle; unsigned Shuffle;
MVT ShuffleVT; MVT ShuffleVT;
// Check if we have SSE3 which will let us use MOVDDUP. That instruction // 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<int> Mask,
return true; return true;
} }
if (Subtarget->hasSSE3() && if (Subtarget->hasSSE3() &&
(Mask.equals(0, 0, 2, 2) || Mask.equals(1, 1, 3, 3))) { (Mask.equals({0, 0, 2, 2}) || Mask.equals({1, 1, 3, 3}))) {
bool Lo = Mask.equals(0, 0, 2, 2); bool Lo = Mask.equals({0, 0, 2, 2});
unsigned Shuffle = Lo ? X86ISD::MOVSLDUP : X86ISD::MOVSHDUP; unsigned Shuffle = Lo ? X86ISD::MOVSLDUP : X86ISD::MOVSHDUP;
MVT ShuffleVT = MVT::v4f32; MVT ShuffleVT = MVT::v4f32;
if (Depth == 1 && Root->getOpcode() == Shuffle) if (Depth == 1 && Root->getOpcode() == Shuffle)
@ -19193,8 +19193,8 @@ static bool combineX86ShuffleChain(SDValue Op, SDValue Root, ArrayRef<int> Mask,
/*AddTo*/ true); /*AddTo*/ true);
return true; return true;
} }
if (Mask.equals(0, 0, 1, 1) || Mask.equals(2, 2, 3, 3)) { if (Mask.equals({0, 0, 1, 1}) || Mask.equals({2, 2, 3, 3})) {
bool Lo = Mask.equals(0, 0, 1, 1); bool Lo = Mask.equals({0, 0, 1, 1});
unsigned Shuffle = Lo ? X86ISD::UNPCKL : X86ISD::UNPCKH; unsigned Shuffle = Lo ? X86ISD::UNPCKL : X86ISD::UNPCKH;
MVT ShuffleVT = MVT::v4f32; MVT ShuffleVT = MVT::v4f32;
if (Depth == 1 && Root->getOpcode() == Shuffle) if (Depth == 1 && Root->getOpcode() == Shuffle)
@ -19213,11 +19213,11 @@ static bool combineX86ShuffleChain(SDValue Op, SDValue Root, ArrayRef<int> Mask,
// variants as none of these have single-instruction variants that are // variants as none of these have single-instruction variants that are
// superior to the UNPCK formulation. // superior to the UNPCK formulation.
if (!FloatDomain && VT.getSizeInBits() == 128 && if (!FloatDomain && VT.getSizeInBits() == 128 &&
(Mask.equals(0, 0, 1, 1, 2, 2, 3, 3) || (Mask.equals({0, 0, 1, 1, 2, 2, 3, 3}) ||
Mask.equals(4, 4, 5, 5, 6, 6, 7, 7) || 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({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, Mask.equals(
15))) { {8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15}))) {
bool Lo = Mask[0] == 0; bool Lo = Mask[0] == 0;
unsigned Shuffle = Lo ? X86ISD::UNPCKL : X86ISD::UNPCKH; unsigned Shuffle = Lo ? X86ISD::UNPCKL : X86ISD::UNPCKH;
if (Depth == 1 && Root->getOpcode() == Shuffle) 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 // 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 // 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. // 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 DMask[] = {0, 1, 2, 3};
int DOffset = N.getOpcode() == X86ISD::PSHUFLW ? 0 : 2; int DOffset = N.getOpcode() == X86ISD::PSHUFLW ? 0 : 2;
DMask[DOffset + 0] = DOffset + 1; DMask[DOffset + 0] = DOffset + 1;
@ -19745,12 +19745,8 @@ static SDValue PerformTargetShuffleCombine(SDValue N, SelectionDAG &DAG,
int MappedMask[8]; int MappedMask[8];
for (int i = 0; i < 8; ++i) for (int i = 0; i < 8; ++i)
MappedMask[i] = 2 * DMask[WordMask[i] / 2] + WordMask[i] % 2; MappedMask[i] = 2 * DMask[WordMask[i] / 2] + WordMask[i] % 2;
const int UnpackLoMask[] = {0, 0, 1, 1, 2, 2, 3, 3}; if (makeArrayRef(MappedMask).equals({0, 0, 1, 1, 2, 2, 3, 3}) ||
const int UnpackHiMask[] = {4, 4, 5, 5, 6, 6, 7, 7}; makeArrayRef(MappedMask).equals({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))) {
// We can replace all three shuffles with an unpack. // We can replace all three shuffles with an unpack.
V = DAG.getNode(ISD::BITCAST, DL, VT, D.getOperand(0)); V = DAG.getNode(ISD::BITCAST, DL, VT, D.getOperand(0));
DCI.AddToWorklist(V.getNode()); DCI.AddToWorklist(V.getNode());

28
unittests/ADT/ArrayRefTest.cpp
View File

@ -57,24 +57,24 @@ TEST(ArrayRefTest, DropBack) {
TEST(ArrayRefTest, Equals) { TEST(ArrayRefTest, Equals) {
static const int A1[] = {1, 2, 3, 4, 5, 6, 7, 8}; static const int A1[] = {1, 2, 3, 4, 5, 6, 7, 8};
ArrayRef<int> AR1(A1); ArrayRef<int> AR1(A1);
EXPECT_TRUE(AR1.equals(1, 2, 3, 4, 5, 6, 7, 8)); 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({8, 1, 2, 4, 5, 6, 6, 7}));
EXPECT_FALSE(AR1.equals(2, 4, 5, 6, 6, 7, 8, 1)); 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({0, 1, 2, 4, 5, 6, 6, 7}));
EXPECT_FALSE(AR1.equals(1, 2, 42, 4, 5, 6, 7, 8)); 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({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, 42}));
EXPECT_FALSE(AR1.equals(1, 2, 3, 4, 5, 6, 7)); 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_FALSE(AR1.equals({1, 2, 3, 4, 5, 6, 7, 8, 9}));
ArrayRef<int> AR1a = AR1.drop_back(); ArrayRef<int> AR1a = AR1.drop_back();
EXPECT_TRUE(AR1a.equals(1, 2, 3, 4, 5, 6, 7)); EXPECT_TRUE(AR1a.equals({1, 2, 3, 4, 5, 6, 7}));
EXPECT_FALSE(AR1a.equals(1, 2, 3, 4, 5, 6, 7, 8)); EXPECT_FALSE(AR1a.equals({1, 2, 3, 4, 5, 6, 7, 8}));
ArrayRef<int> AR1b = AR1a.slice(2, 4); ArrayRef<int> AR1b = AR1a.slice(2, 4);
EXPECT_TRUE(AR1b.equals(3, 4, 5, 6)); EXPECT_TRUE(AR1b.equals({3, 4, 5, 6}));
EXPECT_FALSE(AR1b.equals(2, 3, 4, 5, 6)); EXPECT_FALSE(AR1b.equals({2, 3, 4, 5, 6}));
EXPECT_FALSE(AR1b.equals(3, 4, 5, 6, 7)); EXPECT_FALSE(AR1b.equals({3, 4, 5, 6, 7}));
} }
TEST(ArrayRefTest, EmptyEquals) { TEST(ArrayRefTest, EmptyEquals) {