1//===- lib/CodeGen/GlobalISel/LegalizerPredicates.cpp - Predicates --------===//
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// A library of predicate factories to use for LegalityPredicate.
10//
11//===----------------------------------------------------------------------===//
12
13// Enable optimizations to work around MSVC debug mode bug in 32-bit:
14// https://developercommunity.visualstudio.com/content/problem/1179643/msvc-copies-overaligned-non-trivially-copyable-par.html
15// FIXME: Remove this when the issue is closed.
16#if defined(_MSC_VER) && !defined(__clang__) && defined(_M_IX86)
17// We have to disable runtime checks in order to enable optimizations. This is
18// done for the entire file because the problem is actually observed in STL
19// template functions.
20#pragma runtime_checks("", off)
21#pragma optimize("gs", on)
22#endif
23
24#include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
25
26using namespace llvm;
27
28LegalityPredicate LegalityPredicates::typeIs(unsigned TypeIdx, LLT Type) {
29 return
30 [=](const LegalityQuery &Query) { return Query.Types[TypeIdx] == Type; };
31}
32
33LegalityPredicate
34LegalityPredicates::typeInSet(unsigned TypeIdx,
35 std::initializer_list<LLT> TypesInit) {
36 SmallVector<LLT, 4> Types = TypesInit;
37 return [=](const LegalityQuery &Query) {
38 return llvm::is_contained(Range: Types, Element: Query.Types[TypeIdx]);
39 };
40}
41
42LegalityPredicate LegalityPredicates::typePairInSet(
43 unsigned TypeIdx0, unsigned TypeIdx1,
44 std::initializer_list<std::pair<LLT, LLT>> TypesInit) {
45 SmallVector<std::pair<LLT, LLT>, 4> Types = TypesInit;
46 return [=](const LegalityQuery &Query) {
47 std::pair<LLT, LLT> Match = {Query.Types[TypeIdx0], Query.Types[TypeIdx1]};
48 return llvm::is_contained(Range: Types, Element: Match);
49 };
50}
51
52LegalityPredicate LegalityPredicates::typeTupleInSet(
53 unsigned TypeIdx0, unsigned TypeIdx1, unsigned TypeIdx2,
54 std::initializer_list<std::tuple<LLT, LLT, LLT>> TypesInit) {
55 SmallVector<std::tuple<LLT, LLT, LLT>, 4> Types = TypesInit;
56 return [=](const LegalityQuery &Query) {
57 std::tuple<LLT, LLT, LLT> Match = {
58 Query.Types[TypeIdx0], Query.Types[TypeIdx1], Query.Types[TypeIdx2]};
59 return llvm::is_contained(Range: Types, Element: Match);
60 };
61}
62
63LegalityPredicate LegalityPredicates::typePairAndMemDescInSet(
64 unsigned TypeIdx0, unsigned TypeIdx1, unsigned MMOIdx,
65 std::initializer_list<TypePairAndMemDesc> TypesAndMemDescInit) {
66 SmallVector<TypePairAndMemDesc, 4> TypesAndMemDesc = TypesAndMemDescInit;
67 return [=](const LegalityQuery &Query) {
68 TypePairAndMemDesc Match = {.Type0: Query.Types[TypeIdx0], .Type1: Query.Types[TypeIdx1],
69 .MemTy: Query.MMODescrs[MMOIdx].MemoryTy,
70 .Align: Query.MMODescrs[MMOIdx].AlignInBits};
71 return llvm::any_of(Range: TypesAndMemDesc,
72 P: [=](const TypePairAndMemDesc &Entry) -> bool {
73 return Match.isCompatible(Other: Entry);
74 });
75 };
76}
77
78LegalityPredicate LegalityPredicates::isScalar(unsigned TypeIdx) {
79 return [=](const LegalityQuery &Query) {
80 return Query.Types[TypeIdx].isScalar();
81 };
82}
83
84LegalityPredicate LegalityPredicates::isVector(unsigned TypeIdx) {
85 return [=](const LegalityQuery &Query) {
86 return Query.Types[TypeIdx].isVector();
87 };
88}
89
90LegalityPredicate LegalityPredicates::isPointer(unsigned TypeIdx) {
91 return [=](const LegalityQuery &Query) {
92 return Query.Types[TypeIdx].isPointer();
93 };
94}
95
96LegalityPredicate LegalityPredicates::isPointer(unsigned TypeIdx,
97 unsigned AddrSpace) {
98 return [=](const LegalityQuery &Query) {
99 LLT Ty = Query.Types[TypeIdx];
100 return Ty.isPointer() && Ty.getAddressSpace() == AddrSpace;
101 };
102}
103
104LegalityPredicate LegalityPredicates::isPointerVector(unsigned TypeIdx) {
105 return [=](const LegalityQuery &Query) {
106 return Query.Types[TypeIdx].isPointerVector();
107 };
108}
109
110LegalityPredicate LegalityPredicates::elementTypeIs(unsigned TypeIdx,
111 LLT EltTy) {
112 return [=](const LegalityQuery &Query) {
113 const LLT QueryTy = Query.Types[TypeIdx];
114 return QueryTy.isVector() && QueryTy.getElementType() == EltTy;
115 };
116}
117
118LegalityPredicate LegalityPredicates::scalarNarrowerThan(unsigned TypeIdx,
119 unsigned Size) {
120 return [=](const LegalityQuery &Query) {
121 const LLT QueryTy = Query.Types[TypeIdx];
122 return QueryTy.isScalar() && QueryTy.getSizeInBits() < Size;
123 };
124}
125
126LegalityPredicate LegalityPredicates::scalarWiderThan(unsigned TypeIdx,
127 unsigned Size) {
128 return [=](const LegalityQuery &Query) {
129 const LLT QueryTy = Query.Types[TypeIdx];
130 return QueryTy.isScalar() && QueryTy.getSizeInBits() > Size;
131 };
132}
133
134LegalityPredicate LegalityPredicates::smallerThan(unsigned TypeIdx0,
135 unsigned TypeIdx1) {
136 return [=](const LegalityQuery &Query) {
137 return Query.Types[TypeIdx0].getSizeInBits() <
138 Query.Types[TypeIdx1].getSizeInBits();
139 };
140}
141
142LegalityPredicate LegalityPredicates::largerThan(unsigned TypeIdx0,
143 unsigned TypeIdx1) {
144 return [=](const LegalityQuery &Query) {
145 return Query.Types[TypeIdx0].getSizeInBits() >
146 Query.Types[TypeIdx1].getSizeInBits();
147 };
148}
149
150LegalityPredicate LegalityPredicates::scalarOrEltNarrowerThan(unsigned TypeIdx,
151 unsigned Size) {
152 return [=](const LegalityQuery &Query) {
153 const LLT QueryTy = Query.Types[TypeIdx];
154 return QueryTy.getScalarSizeInBits() < Size;
155 };
156}
157
158LegalityPredicate LegalityPredicates::scalarOrEltWiderThan(unsigned TypeIdx,
159 unsigned Size) {
160 return [=](const LegalityQuery &Query) {
161 const LLT QueryTy = Query.Types[TypeIdx];
162 return QueryTy.getScalarSizeInBits() > Size;
163 };
164}
165
166LegalityPredicate LegalityPredicates::scalarOrEltSizeNotPow2(unsigned TypeIdx) {
167 return [=](const LegalityQuery &Query) {
168 const LLT QueryTy = Query.Types[TypeIdx];
169 return !isPowerOf2_32(Value: QueryTy.getScalarSizeInBits());
170 };
171}
172
173LegalityPredicate LegalityPredicates::sizeNotMultipleOf(unsigned TypeIdx,
174 unsigned Size) {
175 return [=](const LegalityQuery &Query) {
176 const LLT QueryTy = Query.Types[TypeIdx];
177 return QueryTy.isScalar() && QueryTy.getSizeInBits() % Size != 0;
178 };
179}
180
181LegalityPredicate LegalityPredicates::sizeNotPow2(unsigned TypeIdx) {
182 return [=](const LegalityQuery &Query) {
183 const LLT QueryTy = Query.Types[TypeIdx];
184 return QueryTy.isScalar() &&
185 !llvm::has_single_bit<uint32_t>(Value: QueryTy.getSizeInBits());
186 };
187}
188
189LegalityPredicate LegalityPredicates::sizeIs(unsigned TypeIdx, unsigned Size) {
190 return [=](const LegalityQuery &Query) {
191 return Query.Types[TypeIdx].getSizeInBits() == Size;
192 };
193}
194
195LegalityPredicate LegalityPredicates::sameSize(unsigned TypeIdx0,
196 unsigned TypeIdx1) {
197 return [=](const LegalityQuery &Query) {
198 return Query.Types[TypeIdx0].getSizeInBits() ==
199 Query.Types[TypeIdx1].getSizeInBits();
200 };
201}
202
203LegalityPredicate LegalityPredicates::memSizeInBytesNotPow2(unsigned MMOIdx) {
204 return [=](const LegalityQuery &Query) {
205 return !llvm::has_single_bit<uint32_t>(
206 Value: Query.MMODescrs[MMOIdx].MemoryTy.getSizeInBytes());
207 };
208}
209
210LegalityPredicate LegalityPredicates::memSizeNotByteSizePow2(unsigned MMOIdx) {
211 return [=](const LegalityQuery &Query) {
212 const LLT MemTy = Query.MMODescrs[MMOIdx].MemoryTy;
213 return !MemTy.isByteSized() ||
214 !llvm::has_single_bit<uint32_t>(
215 Value: MemTy.getSizeInBytes().getKnownMinValue());
216 };
217}
218
219LegalityPredicate LegalityPredicates::numElementsNotPow2(unsigned TypeIdx) {
220 return [=](const LegalityQuery &Query) {
221 const LLT QueryTy = Query.Types[TypeIdx];
222 return QueryTy.isFixedVector() && !isPowerOf2_32(Value: QueryTy.getNumElements());
223 };
224}
225
226LegalityPredicate LegalityPredicates::atomicOrderingAtLeastOrStrongerThan(
227 unsigned MMOIdx, AtomicOrdering Ordering) {
228 return [=](const LegalityQuery &Query) {
229 return isAtLeastOrStrongerThan(AO: Query.MMODescrs[MMOIdx].Ordering, Other: Ordering);
230 };
231}
232