llvm-project

ShuffleVectorInstTest.cpp
181 строка · 6.7 Кб
Перенос по словам
1
//===- llvm/unittest/IR/ShuffleVectorInstTest.cpp - Shuffle unit tests ----===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8

9
#include "llvm/IR/Instructions.h"
10
#include "gtest/gtest.h"
11

12
using namespace llvm;
13

14
namespace {
15

16
TEST(ShuffleVectorInst, isIdentityMask) {
17
  ASSERT_TRUE(ShuffleVectorInst::isIdentityMask({0, 1, 2, 3}, 4));
18
  ASSERT_TRUE(ShuffleVectorInst::isIdentityMask({0, 1, 2, 3, -1}, 5));
19
  ASSERT_TRUE(ShuffleVectorInst::isIdentityMask({0, 1, -1, 3}, 4));
20

21
  ASSERT_FALSE(ShuffleVectorInst::isIdentityMask({0, 1, 2, 3}, 3));
22
  ASSERT_FALSE(ShuffleVectorInst::isIdentityMask({0, 1, 2, 3, -1}, 4));
23
  ASSERT_FALSE(ShuffleVectorInst::isIdentityMask({0, 1, -1, 3}, 3));
24

25
  ASSERT_FALSE(ShuffleVectorInst::isIdentityMask({0, 1, 2, 3}, 5));
26
  ASSERT_FALSE(ShuffleVectorInst::isIdentityMask({0, 1, 2, 3, -1}, 6));
27
  ASSERT_FALSE(ShuffleVectorInst::isIdentityMask({0, 1, -1, 3}, 5));
28

29
  ASSERT_FALSE(ShuffleVectorInst::isIdentityMask({0, 1, 2, 4}, 4));
30
  ASSERT_FALSE(ShuffleVectorInst::isIdentityMask({0, -1, 2, 4}, 4));
31
}
32

33
TEST(ShuffleVectorInst, isSelectMask) {
34
  ASSERT_TRUE(ShuffleVectorInst::isSelectMask({0, 5, 6, 3}, 4));
35

36
  ASSERT_FALSE(ShuffleVectorInst::isSelectMask({0, 5, 6, 3}, 3));
37
  ASSERT_FALSE(ShuffleVectorInst::isSelectMask({0, 5, 6, 3}, 5));
38

39
  ASSERT_FALSE(ShuffleVectorInst::isSelectMask({0, 1, 2, 3}, 4));
40
}
41

42
TEST(ShuffleVectorInst, isReverseMask) {
43
  ASSERT_TRUE(ShuffleVectorInst::isReverseMask({3, 2, 1, 0}, 4));
44
  ASSERT_TRUE(ShuffleVectorInst::isReverseMask({-1, -1, 1, 0}, 4));
45

46
  ASSERT_FALSE(ShuffleVectorInst::isReverseMask({3, 2, 1, 0}, 3));
47
  ASSERT_FALSE(ShuffleVectorInst::isReverseMask({-1, -1, 1, 0}, 3));
48
  ASSERT_FALSE(ShuffleVectorInst::isReverseMask({3, 2, 1, 0}, 5));
49
  ASSERT_FALSE(ShuffleVectorInst::isReverseMask({-1, -1, 1, 0}, 5));
50

51
  ASSERT_FALSE(ShuffleVectorInst::isReverseMask({4, 3, 2, 1}, 4));
52
}
53

54
TEST(ShuffleVectorInst, isZeroEltSplatMask) {
55
  ASSERT_TRUE(ShuffleVectorInst::isZeroEltSplatMask({0, 0, 0, 0}, 4));
56
  ASSERT_TRUE(ShuffleVectorInst::isZeroEltSplatMask({0, -1, 0, -1}, 4));
57

58
  ASSERT_FALSE(ShuffleVectorInst::isZeroEltSplatMask({0, 0, 0, 0}, 3));
59
  ASSERT_FALSE(ShuffleVectorInst::isZeroEltSplatMask({0, -1, 0, -1}, 3));
60
  ASSERT_FALSE(ShuffleVectorInst::isZeroEltSplatMask({0, 0, 0, 0}, 5));
61
  ASSERT_FALSE(ShuffleVectorInst::isZeroEltSplatMask({0, -1, 0, -1}, 5));
62

63
  ASSERT_FALSE(ShuffleVectorInst::isZeroEltSplatMask({1, 1, 1, 1}, 4));
64
}
65

66
TEST(ShuffleVectorInst, isTransposeMask) {
67
  ASSERT_TRUE(ShuffleVectorInst::isTransposeMask({0, 4, 2, 6}, 4));
68
  ASSERT_TRUE(ShuffleVectorInst::isTransposeMask({1, 5, 3, 7}, 4));
69

70
  ASSERT_FALSE(ShuffleVectorInst::isTransposeMask({0, 4, 2, 6}, 3));
71
  ASSERT_FALSE(ShuffleVectorInst::isTransposeMask({1, 5, 3, 7}, 3));
72
  ASSERT_FALSE(ShuffleVectorInst::isTransposeMask({0, 4, 2, 6}, 5));
73
  ASSERT_FALSE(ShuffleVectorInst::isTransposeMask({1, 5, 3, 7}, 5));
74

75
  ASSERT_FALSE(ShuffleVectorInst::isTransposeMask({2, 6, 4, 8}, 4));
76
}
77

78
TEST(ShuffleVectorInst, isSpliceMask) {
79
  int Index;
80

81
  ASSERT_TRUE(ShuffleVectorInst::isSpliceMask({0, 1, 2, 3}, 4, Index));
82
  ASSERT_EQ(0, Index);
83

84
  ASSERT_TRUE(ShuffleVectorInst::isSpliceMask({1, 2, 3, 4, 5, 6, 7}, 7, Index));
85
  ASSERT_EQ(1, Index);
86

87
  ASSERT_FALSE(ShuffleVectorInst::isSpliceMask({0, 1, 2, 3}, 3, Index));
88
  ASSERT_FALSE(
89
      ShuffleVectorInst::isSpliceMask({1, 2, 3, 4, 5, 6, 7}, 6, Index));
90
  ASSERT_FALSE(ShuffleVectorInst::isSpliceMask({0, 1, 2, 3}, 5, Index));
91
  ASSERT_FALSE(
92
      ShuffleVectorInst::isSpliceMask({1, 2, 3, 4, 5, 6, 7}, 8, Index));
93

94
  ASSERT_FALSE(ShuffleVectorInst::isSpliceMask({4, 5, 6, 7}, 4, Index));
95
}
96

97
TEST(ShuffleVectorInst, isExtractSubvectorMask) {
98
  int Index;
99

100
  ASSERT_TRUE(
101
      ShuffleVectorInst::isExtractSubvectorMask({0, 1, 2, 3}, 8, Index));
102
  ASSERT_EQ(0, Index);
103

104
  ASSERT_TRUE(
105
      ShuffleVectorInst::isExtractSubvectorMask({-1, 3, 4, 5}, 8, Index));
106
  ASSERT_EQ(2, Index);
107

108
  ASSERT_FALSE(
109
      ShuffleVectorInst::isExtractSubvectorMask({1, 2, 3, -1}, 4, Index));
110
}
111

112
TEST(ShuffleVectorInst, isInsertSubvectorMask) {
113
  int NumSubElts, Index;
114

115
  ASSERT_TRUE(ShuffleVectorInst::isInsertSubvectorMask(
116
      {8, 9, 10, 11, 4, 5, 6, 7}, 8, NumSubElts, Index));
117
  ASSERT_EQ(0, Index);
118
  ASSERT_EQ(4, NumSubElts);
119

120
  ASSERT_TRUE(
121
      ShuffleVectorInst::isInsertSubvectorMask({0, 2}, 2, NumSubElts, Index));
122
  ASSERT_EQ(1, Index);
123
  ASSERT_EQ(1, NumSubElts);
124
}
125

126
TEST(ShuffleVectorInst, isReplicationMask) {
127
  int ReplicationFactor, VF;
128

129
  ASSERT_TRUE(ShuffleVectorInst::isReplicationMask({0, 0, 1, 1, 2, 2, 3, 3},
130
                                                   ReplicationFactor, VF));
131
  ASSERT_EQ(2, ReplicationFactor);
132
  ASSERT_EQ(4, VF);
133

134
  ASSERT_TRUE(ShuffleVectorInst::isReplicationMask(
135
      {0, 0, 0, 1, 1, 1, -1, -1, -1, 3, 3, 3, 4, 4, 4}, ReplicationFactor, VF));
136
  ASSERT_EQ(3, ReplicationFactor);
137
  ASSERT_EQ(5, VF);
138
}
139

140
TEST(ShuffleVectorInst, isOneUseSingleSourceMask) {
141
  ASSERT_TRUE(
142
      ShuffleVectorInst::isOneUseSingleSourceMask({0, 1, 2, 3, 3, 2, 0, 1}, 4));
143
  ASSERT_TRUE(
144
      ShuffleVectorInst::isOneUseSingleSourceMask({2, 3, 4, 5, 6, 7, 0, 1}, 8));
145

146
  ASSERT_FALSE(ShuffleVectorInst::isOneUseSingleSourceMask(
147
      {0, -1, 2, 3, 3, 2, 0, 1}, 4));
148
  ASSERT_FALSE(
149
      ShuffleVectorInst::isOneUseSingleSourceMask({0, 1, 2, 3, 3, 3, 1, 0}, 4));
150
}
151

152
TEST(ShuffleVectorInst, isInterleaveMask) {
153
  SmallVector<unsigned> StartIndexes;
154
  ASSERT_TRUE(ShuffleVectorInst::isInterleaveMask({0, 4, 1, 5, 2, 6, 3, 7}, 2,
155
                                                  8, StartIndexes));
156
  ASSERT_EQ(StartIndexes, SmallVector<unsigned>({0, 4}));
157

158
  ASSERT_FALSE(
159
      ShuffleVectorInst::isInterleaveMask({0, 4, 1, 6, 2, 6, 3, 7}, 2, 8));
160

161
  ASSERT_TRUE(ShuffleVectorInst::isInterleaveMask({4, 0, 5, 1, 6, 2, 7, 3}, 2,
162
                                                  8, StartIndexes));
163
  ASSERT_EQ(StartIndexes, SmallVector<unsigned>({4, 0}));
164

165
  ASSERT_TRUE(ShuffleVectorInst::isInterleaveMask({4, 0, -1, 1, -1, 2, 7, 3}, 2,
166
                                                  8, StartIndexes));
167
  ASSERT_EQ(StartIndexes, SmallVector<unsigned>({4, 0}));
168

169
  ASSERT_TRUE(ShuffleVectorInst::isInterleaveMask({0, 2, 4, 1, 3, 5}, 3, 6,
170
                                                  StartIndexes));
171
  ASSERT_EQ(StartIndexes, SmallVector<unsigned>({0, 2, 4}));
172

173
  ASSERT_TRUE(ShuffleVectorInst::isInterleaveMask({4, -1, 0, 5, 3, 1}, 3, 6,
174
                                                  StartIndexes));
175
  ASSERT_EQ(StartIndexes, SmallVector<unsigned>({4, 2, 0}));
176

177
  ASSERT_FALSE(
178
      ShuffleVectorInst::isInterleaveMask({8, 2, 12, 4, 9, 3, 13, 5}, 4, 8));
179
}
180

181
} // end anonymous namespace
182
llvm-project

Использование cookies
