Skip to content

Commit f8b08f7

Browse files
rotaterightrotateright
committedJun 24, 2016
[InstCombine] consolidate commutation variants of matchSelectFromAndOr() in one place; NFCI
By putting all the possible commutations together, we simplify the code. Note that this is NFCI, but I'm adding tests that actually exercise each commutation pattern because we don't have this anywhere else. llvm-svn: 273702
·
llvmorg-21-initllvmorg-3.9.0-rc1
1 parent 931cb65 commit f8b08f7

File tree

2 files changed

+165
-65
lines changed

2 files changed

+165
-65
lines changed
 

‎llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

+18-27
Original file line numberDiff line numberDiff line change
@@ -1628,26 +1628,18 @@ Instruction *InstCombiner::MatchBSwap(BinaryOperator &I) {
16281628
return LastInst;
16291629
}
16301630

1631-
/// We have an expression of the form (A&C)|(B&D). Check if A is (cond?-1:0)
1632-
/// and either B or D is ~(cond?-1,0) or (cond?0,-1), then we can simplify this
1633-
/// expression to "cond ? C : D or B".
1634-
static Instruction *matchSelectFromAndOr(Value *A, Value *B, Value *C, Value *D,
1631+
/// We have an expression of the form (A & C) | (B & D). If A is (Cond?-1:0)
1632+
/// and B is ~(Cond?-1,0), then simplify this expression to "Cond ? C : D".
1633+
static Instruction *matchSelectFromAndOr(Value *A, Value *C, Value *B, Value *D,
16351634
InstCombiner::BuilderTy &Builder) {
16361635
// If A is not a select of -1/0, this cannot match.
16371636
Value *Cond = nullptr;
16381637
if (match(A, m_SExt(m_Value(Cond))) &&
16391638
Cond->getType()->getScalarType()->isIntegerTy(1)) {
16401639

1641-
// ((cond ? -1:0) & C) | (B & (cond ? 0:-1)) -> cond ? C : B.
1642-
if (match(D, m_Not(m_SExt(m_Specific(Cond)))))
1643-
return SelectInst::Create(Cond, C, B);
1644-
if (match(D, m_SExt(m_Not(m_Specific(Cond)))))
1645-
return SelectInst::Create(Cond, C, B);
1646-
16471640
// ((cond ? -1:0) & C) | ((cond ? 0:-1) & D) -> cond ? C : D.
1648-
if (match(B, m_Not(m_SExt(m_Specific(Cond)))))
1649-
return SelectInst::Create(Cond, C, D);
1650-
if (match(B, m_SExt(m_Not(m_Specific(Cond)))))
1641+
if (match(B, m_CombineOr(m_Not(m_SExt(m_Specific(Cond))),
1642+
m_SExt(m_Not(m_Specific(Cond))))))
16511643
return SelectInst::Create(Cond, C, D);
16521644
}
16531645

@@ -1662,15 +1654,6 @@ static Instruction *matchSelectFromAndOr(Value *A, Value *B, Value *C, Value *D,
16621654

16631655
Type *SrcType = cast<BitCastInst>(A)->getSrcTy();
16641656

1665-
// ((bc Cond) & C) | (B & (bc ~Cond)) --> bc (select Cond, (bc C), (bc B))
1666-
if (match(D, m_CombineOr(m_BitCast(m_Not(m_SExt(m_Specific(Cond)))),
1667-
m_BitCast(m_SExt(m_Not(m_Specific(Cond))))))) {
1668-
Value *BitcastC = Builder.CreateBitCast(C, SrcType);
1669-
Value *BitcastB = Builder.CreateBitCast(B, SrcType);
1670-
Value *Select = Builder.CreateSelect(Cond, BitcastC, BitcastB);
1671-
return CastInst::Create(Instruction::BitCast, Select, A->getType());
1672-
}
1673-
16741657
// ((bc Cond) & C) | ((bc ~Cond) & D) --> bc (select Cond, (bc C), (bc D))
16751658
if (match(B, m_CombineOr(m_BitCast(m_Not(m_SExt(m_Specific(Cond)))),
16761659
m_BitCast(m_SExt(m_Not(m_Specific(Cond))))))) {
@@ -2276,14 +2259,22 @@ Instruction *InstCombiner::visitOr(BinaryOperator &I) {
22762259
}
22772260
}
22782261

2279-
// (A & (C0?-1:0)) | (B & ~(C0?-1:0)) -> C0 ? A : B, and commuted variants.
2280-
if (Instruction *Match = matchSelectFromAndOr(A, B, C, D, *Builder))
2262+
// (Cond & C) | (~Cond & D) -> Cond ? C : D, and commuted variants.
2263+
if (Instruction *Match = matchSelectFromAndOr(A, C, B, D, *Builder))
2264+
return Match;
2265+
if (Instruction *Match = matchSelectFromAndOr(A, C, D, B, *Builder))
2266+
return Match;
2267+
if (Instruction *Match = matchSelectFromAndOr(C, A, B, D, *Builder))
2268+
return Match;
2269+
if (Instruction *Match = matchSelectFromAndOr(C, A, D, B, *Builder))
2270+
return Match;
2271+
if (Instruction *Match = matchSelectFromAndOr(B, D, A, C, *Builder))
22812272
return Match;
2282-
if (Instruction *Match = matchSelectFromAndOr(B, A, D, C, *Builder))
2273+
if (Instruction *Match = matchSelectFromAndOr(B, D, C, A, *Builder))
22832274
return Match;
2284-
if (Instruction *Match = matchSelectFromAndOr(C, B, A, D, *Builder))
2275+
if (Instruction *Match = matchSelectFromAndOr(D, B, A, C, *Builder))
22852276
return Match;
2286-
if (Instruction *Match = matchSelectFromAndOr(D, A, B, C, *Builder))
2277+
if (Instruction *Match = matchSelectFromAndOr(D, B, C, A, *Builder))
22872278
return Match;
22882279

22892280
// ((A&~B)|(~A&B)) -> A^B

‎llvm/test/Transforms/InstCombine/logical-select.ll

+147-38
Original file line numberDiff line numberDiff line change
@@ -77,79 +77,188 @@ define i32 @par(i32 %a, i32 %b, i32 %c, i32 %d) {
7777
ret i32 %t3
7878
}
7979

80-
; In the following tests, verify that a bitcast doesn't get in the way
81-
; of a select transform. These bitcasts are common in SSE/AVX and possibly
80+
; In the following tests (8 commutation variants), verify that a bitcast doesn't get
81+
; in the way of a select transform. These bitcasts are common in SSE/AVX and possibly
8282
; other vector code because of canonicalization to i64 elements for vectors.
8383

84-
define <2 x i64> @bitcast_select(<4 x i1> %cmp, <2 x i64> %a, <2 x i64> %b) {
85-
; CHECK-LABEL: @bitcast_select(
86-
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <2 x i64> %a to <4 x i32>
87-
; CHECK-NEXT: [[TMP2:%.*]] = bitcast <2 x i64> %b to <4 x i32>
84+
; The fptosi instructions are included to avoid commutation canonicalization based on
85+
; operator weight. Using another cast operator ensures that both operands of all logic
86+
; ops are equally weighted, and this ensures that we're testing all commutation
87+
; possibilities.
88+
89+
define <2 x i64> @bitcast_select_swap0(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
90+
; CHECK-LABEL: @bitcast_select_swap0(
91+
; CHECK-NEXT: [[SIA:%.*]] = fptosi <2 x double> %a to <2 x i64>
92+
; CHECK-NEXT: [[SIB:%.*]] = fptosi <2 x double> %b to <2 x i64>
93+
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <2 x i64> [[SIA]] to <4 x i32>
94+
; CHECK-NEXT: [[TMP2:%.*]] = bitcast <2 x i64> [[SIB]] to <4 x i32>
95+
; CHECK-NEXT: [[TMP3:%.*]] = select <4 x i1> %cmp, <4 x i32> [[TMP1]], <4 x i32> [[TMP2]]
96+
; CHECK-NEXT: [[OR:%.*]] = bitcast <4 x i32> [[TMP3]] to <2 x i64>
97+
; CHECK-NEXT: ret <2 x i64> [[OR]]
98+
;
99+
%sia = fptosi <2 x double> %a to <2 x i64>
100+
%sib = fptosi <2 x double> %b to <2 x i64>
101+
%sext = sext <4 x i1> %cmp to <4 x i32>
102+
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
103+
%and1 = and <2 x i64> %bc1, %sia
104+
%neg = xor <4 x i32> %sext, <i32 -1, i32 -1, i32 -1, i32 -1>
105+
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
106+
%and2 = and <2 x i64> %bc2, %sib
107+
%or = or <2 x i64> %and1, %and2
108+
ret <2 x i64> %or
109+
}
110+
111+
define <2 x i64> @bitcast_select_swap1(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
112+
; CHECK-LABEL: @bitcast_select_swap1(
113+
; CHECK-NEXT: [[SIA:%.*]] = fptosi <2 x double> %a to <2 x i64>
114+
; CHECK-NEXT: [[SIB:%.*]] = fptosi <2 x double> %b to <2 x i64>
115+
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <2 x i64> [[SIA]] to <4 x i32>
116+
; CHECK-NEXT: [[TMP2:%.*]] = bitcast <2 x i64> [[SIB]] to <4 x i32>
117+
; CHECK-NEXT: [[TMP3:%.*]] = select <4 x i1> %cmp, <4 x i32> [[TMP1]], <4 x i32> [[TMP2]]
118+
; CHECK-NEXT: [[OR:%.*]] = bitcast <4 x i32> [[TMP3]] to <2 x i64>
119+
; CHECK-NEXT: ret <2 x i64> [[OR]]
120+
;
121+
%sia = fptosi <2 x double> %a to <2 x i64>
122+
%sib = fptosi <2 x double> %b to <2 x i64>
123+
%sext = sext <4 x i1> %cmp to <4 x i32>
124+
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
125+
%and1 = and <2 x i64> %bc1, %sia
126+
%neg = xor <4 x i32> %sext, <i32 -1, i32 -1, i32 -1, i32 -1>
127+
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
128+
%and2 = and <2 x i64> %bc2, %sib
129+
%or = or <2 x i64> %and2, %and1
130+
ret <2 x i64> %or
131+
}
132+
133+
define <2 x i64> @bitcast_select_swap2(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
134+
; CHECK-LABEL: @bitcast_select_swap2(
135+
; CHECK-NEXT: [[SIA:%.*]] = fptosi <2 x double> %a to <2 x i64>
136+
; CHECK-NEXT: [[SIB:%.*]] = fptosi <2 x double> %b to <2 x i64>
137+
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <2 x i64> [[SIA]] to <4 x i32>
138+
; CHECK-NEXT: [[TMP2:%.*]] = bitcast <2 x i64> [[SIB]] to <4 x i32>
139+
; CHECK-NEXT: [[TMP3:%.*]] = select <4 x i1> %cmp, <4 x i32> [[TMP1]], <4 x i32> [[TMP2]]
140+
; CHECK-NEXT: [[OR:%.*]] = bitcast <4 x i32> [[TMP3]] to <2 x i64>
141+
; CHECK-NEXT: ret <2 x i64> [[OR]]
142+
;
143+
%sia = fptosi <2 x double> %a to <2 x i64>
144+
%sib = fptosi <2 x double> %b to <2 x i64>
145+
%sext = sext <4 x i1> %cmp to <4 x i32>
146+
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
147+
%and1 = and <2 x i64> %bc1, %sia
148+
%neg = xor <4 x i32> %sext, <i32 -1, i32 -1, i32 -1, i32 -1>
149+
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
150+
%and2 = and <2 x i64> %sib, %bc2
151+
%or = or <2 x i64> %and1, %and2
152+
ret <2 x i64> %or
153+
}
154+
155+
define <2 x i64> @bitcast_select_swap3(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
156+
; CHECK-LABEL: @bitcast_select_swap3(
157+
; CHECK-NEXT: [[SIA:%.*]] = fptosi <2 x double> %a to <2 x i64>
158+
; CHECK-NEXT: [[SIB:%.*]] = fptosi <2 x double> %b to <2 x i64>
159+
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <2 x i64> [[SIA]] to <4 x i32>
160+
; CHECK-NEXT: [[TMP2:%.*]] = bitcast <2 x i64> [[SIB]] to <4 x i32>
161+
; CHECK-NEXT: [[TMP3:%.*]] = select <4 x i1> %cmp, <4 x i32> [[TMP1]], <4 x i32> [[TMP2]]
162+
; CHECK-NEXT: [[OR:%.*]] = bitcast <4 x i32> [[TMP3]] to <2 x i64>
163+
; CHECK-NEXT: ret <2 x i64> [[OR]]
164+
;
165+
%sia = fptosi <2 x double> %a to <2 x i64>
166+
%sib = fptosi <2 x double> %b to <2 x i64>
167+
%sext = sext <4 x i1> %cmp to <4 x i32>
168+
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
169+
%and1 = and <2 x i64> %bc1, %sia
170+
%neg = xor <4 x i32> %sext, <i32 -1, i32 -1, i32 -1, i32 -1>
171+
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
172+
%and2 = and <2 x i64> %sib, %bc2
173+
%or = or <2 x i64> %and2, %and1
174+
ret <2 x i64> %or
175+
}
176+
177+
define <2 x i64> @bitcast_select_swap4(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
178+
; CHECK-LABEL: @bitcast_select_swap4(
179+
; CHECK-NEXT: [[SIA:%.*]] = fptosi <2 x double> %a to <2 x i64>
180+
; CHECK-NEXT: [[SIB:%.*]] = fptosi <2 x double> %b to <2 x i64>
181+
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <2 x i64> [[SIA]] to <4 x i32>
182+
; CHECK-NEXT: [[TMP2:%.*]] = bitcast <2 x i64> [[SIB]] to <4 x i32>
88183
; CHECK-NEXT: [[TMP3:%.*]] = select <4 x i1> %cmp, <4 x i32> [[TMP1]], <4 x i32> [[TMP2]]
89184
; CHECK-NEXT: [[OR:%.*]] = bitcast <4 x i32> [[TMP3]] to <2 x i64>
90185
; CHECK-NEXT: ret <2 x i64> [[OR]]
91186
;
187+
%sia = fptosi <2 x double> %a to <2 x i64>
188+
%sib = fptosi <2 x double> %b to <2 x i64>
92189
%sext = sext <4 x i1> %cmp to <4 x i32>
93-
%t2 = bitcast <4 x i32> %sext to <2 x i64>
94-
%and = and <2 x i64> %t2, %a
190+
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
191+
%and1 = and <2 x i64> %sia, %bc1
95192
%neg = xor <4 x i32> %sext, <i32 -1, i32 -1, i32 -1, i32 -1>
96-
%neg2 = bitcast <4 x i32> %neg to <2 x i64>
97-
%and2 = and <2 x i64> %neg2, %b
98-
%or = or <2 x i64> %and, %and2
193+
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
194+
%and2 = and <2 x i64> %bc2, %sib
195+
%or = or <2 x i64> %and1, %and2
99196
ret <2 x i64> %or
100197
}
101198

102-
define <2 x i64> @bitcast_select_swap_or_ops(<4 x i1> %cmp, <2 x i64> %a, <2 x i64> %b) {
103-
; CHECK-LABEL: @bitcast_select_swap_or_ops(
104-
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <2 x i64> %a to <4 x i32>
105-
; CHECK-NEXT: [[TMP2:%.*]] = bitcast <2 x i64> %b to <4 x i32>
199+
define <2 x i64> @bitcast_select_swap5(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
200+
; CHECK-LABEL: @bitcast_select_swap5(
201+
; CHECK-NEXT: [[SIA:%.*]] = fptosi <2 x double> %a to <2 x i64>
202+
; CHECK-NEXT: [[SIB:%.*]] = fptosi <2 x double> %b to <2 x i64>
203+
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <2 x i64> [[SIA]] to <4 x i32>
204+
; CHECK-NEXT: [[TMP2:%.*]] = bitcast <2 x i64> [[SIB]] to <4 x i32>
106205
; CHECK-NEXT: [[TMP3:%.*]] = select <4 x i1> %cmp, <4 x i32> [[TMP1]], <4 x i32> [[TMP2]]
107206
; CHECK-NEXT: [[OR:%.*]] = bitcast <4 x i32> [[TMP3]] to <2 x i64>
108207
; CHECK-NEXT: ret <2 x i64> [[OR]]
109208
;
209+
%sia = fptosi <2 x double> %a to <2 x i64>
210+
%sib = fptosi <2 x double> %b to <2 x i64>
110211
%sext = sext <4 x i1> %cmp to <4 x i32>
111-
%t2 = bitcast <4 x i32> %sext to <2 x i64>
112-
%and = and <2 x i64> %t2, %a
212+
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
213+
%and1 = and <2 x i64> %sia, %bc1
113214
%neg = xor <4 x i32> %sext, <i32 -1, i32 -1, i32 -1, i32 -1>
114-
%neg2 = bitcast <4 x i32> %neg to <2 x i64>
115-
%and2 = and <2 x i64> %neg2, %b
116-
%or = or <2 x i64> %and2, %and
215+
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
216+
%and2 = and <2 x i64> %bc2, %sib
217+
%or = or <2 x i64> %and2, %and1
117218
ret <2 x i64> %or
118219
}
119220

120-
define <2 x i64> @bitcast_select_swap_and_ops(<4 x i1> %cmp, <2 x i64> %a, <2 x i64> %b) {
121-
; CHECK-LABEL: @bitcast_select_swap_and_ops(
122-
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <2 x i64> %a to <4 x i32>
123-
; CHECK-NEXT: [[TMP2:%.*]] = bitcast <2 x i64> %b to <4 x i32>
221+
define <2 x i64> @bitcast_select_swap6(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
222+
; CHECK-LABEL: @bitcast_select_swap6(
223+
; CHECK-NEXT: [[SIA:%.*]] = fptosi <2 x double> %a to <2 x i64>
224+
; CHECK-NEXT: [[SIB:%.*]] = fptosi <2 x double> %b to <2 x i64>
225+
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <2 x i64> [[SIA]] to <4 x i32>
226+
; CHECK-NEXT: [[TMP2:%.*]] = bitcast <2 x i64> [[SIB]] to <4 x i32>
124227
; CHECK-NEXT: [[TMP3:%.*]] = select <4 x i1> %cmp, <4 x i32> [[TMP1]], <4 x i32> [[TMP2]]
125228
; CHECK-NEXT: [[OR:%.*]] = bitcast <4 x i32> [[TMP3]] to <2 x i64>
126229
; CHECK-NEXT: ret <2 x i64> [[OR]]
127230
;
231+
%sia = fptosi <2 x double> %a to <2 x i64>
232+
%sib = fptosi <2 x double> %b to <2 x i64>
128233
%sext = sext <4 x i1> %cmp to <4 x i32>
129-
%t2 = bitcast <4 x i32> %sext to <2 x i64>
130-
%and = and <2 x i64> %t2, %a
234+
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
235+
%and1 = and <2 x i64> %sia, %bc1
131236
%neg = xor <4 x i32> %sext, <i32 -1, i32 -1, i32 -1, i32 -1>
132-
%neg2 = bitcast <4 x i32> %neg to <2 x i64>
133-
%and2 = and <2 x i64> %b, %neg2
134-
%or = or <2 x i64> %and, %and2
237+
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
238+
%and2 = and <2 x i64> %sib, %bc2
239+
%or = or <2 x i64> %and1, %and2
135240
ret <2 x i64> %or
136241
}
137242

138-
define <2 x i64> @bitcast_select_swap_and_ops2(<4 x i1> %cmp, <2 x i64> %a, <2 x i64> %b) {
139-
; CHECK-LABEL: @bitcast_select_swap_and_ops2(
140-
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <2 x i64> %a to <4 x i32>
141-
; CHECK-NEXT: [[TMP2:%.*]] = bitcast <2 x i64> %b to <4 x i32>
243+
define <2 x i64> @bitcast_select_swap7(<4 x i1> %cmp, <2 x double> %a, <2 x double> %b) {
244+
; CHECK-LABEL: @bitcast_select_swap7(
245+
; CHECK-NEXT: [[SIA:%.*]] = fptosi <2 x double> %a to <2 x i64>
246+
; CHECK-NEXT: [[SIB:%.*]] = fptosi <2 x double> %b to <2 x i64>
247+
; CHECK-NEXT: [[TMP1:%.*]] = bitcast <2 x i64> [[SIA]] to <4 x i32>
248+
; CHECK-NEXT: [[TMP2:%.*]] = bitcast <2 x i64> [[SIB]] to <4 x i32>
142249
; CHECK-NEXT: [[TMP3:%.*]] = select <4 x i1> %cmp, <4 x i32> [[TMP1]], <4 x i32> [[TMP2]]
143250
; CHECK-NEXT: [[OR:%.*]] = bitcast <4 x i32> [[TMP3]] to <2 x i64>
144251
; CHECK-NEXT: ret <2 x i64> [[OR]]
145252
;
253+
%sia = fptosi <2 x double> %a to <2 x i64>
254+
%sib = fptosi <2 x double> %b to <2 x i64>
146255
%sext = sext <4 x i1> %cmp to <4 x i32>
147-
%t2 = bitcast <4 x i32> %sext to <2 x i64>
148-
%and = and <2 x i64> %a, %t2
256+
%bc1 = bitcast <4 x i32> %sext to <2 x i64>
257+
%and1 = and <2 x i64> %sia, %bc1
149258
%neg = xor <4 x i32> %sext, <i32 -1, i32 -1, i32 -1, i32 -1>
150-
%neg2 = bitcast <4 x i32> %neg to <2 x i64>
151-
%and2 = and <2 x i64> %neg2, %b
152-
%or = or <2 x i64> %and, %and2
259+
%bc2 = bitcast <4 x i32> %neg to <2 x i64>
260+
%and2 = and <2 x i64> %sib, %bc2
261+
%or = or <2 x i64> %and2, %and1
153262
ret <2 x i64> %or
154263
}
155264

0 commit comments

Comments
 (0)
Please sign in to comment.