File: | utils/TableGen/CodeGenDAGPatterns.cpp |
Warning: | line 3412, column 7 Called C++ object pointer is null |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===- CodeGenDAGPatterns.cpp - Read DAG patterns from .td file -----------===// | |||
2 | // | |||
3 | // The LLVM Compiler Infrastructure | |||
4 | // | |||
5 | // This file is distributed under the University of Illinois Open Source | |||
6 | // License. See LICENSE.TXT for details. | |||
7 | // | |||
8 | //===----------------------------------------------------------------------===// | |||
9 | // | |||
10 | // This file implements the CodeGenDAGPatterns class, which is used to read and | |||
11 | // represent the patterns present in a .td file for instructions. | |||
12 | // | |||
13 | //===----------------------------------------------------------------------===// | |||
14 | ||||
15 | #include "CodeGenDAGPatterns.h" | |||
16 | #include "llvm/ADT/DenseSet.h" | |||
17 | #include "llvm/ADT/STLExtras.h" | |||
18 | #include "llvm/ADT/SmallSet.h" | |||
19 | #include "llvm/ADT/SmallString.h" | |||
20 | #include "llvm/ADT/StringExtras.h" | |||
21 | #include "llvm/ADT/StringMap.h" | |||
22 | #include "llvm/ADT/Twine.h" | |||
23 | #include "llvm/Support/Debug.h" | |||
24 | #include "llvm/Support/ErrorHandling.h" | |||
25 | #include "llvm/TableGen/Error.h" | |||
26 | #include "llvm/TableGen/Record.h" | |||
27 | #include <algorithm> | |||
28 | #include <cstdio> | |||
29 | #include <set> | |||
30 | using namespace llvm; | |||
31 | ||||
32 | #define DEBUG_TYPE"dag-patterns" "dag-patterns" | |||
33 | ||||
34 | static inline bool isIntegerOrPtr(MVT VT) { | |||
35 | return VT.isInteger() || VT == MVT::iPTR; | |||
36 | } | |||
37 | static inline bool isFloatingPoint(MVT VT) { | |||
38 | return VT.isFloatingPoint(); | |||
39 | } | |||
40 | static inline bool isVector(MVT VT) { | |||
41 | return VT.isVector(); | |||
42 | } | |||
43 | static inline bool isScalar(MVT VT) { | |||
44 | return !VT.isVector(); | |||
45 | } | |||
46 | ||||
47 | template <typename Predicate> | |||
48 | static bool berase_if(MachineValueTypeSet &S, Predicate P) { | |||
49 | bool Erased = false; | |||
50 | // It is ok to iterate over MachineValueTypeSet and remove elements from it | |||
51 | // at the same time. | |||
52 | for (MVT T : S) { | |||
53 | if (!P(T)) | |||
54 | continue; | |||
55 | Erased = true; | |||
56 | S.erase(T); | |||
57 | } | |||
58 | return Erased; | |||
59 | } | |||
60 | ||||
61 | // --- TypeSetByHwMode | |||
62 | ||||
63 | // This is a parameterized type-set class. For each mode there is a list | |||
64 | // of types that are currently possible for a given tree node. Type | |||
65 | // inference will apply to each mode separately. | |||
66 | ||||
67 | TypeSetByHwMode::TypeSetByHwMode(ArrayRef<ValueTypeByHwMode> VTList) { | |||
68 | for (const ValueTypeByHwMode &VVT : VTList) | |||
69 | insert(VVT); | |||
70 | } | |||
71 | ||||
72 | bool TypeSetByHwMode::isValueTypeByHwMode(bool AllowEmpty) const { | |||
73 | for (const auto &I : *this) { | |||
74 | if (I.second.size() > 1) | |||
75 | return false; | |||
76 | if (!AllowEmpty && I.second.empty()) | |||
77 | return false; | |||
78 | } | |||
79 | return true; | |||
80 | } | |||
81 | ||||
82 | ValueTypeByHwMode TypeSetByHwMode::getValueTypeByHwMode() const { | |||
83 | assert(isValueTypeByHwMode(true) &&(static_cast <bool> (isValueTypeByHwMode(true) && "The type set has multiple types for at least one HW mode") ? void (0) : __assert_fail ("isValueTypeByHwMode(true) && \"The type set has multiple types for at least one HW mode\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 84, __extension__ __PRETTY_FUNCTION__)) | |||
84 | "The type set has multiple types for at least one HW mode")(static_cast <bool> (isValueTypeByHwMode(true) && "The type set has multiple types for at least one HW mode") ? void (0) : __assert_fail ("isValueTypeByHwMode(true) && \"The type set has multiple types for at least one HW mode\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 84, __extension__ __PRETTY_FUNCTION__)); | |||
85 | ValueTypeByHwMode VVT; | |||
86 | for (const auto &I : *this) { | |||
87 | MVT T = I.second.empty() ? MVT::Other : *I.second.begin(); | |||
88 | VVT.getOrCreateTypeForMode(I.first, T); | |||
89 | } | |||
90 | return VVT; | |||
91 | } | |||
92 | ||||
93 | bool TypeSetByHwMode::isPossible() const { | |||
94 | for (const auto &I : *this) | |||
95 | if (!I.second.empty()) | |||
96 | return true; | |||
97 | return false; | |||
98 | } | |||
99 | ||||
100 | bool TypeSetByHwMode::insert(const ValueTypeByHwMode &VVT) { | |||
101 | bool Changed = false; | |||
102 | SmallDenseSet<unsigned, 4> Modes; | |||
103 | for (const auto &P : VVT) { | |||
104 | unsigned M = P.first; | |||
105 | Modes.insert(M); | |||
106 | // Make sure there exists a set for each specific mode from VVT. | |||
107 | Changed |= getOrCreate(M).insert(P.second).second; | |||
108 | } | |||
109 | ||||
110 | // If VVT has a default mode, add the corresponding type to all | |||
111 | // modes in "this" that do not exist in VVT. | |||
112 | if (Modes.count(DefaultMode)) { | |||
113 | MVT DT = VVT.getType(DefaultMode); | |||
114 | for (auto &I : *this) | |||
115 | if (!Modes.count(I.first)) | |||
116 | Changed |= I.second.insert(DT).second; | |||
117 | } | |||
118 | return Changed; | |||
119 | } | |||
120 | ||||
121 | // Constrain the type set to be the intersection with VTS. | |||
122 | bool TypeSetByHwMode::constrain(const TypeSetByHwMode &VTS) { | |||
123 | bool Changed = false; | |||
124 | if (hasDefault()) { | |||
125 | for (const auto &I : VTS) { | |||
126 | unsigned M = I.first; | |||
127 | if (M == DefaultMode || hasMode(M)) | |||
128 | continue; | |||
129 | Map.insert({M, Map.at(DefaultMode)}); | |||
130 | Changed = true; | |||
131 | } | |||
132 | } | |||
133 | ||||
134 | for (auto &I : *this) { | |||
135 | unsigned M = I.first; | |||
136 | SetType &S = I.second; | |||
137 | if (VTS.hasMode(M) || VTS.hasDefault()) { | |||
138 | Changed |= intersect(I.second, VTS.get(M)); | |||
139 | } else if (!S.empty()) { | |||
140 | S.clear(); | |||
141 | Changed = true; | |||
142 | } | |||
143 | } | |||
144 | return Changed; | |||
145 | } | |||
146 | ||||
147 | template <typename Predicate> | |||
148 | bool TypeSetByHwMode::constrain(Predicate P) { | |||
149 | bool Changed = false; | |||
150 | for (auto &I : *this) | |||
151 | Changed |= berase_if(I.second, [&P](MVT VT) { return !P(VT); }); | |||
152 | return Changed; | |||
153 | } | |||
154 | ||||
155 | template <typename Predicate> | |||
156 | bool TypeSetByHwMode::assign_if(const TypeSetByHwMode &VTS, Predicate P) { | |||
157 | assert(empty())(static_cast <bool> (empty()) ? void (0) : __assert_fail ("empty()", "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 157, __extension__ __PRETTY_FUNCTION__)); | |||
158 | for (const auto &I : VTS) { | |||
159 | SetType &S = getOrCreate(I.first); | |||
160 | for (auto J : I.second) | |||
161 | if (P(J)) | |||
162 | S.insert(J); | |||
163 | } | |||
164 | return !empty(); | |||
165 | } | |||
166 | ||||
167 | void TypeSetByHwMode::writeToStream(raw_ostream &OS) const { | |||
168 | SmallVector<unsigned, 4> Modes; | |||
169 | Modes.reserve(Map.size()); | |||
170 | ||||
171 | for (const auto &I : *this) | |||
172 | Modes.push_back(I.first); | |||
173 | if (Modes.empty()) { | |||
174 | OS << "{}"; | |||
175 | return; | |||
176 | } | |||
177 | array_pod_sort(Modes.begin(), Modes.end()); | |||
178 | ||||
179 | OS << '{'; | |||
180 | for (unsigned M : Modes) { | |||
181 | OS << ' ' << getModeName(M) << ':'; | |||
182 | writeToStream(get(M), OS); | |||
183 | } | |||
184 | OS << " }"; | |||
185 | } | |||
186 | ||||
187 | void TypeSetByHwMode::writeToStream(const SetType &S, raw_ostream &OS) { | |||
188 | SmallVector<MVT, 4> Types(S.begin(), S.end()); | |||
189 | array_pod_sort(Types.begin(), Types.end()); | |||
190 | ||||
191 | OS << '['; | |||
192 | for (unsigned i = 0, e = Types.size(); i != e; ++i) { | |||
193 | OS << ValueTypeByHwMode::getMVTName(Types[i]); | |||
194 | if (i != e-1) | |||
195 | OS << ' '; | |||
196 | } | |||
197 | OS << ']'; | |||
198 | } | |||
199 | ||||
200 | bool TypeSetByHwMode::operator==(const TypeSetByHwMode &VTS) const { | |||
201 | bool HaveDefault = hasDefault(); | |||
202 | if (HaveDefault != VTS.hasDefault()) | |||
203 | return false; | |||
204 | ||||
205 | if (isSimple()) { | |||
206 | if (VTS.isSimple()) | |||
207 | return *begin() == *VTS.begin(); | |||
208 | return false; | |||
209 | } | |||
210 | ||||
211 | SmallDenseSet<unsigned, 4> Modes; | |||
212 | for (auto &I : *this) | |||
213 | Modes.insert(I.first); | |||
214 | for (const auto &I : VTS) | |||
215 | Modes.insert(I.first); | |||
216 | ||||
217 | if (HaveDefault) { | |||
218 | // Both sets have default mode. | |||
219 | for (unsigned M : Modes) { | |||
220 | if (get(M) != VTS.get(M)) | |||
221 | return false; | |||
222 | } | |||
223 | } else { | |||
224 | // Neither set has default mode. | |||
225 | for (unsigned M : Modes) { | |||
226 | // If there is no default mode, an empty set is equivalent to not having | |||
227 | // the corresponding mode. | |||
228 | bool NoModeThis = !hasMode(M) || get(M).empty(); | |||
229 | bool NoModeVTS = !VTS.hasMode(M) || VTS.get(M).empty(); | |||
230 | if (NoModeThis != NoModeVTS) | |||
231 | return false; | |||
232 | if (!NoModeThis) | |||
233 | if (get(M) != VTS.get(M)) | |||
234 | return false; | |||
235 | } | |||
236 | } | |||
237 | ||||
238 | return true; | |||
239 | } | |||
240 | ||||
241 | namespace llvm { | |||
242 | raw_ostream &operator<<(raw_ostream &OS, const TypeSetByHwMode &T) { | |||
243 | T.writeToStream(OS); | |||
244 | return OS; | |||
245 | } | |||
246 | } | |||
247 | ||||
248 | LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__)) | |||
249 | void TypeSetByHwMode::dump() const { | |||
250 | dbgs() << *this << '\n'; | |||
251 | } | |||
252 | ||||
253 | bool TypeSetByHwMode::intersect(SetType &Out, const SetType &In) { | |||
254 | bool OutP = Out.count(MVT::iPTR), InP = In.count(MVT::iPTR); | |||
255 | auto Int = [&In](MVT T) -> bool { return !In.count(T); }; | |||
256 | ||||
257 | if (OutP == InP) | |||
258 | return berase_if(Out, Int); | |||
259 | ||||
260 | // Compute the intersection of scalars separately to account for only | |||
261 | // one set containing iPTR. | |||
262 | // The itersection of iPTR with a set of integer scalar types that does not | |||
263 | // include iPTR will result in the most specific scalar type: | |||
264 | // - iPTR is more specific than any set with two elements or more | |||
265 | // - iPTR is less specific than any single integer scalar type. | |||
266 | // For example | |||
267 | // { iPTR } * { i32 } -> { i32 } | |||
268 | // { iPTR } * { i32 i64 } -> { iPTR } | |||
269 | // and | |||
270 | // { iPTR i32 } * { i32 } -> { i32 } | |||
271 | // { iPTR i32 } * { i32 i64 } -> { i32 i64 } | |||
272 | // { iPTR i32 } * { i32 i64 i128 } -> { iPTR i32 } | |||
273 | ||||
274 | // Compute the difference between the two sets in such a way that the | |||
275 | // iPTR is in the set that is being subtracted. This is to see if there | |||
276 | // are any extra scalars in the set without iPTR that are not in the | |||
277 | // set containing iPTR. Then the iPTR could be considered a "wildcard" | |||
278 | // matching these scalars. If there is only one such scalar, it would | |||
279 | // replace the iPTR, if there are more, the iPTR would be retained. | |||
280 | SetType Diff; | |||
281 | if (InP) { | |||
282 | Diff = Out; | |||
283 | berase_if(Diff, [&In](MVT T) { return In.count(T); }); | |||
284 | // Pre-remove these elements and rely only on InP/OutP to determine | |||
285 | // whether a change has been made. | |||
286 | berase_if(Out, [&Diff](MVT T) { return Diff.count(T); }); | |||
287 | } else { | |||
288 | Diff = In; | |||
289 | berase_if(Diff, [&Out](MVT T) { return Out.count(T); }); | |||
290 | Out.erase(MVT::iPTR); | |||
291 | } | |||
292 | ||||
293 | // The actual intersection. | |||
294 | bool Changed = berase_if(Out, Int); | |||
295 | unsigned NumD = Diff.size(); | |||
296 | if (NumD == 0) | |||
297 | return Changed; | |||
298 | ||||
299 | if (NumD == 1) { | |||
300 | Out.insert(*Diff.begin()); | |||
301 | // This is a change only if Out was the one with iPTR (which is now | |||
302 | // being replaced). | |||
303 | Changed |= OutP; | |||
304 | } else { | |||
305 | // Multiple elements from Out are now replaced with iPTR. | |||
306 | Out.insert(MVT::iPTR); | |||
307 | Changed |= !OutP; | |||
308 | } | |||
309 | return Changed; | |||
310 | } | |||
311 | ||||
312 | bool TypeSetByHwMode::validate() const { | |||
313 | #ifndef NDEBUG | |||
314 | if (empty()) | |||
315 | return true; | |||
316 | bool AllEmpty = true; | |||
317 | for (const auto &I : *this) | |||
318 | AllEmpty &= I.second.empty(); | |||
319 | return !AllEmpty; | |||
320 | #endif | |||
321 | return true; | |||
322 | } | |||
323 | ||||
324 | // --- TypeInfer | |||
325 | ||||
326 | bool TypeInfer::MergeInTypeInfo(TypeSetByHwMode &Out, | |||
327 | const TypeSetByHwMode &In) { | |||
328 | ValidateOnExit _1(Out, *this); | |||
329 | In.validate(); | |||
330 | if (In.empty() || Out == In || TP.hasError()) | |||
331 | return false; | |||
332 | if (Out.empty()) { | |||
333 | Out = In; | |||
334 | return true; | |||
335 | } | |||
336 | ||||
337 | bool Changed = Out.constrain(In); | |||
338 | if (Changed && Out.empty()) | |||
339 | TP.error("Type contradiction"); | |||
340 | ||||
341 | return Changed; | |||
342 | } | |||
343 | ||||
344 | bool TypeInfer::forceArbitrary(TypeSetByHwMode &Out) { | |||
345 | ValidateOnExit _1(Out, *this); | |||
346 | if (TP.hasError()) | |||
347 | return false; | |||
348 | assert(!Out.empty() && "cannot pick from an empty set")(static_cast <bool> (!Out.empty() && "cannot pick from an empty set" ) ? void (0) : __assert_fail ("!Out.empty() && \"cannot pick from an empty set\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 348, __extension__ __PRETTY_FUNCTION__)); | |||
349 | ||||
350 | bool Changed = false; | |||
351 | for (auto &I : Out) { | |||
352 | TypeSetByHwMode::SetType &S = I.second; | |||
353 | if (S.size() <= 1) | |||
354 | continue; | |||
355 | MVT T = *S.begin(); // Pick the first element. | |||
356 | S.clear(); | |||
357 | S.insert(T); | |||
358 | Changed = true; | |||
359 | } | |||
360 | return Changed; | |||
361 | } | |||
362 | ||||
363 | bool TypeInfer::EnforceInteger(TypeSetByHwMode &Out) { | |||
364 | ValidateOnExit _1(Out, *this); | |||
365 | if (TP.hasError()) | |||
366 | return false; | |||
367 | if (!Out.empty()) | |||
368 | return Out.constrain(isIntegerOrPtr); | |||
369 | ||||
370 | return Out.assign_if(getLegalTypes(), isIntegerOrPtr); | |||
371 | } | |||
372 | ||||
373 | bool TypeInfer::EnforceFloatingPoint(TypeSetByHwMode &Out) { | |||
374 | ValidateOnExit _1(Out, *this); | |||
375 | if (TP.hasError()) | |||
376 | return false; | |||
377 | if (!Out.empty()) | |||
378 | return Out.constrain(isFloatingPoint); | |||
379 | ||||
380 | return Out.assign_if(getLegalTypes(), isFloatingPoint); | |||
381 | } | |||
382 | ||||
383 | bool TypeInfer::EnforceScalar(TypeSetByHwMode &Out) { | |||
384 | ValidateOnExit _1(Out, *this); | |||
385 | if (TP.hasError()) | |||
386 | return false; | |||
387 | if (!Out.empty()) | |||
388 | return Out.constrain(isScalar); | |||
389 | ||||
390 | return Out.assign_if(getLegalTypes(), isScalar); | |||
391 | } | |||
392 | ||||
393 | bool TypeInfer::EnforceVector(TypeSetByHwMode &Out) { | |||
394 | ValidateOnExit _1(Out, *this); | |||
395 | if (TP.hasError()) | |||
396 | return false; | |||
397 | if (!Out.empty()) | |||
398 | return Out.constrain(isVector); | |||
399 | ||||
400 | return Out.assign_if(getLegalTypes(), isVector); | |||
401 | } | |||
402 | ||||
403 | bool TypeInfer::EnforceAny(TypeSetByHwMode &Out) { | |||
404 | ValidateOnExit _1(Out, *this); | |||
405 | if (TP.hasError() || !Out.empty()) | |||
406 | return false; | |||
407 | ||||
408 | Out = getLegalTypes(); | |||
409 | return true; | |||
410 | } | |||
411 | ||||
412 | template <typename Iter, typename Pred, typename Less> | |||
413 | static Iter min_if(Iter B, Iter E, Pred P, Less L) { | |||
414 | if (B == E) | |||
415 | return E; | |||
416 | Iter Min = E; | |||
417 | for (Iter I = B; I != E; ++I) { | |||
418 | if (!P(*I)) | |||
419 | continue; | |||
420 | if (Min == E || L(*I, *Min)) | |||
421 | Min = I; | |||
422 | } | |||
423 | return Min; | |||
424 | } | |||
425 | ||||
426 | template <typename Iter, typename Pred, typename Less> | |||
427 | static Iter max_if(Iter B, Iter E, Pred P, Less L) { | |||
428 | if (B == E) | |||
429 | return E; | |||
430 | Iter Max = E; | |||
431 | for (Iter I = B; I != E; ++I) { | |||
432 | if (!P(*I)) | |||
433 | continue; | |||
434 | if (Max == E || L(*Max, *I)) | |||
435 | Max = I; | |||
436 | } | |||
437 | return Max; | |||
438 | } | |||
439 | ||||
440 | /// Make sure that for each type in Small, there exists a larger type in Big. | |||
441 | bool TypeInfer::EnforceSmallerThan(TypeSetByHwMode &Small, | |||
442 | TypeSetByHwMode &Big) { | |||
443 | ValidateOnExit _1(Small, *this), _2(Big, *this); | |||
444 | if (TP.hasError()) | |||
445 | return false; | |||
446 | bool Changed = false; | |||
447 | ||||
448 | if (Small.empty()) | |||
449 | Changed |= EnforceAny(Small); | |||
450 | if (Big.empty()) | |||
451 | Changed |= EnforceAny(Big); | |||
452 | ||||
453 | assert(Small.hasDefault() && Big.hasDefault())(static_cast <bool> (Small.hasDefault() && Big. hasDefault()) ? void (0) : __assert_fail ("Small.hasDefault() && Big.hasDefault()" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 453, __extension__ __PRETTY_FUNCTION__)); | |||
454 | ||||
455 | std::vector<unsigned> Modes = union_modes(Small, Big); | |||
456 | ||||
457 | // 1. Only allow integer or floating point types and make sure that | |||
458 | // both sides are both integer or both floating point. | |||
459 | // 2. Make sure that either both sides have vector types, or neither | |||
460 | // of them does. | |||
461 | for (unsigned M : Modes) { | |||
462 | TypeSetByHwMode::SetType &S = Small.get(M); | |||
463 | TypeSetByHwMode::SetType &B = Big.get(M); | |||
464 | ||||
465 | if (any_of(S, isIntegerOrPtr) && any_of(S, isIntegerOrPtr)) { | |||
466 | auto NotInt = [](MVT VT) { return !isIntegerOrPtr(VT); }; | |||
467 | Changed |= berase_if(S, NotInt) | | |||
468 | berase_if(B, NotInt); | |||
469 | } else if (any_of(S, isFloatingPoint) && any_of(B, isFloatingPoint)) { | |||
470 | auto NotFP = [](MVT VT) { return !isFloatingPoint(VT); }; | |||
471 | Changed |= berase_if(S, NotFP) | | |||
472 | berase_if(B, NotFP); | |||
473 | } else if (S.empty() || B.empty()) { | |||
474 | Changed = !S.empty() || !B.empty(); | |||
475 | S.clear(); | |||
476 | B.clear(); | |||
477 | } else { | |||
478 | TP.error("Incompatible types"); | |||
479 | return Changed; | |||
480 | } | |||
481 | ||||
482 | if (none_of(S, isVector) || none_of(B, isVector)) { | |||
483 | Changed |= berase_if(S, isVector) | | |||
484 | berase_if(B, isVector); | |||
485 | } | |||
486 | } | |||
487 | ||||
488 | auto LT = [](MVT A, MVT B) -> bool { | |||
489 | return A.getScalarSizeInBits() < B.getScalarSizeInBits() || | |||
490 | (A.getScalarSizeInBits() == B.getScalarSizeInBits() && | |||
491 | A.getSizeInBits() < B.getSizeInBits()); | |||
492 | }; | |||
493 | auto LE = [](MVT A, MVT B) -> bool { | |||
494 | // This function is used when removing elements: when a vector is compared | |||
495 | // to a non-vector, it should return false (to avoid removal). | |||
496 | if (A.isVector() != B.isVector()) | |||
497 | return false; | |||
498 | ||||
499 | // Note on the < comparison below: | |||
500 | // X86 has patterns like | |||
501 | // (set VR128X:$dst, (v16i8 (X86vtrunc (v4i32 VR128X:$src1)))), | |||
502 | // where the truncated vector is given a type v16i8, while the source | |||
503 | // vector has type v4i32. They both have the same size in bits. | |||
504 | // The minimal type in the result is obviously v16i8, and when we remove | |||
505 | // all types from the source that are smaller-or-equal than v8i16, the | |||
506 | // only source type would also be removed (since it's equal in size). | |||
507 | return A.getScalarSizeInBits() <= B.getScalarSizeInBits() || | |||
508 | A.getSizeInBits() < B.getSizeInBits(); | |||
509 | }; | |||
510 | ||||
511 | for (unsigned M : Modes) { | |||
512 | TypeSetByHwMode::SetType &S = Small.get(M); | |||
513 | TypeSetByHwMode::SetType &B = Big.get(M); | |||
514 | // MinS = min scalar in Small, remove all scalars from Big that are | |||
515 | // smaller-or-equal than MinS. | |||
516 | auto MinS = min_if(S.begin(), S.end(), isScalar, LT); | |||
517 | if (MinS != S.end()) | |||
518 | Changed |= berase_if(B, std::bind(LE, std::placeholders::_1, *MinS)); | |||
519 | ||||
520 | // MaxS = max scalar in Big, remove all scalars from Small that are | |||
521 | // larger than MaxS. | |||
522 | auto MaxS = max_if(B.begin(), B.end(), isScalar, LT); | |||
523 | if (MaxS != B.end()) | |||
524 | Changed |= berase_if(S, std::bind(LE, *MaxS, std::placeholders::_1)); | |||
525 | ||||
526 | // MinV = min vector in Small, remove all vectors from Big that are | |||
527 | // smaller-or-equal than MinV. | |||
528 | auto MinV = min_if(S.begin(), S.end(), isVector, LT); | |||
529 | if (MinV != S.end()) | |||
530 | Changed |= berase_if(B, std::bind(LE, std::placeholders::_1, *MinV)); | |||
531 | ||||
532 | // MaxV = max vector in Big, remove all vectors from Small that are | |||
533 | // larger than MaxV. | |||
534 | auto MaxV = max_if(B.begin(), B.end(), isVector, LT); | |||
535 | if (MaxV != B.end()) | |||
536 | Changed |= berase_if(S, std::bind(LE, *MaxV, std::placeholders::_1)); | |||
537 | } | |||
538 | ||||
539 | return Changed; | |||
540 | } | |||
541 | ||||
542 | /// 1. Ensure that for each type T in Vec, T is a vector type, and that | |||
543 | /// for each type U in Elem, U is a scalar type. | |||
544 | /// 2. Ensure that for each (scalar) type U in Elem, there exists a (vector) | |||
545 | /// type T in Vec, such that U is the element type of T. | |||
546 | bool TypeInfer::EnforceVectorEltTypeIs(TypeSetByHwMode &Vec, | |||
547 | TypeSetByHwMode &Elem) { | |||
548 | ValidateOnExit _1(Vec, *this), _2(Elem, *this); | |||
549 | if (TP.hasError()) | |||
550 | return false; | |||
551 | bool Changed = false; | |||
552 | ||||
553 | if (Vec.empty()) | |||
554 | Changed |= EnforceVector(Vec); | |||
555 | if (Elem.empty()) | |||
556 | Changed |= EnforceScalar(Elem); | |||
557 | ||||
558 | for (unsigned M : union_modes(Vec, Elem)) { | |||
559 | TypeSetByHwMode::SetType &V = Vec.get(M); | |||
560 | TypeSetByHwMode::SetType &E = Elem.get(M); | |||
561 | ||||
562 | Changed |= berase_if(V, isScalar); // Scalar = !vector | |||
563 | Changed |= berase_if(E, isVector); // Vector = !scalar | |||
564 | assert(!V.empty() && !E.empty())(static_cast <bool> (!V.empty() && !E.empty()) ? void (0) : __assert_fail ("!V.empty() && !E.empty()" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 564, __extension__ __PRETTY_FUNCTION__)); | |||
565 | ||||
566 | SmallSet<MVT,4> VT, ST; | |||
567 | // Collect element types from the "vector" set. | |||
568 | for (MVT T : V) | |||
569 | VT.insert(T.getVectorElementType()); | |||
570 | // Collect scalar types from the "element" set. | |||
571 | for (MVT T : E) | |||
572 | ST.insert(T); | |||
573 | ||||
574 | // Remove from V all (vector) types whose element type is not in S. | |||
575 | Changed |= berase_if(V, [&ST](MVT T) -> bool { | |||
576 | return !ST.count(T.getVectorElementType()); | |||
577 | }); | |||
578 | // Remove from E all (scalar) types, for which there is no corresponding | |||
579 | // type in V. | |||
580 | Changed |= berase_if(E, [&VT](MVT T) -> bool { return !VT.count(T); }); | |||
581 | } | |||
582 | ||||
583 | return Changed; | |||
584 | } | |||
585 | ||||
586 | bool TypeInfer::EnforceVectorEltTypeIs(TypeSetByHwMode &Vec, | |||
587 | const ValueTypeByHwMode &VVT) { | |||
588 | TypeSetByHwMode Tmp(VVT); | |||
589 | ValidateOnExit _1(Vec, *this), _2(Tmp, *this); | |||
590 | return EnforceVectorEltTypeIs(Vec, Tmp); | |||
591 | } | |||
592 | ||||
593 | /// Ensure that for each type T in Sub, T is a vector type, and there | |||
594 | /// exists a type U in Vec such that U is a vector type with the same | |||
595 | /// element type as T and at least as many elements as T. | |||
596 | bool TypeInfer::EnforceVectorSubVectorTypeIs(TypeSetByHwMode &Vec, | |||
597 | TypeSetByHwMode &Sub) { | |||
598 | ValidateOnExit _1(Vec, *this), _2(Sub, *this); | |||
599 | if (TP.hasError()) | |||
600 | return false; | |||
601 | ||||
602 | /// Return true if B is a suB-vector of P, i.e. P is a suPer-vector of B. | |||
603 | auto IsSubVec = [](MVT B, MVT P) -> bool { | |||
604 | if (!B.isVector() || !P.isVector()) | |||
605 | return false; | |||
606 | // Logically a <4 x i32> is a valid subvector of <n x 4 x i32> | |||
607 | // but until there are obvious use-cases for this, keep the | |||
608 | // types separate. | |||
609 | if (B.isScalableVector() != P.isScalableVector()) | |||
610 | return false; | |||
611 | if (B.getVectorElementType() != P.getVectorElementType()) | |||
612 | return false; | |||
613 | return B.getVectorNumElements() < P.getVectorNumElements(); | |||
614 | }; | |||
615 | ||||
616 | /// Return true if S has no element (vector type) that T is a sub-vector of, | |||
617 | /// i.e. has the same element type as T and more elements. | |||
618 | auto NoSubV = [&IsSubVec](const TypeSetByHwMode::SetType &S, MVT T) -> bool { | |||
619 | for (const auto &I : S) | |||
620 | if (IsSubVec(T, I)) | |||
621 | return false; | |||
622 | return true; | |||
623 | }; | |||
624 | ||||
625 | /// Return true if S has no element (vector type) that T is a super-vector | |||
626 | /// of, i.e. has the same element type as T and fewer elements. | |||
627 | auto NoSupV = [&IsSubVec](const TypeSetByHwMode::SetType &S, MVT T) -> bool { | |||
628 | for (const auto &I : S) | |||
629 | if (IsSubVec(I, T)) | |||
630 | return false; | |||
631 | return true; | |||
632 | }; | |||
633 | ||||
634 | bool Changed = false; | |||
635 | ||||
636 | if (Vec.empty()) | |||
637 | Changed |= EnforceVector(Vec); | |||
638 | if (Sub.empty()) | |||
639 | Changed |= EnforceVector(Sub); | |||
640 | ||||
641 | for (unsigned M : union_modes(Vec, Sub)) { | |||
642 | TypeSetByHwMode::SetType &S = Sub.get(M); | |||
643 | TypeSetByHwMode::SetType &V = Vec.get(M); | |||
644 | ||||
645 | Changed |= berase_if(S, isScalar); | |||
646 | ||||
647 | // Erase all types from S that are not sub-vectors of a type in V. | |||
648 | Changed |= berase_if(S, std::bind(NoSubV, V, std::placeholders::_1)); | |||
649 | ||||
650 | // Erase all types from V that are not super-vectors of a type in S. | |||
651 | Changed |= berase_if(V, std::bind(NoSupV, S, std::placeholders::_1)); | |||
652 | } | |||
653 | ||||
654 | return Changed; | |||
655 | } | |||
656 | ||||
657 | /// 1. Ensure that V has a scalar type iff W has a scalar type. | |||
658 | /// 2. Ensure that for each vector type T in V, there exists a vector | |||
659 | /// type U in W, such that T and U have the same number of elements. | |||
660 | /// 3. Ensure that for each vector type U in W, there exists a vector | |||
661 | /// type T in V, such that T and U have the same number of elements | |||
662 | /// (reverse of 2). | |||
663 | bool TypeInfer::EnforceSameNumElts(TypeSetByHwMode &V, TypeSetByHwMode &W) { | |||
664 | ValidateOnExit _1(V, *this), _2(W, *this); | |||
665 | if (TP.hasError()) | |||
666 | return false; | |||
667 | ||||
668 | bool Changed = false; | |||
669 | if (V.empty()) | |||
670 | Changed |= EnforceAny(V); | |||
671 | if (W.empty()) | |||
672 | Changed |= EnforceAny(W); | |||
673 | ||||
674 | // An actual vector type cannot have 0 elements, so we can treat scalars | |||
675 | // as zero-length vectors. This way both vectors and scalars can be | |||
676 | // processed identically. | |||
677 | auto NoLength = [](const SmallSet<unsigned,2> &Lengths, MVT T) -> bool { | |||
678 | return !Lengths.count(T.isVector() ? T.getVectorNumElements() : 0); | |||
679 | }; | |||
680 | ||||
681 | for (unsigned M : union_modes(V, W)) { | |||
682 | TypeSetByHwMode::SetType &VS = V.get(M); | |||
683 | TypeSetByHwMode::SetType &WS = W.get(M); | |||
684 | ||||
685 | SmallSet<unsigned,2> VN, WN; | |||
686 | for (MVT T : VS) | |||
687 | VN.insert(T.isVector() ? T.getVectorNumElements() : 0); | |||
688 | for (MVT T : WS) | |||
689 | WN.insert(T.isVector() ? T.getVectorNumElements() : 0); | |||
690 | ||||
691 | Changed |= berase_if(VS, std::bind(NoLength, WN, std::placeholders::_1)); | |||
692 | Changed |= berase_if(WS, std::bind(NoLength, VN, std::placeholders::_1)); | |||
693 | } | |||
694 | return Changed; | |||
695 | } | |||
696 | ||||
697 | /// 1. Ensure that for each type T in A, there exists a type U in B, | |||
698 | /// such that T and U have equal size in bits. | |||
699 | /// 2. Ensure that for each type U in B, there exists a type T in A | |||
700 | /// such that T and U have equal size in bits (reverse of 1). | |||
701 | bool TypeInfer::EnforceSameSize(TypeSetByHwMode &A, TypeSetByHwMode &B) { | |||
702 | ValidateOnExit _1(A, *this), _2(B, *this); | |||
703 | if (TP.hasError()) | |||
704 | return false; | |||
705 | bool Changed = false; | |||
706 | if (A.empty()) | |||
707 | Changed |= EnforceAny(A); | |||
708 | if (B.empty()) | |||
709 | Changed |= EnforceAny(B); | |||
710 | ||||
711 | auto NoSize = [](const SmallSet<unsigned,2> &Sizes, MVT T) -> bool { | |||
712 | return !Sizes.count(T.getSizeInBits()); | |||
713 | }; | |||
714 | ||||
715 | for (unsigned M : union_modes(A, B)) { | |||
716 | TypeSetByHwMode::SetType &AS = A.get(M); | |||
717 | TypeSetByHwMode::SetType &BS = B.get(M); | |||
718 | SmallSet<unsigned,2> AN, BN; | |||
719 | ||||
720 | for (MVT T : AS) | |||
721 | AN.insert(T.getSizeInBits()); | |||
722 | for (MVT T : BS) | |||
723 | BN.insert(T.getSizeInBits()); | |||
724 | ||||
725 | Changed |= berase_if(AS, std::bind(NoSize, BN, std::placeholders::_1)); | |||
726 | Changed |= berase_if(BS, std::bind(NoSize, AN, std::placeholders::_1)); | |||
727 | } | |||
728 | ||||
729 | return Changed; | |||
730 | } | |||
731 | ||||
732 | void TypeInfer::expandOverloads(TypeSetByHwMode &VTS) { | |||
733 | ValidateOnExit _1(VTS, *this); | |||
734 | TypeSetByHwMode Legal = getLegalTypes(); | |||
735 | bool HaveLegalDef = Legal.hasDefault(); | |||
736 | ||||
737 | for (auto &I : VTS) { | |||
738 | unsigned M = I.first; | |||
739 | if (!Legal.hasMode(M) && !HaveLegalDef) { | |||
740 | TP.error("Invalid mode " + Twine(M)); | |||
741 | return; | |||
742 | } | |||
743 | expandOverloads(I.second, Legal.get(M)); | |||
744 | } | |||
745 | } | |||
746 | ||||
747 | void TypeInfer::expandOverloads(TypeSetByHwMode::SetType &Out, | |||
748 | const TypeSetByHwMode::SetType &Legal) { | |||
749 | std::set<MVT> Ovs; | |||
750 | for (MVT T : Out) { | |||
751 | if (!T.isOverloaded()) | |||
752 | continue; | |||
753 | ||||
754 | Ovs.insert(T); | |||
755 | // MachineValueTypeSet allows iteration and erasing. | |||
756 | Out.erase(T); | |||
757 | } | |||
758 | ||||
759 | for (MVT Ov : Ovs) { | |||
760 | switch (Ov.SimpleTy) { | |||
761 | case MVT::iPTRAny: | |||
762 | Out.insert(MVT::iPTR); | |||
763 | return; | |||
764 | case MVT::iAny: | |||
765 | for (MVT T : MVT::integer_valuetypes()) | |||
766 | if (Legal.count(T)) | |||
767 | Out.insert(T); | |||
768 | for (MVT T : MVT::integer_vector_valuetypes()) | |||
769 | if (Legal.count(T)) | |||
770 | Out.insert(T); | |||
771 | return; | |||
772 | case MVT::fAny: | |||
773 | for (MVT T : MVT::fp_valuetypes()) | |||
774 | if (Legal.count(T)) | |||
775 | Out.insert(T); | |||
776 | for (MVT T : MVT::fp_vector_valuetypes()) | |||
777 | if (Legal.count(T)) | |||
778 | Out.insert(T); | |||
779 | return; | |||
780 | case MVT::vAny: | |||
781 | for (MVT T : MVT::vector_valuetypes()) | |||
782 | if (Legal.count(T)) | |||
783 | Out.insert(T); | |||
784 | return; | |||
785 | case MVT::Any: | |||
786 | for (MVT T : MVT::all_valuetypes()) | |||
787 | if (Legal.count(T)) | |||
788 | Out.insert(T); | |||
789 | return; | |||
790 | default: | |||
791 | break; | |||
792 | } | |||
793 | } | |||
794 | } | |||
795 | ||||
796 | TypeSetByHwMode TypeInfer::getLegalTypes() { | |||
797 | if (!LegalTypesCached) { | |||
798 | // Stuff all types from all modes into the default mode. | |||
799 | const TypeSetByHwMode <S = TP.getDAGPatterns().getLegalTypes(); | |||
800 | for (const auto &I : LTS) | |||
801 | LegalCache.insert(I.second); | |||
802 | LegalTypesCached = true; | |||
803 | } | |||
804 | TypeSetByHwMode VTS; | |||
805 | VTS.getOrCreate(DefaultMode) = LegalCache; | |||
806 | return VTS; | |||
807 | } | |||
808 | ||||
809 | #ifndef NDEBUG | |||
810 | TypeInfer::ValidateOnExit::~ValidateOnExit() { | |||
811 | if (!VTS.validate()) { | |||
812 | dbgs() << "Type set is empty for each HW mode:\n" | |||
813 | "possible type contradiction in the pattern below " | |||
814 | "(use -print-records with llvm-tblgen to see all " | |||
815 | "expanded records).\n"; | |||
816 | Infer.TP.dump(); | |||
817 | llvm_unreachable(nullptr)::llvm::llvm_unreachable_internal(nullptr, "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 817); | |||
818 | } | |||
819 | } | |||
820 | #endif | |||
821 | ||||
822 | //===----------------------------------------------------------------------===// | |||
823 | // TreePredicateFn Implementation | |||
824 | //===----------------------------------------------------------------------===// | |||
825 | ||||
826 | /// TreePredicateFn constructor. Here 'N' is a subclass of PatFrag. | |||
827 | TreePredicateFn::TreePredicateFn(TreePattern *N) : PatFragRec(N) { | |||
828 | assert((static_cast <bool> ((!hasPredCode() || !hasImmCode()) && ".td file corrupt: can't have a node predicate *and* an imm predicate" ) ? void (0) : __assert_fail ("(!hasPredCode() || !hasImmCode()) && \".td file corrupt: can't have a node predicate *and* an imm predicate\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 830, __extension__ __PRETTY_FUNCTION__)) | |||
829 | (!hasPredCode() || !hasImmCode()) &&(static_cast <bool> ((!hasPredCode() || !hasImmCode()) && ".td file corrupt: can't have a node predicate *and* an imm predicate" ) ? void (0) : __assert_fail ("(!hasPredCode() || !hasImmCode()) && \".td file corrupt: can't have a node predicate *and* an imm predicate\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 830, __extension__ __PRETTY_FUNCTION__)) | |||
830 | ".td file corrupt: can't have a node predicate *and* an imm predicate")(static_cast <bool> ((!hasPredCode() || !hasImmCode()) && ".td file corrupt: can't have a node predicate *and* an imm predicate" ) ? void (0) : __assert_fail ("(!hasPredCode() || !hasImmCode()) && \".td file corrupt: can't have a node predicate *and* an imm predicate\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 830, __extension__ __PRETTY_FUNCTION__)); | |||
831 | } | |||
832 | ||||
833 | bool TreePredicateFn::hasPredCode() const { | |||
834 | return isLoad() || isStore() || isAtomic() || | |||
835 | !PatFragRec->getRecord()->getValueAsString("PredicateCode").empty(); | |||
836 | } | |||
837 | ||||
838 | std::string TreePredicateFn::getPredCode() const { | |||
839 | std::string Code = ""; | |||
840 | ||||
841 | if (!isLoad() && !isStore() && !isAtomic()) { | |||
842 | Record *MemoryVT = getMemoryVT(); | |||
843 | ||||
844 | if (MemoryVT) | |||
845 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
846 | "MemoryVT requires IsLoad or IsStore"); | |||
847 | } | |||
848 | ||||
849 | if (!isLoad() && !isStore()) { | |||
850 | if (isUnindexed()) | |||
851 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
852 | "IsUnindexed requires IsLoad or IsStore"); | |||
853 | ||||
854 | Record *ScalarMemoryVT = getScalarMemoryVT(); | |||
855 | ||||
856 | if (ScalarMemoryVT) | |||
857 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
858 | "ScalarMemoryVT requires IsLoad or IsStore"); | |||
859 | } | |||
860 | ||||
861 | if (isLoad() + isStore() + isAtomic() > 1) | |||
862 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
863 | "IsLoad, IsStore, and IsAtomic are mutually exclusive"); | |||
864 | ||||
865 | if (isLoad()) { | |||
866 | if (!isUnindexed() && !isNonExtLoad() && !isAnyExtLoad() && | |||
867 | !isSignExtLoad() && !isZeroExtLoad() && getMemoryVT() == nullptr && | |||
868 | getScalarMemoryVT() == nullptr) | |||
869 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
870 | "IsLoad cannot be used by itself"); | |||
871 | } else { | |||
872 | if (isNonExtLoad()) | |||
873 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
874 | "IsNonExtLoad requires IsLoad"); | |||
875 | if (isAnyExtLoad()) | |||
876 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
877 | "IsAnyExtLoad requires IsLoad"); | |||
878 | if (isSignExtLoad()) | |||
879 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
880 | "IsSignExtLoad requires IsLoad"); | |||
881 | if (isZeroExtLoad()) | |||
882 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
883 | "IsZeroExtLoad requires IsLoad"); | |||
884 | } | |||
885 | ||||
886 | if (isStore()) { | |||
887 | if (!isUnindexed() && !isTruncStore() && !isNonTruncStore() && | |||
888 | getMemoryVT() == nullptr && getScalarMemoryVT() == nullptr) | |||
889 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
890 | "IsStore cannot be used by itself"); | |||
891 | } else { | |||
892 | if (isNonTruncStore()) | |||
893 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
894 | "IsNonTruncStore requires IsStore"); | |||
895 | if (isTruncStore()) | |||
896 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
897 | "IsTruncStore requires IsStore"); | |||
898 | } | |||
899 | ||||
900 | if (isAtomic()) { | |||
901 | if (getMemoryVT() == nullptr && !isAtomicOrderingMonotonic() && | |||
902 | !isAtomicOrderingAcquire() && !isAtomicOrderingRelease() && | |||
903 | !isAtomicOrderingAcquireRelease() && | |||
904 | !isAtomicOrderingSequentiallyConsistent() && | |||
905 | !isAtomicOrderingAcquireOrStronger() && | |||
906 | !isAtomicOrderingReleaseOrStronger() && | |||
907 | !isAtomicOrderingWeakerThanAcquire() && | |||
908 | !isAtomicOrderingWeakerThanRelease()) | |||
909 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
910 | "IsAtomic cannot be used by itself"); | |||
911 | } else { | |||
912 | if (isAtomicOrderingMonotonic()) | |||
913 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
914 | "IsAtomicOrderingMonotonic requires IsAtomic"); | |||
915 | if (isAtomicOrderingAcquire()) | |||
916 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
917 | "IsAtomicOrderingAcquire requires IsAtomic"); | |||
918 | if (isAtomicOrderingRelease()) | |||
919 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
920 | "IsAtomicOrderingRelease requires IsAtomic"); | |||
921 | if (isAtomicOrderingAcquireRelease()) | |||
922 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
923 | "IsAtomicOrderingAcquireRelease requires IsAtomic"); | |||
924 | if (isAtomicOrderingSequentiallyConsistent()) | |||
925 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
926 | "IsAtomicOrderingSequentiallyConsistent requires IsAtomic"); | |||
927 | if (isAtomicOrderingAcquireOrStronger()) | |||
928 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
929 | "IsAtomicOrderingAcquireOrStronger requires IsAtomic"); | |||
930 | if (isAtomicOrderingReleaseOrStronger()) | |||
931 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
932 | "IsAtomicOrderingReleaseOrStronger requires IsAtomic"); | |||
933 | if (isAtomicOrderingWeakerThanAcquire()) | |||
934 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
935 | "IsAtomicOrderingWeakerThanAcquire requires IsAtomic"); | |||
936 | } | |||
937 | ||||
938 | if (isLoad() || isStore() || isAtomic()) { | |||
939 | StringRef SDNodeName = | |||
940 | isLoad() ? "LoadSDNode" : isStore() ? "StoreSDNode" : "AtomicSDNode"; | |||
941 | ||||
942 | Record *MemoryVT = getMemoryVT(); | |||
943 | ||||
944 | if (MemoryVT) | |||
945 | Code += ("if (cast<" + SDNodeName + ">(N)->getMemoryVT() != MVT::" + | |||
946 | MemoryVT->getName() + ") return false;\n") | |||
947 | .str(); | |||
948 | } | |||
949 | ||||
950 | if (isAtomic() && isAtomicOrderingMonotonic()) | |||
951 | Code += "if (cast<AtomicSDNode>(N)->getOrdering() != " | |||
952 | "AtomicOrdering::Monotonic) return false;\n"; | |||
953 | if (isAtomic() && isAtomicOrderingAcquire()) | |||
954 | Code += "if (cast<AtomicSDNode>(N)->getOrdering() != " | |||
955 | "AtomicOrdering::Acquire) return false;\n"; | |||
956 | if (isAtomic() && isAtomicOrderingRelease()) | |||
957 | Code += "if (cast<AtomicSDNode>(N)->getOrdering() != " | |||
958 | "AtomicOrdering::Release) return false;\n"; | |||
959 | if (isAtomic() && isAtomicOrderingAcquireRelease()) | |||
960 | Code += "if (cast<AtomicSDNode>(N)->getOrdering() != " | |||
961 | "AtomicOrdering::AcquireRelease) return false;\n"; | |||
962 | if (isAtomic() && isAtomicOrderingSequentiallyConsistent()) | |||
963 | Code += "if (cast<AtomicSDNode>(N)->getOrdering() != " | |||
964 | "AtomicOrdering::SequentiallyConsistent) return false;\n"; | |||
965 | ||||
966 | if (isAtomic() && isAtomicOrderingAcquireOrStronger()) | |||
967 | Code += "if (!isAcquireOrStronger(cast<AtomicSDNode>(N)->getOrdering())) " | |||
968 | "return false;\n"; | |||
969 | if (isAtomic() && isAtomicOrderingWeakerThanAcquire()) | |||
970 | Code += "if (isAcquireOrStronger(cast<AtomicSDNode>(N)->getOrdering())) " | |||
971 | "return false;\n"; | |||
972 | ||||
973 | if (isAtomic() && isAtomicOrderingReleaseOrStronger()) | |||
974 | Code += "if (!isReleaseOrStronger(cast<AtomicSDNode>(N)->getOrdering())) " | |||
975 | "return false;\n"; | |||
976 | if (isAtomic() && isAtomicOrderingWeakerThanRelease()) | |||
977 | Code += "if (isReleaseOrStronger(cast<AtomicSDNode>(N)->getOrdering())) " | |||
978 | "return false;\n"; | |||
979 | ||||
980 | if (isLoad() || isStore()) { | |||
981 | StringRef SDNodeName = isLoad() ? "LoadSDNode" : "StoreSDNode"; | |||
982 | ||||
983 | if (isUnindexed()) | |||
984 | Code += ("if (cast<" + SDNodeName + | |||
985 | ">(N)->getAddressingMode() != ISD::UNINDEXED) " | |||
986 | "return false;\n") | |||
987 | .str(); | |||
988 | ||||
989 | if (isLoad()) { | |||
990 | if ((isNonExtLoad() + isAnyExtLoad() + isSignExtLoad() + | |||
991 | isZeroExtLoad()) > 1) | |||
992 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
993 | "IsNonExtLoad, IsAnyExtLoad, IsSignExtLoad, and " | |||
994 | "IsZeroExtLoad are mutually exclusive"); | |||
995 | if (isNonExtLoad()) | |||
996 | Code += "if (cast<LoadSDNode>(N)->getExtensionType() != " | |||
997 | "ISD::NON_EXTLOAD) return false;\n"; | |||
998 | if (isAnyExtLoad()) | |||
999 | Code += "if (cast<LoadSDNode>(N)->getExtensionType() != ISD::EXTLOAD) " | |||
1000 | "return false;\n"; | |||
1001 | if (isSignExtLoad()) | |||
1002 | Code += "if (cast<LoadSDNode>(N)->getExtensionType() != ISD::SEXTLOAD) " | |||
1003 | "return false;\n"; | |||
1004 | if (isZeroExtLoad()) | |||
1005 | Code += "if (cast<LoadSDNode>(N)->getExtensionType() != ISD::ZEXTLOAD) " | |||
1006 | "return false;\n"; | |||
1007 | } else { | |||
1008 | if ((isNonTruncStore() + isTruncStore()) > 1) | |||
1009 | PrintFatalError( | |||
1010 | getOrigPatFragRecord()->getRecord()->getLoc(), | |||
1011 | "IsNonTruncStore, and IsTruncStore are mutually exclusive"); | |||
1012 | if (isNonTruncStore()) | |||
1013 | Code += | |||
1014 | " if (cast<StoreSDNode>(N)->isTruncatingStore()) return false;\n"; | |||
1015 | if (isTruncStore()) | |||
1016 | Code += | |||
1017 | " if (!cast<StoreSDNode>(N)->isTruncatingStore()) return false;\n"; | |||
1018 | } | |||
1019 | ||||
1020 | Record *ScalarMemoryVT = getScalarMemoryVT(); | |||
1021 | ||||
1022 | if (ScalarMemoryVT) | |||
1023 | Code += ("if (cast<" + SDNodeName + | |||
1024 | ">(N)->getMemoryVT().getScalarType() != MVT::" + | |||
1025 | ScalarMemoryVT->getName() + ") return false;\n") | |||
1026 | .str(); | |||
1027 | } | |||
1028 | ||||
1029 | std::string PredicateCode = PatFragRec->getRecord()->getValueAsString("PredicateCode"); | |||
1030 | ||||
1031 | Code += PredicateCode; | |||
1032 | ||||
1033 | if (PredicateCode.empty() && !Code.empty()) | |||
1034 | Code += "return true;\n"; | |||
1035 | ||||
1036 | return Code; | |||
1037 | } | |||
1038 | ||||
1039 | bool TreePredicateFn::hasImmCode() const { | |||
1040 | return !PatFragRec->getRecord()->getValueAsString("ImmediateCode").empty(); | |||
1041 | } | |||
1042 | ||||
1043 | std::string TreePredicateFn::getImmCode() const { | |||
1044 | return PatFragRec->getRecord()->getValueAsString("ImmediateCode"); | |||
1045 | } | |||
1046 | ||||
1047 | bool TreePredicateFn::immCodeUsesAPInt() const { | |||
1048 | return getOrigPatFragRecord()->getRecord()->getValueAsBit("IsAPInt"); | |||
1049 | } | |||
1050 | ||||
1051 | bool TreePredicateFn::immCodeUsesAPFloat() const { | |||
1052 | bool Unset; | |||
1053 | // The return value will be false when IsAPFloat is unset. | |||
1054 | return getOrigPatFragRecord()->getRecord()->getValueAsBitOrUnset("IsAPFloat", | |||
1055 | Unset); | |||
1056 | } | |||
1057 | ||||
1058 | bool TreePredicateFn::isPredefinedPredicateEqualTo(StringRef Field, | |||
1059 | bool Value) const { | |||
1060 | bool Unset; | |||
1061 | bool Result = | |||
1062 | getOrigPatFragRecord()->getRecord()->getValueAsBitOrUnset(Field, Unset); | |||
1063 | if (Unset) | |||
1064 | return false; | |||
1065 | return Result == Value; | |||
1066 | } | |||
1067 | bool TreePredicateFn::isLoad() const { | |||
1068 | return isPredefinedPredicateEqualTo("IsLoad", true); | |||
1069 | } | |||
1070 | bool TreePredicateFn::isStore() const { | |||
1071 | return isPredefinedPredicateEqualTo("IsStore", true); | |||
1072 | } | |||
1073 | bool TreePredicateFn::isAtomic() const { | |||
1074 | return isPredefinedPredicateEqualTo("IsAtomic", true); | |||
1075 | } | |||
1076 | bool TreePredicateFn::isUnindexed() const { | |||
1077 | return isPredefinedPredicateEqualTo("IsUnindexed", true); | |||
1078 | } | |||
1079 | bool TreePredicateFn::isNonExtLoad() const { | |||
1080 | return isPredefinedPredicateEqualTo("IsNonExtLoad", true); | |||
1081 | } | |||
1082 | bool TreePredicateFn::isAnyExtLoad() const { | |||
1083 | return isPredefinedPredicateEqualTo("IsAnyExtLoad", true); | |||
1084 | } | |||
1085 | bool TreePredicateFn::isSignExtLoad() const { | |||
1086 | return isPredefinedPredicateEqualTo("IsSignExtLoad", true); | |||
1087 | } | |||
1088 | bool TreePredicateFn::isZeroExtLoad() const { | |||
1089 | return isPredefinedPredicateEqualTo("IsZeroExtLoad", true); | |||
1090 | } | |||
1091 | bool TreePredicateFn::isNonTruncStore() const { | |||
1092 | return isPredefinedPredicateEqualTo("IsTruncStore", false); | |||
1093 | } | |||
1094 | bool TreePredicateFn::isTruncStore() const { | |||
1095 | return isPredefinedPredicateEqualTo("IsTruncStore", true); | |||
1096 | } | |||
1097 | bool TreePredicateFn::isAtomicOrderingMonotonic() const { | |||
1098 | return isPredefinedPredicateEqualTo("IsAtomicOrderingMonotonic", true); | |||
1099 | } | |||
1100 | bool TreePredicateFn::isAtomicOrderingAcquire() const { | |||
1101 | return isPredefinedPredicateEqualTo("IsAtomicOrderingAcquire", true); | |||
1102 | } | |||
1103 | bool TreePredicateFn::isAtomicOrderingRelease() const { | |||
1104 | return isPredefinedPredicateEqualTo("IsAtomicOrderingRelease", true); | |||
1105 | } | |||
1106 | bool TreePredicateFn::isAtomicOrderingAcquireRelease() const { | |||
1107 | return isPredefinedPredicateEqualTo("IsAtomicOrderingAcquireRelease", true); | |||
1108 | } | |||
1109 | bool TreePredicateFn::isAtomicOrderingSequentiallyConsistent() const { | |||
1110 | return isPredefinedPredicateEqualTo("IsAtomicOrderingSequentiallyConsistent", | |||
1111 | true); | |||
1112 | } | |||
1113 | bool TreePredicateFn::isAtomicOrderingAcquireOrStronger() const { | |||
1114 | return isPredefinedPredicateEqualTo("IsAtomicOrderingAcquireOrStronger", true); | |||
1115 | } | |||
1116 | bool TreePredicateFn::isAtomicOrderingWeakerThanAcquire() const { | |||
1117 | return isPredefinedPredicateEqualTo("IsAtomicOrderingAcquireOrStronger", false); | |||
1118 | } | |||
1119 | bool TreePredicateFn::isAtomicOrderingReleaseOrStronger() const { | |||
1120 | return isPredefinedPredicateEqualTo("IsAtomicOrderingReleaseOrStronger", true); | |||
1121 | } | |||
1122 | bool TreePredicateFn::isAtomicOrderingWeakerThanRelease() const { | |||
1123 | return isPredefinedPredicateEqualTo("IsAtomicOrderingReleaseOrStronger", false); | |||
1124 | } | |||
1125 | Record *TreePredicateFn::getMemoryVT() const { | |||
1126 | Record *R = getOrigPatFragRecord()->getRecord(); | |||
1127 | if (R->isValueUnset("MemoryVT")) | |||
1128 | return nullptr; | |||
1129 | return R->getValueAsDef("MemoryVT"); | |||
1130 | } | |||
1131 | Record *TreePredicateFn::getScalarMemoryVT() const { | |||
1132 | Record *R = getOrigPatFragRecord()->getRecord(); | |||
1133 | if (R->isValueUnset("ScalarMemoryVT")) | |||
1134 | return nullptr; | |||
1135 | return R->getValueAsDef("ScalarMemoryVT"); | |||
1136 | } | |||
1137 | ||||
1138 | StringRef TreePredicateFn::getImmType() const { | |||
1139 | if (immCodeUsesAPInt()) | |||
1140 | return "const APInt &"; | |||
1141 | if (immCodeUsesAPFloat()) | |||
1142 | return "const APFloat &"; | |||
1143 | return "int64_t"; | |||
1144 | } | |||
1145 | ||||
1146 | StringRef TreePredicateFn::getImmTypeIdentifier() const { | |||
1147 | if (immCodeUsesAPInt()) | |||
1148 | return "APInt"; | |||
1149 | else if (immCodeUsesAPFloat()) | |||
1150 | return "APFloat"; | |||
1151 | return "I64"; | |||
1152 | } | |||
1153 | ||||
1154 | /// isAlwaysTrue - Return true if this is a noop predicate. | |||
1155 | bool TreePredicateFn::isAlwaysTrue() const { | |||
1156 | return !hasPredCode() && !hasImmCode(); | |||
1157 | } | |||
1158 | ||||
1159 | /// Return the name to use in the generated code to reference this, this is | |||
1160 | /// "Predicate_foo" if from a pattern fragment "foo". | |||
1161 | std::string TreePredicateFn::getFnName() const { | |||
1162 | return "Predicate_" + PatFragRec->getRecord()->getName().str(); | |||
1163 | } | |||
1164 | ||||
1165 | /// getCodeToRunOnSDNode - Return the code for the function body that | |||
1166 | /// evaluates this predicate. The argument is expected to be in "Node", | |||
1167 | /// not N. This handles casting and conversion to a concrete node type as | |||
1168 | /// appropriate. | |||
1169 | std::string TreePredicateFn::getCodeToRunOnSDNode() const { | |||
1170 | // Handle immediate predicates first. | |||
1171 | std::string ImmCode = getImmCode(); | |||
1172 | if (!ImmCode.empty()) { | |||
1173 | if (isLoad()) | |||
1174 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
1175 | "IsLoad cannot be used with ImmLeaf or its subclasses"); | |||
1176 | if (isStore()) | |||
1177 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
1178 | "IsStore cannot be used with ImmLeaf or its subclasses"); | |||
1179 | if (isUnindexed()) | |||
1180 | PrintFatalError( | |||
1181 | getOrigPatFragRecord()->getRecord()->getLoc(), | |||
1182 | "IsUnindexed cannot be used with ImmLeaf or its subclasses"); | |||
1183 | if (isNonExtLoad()) | |||
1184 | PrintFatalError( | |||
1185 | getOrigPatFragRecord()->getRecord()->getLoc(), | |||
1186 | "IsNonExtLoad cannot be used with ImmLeaf or its subclasses"); | |||
1187 | if (isAnyExtLoad()) | |||
1188 | PrintFatalError( | |||
1189 | getOrigPatFragRecord()->getRecord()->getLoc(), | |||
1190 | "IsAnyExtLoad cannot be used with ImmLeaf or its subclasses"); | |||
1191 | if (isSignExtLoad()) | |||
1192 | PrintFatalError( | |||
1193 | getOrigPatFragRecord()->getRecord()->getLoc(), | |||
1194 | "IsSignExtLoad cannot be used with ImmLeaf or its subclasses"); | |||
1195 | if (isZeroExtLoad()) | |||
1196 | PrintFatalError( | |||
1197 | getOrigPatFragRecord()->getRecord()->getLoc(), | |||
1198 | "IsZeroExtLoad cannot be used with ImmLeaf or its subclasses"); | |||
1199 | if (isNonTruncStore()) | |||
1200 | PrintFatalError( | |||
1201 | getOrigPatFragRecord()->getRecord()->getLoc(), | |||
1202 | "IsNonTruncStore cannot be used with ImmLeaf or its subclasses"); | |||
1203 | if (isTruncStore()) | |||
1204 | PrintFatalError( | |||
1205 | getOrigPatFragRecord()->getRecord()->getLoc(), | |||
1206 | "IsTruncStore cannot be used with ImmLeaf or its subclasses"); | |||
1207 | if (getMemoryVT()) | |||
1208 | PrintFatalError(getOrigPatFragRecord()->getRecord()->getLoc(), | |||
1209 | "MemoryVT cannot be used with ImmLeaf or its subclasses"); | |||
1210 | if (getScalarMemoryVT()) | |||
1211 | PrintFatalError( | |||
1212 | getOrigPatFragRecord()->getRecord()->getLoc(), | |||
1213 | "ScalarMemoryVT cannot be used with ImmLeaf or its subclasses"); | |||
1214 | ||||
1215 | std::string Result = (" " + getImmType() + " Imm = ").str(); | |||
1216 | if (immCodeUsesAPFloat()) | |||
1217 | Result += "cast<ConstantFPSDNode>(Node)->getValueAPF();\n"; | |||
1218 | else if (immCodeUsesAPInt()) | |||
1219 | Result += "cast<ConstantSDNode>(Node)->getAPIntValue();\n"; | |||
1220 | else | |||
1221 | Result += "cast<ConstantSDNode>(Node)->getSExtValue();\n"; | |||
1222 | return Result + ImmCode; | |||
1223 | } | |||
1224 | ||||
1225 | // Handle arbitrary node predicates. | |||
1226 | assert(hasPredCode() && "Don't have any predicate code!")(static_cast <bool> (hasPredCode() && "Don't have any predicate code!" ) ? void (0) : __assert_fail ("hasPredCode() && \"Don't have any predicate code!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 1226, __extension__ __PRETTY_FUNCTION__)); | |||
1227 | StringRef ClassName; | |||
1228 | if (PatFragRec->getOnlyTree()->isLeaf()) | |||
1229 | ClassName = "SDNode"; | |||
1230 | else { | |||
1231 | Record *Op = PatFragRec->getOnlyTree()->getOperator(); | |||
1232 | ClassName = PatFragRec->getDAGPatterns().getSDNodeInfo(Op).getSDClassName(); | |||
1233 | } | |||
1234 | std::string Result; | |||
1235 | if (ClassName == "SDNode") | |||
1236 | Result = " SDNode *N = Node;\n"; | |||
1237 | else | |||
1238 | Result = " auto *N = cast<" + ClassName.str() + ">(Node);\n"; | |||
1239 | ||||
1240 | return Result + getPredCode(); | |||
1241 | } | |||
1242 | ||||
1243 | //===----------------------------------------------------------------------===// | |||
1244 | // PatternToMatch implementation | |||
1245 | // | |||
1246 | ||||
1247 | /// getPatternSize - Return the 'size' of this pattern. We want to match large | |||
1248 | /// patterns before small ones. This is used to determine the size of a | |||
1249 | /// pattern. | |||
1250 | static unsigned getPatternSize(const TreePatternNode *P, | |||
1251 | const CodeGenDAGPatterns &CGP) { | |||
1252 | unsigned Size = 3; // The node itself. | |||
1253 | // If the root node is a ConstantSDNode, increases its size. | |||
1254 | // e.g. (set R32:$dst, 0). | |||
1255 | if (P->isLeaf() && isa<IntInit>(P->getLeafValue())) | |||
1256 | Size += 2; | |||
1257 | ||||
1258 | if (const ComplexPattern *AM = P->getComplexPatternInfo(CGP)) { | |||
1259 | Size += AM->getComplexity(); | |||
1260 | // We don't want to count any children twice, so return early. | |||
1261 | return Size; | |||
1262 | } | |||
1263 | ||||
1264 | // If this node has some predicate function that must match, it adds to the | |||
1265 | // complexity of this node. | |||
1266 | if (!P->getPredicateFns().empty()) | |||
1267 | ++Size; | |||
1268 | ||||
1269 | // Count children in the count if they are also nodes. | |||
1270 | for (unsigned i = 0, e = P->getNumChildren(); i != e; ++i) { | |||
1271 | const TreePatternNode *Child = P->getChild(i); | |||
1272 | if (!Child->isLeaf() && Child->getNumTypes()) { | |||
1273 | const TypeSetByHwMode &T0 = Child->getType(0); | |||
1274 | // At this point, all variable type sets should be simple, i.e. only | |||
1275 | // have a default mode. | |||
1276 | if (T0.getMachineValueType() != MVT::Other) { | |||
1277 | Size += getPatternSize(Child, CGP); | |||
1278 | continue; | |||
1279 | } | |||
1280 | } | |||
1281 | if (Child->isLeaf()) { | |||
1282 | if (isa<IntInit>(Child->getLeafValue())) | |||
1283 | Size += 5; // Matches a ConstantSDNode (+3) and a specific value (+2). | |||
1284 | else if (Child->getComplexPatternInfo(CGP)) | |||
1285 | Size += getPatternSize(Child, CGP); | |||
1286 | else if (!Child->getPredicateFns().empty()) | |||
1287 | ++Size; | |||
1288 | } | |||
1289 | } | |||
1290 | ||||
1291 | return Size; | |||
1292 | } | |||
1293 | ||||
1294 | /// Compute the complexity metric for the input pattern. This roughly | |||
1295 | /// corresponds to the number of nodes that are covered. | |||
1296 | int PatternToMatch:: | |||
1297 | getPatternComplexity(const CodeGenDAGPatterns &CGP) const { | |||
1298 | return getPatternSize(getSrcPattern(), CGP) + getAddedComplexity(); | |||
1299 | } | |||
1300 | ||||
1301 | /// getPredicateCheck - Return a single string containing all of this | |||
1302 | /// pattern's predicates concatenated with "&&" operators. | |||
1303 | /// | |||
1304 | std::string PatternToMatch::getPredicateCheck() const { | |||
1305 | SmallVector<const Predicate*,4> PredList; | |||
1306 | for (const Predicate &P : Predicates) | |||
1307 | PredList.push_back(&P); | |||
1308 | llvm::sort(PredList.begin(), PredList.end(), deref<llvm::less>()); | |||
1309 | ||||
1310 | std::string Check; | |||
1311 | for (unsigned i = 0, e = PredList.size(); i != e; ++i) { | |||
1312 | if (i != 0) | |||
1313 | Check += " && "; | |||
1314 | Check += '(' + PredList[i]->getCondString() + ')'; | |||
1315 | } | |||
1316 | return Check; | |||
1317 | } | |||
1318 | ||||
1319 | //===----------------------------------------------------------------------===// | |||
1320 | // SDTypeConstraint implementation | |||
1321 | // | |||
1322 | ||||
1323 | SDTypeConstraint::SDTypeConstraint(Record *R, const CodeGenHwModes &CGH) { | |||
1324 | OperandNo = R->getValueAsInt("OperandNum"); | |||
1325 | ||||
1326 | if (R->isSubClassOf("SDTCisVT")) { | |||
1327 | ConstraintType = SDTCisVT; | |||
1328 | VVT = getValueTypeByHwMode(R->getValueAsDef("VT"), CGH); | |||
1329 | for (const auto &P : VVT) | |||
1330 | if (P.second == MVT::isVoid) | |||
1331 | PrintFatalError(R->getLoc(), "Cannot use 'Void' as type to SDTCisVT"); | |||
1332 | } else if (R->isSubClassOf("SDTCisPtrTy")) { | |||
1333 | ConstraintType = SDTCisPtrTy; | |||
1334 | } else if (R->isSubClassOf("SDTCisInt")) { | |||
1335 | ConstraintType = SDTCisInt; | |||
1336 | } else if (R->isSubClassOf("SDTCisFP")) { | |||
1337 | ConstraintType = SDTCisFP; | |||
1338 | } else if (R->isSubClassOf("SDTCisVec")) { | |||
1339 | ConstraintType = SDTCisVec; | |||
1340 | } else if (R->isSubClassOf("SDTCisSameAs")) { | |||
1341 | ConstraintType = SDTCisSameAs; | |||
1342 | x.SDTCisSameAs_Info.OtherOperandNum = R->getValueAsInt("OtherOperandNum"); | |||
1343 | } else if (R->isSubClassOf("SDTCisVTSmallerThanOp")) { | |||
1344 | ConstraintType = SDTCisVTSmallerThanOp; | |||
1345 | x.SDTCisVTSmallerThanOp_Info.OtherOperandNum = | |||
1346 | R->getValueAsInt("OtherOperandNum"); | |||
1347 | } else if (R->isSubClassOf("SDTCisOpSmallerThanOp")) { | |||
1348 | ConstraintType = SDTCisOpSmallerThanOp; | |||
1349 | x.SDTCisOpSmallerThanOp_Info.BigOperandNum = | |||
1350 | R->getValueAsInt("BigOperandNum"); | |||
1351 | } else if (R->isSubClassOf("SDTCisEltOfVec")) { | |||
1352 | ConstraintType = SDTCisEltOfVec; | |||
1353 | x.SDTCisEltOfVec_Info.OtherOperandNum = R->getValueAsInt("OtherOpNum"); | |||
1354 | } else if (R->isSubClassOf("SDTCisSubVecOfVec")) { | |||
1355 | ConstraintType = SDTCisSubVecOfVec; | |||
1356 | x.SDTCisSubVecOfVec_Info.OtherOperandNum = | |||
1357 | R->getValueAsInt("OtherOpNum"); | |||
1358 | } else if (R->isSubClassOf("SDTCVecEltisVT")) { | |||
1359 | ConstraintType = SDTCVecEltisVT; | |||
1360 | VVT = getValueTypeByHwMode(R->getValueAsDef("VT"), CGH); | |||
1361 | for (const auto &P : VVT) { | |||
1362 | MVT T = P.second; | |||
1363 | if (T.isVector()) | |||
1364 | PrintFatalError(R->getLoc(), | |||
1365 | "Cannot use vector type as SDTCVecEltisVT"); | |||
1366 | if (!T.isInteger() && !T.isFloatingPoint()) | |||
1367 | PrintFatalError(R->getLoc(), "Must use integer or floating point type " | |||
1368 | "as SDTCVecEltisVT"); | |||
1369 | } | |||
1370 | } else if (R->isSubClassOf("SDTCisSameNumEltsAs")) { | |||
1371 | ConstraintType = SDTCisSameNumEltsAs; | |||
1372 | x.SDTCisSameNumEltsAs_Info.OtherOperandNum = | |||
1373 | R->getValueAsInt("OtherOperandNum"); | |||
1374 | } else if (R->isSubClassOf("SDTCisSameSizeAs")) { | |||
1375 | ConstraintType = SDTCisSameSizeAs; | |||
1376 | x.SDTCisSameSizeAs_Info.OtherOperandNum = | |||
1377 | R->getValueAsInt("OtherOperandNum"); | |||
1378 | } else { | |||
1379 | PrintFatalError("Unrecognized SDTypeConstraint '" + R->getName() + "'!\n"); | |||
1380 | } | |||
1381 | } | |||
1382 | ||||
1383 | /// getOperandNum - Return the node corresponding to operand #OpNo in tree | |||
1384 | /// N, and the result number in ResNo. | |||
1385 | static TreePatternNode *getOperandNum(unsigned OpNo, TreePatternNode *N, | |||
1386 | const SDNodeInfo &NodeInfo, | |||
1387 | unsigned &ResNo) { | |||
1388 | unsigned NumResults = NodeInfo.getNumResults(); | |||
1389 | if (OpNo < NumResults) { | |||
1390 | ResNo = OpNo; | |||
1391 | return N; | |||
1392 | } | |||
1393 | ||||
1394 | OpNo -= NumResults; | |||
1395 | ||||
1396 | if (OpNo >= N->getNumChildren()) { | |||
1397 | std::string S; | |||
1398 | raw_string_ostream OS(S); | |||
1399 | OS << "Invalid operand number in type constraint " | |||
1400 | << (OpNo+NumResults) << " "; | |||
1401 | N->print(OS); | |||
1402 | PrintFatalError(OS.str()); | |||
1403 | } | |||
1404 | ||||
1405 | return N->getChild(OpNo); | |||
1406 | } | |||
1407 | ||||
1408 | /// ApplyTypeConstraint - Given a node in a pattern, apply this type | |||
1409 | /// constraint to the nodes operands. This returns true if it makes a | |||
1410 | /// change, false otherwise. If a type contradiction is found, flag an error. | |||
1411 | bool SDTypeConstraint::ApplyTypeConstraint(TreePatternNode *N, | |||
1412 | const SDNodeInfo &NodeInfo, | |||
1413 | TreePattern &TP) const { | |||
1414 | if (TP.hasError()) | |||
1415 | return false; | |||
1416 | ||||
1417 | unsigned ResNo = 0; // The result number being referenced. | |||
1418 | TreePatternNode *NodeToApply = getOperandNum(OperandNo, N, NodeInfo, ResNo); | |||
1419 | TypeInfer &TI = TP.getInfer(); | |||
1420 | ||||
1421 | switch (ConstraintType) { | |||
1422 | case SDTCisVT: | |||
1423 | // Operand must be a particular type. | |||
1424 | return NodeToApply->UpdateNodeType(ResNo, VVT, TP); | |||
1425 | case SDTCisPtrTy: | |||
1426 | // Operand must be same as target pointer type. | |||
1427 | return NodeToApply->UpdateNodeType(ResNo, MVT::iPTR, TP); | |||
1428 | case SDTCisInt: | |||
1429 | // Require it to be one of the legal integer VTs. | |||
1430 | return TI.EnforceInteger(NodeToApply->getExtType(ResNo)); | |||
1431 | case SDTCisFP: | |||
1432 | // Require it to be one of the legal fp VTs. | |||
1433 | return TI.EnforceFloatingPoint(NodeToApply->getExtType(ResNo)); | |||
1434 | case SDTCisVec: | |||
1435 | // Require it to be one of the legal vector VTs. | |||
1436 | return TI.EnforceVector(NodeToApply->getExtType(ResNo)); | |||
1437 | case SDTCisSameAs: { | |||
1438 | unsigned OResNo = 0; | |||
1439 | TreePatternNode *OtherNode = | |||
1440 | getOperandNum(x.SDTCisSameAs_Info.OtherOperandNum, N, NodeInfo, OResNo); | |||
1441 | return NodeToApply->UpdateNodeType(ResNo, OtherNode->getExtType(OResNo),TP)| | |||
1442 | OtherNode->UpdateNodeType(OResNo,NodeToApply->getExtType(ResNo),TP); | |||
1443 | } | |||
1444 | case SDTCisVTSmallerThanOp: { | |||
1445 | // The NodeToApply must be a leaf node that is a VT. OtherOperandNum must | |||
1446 | // have an integer type that is smaller than the VT. | |||
1447 | if (!NodeToApply->isLeaf() || | |||
1448 | !isa<DefInit>(NodeToApply->getLeafValue()) || | |||
1449 | !static_cast<DefInit*>(NodeToApply->getLeafValue())->getDef() | |||
1450 | ->isSubClassOf("ValueType")) { | |||
1451 | TP.error(N->getOperator()->getName() + " expects a VT operand!"); | |||
1452 | return false; | |||
1453 | } | |||
1454 | DefInit *DI = static_cast<DefInit*>(NodeToApply->getLeafValue()); | |||
1455 | const CodeGenTarget &T = TP.getDAGPatterns().getTargetInfo(); | |||
1456 | auto VVT = getValueTypeByHwMode(DI->getDef(), T.getHwModes()); | |||
1457 | TypeSetByHwMode TypeListTmp(VVT); | |||
1458 | ||||
1459 | unsigned OResNo = 0; | |||
1460 | TreePatternNode *OtherNode = | |||
1461 | getOperandNum(x.SDTCisVTSmallerThanOp_Info.OtherOperandNum, N, NodeInfo, | |||
1462 | OResNo); | |||
1463 | ||||
1464 | return TI.EnforceSmallerThan(TypeListTmp, OtherNode->getExtType(OResNo)); | |||
1465 | } | |||
1466 | case SDTCisOpSmallerThanOp: { | |||
1467 | unsigned BResNo = 0; | |||
1468 | TreePatternNode *BigOperand = | |||
1469 | getOperandNum(x.SDTCisOpSmallerThanOp_Info.BigOperandNum, N, NodeInfo, | |||
1470 | BResNo); | |||
1471 | return TI.EnforceSmallerThan(NodeToApply->getExtType(ResNo), | |||
1472 | BigOperand->getExtType(BResNo)); | |||
1473 | } | |||
1474 | case SDTCisEltOfVec: { | |||
1475 | unsigned VResNo = 0; | |||
1476 | TreePatternNode *VecOperand = | |||
1477 | getOperandNum(x.SDTCisEltOfVec_Info.OtherOperandNum, N, NodeInfo, | |||
1478 | VResNo); | |||
1479 | // Filter vector types out of VecOperand that don't have the right element | |||
1480 | // type. | |||
1481 | return TI.EnforceVectorEltTypeIs(VecOperand->getExtType(VResNo), | |||
1482 | NodeToApply->getExtType(ResNo)); | |||
1483 | } | |||
1484 | case SDTCisSubVecOfVec: { | |||
1485 | unsigned VResNo = 0; | |||
1486 | TreePatternNode *BigVecOperand = | |||
1487 | getOperandNum(x.SDTCisSubVecOfVec_Info.OtherOperandNum, N, NodeInfo, | |||
1488 | VResNo); | |||
1489 | ||||
1490 | // Filter vector types out of BigVecOperand that don't have the | |||
1491 | // right subvector type. | |||
1492 | return TI.EnforceVectorSubVectorTypeIs(BigVecOperand->getExtType(VResNo), | |||
1493 | NodeToApply->getExtType(ResNo)); | |||
1494 | } | |||
1495 | case SDTCVecEltisVT: { | |||
1496 | return TI.EnforceVectorEltTypeIs(NodeToApply->getExtType(ResNo), VVT); | |||
1497 | } | |||
1498 | case SDTCisSameNumEltsAs: { | |||
1499 | unsigned OResNo = 0; | |||
1500 | TreePatternNode *OtherNode = | |||
1501 | getOperandNum(x.SDTCisSameNumEltsAs_Info.OtherOperandNum, | |||
1502 | N, NodeInfo, OResNo); | |||
1503 | return TI.EnforceSameNumElts(OtherNode->getExtType(OResNo), | |||
1504 | NodeToApply->getExtType(ResNo)); | |||
1505 | } | |||
1506 | case SDTCisSameSizeAs: { | |||
1507 | unsigned OResNo = 0; | |||
1508 | TreePatternNode *OtherNode = | |||
1509 | getOperandNum(x.SDTCisSameSizeAs_Info.OtherOperandNum, | |||
1510 | N, NodeInfo, OResNo); | |||
1511 | return TI.EnforceSameSize(OtherNode->getExtType(OResNo), | |||
1512 | NodeToApply->getExtType(ResNo)); | |||
1513 | } | |||
1514 | } | |||
1515 | llvm_unreachable("Invalid ConstraintType!")::llvm::llvm_unreachable_internal("Invalid ConstraintType!", "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 1515); | |||
1516 | } | |||
1517 | ||||
1518 | // Update the node type to match an instruction operand or result as specified | |||
1519 | // in the ins or outs lists on the instruction definition. Return true if the | |||
1520 | // type was actually changed. | |||
1521 | bool TreePatternNode::UpdateNodeTypeFromInst(unsigned ResNo, | |||
1522 | Record *Operand, | |||
1523 | TreePattern &TP) { | |||
1524 | // The 'unknown' operand indicates that types should be inferred from the | |||
1525 | // context. | |||
1526 | if (Operand->isSubClassOf("unknown_class")) | |||
1527 | return false; | |||
1528 | ||||
1529 | // The Operand class specifies a type directly. | |||
1530 | if (Operand->isSubClassOf("Operand")) { | |||
1531 | Record *R = Operand->getValueAsDef("Type"); | |||
1532 | const CodeGenTarget &T = TP.getDAGPatterns().getTargetInfo(); | |||
1533 | return UpdateNodeType(ResNo, getValueTypeByHwMode(R, T.getHwModes()), TP); | |||
1534 | } | |||
1535 | ||||
1536 | // PointerLikeRegClass has a type that is determined at runtime. | |||
1537 | if (Operand->isSubClassOf("PointerLikeRegClass")) | |||
1538 | return UpdateNodeType(ResNo, MVT::iPTR, TP); | |||
1539 | ||||
1540 | // Both RegisterClass and RegisterOperand operands derive their types from a | |||
1541 | // register class def. | |||
1542 | Record *RC = nullptr; | |||
1543 | if (Operand->isSubClassOf("RegisterClass")) | |||
1544 | RC = Operand; | |||
1545 | else if (Operand->isSubClassOf("RegisterOperand")) | |||
1546 | RC = Operand->getValueAsDef("RegClass"); | |||
1547 | ||||
1548 | assert(RC && "Unknown operand type")(static_cast <bool> (RC && "Unknown operand type" ) ? void (0) : __assert_fail ("RC && \"Unknown operand type\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 1548, __extension__ __PRETTY_FUNCTION__)); | |||
1549 | CodeGenTarget &Tgt = TP.getDAGPatterns().getTargetInfo(); | |||
1550 | return UpdateNodeType(ResNo, Tgt.getRegisterClass(RC).getValueTypes(), TP); | |||
1551 | } | |||
1552 | ||||
1553 | bool TreePatternNode::ContainsUnresolvedType(TreePattern &TP) const { | |||
1554 | for (unsigned i = 0, e = Types.size(); i != e; ++i) | |||
1555 | if (!TP.getInfer().isConcrete(Types[i], true)) | |||
1556 | return true; | |||
1557 | for (unsigned i = 0, e = getNumChildren(); i != e; ++i) | |||
1558 | if (getChild(i)->ContainsUnresolvedType(TP)) | |||
1559 | return true; | |||
1560 | return false; | |||
1561 | } | |||
1562 | ||||
1563 | bool TreePatternNode::hasProperTypeByHwMode() const { | |||
1564 | for (const TypeSetByHwMode &S : Types) | |||
1565 | if (!S.isDefaultOnly()) | |||
1566 | return true; | |||
1567 | for (TreePatternNode *C : Children) | |||
1568 | if (C->hasProperTypeByHwMode()) | |||
1569 | return true; | |||
1570 | return false; | |||
1571 | } | |||
1572 | ||||
1573 | bool TreePatternNode::hasPossibleType() const { | |||
1574 | for (const TypeSetByHwMode &S : Types) | |||
1575 | if (!S.isPossible()) | |||
1576 | return false; | |||
1577 | for (TreePatternNode *C : Children) | |||
1578 | if (!C->hasPossibleType()) | |||
1579 | return false; | |||
1580 | return true; | |||
1581 | } | |||
1582 | ||||
1583 | bool TreePatternNode::setDefaultMode(unsigned Mode) { | |||
1584 | for (TypeSetByHwMode &S : Types) { | |||
1585 | S.makeSimple(Mode); | |||
1586 | // Check if the selected mode had a type conflict. | |||
1587 | if (S.get(DefaultMode).empty()) | |||
1588 | return false; | |||
1589 | } | |||
1590 | for (TreePatternNode *C : Children) | |||
1591 | if (!C->setDefaultMode(Mode)) | |||
1592 | return false; | |||
1593 | return true; | |||
1594 | } | |||
1595 | ||||
1596 | //===----------------------------------------------------------------------===// | |||
1597 | // SDNodeInfo implementation | |||
1598 | // | |||
1599 | SDNodeInfo::SDNodeInfo(Record *R, const CodeGenHwModes &CGH) : Def(R) { | |||
1600 | EnumName = R->getValueAsString("Opcode"); | |||
1601 | SDClassName = R->getValueAsString("SDClass"); | |||
1602 | Record *TypeProfile = R->getValueAsDef("TypeProfile"); | |||
1603 | NumResults = TypeProfile->getValueAsInt("NumResults"); | |||
1604 | NumOperands = TypeProfile->getValueAsInt("NumOperands"); | |||
1605 | ||||
1606 | // Parse the properties. | |||
1607 | Properties = parseSDPatternOperatorProperties(R); | |||
1608 | ||||
1609 | // Parse the type constraints. | |||
1610 | std::vector<Record*> ConstraintList = | |||
1611 | TypeProfile->getValueAsListOfDefs("Constraints"); | |||
1612 | for (Record *R : ConstraintList) | |||
1613 | TypeConstraints.emplace_back(R, CGH); | |||
1614 | } | |||
1615 | ||||
1616 | /// getKnownType - If the type constraints on this node imply a fixed type | |||
1617 | /// (e.g. all stores return void, etc), then return it as an | |||
1618 | /// MVT::SimpleValueType. Otherwise, return EEVT::Other. | |||
1619 | MVT::SimpleValueType SDNodeInfo::getKnownType(unsigned ResNo) const { | |||
1620 | unsigned NumResults = getNumResults(); | |||
1621 | assert(NumResults <= 1 &&(static_cast <bool> (NumResults <= 1 && "We only work with nodes with zero or one result so far!" ) ? void (0) : __assert_fail ("NumResults <= 1 && \"We only work with nodes with zero or one result so far!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 1622, __extension__ __PRETTY_FUNCTION__)) | |||
1622 | "We only work with nodes with zero or one result so far!")(static_cast <bool> (NumResults <= 1 && "We only work with nodes with zero or one result so far!" ) ? void (0) : __assert_fail ("NumResults <= 1 && \"We only work with nodes with zero or one result so far!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 1622, __extension__ __PRETTY_FUNCTION__)); | |||
1623 | assert(ResNo == 0 && "Only handles single result nodes so far")(static_cast <bool> (ResNo == 0 && "Only handles single result nodes so far" ) ? void (0) : __assert_fail ("ResNo == 0 && \"Only handles single result nodes so far\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 1623, __extension__ __PRETTY_FUNCTION__)); | |||
1624 | ||||
1625 | for (const SDTypeConstraint &Constraint : TypeConstraints) { | |||
1626 | // Make sure that this applies to the correct node result. | |||
1627 | if (Constraint.OperandNo >= NumResults) // FIXME: need value # | |||
1628 | continue; | |||
1629 | ||||
1630 | switch (Constraint.ConstraintType) { | |||
1631 | default: break; | |||
1632 | case SDTypeConstraint::SDTCisVT: | |||
1633 | if (Constraint.VVT.isSimple()) | |||
1634 | return Constraint.VVT.getSimple().SimpleTy; | |||
1635 | break; | |||
1636 | case SDTypeConstraint::SDTCisPtrTy: | |||
1637 | return MVT::iPTR; | |||
1638 | } | |||
1639 | } | |||
1640 | return MVT::Other; | |||
1641 | } | |||
1642 | ||||
1643 | //===----------------------------------------------------------------------===// | |||
1644 | // TreePatternNode implementation | |||
1645 | // | |||
1646 | ||||
1647 | TreePatternNode::~TreePatternNode() { | |||
1648 | #if 0 // FIXME: implement refcounted tree nodes! | |||
1649 | for (unsigned i = 0, e = getNumChildren(); i != e; ++i) | |||
1650 | delete getChild(i); | |||
1651 | #endif | |||
1652 | } | |||
1653 | ||||
1654 | static unsigned GetNumNodeResults(Record *Operator, CodeGenDAGPatterns &CDP) { | |||
1655 | if (Operator->getName() == "set" || | |||
1656 | Operator->getName() == "implicit") | |||
1657 | return 0; // All return nothing. | |||
1658 | ||||
1659 | if (Operator->isSubClassOf("Intrinsic")) | |||
1660 | return CDP.getIntrinsic(Operator).IS.RetVTs.size(); | |||
1661 | ||||
1662 | if (Operator->isSubClassOf("SDNode")) | |||
1663 | return CDP.getSDNodeInfo(Operator).getNumResults(); | |||
1664 | ||||
1665 | if (Operator->isSubClassOf("PatFrag")) { | |||
1666 | // If we've already parsed this pattern fragment, get it. Otherwise, handle | |||
1667 | // the forward reference case where one pattern fragment references another | |||
1668 | // before it is processed. | |||
1669 | if (TreePattern *PFRec = CDP.getPatternFragmentIfRead(Operator)) | |||
1670 | return PFRec->getOnlyTree()->getNumTypes(); | |||
1671 | ||||
1672 | // Get the result tree. | |||
1673 | DagInit *Tree = Operator->getValueAsDag("Fragment"); | |||
1674 | Record *Op = nullptr; | |||
1675 | if (Tree) | |||
1676 | if (DefInit *DI = dyn_cast<DefInit>(Tree->getOperator())) | |||
1677 | Op = DI->getDef(); | |||
1678 | assert(Op && "Invalid Fragment")(static_cast <bool> (Op && "Invalid Fragment") ? void (0) : __assert_fail ("Op && \"Invalid Fragment\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 1678, __extension__ __PRETTY_FUNCTION__)); | |||
1679 | return GetNumNodeResults(Op, CDP); | |||
1680 | } | |||
1681 | ||||
1682 | if (Operator->isSubClassOf("Instruction")) { | |||
1683 | CodeGenInstruction &InstInfo = CDP.getTargetInfo().getInstruction(Operator); | |||
1684 | ||||
1685 | unsigned NumDefsToAdd = InstInfo.Operands.NumDefs; | |||
1686 | ||||
1687 | // Subtract any defaulted outputs. | |||
1688 | for (unsigned i = 0; i != InstInfo.Operands.NumDefs; ++i) { | |||
1689 | Record *OperandNode = InstInfo.Operands[i].Rec; | |||
1690 | ||||
1691 | if (OperandNode->isSubClassOf("OperandWithDefaultOps") && | |||
1692 | !CDP.getDefaultOperand(OperandNode).DefaultOps.empty()) | |||
1693 | --NumDefsToAdd; | |||
1694 | } | |||
1695 | ||||
1696 | // Add on one implicit def if it has a resolvable type. | |||
1697 | if (InstInfo.HasOneImplicitDefWithKnownVT(CDP.getTargetInfo()) !=MVT::Other) | |||
1698 | ++NumDefsToAdd; | |||
1699 | return NumDefsToAdd; | |||
1700 | } | |||
1701 | ||||
1702 | if (Operator->isSubClassOf("SDNodeXForm")) | |||
1703 | return 1; // FIXME: Generalize SDNodeXForm | |||
1704 | ||||
1705 | if (Operator->isSubClassOf("ValueType")) | |||
1706 | return 1; // A type-cast of one result. | |||
1707 | ||||
1708 | if (Operator->isSubClassOf("ComplexPattern")) | |||
1709 | return 1; | |||
1710 | ||||
1711 | errs() << *Operator; | |||
1712 | PrintFatalError("Unhandled node in GetNumNodeResults"); | |||
1713 | } | |||
1714 | ||||
1715 | void TreePatternNode::print(raw_ostream &OS) const { | |||
1716 | if (isLeaf()) | |||
1717 | OS << *getLeafValue(); | |||
1718 | else | |||
1719 | OS << '(' << getOperator()->getName(); | |||
1720 | ||||
1721 | for (unsigned i = 0, e = Types.size(); i != e; ++i) { | |||
1722 | OS << ':'; | |||
1723 | getExtType(i).writeToStream(OS); | |||
1724 | } | |||
1725 | ||||
1726 | if (!isLeaf()) { | |||
1727 | if (getNumChildren() != 0) { | |||
1728 | OS << " "; | |||
1729 | getChild(0)->print(OS); | |||
1730 | for (unsigned i = 1, e = getNumChildren(); i != e; ++i) { | |||
1731 | OS << ", "; | |||
1732 | getChild(i)->print(OS); | |||
1733 | } | |||
1734 | } | |||
1735 | OS << ")"; | |||
1736 | } | |||
1737 | ||||
1738 | for (const TreePredicateFn &Pred : PredicateFns) | |||
1739 | OS << "<<P:" << Pred.getFnName() << ">>"; | |||
1740 | if (TransformFn) | |||
1741 | OS << "<<X:" << TransformFn->getName() << ">>"; | |||
1742 | if (!getName().empty()) | |||
1743 | OS << ":$" << getName(); | |||
1744 | ||||
1745 | } | |||
1746 | void TreePatternNode::dump() const { | |||
1747 | print(errs()); | |||
1748 | } | |||
1749 | ||||
1750 | /// isIsomorphicTo - Return true if this node is recursively | |||
1751 | /// isomorphic to the specified node. For this comparison, the node's | |||
1752 | /// entire state is considered. The assigned name is ignored, since | |||
1753 | /// nodes with differing names are considered isomorphic. However, if | |||
1754 | /// the assigned name is present in the dependent variable set, then | |||
1755 | /// the assigned name is considered significant and the node is | |||
1756 | /// isomorphic if the names match. | |||
1757 | bool TreePatternNode::isIsomorphicTo(const TreePatternNode *N, | |||
1758 | const MultipleUseVarSet &DepVars) const { | |||
1759 | if (N == this) return true; | |||
1760 | if (N->isLeaf() != isLeaf() || getExtTypes() != N->getExtTypes() || | |||
1761 | getPredicateFns() != N->getPredicateFns() || | |||
1762 | getTransformFn() != N->getTransformFn()) | |||
1763 | return false; | |||
1764 | ||||
1765 | if (isLeaf()) { | |||
1766 | if (DefInit *DI = dyn_cast<DefInit>(getLeafValue())) { | |||
1767 | if (DefInit *NDI = dyn_cast<DefInit>(N->getLeafValue())) { | |||
1768 | return ((DI->getDef() == NDI->getDef()) | |||
1769 | && (DepVars.find(getName()) == DepVars.end() | |||
1770 | || getName() == N->getName())); | |||
1771 | } | |||
1772 | } | |||
1773 | return getLeafValue() == N->getLeafValue(); | |||
1774 | } | |||
1775 | ||||
1776 | if (N->getOperator() != getOperator() || | |||
1777 | N->getNumChildren() != getNumChildren()) return false; | |||
1778 | for (unsigned i = 0, e = getNumChildren(); i != e; ++i) | |||
1779 | if (!getChild(i)->isIsomorphicTo(N->getChild(i), DepVars)) | |||
1780 | return false; | |||
1781 | return true; | |||
1782 | } | |||
1783 | ||||
1784 | /// clone - Make a copy of this tree and all of its children. | |||
1785 | /// | |||
1786 | TreePatternNode *TreePatternNode::clone() const { | |||
1787 | TreePatternNode *New; | |||
1788 | if (isLeaf()) { | |||
1789 | New = new TreePatternNode(getLeafValue(), getNumTypes()); | |||
1790 | } else { | |||
1791 | std::vector<TreePatternNode*> CChildren; | |||
1792 | CChildren.reserve(Children.size()); | |||
1793 | for (unsigned i = 0, e = getNumChildren(); i != e; ++i) | |||
1794 | CChildren.push_back(getChild(i)->clone()); | |||
1795 | New = new TreePatternNode(getOperator(), CChildren, getNumTypes()); | |||
1796 | } | |||
1797 | New->setName(getName()); | |||
1798 | New->Types = Types; | |||
1799 | New->setPredicateFns(getPredicateFns()); | |||
1800 | New->setTransformFn(getTransformFn()); | |||
1801 | return New; | |||
1802 | } | |||
1803 | ||||
1804 | /// RemoveAllTypes - Recursively strip all the types of this tree. | |||
1805 | void TreePatternNode::RemoveAllTypes() { | |||
1806 | // Reset to unknown type. | |||
1807 | std::fill(Types.begin(), Types.end(), TypeSetByHwMode()); | |||
1808 | if (isLeaf()) return; | |||
1809 | for (unsigned i = 0, e = getNumChildren(); i != e; ++i) | |||
1810 | getChild(i)->RemoveAllTypes(); | |||
1811 | } | |||
1812 | ||||
1813 | ||||
1814 | /// SubstituteFormalArguments - Replace the formal arguments in this tree | |||
1815 | /// with actual values specified by ArgMap. | |||
1816 | void TreePatternNode:: | |||
1817 | SubstituteFormalArguments(std::map<std::string, TreePatternNode*> &ArgMap) { | |||
1818 | if (isLeaf()) return; | |||
1819 | ||||
1820 | for (unsigned i = 0, e = getNumChildren(); i != e; ++i) { | |||
1821 | TreePatternNode *Child = getChild(i); | |||
1822 | if (Child->isLeaf()) { | |||
1823 | Init *Val = Child->getLeafValue(); | |||
1824 | // Note that, when substituting into an output pattern, Val might be an | |||
1825 | // UnsetInit. | |||
1826 | if (isa<UnsetInit>(Val) || (isa<DefInit>(Val) && | |||
1827 | cast<DefInit>(Val)->getDef()->getName() == "node")) { | |||
1828 | // We found a use of a formal argument, replace it with its value. | |||
1829 | TreePatternNode *NewChild = ArgMap[Child->getName()]; | |||
1830 | assert(NewChild && "Couldn't find formal argument!")(static_cast <bool> (NewChild && "Couldn't find formal argument!" ) ? void (0) : __assert_fail ("NewChild && \"Couldn't find formal argument!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 1830, __extension__ __PRETTY_FUNCTION__)); | |||
1831 | assert((Child->getPredicateFns().empty() ||(static_cast <bool> ((Child->getPredicateFns().empty () || NewChild->getPredicateFns() == Child->getPredicateFns ()) && "Non-empty child predicate clobbered!") ? void (0) : __assert_fail ("(Child->getPredicateFns().empty() || NewChild->getPredicateFns() == Child->getPredicateFns()) && \"Non-empty child predicate clobbered!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 1833, __extension__ __PRETTY_FUNCTION__)) | |||
1832 | NewChild->getPredicateFns() == Child->getPredicateFns()) &&(static_cast <bool> ((Child->getPredicateFns().empty () || NewChild->getPredicateFns() == Child->getPredicateFns ()) && "Non-empty child predicate clobbered!") ? void (0) : __assert_fail ("(Child->getPredicateFns().empty() || NewChild->getPredicateFns() == Child->getPredicateFns()) && \"Non-empty child predicate clobbered!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 1833, __extension__ __PRETTY_FUNCTION__)) | |||
1833 | "Non-empty child predicate clobbered!")(static_cast <bool> ((Child->getPredicateFns().empty () || NewChild->getPredicateFns() == Child->getPredicateFns ()) && "Non-empty child predicate clobbered!") ? void (0) : __assert_fail ("(Child->getPredicateFns().empty() || NewChild->getPredicateFns() == Child->getPredicateFns()) && \"Non-empty child predicate clobbered!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 1833, __extension__ __PRETTY_FUNCTION__)); | |||
1834 | setChild(i, NewChild); | |||
1835 | } | |||
1836 | } else { | |||
1837 | getChild(i)->SubstituteFormalArguments(ArgMap); | |||
1838 | } | |||
1839 | } | |||
1840 | } | |||
1841 | ||||
1842 | ||||
1843 | /// InlinePatternFragments - If this pattern refers to any pattern | |||
1844 | /// fragments, inline them into place, giving us a pattern without any | |||
1845 | /// PatFrag references. | |||
1846 | TreePatternNode *TreePatternNode::InlinePatternFragments(TreePattern &TP) { | |||
1847 | if (TP.hasError()) | |||
1848 | return nullptr; | |||
1849 | ||||
1850 | if (isLeaf()) | |||
1851 | return this; // nothing to do. | |||
1852 | Record *Op = getOperator(); | |||
1853 | ||||
1854 | if (!Op->isSubClassOf("PatFrag")) { | |||
1855 | // Just recursively inline children nodes. | |||
1856 | for (unsigned i = 0, e = getNumChildren(); i != e; ++i) { | |||
1857 | TreePatternNode *Child = getChild(i); | |||
1858 | TreePatternNode *NewChild = Child->InlinePatternFragments(TP); | |||
1859 | ||||
1860 | assert((Child->getPredicateFns().empty() ||(static_cast <bool> ((Child->getPredicateFns().empty () || NewChild->getPredicateFns() == Child->getPredicateFns ()) && "Non-empty child predicate clobbered!") ? void (0) : __assert_fail ("(Child->getPredicateFns().empty() || NewChild->getPredicateFns() == Child->getPredicateFns()) && \"Non-empty child predicate clobbered!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 1862, __extension__ __PRETTY_FUNCTION__)) | |||
1861 | NewChild->getPredicateFns() == Child->getPredicateFns()) &&(static_cast <bool> ((Child->getPredicateFns().empty () || NewChild->getPredicateFns() == Child->getPredicateFns ()) && "Non-empty child predicate clobbered!") ? void (0) : __assert_fail ("(Child->getPredicateFns().empty() || NewChild->getPredicateFns() == Child->getPredicateFns()) && \"Non-empty child predicate clobbered!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 1862, __extension__ __PRETTY_FUNCTION__)) | |||
1862 | "Non-empty child predicate clobbered!")(static_cast <bool> ((Child->getPredicateFns().empty () || NewChild->getPredicateFns() == Child->getPredicateFns ()) && "Non-empty child predicate clobbered!") ? void (0) : __assert_fail ("(Child->getPredicateFns().empty() || NewChild->getPredicateFns() == Child->getPredicateFns()) && \"Non-empty child predicate clobbered!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 1862, __extension__ __PRETTY_FUNCTION__)); | |||
1863 | ||||
1864 | setChild(i, NewChild); | |||
1865 | } | |||
1866 | return this; | |||
1867 | } | |||
1868 | ||||
1869 | // Otherwise, we found a reference to a fragment. First, look up its | |||
1870 | // TreePattern record. | |||
1871 | TreePattern *Frag = TP.getDAGPatterns().getPatternFragment(Op); | |||
1872 | ||||
1873 | // Verify that we are passing the right number of operands. | |||
1874 | if (Frag->getNumArgs() != Children.size()) { | |||
1875 | TP.error("'" + Op->getName() + "' fragment requires " + | |||
1876 | Twine(Frag->getNumArgs()) + " operands!"); | |||
1877 | return nullptr; | |||
1878 | } | |||
1879 | ||||
1880 | TreePatternNode *FragTree = Frag->getOnlyTree()->clone(); | |||
1881 | ||||
1882 | TreePredicateFn PredFn(Frag); | |||
1883 | if (!PredFn.isAlwaysTrue()) | |||
1884 | FragTree->addPredicateFn(PredFn); | |||
1885 | ||||
1886 | // Resolve formal arguments to their actual value. | |||
1887 | if (Frag->getNumArgs()) { | |||
1888 | // Compute the map of formal to actual arguments. | |||
1889 | std::map<std::string, TreePatternNode*> ArgMap; | |||
1890 | for (unsigned i = 0, e = Frag->getNumArgs(); i != e; ++i) | |||
1891 | ArgMap[Frag->getArgName(i)] = getChild(i)->InlinePatternFragments(TP); | |||
1892 | ||||
1893 | FragTree->SubstituteFormalArguments(ArgMap); | |||
1894 | } | |||
1895 | ||||
1896 | FragTree->setName(getName()); | |||
1897 | for (unsigned i = 0, e = Types.size(); i != e; ++i) | |||
1898 | FragTree->UpdateNodeType(i, getExtType(i), TP); | |||
1899 | ||||
1900 | // Transfer in the old predicates. | |||
1901 | for (const TreePredicateFn &Pred : getPredicateFns()) | |||
1902 | FragTree->addPredicateFn(Pred); | |||
1903 | ||||
1904 | // Get a new copy of this fragment to stitch into here. | |||
1905 | //delete this; // FIXME: implement refcounting! | |||
1906 | ||||
1907 | // The fragment we inlined could have recursive inlining that is needed. See | |||
1908 | // if there are any pattern fragments in it and inline them as needed. | |||
1909 | return FragTree->InlinePatternFragments(TP); | |||
1910 | } | |||
1911 | ||||
1912 | /// getImplicitType - Check to see if the specified record has an implicit | |||
1913 | /// type which should be applied to it. This will infer the type of register | |||
1914 | /// references from the register file information, for example. | |||
1915 | /// | |||
1916 | /// When Unnamed is set, return the type of a DAG operand with no name, such as | |||
1917 | /// the F8RC register class argument in: | |||
1918 | /// | |||
1919 | /// (COPY_TO_REGCLASS GPR:$src, F8RC) | |||
1920 | /// | |||
1921 | /// When Unnamed is false, return the type of a named DAG operand such as the | |||
1922 | /// GPR:$src operand above. | |||
1923 | /// | |||
1924 | static TypeSetByHwMode getImplicitType(Record *R, unsigned ResNo, | |||
1925 | bool NotRegisters, | |||
1926 | bool Unnamed, | |||
1927 | TreePattern &TP) { | |||
1928 | CodeGenDAGPatterns &CDP = TP.getDAGPatterns(); | |||
1929 | ||||
1930 | // Check to see if this is a register operand. | |||
1931 | if (R->isSubClassOf("RegisterOperand")) { | |||
1932 | assert(ResNo == 0 && "Regoperand ref only has one result!")(static_cast <bool> (ResNo == 0 && "Regoperand ref only has one result!" ) ? void (0) : __assert_fail ("ResNo == 0 && \"Regoperand ref only has one result!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 1932, __extension__ __PRETTY_FUNCTION__)); | |||
1933 | if (NotRegisters) | |||
1934 | return TypeSetByHwMode(); // Unknown. | |||
1935 | Record *RegClass = R->getValueAsDef("RegClass"); | |||
1936 | const CodeGenTarget &T = TP.getDAGPatterns().getTargetInfo(); | |||
1937 | return TypeSetByHwMode(T.getRegisterClass(RegClass).getValueTypes()); | |||
1938 | } | |||
1939 | ||||
1940 | // Check to see if this is a register or a register class. | |||
1941 | if (R->isSubClassOf("RegisterClass")) { | |||
1942 | assert(ResNo == 0 && "Regclass ref only has one result!")(static_cast <bool> (ResNo == 0 && "Regclass ref only has one result!" ) ? void (0) : __assert_fail ("ResNo == 0 && \"Regclass ref only has one result!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 1942, __extension__ __PRETTY_FUNCTION__)); | |||
1943 | // An unnamed register class represents itself as an i32 immediate, for | |||
1944 | // example on a COPY_TO_REGCLASS instruction. | |||
1945 | if (Unnamed) | |||
1946 | return TypeSetByHwMode(MVT::i32); | |||
1947 | ||||
1948 | // In a named operand, the register class provides the possible set of | |||
1949 | // types. | |||
1950 | if (NotRegisters) | |||
1951 | return TypeSetByHwMode(); // Unknown. | |||
1952 | const CodeGenTarget &T = TP.getDAGPatterns().getTargetInfo(); | |||
1953 | return TypeSetByHwMode(T.getRegisterClass(R).getValueTypes()); | |||
1954 | } | |||
1955 | ||||
1956 | if (R->isSubClassOf("PatFrag")) { | |||
1957 | assert(ResNo == 0 && "FIXME: PatFrag with multiple results?")(static_cast <bool> (ResNo == 0 && "FIXME: PatFrag with multiple results?" ) ? void (0) : __assert_fail ("ResNo == 0 && \"FIXME: PatFrag with multiple results?\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 1957, __extension__ __PRETTY_FUNCTION__)); | |||
1958 | // Pattern fragment types will be resolved when they are inlined. | |||
1959 | return TypeSetByHwMode(); // Unknown. | |||
1960 | } | |||
1961 | ||||
1962 | if (R->isSubClassOf("Register")) { | |||
1963 | assert(ResNo == 0 && "Registers only produce one result!")(static_cast <bool> (ResNo == 0 && "Registers only produce one result!" ) ? void (0) : __assert_fail ("ResNo == 0 && \"Registers only produce one result!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 1963, __extension__ __PRETTY_FUNCTION__)); | |||
1964 | if (NotRegisters) | |||
1965 | return TypeSetByHwMode(); // Unknown. | |||
1966 | const CodeGenTarget &T = TP.getDAGPatterns().getTargetInfo(); | |||
1967 | return TypeSetByHwMode(T.getRegisterVTs(R)); | |||
1968 | } | |||
1969 | ||||
1970 | if (R->isSubClassOf("SubRegIndex")) { | |||
1971 | assert(ResNo == 0 && "SubRegisterIndices only produce one result!")(static_cast <bool> (ResNo == 0 && "SubRegisterIndices only produce one result!" ) ? void (0) : __assert_fail ("ResNo == 0 && \"SubRegisterIndices only produce one result!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 1971, __extension__ __PRETTY_FUNCTION__)); | |||
1972 | return TypeSetByHwMode(MVT::i32); | |||
1973 | } | |||
1974 | ||||
1975 | if (R->isSubClassOf("ValueType")) { | |||
1976 | assert(ResNo == 0 && "This node only has one result!")(static_cast <bool> (ResNo == 0 && "This node only has one result!" ) ? void (0) : __assert_fail ("ResNo == 0 && \"This node only has one result!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 1976, __extension__ __PRETTY_FUNCTION__)); | |||
1977 | // An unnamed VTSDNode represents itself as an MVT::Other immediate. | |||
1978 | // | |||
1979 | // (sext_inreg GPR:$src, i16) | |||
1980 | // ~~~ | |||
1981 | if (Unnamed) | |||
1982 | return TypeSetByHwMode(MVT::Other); | |||
1983 | // With a name, the ValueType simply provides the type of the named | |||
1984 | // variable. | |||
1985 | // | |||
1986 | // (sext_inreg i32:$src, i16) | |||
1987 | // ~~~~~~~~ | |||
1988 | if (NotRegisters) | |||
1989 | return TypeSetByHwMode(); // Unknown. | |||
1990 | const CodeGenHwModes &CGH = CDP.getTargetInfo().getHwModes(); | |||
1991 | return TypeSetByHwMode(getValueTypeByHwMode(R, CGH)); | |||
1992 | } | |||
1993 | ||||
1994 | if (R->isSubClassOf("CondCode")) { | |||
1995 | assert(ResNo == 0 && "This node only has one result!")(static_cast <bool> (ResNo == 0 && "This node only has one result!" ) ? void (0) : __assert_fail ("ResNo == 0 && \"This node only has one result!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 1995, __extension__ __PRETTY_FUNCTION__)); | |||
1996 | // Using a CondCodeSDNode. | |||
1997 | return TypeSetByHwMode(MVT::Other); | |||
1998 | } | |||
1999 | ||||
2000 | if (R->isSubClassOf("ComplexPattern")) { | |||
2001 | assert(ResNo == 0 && "FIXME: ComplexPattern with multiple results?")(static_cast <bool> (ResNo == 0 && "FIXME: ComplexPattern with multiple results?" ) ? void (0) : __assert_fail ("ResNo == 0 && \"FIXME: ComplexPattern with multiple results?\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 2001, __extension__ __PRETTY_FUNCTION__)); | |||
2002 | if (NotRegisters) | |||
2003 | return TypeSetByHwMode(); // Unknown. | |||
2004 | return TypeSetByHwMode(CDP.getComplexPattern(R).getValueType()); | |||
2005 | } | |||
2006 | if (R->isSubClassOf("PointerLikeRegClass")) { | |||
2007 | assert(ResNo == 0 && "Regclass can only have one result!")(static_cast <bool> (ResNo == 0 && "Regclass can only have one result!" ) ? void (0) : __assert_fail ("ResNo == 0 && \"Regclass can only have one result!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 2007, __extension__ __PRETTY_FUNCTION__)); | |||
2008 | TypeSetByHwMode VTS(MVT::iPTR); | |||
2009 | TP.getInfer().expandOverloads(VTS); | |||
2010 | return VTS; | |||
2011 | } | |||
2012 | ||||
2013 | if (R->getName() == "node" || R->getName() == "srcvalue" || | |||
2014 | R->getName() == "zero_reg") { | |||
2015 | // Placeholder. | |||
2016 | return TypeSetByHwMode(); // Unknown. | |||
2017 | } | |||
2018 | ||||
2019 | if (R->isSubClassOf("Operand")) { | |||
2020 | const CodeGenHwModes &CGH = CDP.getTargetInfo().getHwModes(); | |||
2021 | Record *T = R->getValueAsDef("Type"); | |||
2022 | return TypeSetByHwMode(getValueTypeByHwMode(T, CGH)); | |||
2023 | } | |||
2024 | ||||
2025 | TP.error("Unknown node flavor used in pattern: " + R->getName()); | |||
2026 | return TypeSetByHwMode(MVT::Other); | |||
2027 | } | |||
2028 | ||||
2029 | ||||
2030 | /// getIntrinsicInfo - If this node corresponds to an intrinsic, return the | |||
2031 | /// CodeGenIntrinsic information for it, otherwise return a null pointer. | |||
2032 | const CodeGenIntrinsic *TreePatternNode:: | |||
2033 | getIntrinsicInfo(const CodeGenDAGPatterns &CDP) const { | |||
2034 | if (getOperator() != CDP.get_intrinsic_void_sdnode() && | |||
2035 | getOperator() != CDP.get_intrinsic_w_chain_sdnode() && | |||
2036 | getOperator() != CDP.get_intrinsic_wo_chain_sdnode()) | |||
2037 | return nullptr; | |||
2038 | ||||
2039 | unsigned IID = cast<IntInit>(getChild(0)->getLeafValue())->getValue(); | |||
2040 | return &CDP.getIntrinsicInfo(IID); | |||
2041 | } | |||
2042 | ||||
2043 | /// getComplexPatternInfo - If this node corresponds to a ComplexPattern, | |||
2044 | /// return the ComplexPattern information, otherwise return null. | |||
2045 | const ComplexPattern * | |||
2046 | TreePatternNode::getComplexPatternInfo(const CodeGenDAGPatterns &CGP) const { | |||
2047 | Record *Rec; | |||
2048 | if (isLeaf()) { | |||
2049 | DefInit *DI = dyn_cast<DefInit>(getLeafValue()); | |||
2050 | if (!DI) | |||
2051 | return nullptr; | |||
2052 | Rec = DI->getDef(); | |||
2053 | } else | |||
2054 | Rec = getOperator(); | |||
2055 | ||||
2056 | if (!Rec->isSubClassOf("ComplexPattern")) | |||
2057 | return nullptr; | |||
2058 | return &CGP.getComplexPattern(Rec); | |||
2059 | } | |||
2060 | ||||
2061 | unsigned TreePatternNode::getNumMIResults(const CodeGenDAGPatterns &CGP) const { | |||
2062 | // A ComplexPattern specifically declares how many results it fills in. | |||
2063 | if (const ComplexPattern *CP = getComplexPatternInfo(CGP)) | |||
2064 | return CP->getNumOperands(); | |||
2065 | ||||
2066 | // If MIOperandInfo is specified, that gives the count. | |||
2067 | if (isLeaf()) { | |||
2068 | DefInit *DI = dyn_cast<DefInit>(getLeafValue()); | |||
2069 | if (DI && DI->getDef()->isSubClassOf("Operand")) { | |||
2070 | DagInit *MIOps = DI->getDef()->getValueAsDag("MIOperandInfo"); | |||
2071 | if (MIOps->getNumArgs()) | |||
2072 | return MIOps->getNumArgs(); | |||
2073 | } | |||
2074 | } | |||
2075 | ||||
2076 | // Otherwise there is just one result. | |||
2077 | return 1; | |||
2078 | } | |||
2079 | ||||
2080 | /// NodeHasProperty - Return true if this node has the specified property. | |||
2081 | bool TreePatternNode::NodeHasProperty(SDNP Property, | |||
2082 | const CodeGenDAGPatterns &CGP) const { | |||
2083 | if (isLeaf()) { | |||
2084 | if (const ComplexPattern *CP = getComplexPatternInfo(CGP)) | |||
2085 | return CP->hasProperty(Property); | |||
2086 | ||||
2087 | return false; | |||
2088 | } | |||
2089 | ||||
2090 | if (Property != SDNPHasChain) { | |||
2091 | // The chain proprety is already present on the different intrinsic node | |||
2092 | // types (intrinsic_w_chain, intrinsic_void), and is not explicitly listed | |||
2093 | // on the intrinsic. Anything else is specific to the individual intrinsic. | |||
2094 | if (const CodeGenIntrinsic *Int = getIntrinsicInfo(CGP)) | |||
2095 | return Int->hasProperty(Property); | |||
2096 | } | |||
2097 | ||||
2098 | if (!Operator->isSubClassOf("SDPatternOperator")) | |||
2099 | return false; | |||
2100 | ||||
2101 | return CGP.getSDNodeInfo(Operator).hasProperty(Property); | |||
2102 | } | |||
2103 | ||||
2104 | ||||
2105 | ||||
2106 | ||||
2107 | /// TreeHasProperty - Return true if any node in this tree has the specified | |||
2108 | /// property. | |||
2109 | bool TreePatternNode::TreeHasProperty(SDNP Property, | |||
2110 | const CodeGenDAGPatterns &CGP) const { | |||
2111 | if (NodeHasProperty(Property, CGP)) | |||
2112 | return true; | |||
2113 | for (unsigned i = 0, e = getNumChildren(); i != e; ++i) | |||
2114 | if (getChild(i)->TreeHasProperty(Property, CGP)) | |||
2115 | return true; | |||
2116 | return false; | |||
2117 | } | |||
2118 | ||||
2119 | /// isCommutativeIntrinsic - Return true if the node corresponds to a | |||
2120 | /// commutative intrinsic. | |||
2121 | bool | |||
2122 | TreePatternNode::isCommutativeIntrinsic(const CodeGenDAGPatterns &CDP) const { | |||
2123 | if (const CodeGenIntrinsic *Int = getIntrinsicInfo(CDP)) | |||
2124 | return Int->isCommutative; | |||
2125 | return false; | |||
2126 | } | |||
2127 | ||||
2128 | static bool isOperandClass(const TreePatternNode *N, StringRef Class) { | |||
2129 | if (!N->isLeaf()) | |||
2130 | return N->getOperator()->isSubClassOf(Class); | |||
2131 | ||||
2132 | DefInit *DI = dyn_cast<DefInit>(N->getLeafValue()); | |||
2133 | if (DI && DI->getDef()->isSubClassOf(Class)) | |||
2134 | return true; | |||
2135 | ||||
2136 | return false; | |||
2137 | } | |||
2138 | ||||
2139 | static void emitTooManyOperandsError(TreePattern &TP, | |||
2140 | StringRef InstName, | |||
2141 | unsigned Expected, | |||
2142 | unsigned Actual) { | |||
2143 | TP.error("Instruction '" + InstName + "' was provided " + Twine(Actual) + | |||
2144 | " operands but expected only " + Twine(Expected) + "!"); | |||
2145 | } | |||
2146 | ||||
2147 | static void emitTooFewOperandsError(TreePattern &TP, | |||
2148 | StringRef InstName, | |||
2149 | unsigned Actual) { | |||
2150 | TP.error("Instruction '" + InstName + | |||
2151 | "' expects more than the provided " + Twine(Actual) + " operands!"); | |||
2152 | } | |||
2153 | ||||
2154 | /// ApplyTypeConstraints - Apply all of the type constraints relevant to | |||
2155 | /// this node and its children in the tree. This returns true if it makes a | |||
2156 | /// change, false otherwise. If a type contradiction is found, flag an error. | |||
2157 | bool TreePatternNode::ApplyTypeConstraints(TreePattern &TP, bool NotRegisters) { | |||
2158 | if (TP.hasError()) | |||
2159 | return false; | |||
2160 | ||||
2161 | CodeGenDAGPatterns &CDP = TP.getDAGPatterns(); | |||
2162 | if (isLeaf()) { | |||
2163 | if (DefInit *DI = dyn_cast<DefInit>(getLeafValue())) { | |||
2164 | // If it's a regclass or something else known, include the type. | |||
2165 | bool MadeChange = false; | |||
2166 | for (unsigned i = 0, e = Types.size(); i != e; ++i) | |||
2167 | MadeChange |= UpdateNodeType(i, getImplicitType(DI->getDef(), i, | |||
2168 | NotRegisters, | |||
2169 | !hasName(), TP), TP); | |||
2170 | return MadeChange; | |||
2171 | } | |||
2172 | ||||
2173 | if (IntInit *II = dyn_cast<IntInit>(getLeafValue())) { | |||
2174 | assert(Types.size() == 1 && "Invalid IntInit")(static_cast <bool> (Types.size() == 1 && "Invalid IntInit" ) ? void (0) : __assert_fail ("Types.size() == 1 && \"Invalid IntInit\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 2174, __extension__ __PRETTY_FUNCTION__)); | |||
2175 | ||||
2176 | // Int inits are always integers. :) | |||
2177 | bool MadeChange = TP.getInfer().EnforceInteger(Types[0]); | |||
2178 | ||||
2179 | if (!TP.getInfer().isConcrete(Types[0], false)) | |||
2180 | return MadeChange; | |||
2181 | ||||
2182 | ValueTypeByHwMode VVT = TP.getInfer().getConcrete(Types[0], false); | |||
2183 | for (auto &P : VVT) { | |||
2184 | MVT::SimpleValueType VT = P.second.SimpleTy; | |||
2185 | if (VT == MVT::iPTR || VT == MVT::iPTRAny) | |||
2186 | continue; | |||
2187 | unsigned Size = MVT(VT).getSizeInBits(); | |||
2188 | // Make sure that the value is representable for this type. | |||
2189 | if (Size >= 32) | |||
2190 | continue; | |||
2191 | // Check that the value doesn't use more bits than we have. It must | |||
2192 | // either be a sign- or zero-extended equivalent of the original. | |||
2193 | int64_t SignBitAndAbove = II->getValue() >> (Size - 1); | |||
2194 | if (SignBitAndAbove == -1 || SignBitAndAbove == 0 || | |||
2195 | SignBitAndAbove == 1) | |||
2196 | continue; | |||
2197 | ||||
2198 | TP.error("Integer value '" + Twine(II->getValue()) + | |||
2199 | "' is out of range for type '" + getEnumName(VT) + "'!"); | |||
2200 | break; | |||
2201 | } | |||
2202 | return MadeChange; | |||
2203 | } | |||
2204 | ||||
2205 | return false; | |||
2206 | } | |||
2207 | ||||
2208 | // special handling for set, which isn't really an SDNode. | |||
2209 | if (getOperator()->getName() == "set") { | |||
2210 | assert(getNumTypes() == 0 && "Set doesn't produce a value")(static_cast <bool> (getNumTypes() == 0 && "Set doesn't produce a value" ) ? void (0) : __assert_fail ("getNumTypes() == 0 && \"Set doesn't produce a value\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 2210, __extension__ __PRETTY_FUNCTION__)); | |||
2211 | assert(getNumChildren() >= 2 && "Missing RHS of a set?")(static_cast <bool> (getNumChildren() >= 2 && "Missing RHS of a set?") ? void (0) : __assert_fail ("getNumChildren() >= 2 && \"Missing RHS of a set?\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 2211, __extension__ __PRETTY_FUNCTION__)); | |||
2212 | unsigned NC = getNumChildren(); | |||
2213 | ||||
2214 | TreePatternNode *SetVal = getChild(NC-1); | |||
2215 | bool MadeChange = SetVal->ApplyTypeConstraints(TP, NotRegisters); | |||
2216 | ||||
2217 | for (unsigned i = 0; i < NC-1; ++i) { | |||
2218 | TreePatternNode *Child = getChild(i); | |||
2219 | MadeChange |= Child->ApplyTypeConstraints(TP, NotRegisters); | |||
2220 | ||||
2221 | // Types of operands must match. | |||
2222 | MadeChange |= Child->UpdateNodeType(0, SetVal->getExtType(i), TP); | |||
2223 | MadeChange |= SetVal->UpdateNodeType(i, Child->getExtType(0), TP); | |||
2224 | } | |||
2225 | return MadeChange; | |||
2226 | } | |||
2227 | ||||
2228 | if (getOperator()->getName() == "implicit") { | |||
2229 | assert(getNumTypes() == 0 && "Node doesn't produce a value")(static_cast <bool> (getNumTypes() == 0 && "Node doesn't produce a value" ) ? void (0) : __assert_fail ("getNumTypes() == 0 && \"Node doesn't produce a value\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 2229, __extension__ __PRETTY_FUNCTION__)); | |||
2230 | ||||
2231 | bool MadeChange = false; | |||
2232 | for (unsigned i = 0; i < getNumChildren(); ++i) | |||
2233 | MadeChange |= getChild(i)->ApplyTypeConstraints(TP, NotRegisters); | |||
2234 | return MadeChange; | |||
2235 | } | |||
2236 | ||||
2237 | if (const CodeGenIntrinsic *Int = getIntrinsicInfo(CDP)) { | |||
2238 | bool MadeChange = false; | |||
2239 | ||||
2240 | // Apply the result type to the node. | |||
2241 | unsigned NumRetVTs = Int->IS.RetVTs.size(); | |||
2242 | unsigned NumParamVTs = Int->IS.ParamVTs.size(); | |||
2243 | ||||
2244 | for (unsigned i = 0, e = NumRetVTs; i != e; ++i) | |||
2245 | MadeChange |= UpdateNodeType(i, Int->IS.RetVTs[i], TP); | |||
2246 | ||||
2247 | if (getNumChildren() != NumParamVTs + 1) { | |||
2248 | TP.error("Intrinsic '" + Int->Name + "' expects " + Twine(NumParamVTs) + | |||
2249 | " operands, not " + Twine(getNumChildren() - 1) + " operands!"); | |||
2250 | return false; | |||
2251 | } | |||
2252 | ||||
2253 | // Apply type info to the intrinsic ID. | |||
2254 | MadeChange |= getChild(0)->UpdateNodeType(0, MVT::iPTR, TP); | |||
2255 | ||||
2256 | for (unsigned i = 0, e = getNumChildren()-1; i != e; ++i) { | |||
2257 | MadeChange |= getChild(i+1)->ApplyTypeConstraints(TP, NotRegisters); | |||
2258 | ||||
2259 | MVT::SimpleValueType OpVT = Int->IS.ParamVTs[i]; | |||
2260 | assert(getChild(i+1)->getNumTypes() == 1 && "Unhandled case")(static_cast <bool> (getChild(i+1)->getNumTypes() == 1 && "Unhandled case") ? void (0) : __assert_fail ("getChild(i+1)->getNumTypes() == 1 && \"Unhandled case\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 2260, __extension__ __PRETTY_FUNCTION__)); | |||
2261 | MadeChange |= getChild(i+1)->UpdateNodeType(0, OpVT, TP); | |||
2262 | } | |||
2263 | return MadeChange; | |||
2264 | } | |||
2265 | ||||
2266 | if (getOperator()->isSubClassOf("SDNode")) { | |||
2267 | const SDNodeInfo &NI = CDP.getSDNodeInfo(getOperator()); | |||
2268 | ||||
2269 | // Check that the number of operands is sane. Negative operands -> varargs. | |||
2270 | if (NI.getNumOperands() >= 0 && | |||
2271 | getNumChildren() != (unsigned)NI.getNumOperands()) { | |||
2272 | TP.error(getOperator()->getName() + " node requires exactly " + | |||
2273 | Twine(NI.getNumOperands()) + " operands!"); | |||
2274 | return false; | |||
2275 | } | |||
2276 | ||||
2277 | bool MadeChange = false; | |||
2278 | for (unsigned i = 0, e = getNumChildren(); i != e; ++i) | |||
2279 | MadeChange |= getChild(i)->ApplyTypeConstraints(TP, NotRegisters); | |||
2280 | MadeChange |= NI.ApplyTypeConstraints(this, TP); | |||
2281 | return MadeChange; | |||
2282 | } | |||
2283 | ||||
2284 | if (getOperator()->isSubClassOf("Instruction")) { | |||
2285 | const DAGInstruction &Inst = CDP.getInstruction(getOperator()); | |||
2286 | CodeGenInstruction &InstInfo = | |||
2287 | CDP.getTargetInfo().getInstruction(getOperator()); | |||
2288 | ||||
2289 | bool MadeChange = false; | |||
2290 | ||||
2291 | // Apply the result types to the node, these come from the things in the | |||
2292 | // (outs) list of the instruction. | |||
2293 | unsigned NumResultsToAdd = std::min(InstInfo.Operands.NumDefs, | |||
2294 | Inst.getNumResults()); | |||
2295 | for (unsigned ResNo = 0; ResNo != NumResultsToAdd; ++ResNo) | |||
2296 | MadeChange |= UpdateNodeTypeFromInst(ResNo, Inst.getResult(ResNo), TP); | |||
2297 | ||||
2298 | // If the instruction has implicit defs, we apply the first one as a result. | |||
2299 | // FIXME: This sucks, it should apply all implicit defs. | |||
2300 | if (!InstInfo.ImplicitDefs.empty()) { | |||
2301 | unsigned ResNo = NumResultsToAdd; | |||
2302 | ||||
2303 | // FIXME: Generalize to multiple possible types and multiple possible | |||
2304 | // ImplicitDefs. | |||
2305 | MVT::SimpleValueType VT = | |||
2306 | InstInfo.HasOneImplicitDefWithKnownVT(CDP.getTargetInfo()); | |||
2307 | ||||
2308 | if (VT != MVT::Other) | |||
2309 | MadeChange |= UpdateNodeType(ResNo, VT, TP); | |||
2310 | } | |||
2311 | ||||
2312 | // If this is an INSERT_SUBREG, constrain the source and destination VTs to | |||
2313 | // be the same. | |||
2314 | if (getOperator()->getName() == "INSERT_SUBREG") { | |||
2315 | assert(getChild(0)->getNumTypes() == 1 && "FIXME: Unhandled")(static_cast <bool> (getChild(0)->getNumTypes() == 1 && "FIXME: Unhandled") ? void (0) : __assert_fail ("getChild(0)->getNumTypes() == 1 && \"FIXME: Unhandled\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 2315, __extension__ __PRETTY_FUNCTION__)); | |||
2316 | MadeChange |= UpdateNodeType(0, getChild(0)->getExtType(0), TP); | |||
2317 | MadeChange |= getChild(0)->UpdateNodeType(0, getExtType(0), TP); | |||
2318 | } else if (getOperator()->getName() == "REG_SEQUENCE") { | |||
2319 | // We need to do extra, custom typechecking for REG_SEQUENCE since it is | |||
2320 | // variadic. | |||
2321 | ||||
2322 | unsigned NChild = getNumChildren(); | |||
2323 | if (NChild < 3) { | |||
2324 | TP.error("REG_SEQUENCE requires at least 3 operands!"); | |||
2325 | return false; | |||
2326 | } | |||
2327 | ||||
2328 | if (NChild % 2 == 0) { | |||
2329 | TP.error("REG_SEQUENCE requires an odd number of operands!"); | |||
2330 | return false; | |||
2331 | } | |||
2332 | ||||
2333 | if (!isOperandClass(getChild(0), "RegisterClass")) { | |||
2334 | TP.error("REG_SEQUENCE requires a RegisterClass for first operand!"); | |||
2335 | return false; | |||
2336 | } | |||
2337 | ||||
2338 | for (unsigned I = 1; I < NChild; I += 2) { | |||
2339 | TreePatternNode *SubIdxChild = getChild(I + 1); | |||
2340 | if (!isOperandClass(SubIdxChild, "SubRegIndex")) { | |||
2341 | TP.error("REG_SEQUENCE requires a SubRegIndex for operand " + | |||
2342 | Twine(I + 1) + "!"); | |||
2343 | return false; | |||
2344 | } | |||
2345 | } | |||
2346 | } | |||
2347 | ||||
2348 | unsigned ChildNo = 0; | |||
2349 | for (unsigned i = 0, e = Inst.getNumOperands(); i != e; ++i) { | |||
2350 | Record *OperandNode = Inst.getOperand(i); | |||
2351 | ||||
2352 | // If the instruction expects a predicate or optional def operand, we | |||
2353 | // codegen this by setting the operand to it's default value if it has a | |||
2354 | // non-empty DefaultOps field. | |||
2355 | if (OperandNode->isSubClassOf("OperandWithDefaultOps") && | |||
2356 | !CDP.getDefaultOperand(OperandNode).DefaultOps.empty()) | |||
2357 | continue; | |||
2358 | ||||
2359 | // Verify that we didn't run out of provided operands. | |||
2360 | if (ChildNo >= getNumChildren()) { | |||
2361 | emitTooFewOperandsError(TP, getOperator()->getName(), getNumChildren()); | |||
2362 | return false; | |||
2363 | } | |||
2364 | ||||
2365 | TreePatternNode *Child = getChild(ChildNo++); | |||
2366 | unsigned ChildResNo = 0; // Instructions always use res #0 of their op. | |||
2367 | ||||
2368 | // If the operand has sub-operands, they may be provided by distinct | |||
2369 | // child patterns, so attempt to match each sub-operand separately. | |||
2370 | if (OperandNode->isSubClassOf("Operand")) { | |||
2371 | DagInit *MIOpInfo = OperandNode->getValueAsDag("MIOperandInfo"); | |||
2372 | if (unsigned NumArgs = MIOpInfo->getNumArgs()) { | |||
2373 | // But don't do that if the whole operand is being provided by | |||
2374 | // a single ComplexPattern-related Operand. | |||
2375 | ||||
2376 | if (Child->getNumMIResults(CDP) < NumArgs) { | |||
2377 | // Match first sub-operand against the child we already have. | |||
2378 | Record *SubRec = cast<DefInit>(MIOpInfo->getArg(0))->getDef(); | |||
2379 | MadeChange |= | |||
2380 | Child->UpdateNodeTypeFromInst(ChildResNo, SubRec, TP); | |||
2381 | ||||
2382 | // And the remaining sub-operands against subsequent children. | |||
2383 | for (unsigned Arg = 1; Arg < NumArgs; ++Arg) { | |||
2384 | if (ChildNo >= getNumChildren()) { | |||
2385 | emitTooFewOperandsError(TP, getOperator()->getName(), | |||
2386 | getNumChildren()); | |||
2387 | return false; | |||
2388 | } | |||
2389 | Child = getChild(ChildNo++); | |||
2390 | ||||
2391 | SubRec = cast<DefInit>(MIOpInfo->getArg(Arg))->getDef(); | |||
2392 | MadeChange |= | |||
2393 | Child->UpdateNodeTypeFromInst(ChildResNo, SubRec, TP); | |||
2394 | } | |||
2395 | continue; | |||
2396 | } | |||
2397 | } | |||
2398 | } | |||
2399 | ||||
2400 | // If we didn't match by pieces above, attempt to match the whole | |||
2401 | // operand now. | |||
2402 | MadeChange |= Child->UpdateNodeTypeFromInst(ChildResNo, OperandNode, TP); | |||
2403 | } | |||
2404 | ||||
2405 | if (!InstInfo.Operands.isVariadic && ChildNo != getNumChildren()) { | |||
2406 | emitTooManyOperandsError(TP, getOperator()->getName(), | |||
2407 | ChildNo, getNumChildren()); | |||
2408 | return false; | |||
2409 | } | |||
2410 | ||||
2411 | for (unsigned i = 0, e = getNumChildren(); i != e; ++i) | |||
2412 | MadeChange |= getChild(i)->ApplyTypeConstraints(TP, NotRegisters); | |||
2413 | return MadeChange; | |||
2414 | } | |||
2415 | ||||
2416 | if (getOperator()->isSubClassOf("ComplexPattern")) { | |||
2417 | bool MadeChange = false; | |||
2418 | ||||
2419 | for (unsigned i = 0; i < getNumChildren(); ++i) | |||
2420 | MadeChange |= getChild(i)->ApplyTypeConstraints(TP, NotRegisters); | |||
2421 | ||||
2422 | return MadeChange; | |||
2423 | } | |||
2424 | ||||
2425 | assert(getOperator()->isSubClassOf("SDNodeXForm") && "Unknown node type!")(static_cast <bool> (getOperator()->isSubClassOf("SDNodeXForm" ) && "Unknown node type!") ? void (0) : __assert_fail ("getOperator()->isSubClassOf(\"SDNodeXForm\") && \"Unknown node type!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 2425, __extension__ __PRETTY_FUNCTION__)); | |||
2426 | ||||
2427 | // Node transforms always take one operand. | |||
2428 | if (getNumChildren() != 1) { | |||
2429 | TP.error("Node transform '" + getOperator()->getName() + | |||
2430 | "' requires one operand!"); | |||
2431 | return false; | |||
2432 | } | |||
2433 | ||||
2434 | bool MadeChange = getChild(0)->ApplyTypeConstraints(TP, NotRegisters); | |||
2435 | return MadeChange; | |||
2436 | } | |||
2437 | ||||
2438 | /// OnlyOnRHSOfCommutative - Return true if this value is only allowed on the | |||
2439 | /// RHS of a commutative operation, not the on LHS. | |||
2440 | static bool OnlyOnRHSOfCommutative(TreePatternNode *N) { | |||
2441 | if (!N->isLeaf() && N->getOperator()->getName() == "imm") | |||
2442 | return true; | |||
2443 | if (N->isLeaf() && isa<IntInit>(N->getLeafValue())) | |||
2444 | return true; | |||
2445 | return false; | |||
2446 | } | |||
2447 | ||||
2448 | ||||
2449 | /// canPatternMatch - If it is impossible for this pattern to match on this | |||
2450 | /// target, fill in Reason and return false. Otherwise, return true. This is | |||
2451 | /// used as a sanity check for .td files (to prevent people from writing stuff | |||
2452 | /// that can never possibly work), and to prevent the pattern permuter from | |||
2453 | /// generating stuff that is useless. | |||
2454 | bool TreePatternNode::canPatternMatch(std::string &Reason, | |||
2455 | const CodeGenDAGPatterns &CDP) { | |||
2456 | if (isLeaf()) return true; | |||
2457 | ||||
2458 | for (unsigned i = 0, e = getNumChildren(); i != e; ++i) | |||
2459 | if (!getChild(i)->canPatternMatch(Reason, CDP)) | |||
2460 | return false; | |||
2461 | ||||
2462 | // If this is an intrinsic, handle cases that would make it not match. For | |||
2463 | // example, if an operand is required to be an immediate. | |||
2464 | if (getOperator()->isSubClassOf("Intrinsic")) { | |||
2465 | // TODO: | |||
2466 | return true; | |||
2467 | } | |||
2468 | ||||
2469 | if (getOperator()->isSubClassOf("ComplexPattern")) | |||
2470 | return true; | |||
2471 | ||||
2472 | // If this node is a commutative operator, check that the LHS isn't an | |||
2473 | // immediate. | |||
2474 | const SDNodeInfo &NodeInfo = CDP.getSDNodeInfo(getOperator()); | |||
2475 | bool isCommIntrinsic = isCommutativeIntrinsic(CDP); | |||
2476 | if (NodeInfo.hasProperty(SDNPCommutative) || isCommIntrinsic) { | |||
2477 | // Scan all of the operands of the node and make sure that only the last one | |||
2478 | // is a constant node, unless the RHS also is. | |||
2479 | if (!OnlyOnRHSOfCommutative(getChild(getNumChildren()-1))) { | |||
2480 | unsigned Skip = isCommIntrinsic ? 1 : 0; // First operand is intrinsic id. | |||
2481 | for (unsigned i = Skip, e = getNumChildren()-1; i != e; ++i) | |||
2482 | if (OnlyOnRHSOfCommutative(getChild(i))) { | |||
2483 | Reason="Immediate value must be on the RHS of commutative operators!"; | |||
2484 | return false; | |||
2485 | } | |||
2486 | } | |||
2487 | } | |||
2488 | ||||
2489 | return true; | |||
2490 | } | |||
2491 | ||||
2492 | //===----------------------------------------------------------------------===// | |||
2493 | // TreePattern implementation | |||
2494 | // | |||
2495 | ||||
2496 | TreePattern::TreePattern(Record *TheRec, ListInit *RawPat, bool isInput, | |||
2497 | CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp), | |||
2498 | isInputPattern(isInput), HasError(false), | |||
2499 | Infer(*this) { | |||
2500 | for (Init *I : RawPat->getValues()) | |||
2501 | Trees.push_back(ParseTreePattern(I, "")); | |||
2502 | } | |||
2503 | ||||
2504 | TreePattern::TreePattern(Record *TheRec, DagInit *Pat, bool isInput, | |||
2505 | CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp), | |||
2506 | isInputPattern(isInput), HasError(false), | |||
2507 | Infer(*this) { | |||
2508 | Trees.push_back(ParseTreePattern(Pat, "")); | |||
2509 | } | |||
2510 | ||||
2511 | TreePattern::TreePattern(Record *TheRec, TreePatternNode *Pat, bool isInput, | |||
2512 | CodeGenDAGPatterns &cdp) : TheRecord(TheRec), CDP(cdp), | |||
2513 | isInputPattern(isInput), HasError(false), | |||
2514 | Infer(*this) { | |||
2515 | Trees.push_back(Pat); | |||
2516 | } | |||
2517 | ||||
2518 | void TreePattern::error(const Twine &Msg) { | |||
2519 | if (HasError) | |||
2520 | return; | |||
2521 | dump(); | |||
2522 | PrintError(TheRecord->getLoc(), "In " + TheRecord->getName() + ": " + Msg); | |||
2523 | HasError = true; | |||
2524 | } | |||
2525 | ||||
2526 | void TreePattern::ComputeNamedNodes() { | |||
2527 | for (TreePatternNode *Tree : Trees) | |||
2528 | ComputeNamedNodes(Tree); | |||
2529 | } | |||
2530 | ||||
2531 | void TreePattern::ComputeNamedNodes(TreePatternNode *N) { | |||
2532 | if (!N->getName().empty()) | |||
2533 | NamedNodes[N->getName()].push_back(N); | |||
2534 | ||||
2535 | for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) | |||
2536 | ComputeNamedNodes(N->getChild(i)); | |||
2537 | } | |||
2538 | ||||
2539 | ||||
2540 | TreePatternNode *TreePattern::ParseTreePattern(Init *TheInit, StringRef OpName){ | |||
2541 | if (DefInit *DI = dyn_cast<DefInit>(TheInit)) { | |||
2542 | Record *R = DI->getDef(); | |||
2543 | ||||
2544 | // Direct reference to a leaf DagNode or PatFrag? Turn it into a | |||
2545 | // TreePatternNode of its own. For example: | |||
2546 | /// (foo GPR, imm) -> (foo GPR, (imm)) | |||
2547 | if (R->isSubClassOf("SDNode") || R->isSubClassOf("PatFrag")) | |||
2548 | return ParseTreePattern( | |||
2549 | DagInit::get(DI, nullptr, | |||
2550 | std::vector<std::pair<Init*, StringInit*> >()), | |||
2551 | OpName); | |||
2552 | ||||
2553 | // Input argument? | |||
2554 | TreePatternNode *Res = new TreePatternNode(DI, 1); | |||
2555 | if (R->getName() == "node" && !OpName.empty()) { | |||
2556 | if (OpName.empty()) | |||
2557 | error("'node' argument requires a name to match with operand list"); | |||
2558 | Args.push_back(OpName); | |||
2559 | } | |||
2560 | ||||
2561 | Res->setName(OpName); | |||
2562 | return Res; | |||
2563 | } | |||
2564 | ||||
2565 | // ?:$name or just $name. | |||
2566 | if (isa<UnsetInit>(TheInit)) { | |||
2567 | if (OpName.empty()) | |||
2568 | error("'?' argument requires a name to match with operand list"); | |||
2569 | TreePatternNode *Res = new TreePatternNode(TheInit, 1); | |||
2570 | Args.push_back(OpName); | |||
2571 | Res->setName(OpName); | |||
2572 | return Res; | |||
2573 | } | |||
2574 | ||||
2575 | if (IntInit *II = dyn_cast<IntInit>(TheInit)) { | |||
2576 | if (!OpName.empty()) | |||
2577 | error("Constant int argument should not have a name!"); | |||
2578 | return new TreePatternNode(II, 1); | |||
2579 | } | |||
2580 | ||||
2581 | if (BitsInit *BI = dyn_cast<BitsInit>(TheInit)) { | |||
2582 | // Turn this into an IntInit. | |||
2583 | Init *II = BI->convertInitializerTo(IntRecTy::get()); | |||
2584 | if (!II || !isa<IntInit>(II)) | |||
2585 | error("Bits value must be constants!"); | |||
2586 | return ParseTreePattern(II, OpName); | |||
2587 | } | |||
2588 | ||||
2589 | DagInit *Dag = dyn_cast<DagInit>(TheInit); | |||
2590 | if (!Dag) { | |||
2591 | TheInit->print(errs()); | |||
2592 | error("Pattern has unexpected init kind!"); | |||
2593 | } | |||
2594 | DefInit *OpDef = dyn_cast<DefInit>(Dag->getOperator()); | |||
2595 | if (!OpDef) error("Pattern has unexpected operator type!"); | |||
2596 | Record *Operator = OpDef->getDef(); | |||
2597 | ||||
2598 | if (Operator->isSubClassOf("ValueType")) { | |||
2599 | // If the operator is a ValueType, then this must be "type cast" of a leaf | |||
2600 | // node. | |||
2601 | if (Dag->getNumArgs() != 1) | |||
2602 | error("Type cast only takes one operand!"); | |||
2603 | ||||
2604 | TreePatternNode *New = ParseTreePattern(Dag->getArg(0), | |||
2605 | Dag->getArgNameStr(0)); | |||
2606 | ||||
2607 | // Apply the type cast. | |||
2608 | assert(New->getNumTypes() == 1 && "FIXME: Unhandled")(static_cast <bool> (New->getNumTypes() == 1 && "FIXME: Unhandled") ? void (0) : __assert_fail ("New->getNumTypes() == 1 && \"FIXME: Unhandled\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 2608, __extension__ __PRETTY_FUNCTION__)); | |||
2609 | const CodeGenHwModes &CGH = getDAGPatterns().getTargetInfo().getHwModes(); | |||
2610 | New->UpdateNodeType(0, getValueTypeByHwMode(Operator, CGH), *this); | |||
2611 | ||||
2612 | if (!OpName.empty()) | |||
2613 | error("ValueType cast should not have a name!"); | |||
2614 | return New; | |||
2615 | } | |||
2616 | ||||
2617 | // Verify that this is something that makes sense for an operator. | |||
2618 | if (!Operator->isSubClassOf("PatFrag") && | |||
2619 | !Operator->isSubClassOf("SDNode") && | |||
2620 | !Operator->isSubClassOf("Instruction") && | |||
2621 | !Operator->isSubClassOf("SDNodeXForm") && | |||
2622 | !Operator->isSubClassOf("Intrinsic") && | |||
2623 | !Operator->isSubClassOf("ComplexPattern") && | |||
2624 | Operator->getName() != "set" && | |||
2625 | Operator->getName() != "implicit") | |||
2626 | error("Unrecognized node '" + Operator->getName() + "'!"); | |||
2627 | ||||
2628 | // Check to see if this is something that is illegal in an input pattern. | |||
2629 | if (isInputPattern) { | |||
2630 | if (Operator->isSubClassOf("Instruction") || | |||
2631 | Operator->isSubClassOf("SDNodeXForm")) | |||
2632 | error("Cannot use '" + Operator->getName() + "' in an input pattern!"); | |||
2633 | } else { | |||
2634 | if (Operator->isSubClassOf("Intrinsic")) | |||
2635 | error("Cannot use '" + Operator->getName() + "' in an output pattern!"); | |||
2636 | ||||
2637 | if (Operator->isSubClassOf("SDNode") && | |||
2638 | Operator->getName() != "imm" && | |||
2639 | Operator->getName() != "fpimm" && | |||
2640 | Operator->getName() != "tglobaltlsaddr" && | |||
2641 | Operator->getName() != "tconstpool" && | |||
2642 | Operator->getName() != "tjumptable" && | |||
2643 | Operator->getName() != "tframeindex" && | |||
2644 | Operator->getName() != "texternalsym" && | |||
2645 | Operator->getName() != "tblockaddress" && | |||
2646 | Operator->getName() != "tglobaladdr" && | |||
2647 | Operator->getName() != "bb" && | |||
2648 | Operator->getName() != "vt" && | |||
2649 | Operator->getName() != "mcsym") | |||
2650 | error("Cannot use '" + Operator->getName() + "' in an output pattern!"); | |||
2651 | } | |||
2652 | ||||
2653 | std::vector<TreePatternNode*> Children; | |||
2654 | ||||
2655 | // Parse all the operands. | |||
2656 | for (unsigned i = 0, e = Dag->getNumArgs(); i != e; ++i) | |||
2657 | Children.push_back(ParseTreePattern(Dag->getArg(i), Dag->getArgNameStr(i))); | |||
2658 | ||||
2659 | // Get the actual number of results before Operator is converted to an intrinsic | |||
2660 | // node (which is hard-coded to have either zero or one result). | |||
2661 | unsigned NumResults = GetNumNodeResults(Operator, CDP); | |||
2662 | ||||
2663 | // If the operator is an intrinsic, then this is just syntactic sugar for | |||
2664 | // (intrinsic_* <number>, ..children..). Pick the right intrinsic node, and | |||
2665 | // convert the intrinsic name to a number. | |||
2666 | if (Operator->isSubClassOf("Intrinsic")) { | |||
2667 | const CodeGenIntrinsic &Int = getDAGPatterns().getIntrinsic(Operator); | |||
2668 | unsigned IID = getDAGPatterns().getIntrinsicID(Operator)+1; | |||
2669 | ||||
2670 | // If this intrinsic returns void, it must have side-effects and thus a | |||
2671 | // chain. | |||
2672 | if (Int.IS.RetVTs.empty()) | |||
2673 | Operator = getDAGPatterns().get_intrinsic_void_sdnode(); | |||
2674 | else if (Int.ModRef != CodeGenIntrinsic::NoMem) | |||
2675 | // Has side-effects, requires chain. | |||
2676 | Operator = getDAGPatterns().get_intrinsic_w_chain_sdnode(); | |||
2677 | else // Otherwise, no chain. | |||
2678 | Operator = getDAGPatterns().get_intrinsic_wo_chain_sdnode(); | |||
2679 | ||||
2680 | TreePatternNode *IIDNode = new TreePatternNode(IntInit::get(IID), 1); | |||
2681 | Children.insert(Children.begin(), IIDNode); | |||
2682 | } | |||
2683 | ||||
2684 | if (Operator->isSubClassOf("ComplexPattern")) { | |||
2685 | for (unsigned i = 0; i < Children.size(); ++i) { | |||
2686 | TreePatternNode *Child = Children[i]; | |||
2687 | ||||
2688 | if (Child->getName().empty()) | |||
2689 | error("All arguments to a ComplexPattern must be named"); | |||
2690 | ||||
2691 | // Check that the ComplexPattern uses are consistent: "(MY_PAT $a, $b)" | |||
2692 | // and "(MY_PAT $b, $a)" should not be allowed in the same pattern; | |||
2693 | // neither should "(MY_PAT_1 $a, $b)" and "(MY_PAT_2 $a, $b)". | |||
2694 | auto OperandId = std::make_pair(Operator, i); | |||
2695 | auto PrevOp = ComplexPatternOperands.find(Child->getName()); | |||
2696 | if (PrevOp != ComplexPatternOperands.end()) { | |||
2697 | if (PrevOp->getValue() != OperandId) | |||
2698 | error("All ComplexPattern operands must appear consistently: " | |||
2699 | "in the same order in just one ComplexPattern instance."); | |||
2700 | } else | |||
2701 | ComplexPatternOperands[Child->getName()] = OperandId; | |||
2702 | } | |||
2703 | } | |||
2704 | ||||
2705 | TreePatternNode *Result = new TreePatternNode(Operator, Children, NumResults); | |||
2706 | Result->setName(OpName); | |||
2707 | ||||
2708 | if (Dag->getName()) { | |||
2709 | assert(Result->getName().empty())(static_cast <bool> (Result->getName().empty()) ? void (0) : __assert_fail ("Result->getName().empty()", "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 2709, __extension__ __PRETTY_FUNCTION__)); | |||
2710 | Result->setName(Dag->getNameStr()); | |||
2711 | } | |||
2712 | return Result; | |||
2713 | } | |||
2714 | ||||
2715 | /// SimplifyTree - See if we can simplify this tree to eliminate something that | |||
2716 | /// will never match in favor of something obvious that will. This is here | |||
2717 | /// strictly as a convenience to target authors because it allows them to write | |||
2718 | /// more type generic things and have useless type casts fold away. | |||
2719 | /// | |||
2720 | /// This returns true if any change is made. | |||
2721 | static bool SimplifyTree(TreePatternNode *&N) { | |||
2722 | if (N->isLeaf()) | |||
2723 | return false; | |||
2724 | ||||
2725 | // If we have a bitconvert with a resolved type and if the source and | |||
2726 | // destination types are the same, then the bitconvert is useless, remove it. | |||
2727 | if (N->getOperator()->getName() == "bitconvert" && | |||
2728 | N->getExtType(0).isValueTypeByHwMode(false) && | |||
2729 | N->getExtType(0) == N->getChild(0)->getExtType(0) && | |||
2730 | N->getName().empty()) { | |||
2731 | N = N->getChild(0); | |||
2732 | SimplifyTree(N); | |||
2733 | return true; | |||
2734 | } | |||
2735 | ||||
2736 | // Walk all children. | |||
2737 | bool MadeChange = false; | |||
2738 | for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) { | |||
2739 | TreePatternNode *Child = N->getChild(i); | |||
2740 | MadeChange |= SimplifyTree(Child); | |||
2741 | N->setChild(i, Child); | |||
2742 | } | |||
2743 | return MadeChange; | |||
2744 | } | |||
2745 | ||||
2746 | ||||
2747 | ||||
2748 | /// InferAllTypes - Infer/propagate as many types throughout the expression | |||
2749 | /// patterns as possible. Return true if all types are inferred, false | |||
2750 | /// otherwise. Flags an error if a type contradiction is found. | |||
2751 | bool TreePattern:: | |||
2752 | InferAllTypes(const StringMap<SmallVector<TreePatternNode*,1> > *InNamedTypes) { | |||
2753 | if (NamedNodes.empty()) | |||
2754 | ComputeNamedNodes(); | |||
2755 | ||||
2756 | bool MadeChange = true; | |||
2757 | while (MadeChange) { | |||
2758 | MadeChange = false; | |||
2759 | for (TreePatternNode *&Tree : Trees) { | |||
2760 | MadeChange |= Tree->ApplyTypeConstraints(*this, false); | |||
2761 | MadeChange |= SimplifyTree(Tree); | |||
2762 | } | |||
2763 | ||||
2764 | // If there are constraints on our named nodes, apply them. | |||
2765 | for (auto &Entry : NamedNodes) { | |||
2766 | SmallVectorImpl<TreePatternNode*> &Nodes = Entry.second; | |||
2767 | ||||
2768 | // If we have input named node types, propagate their types to the named | |||
2769 | // values here. | |||
2770 | if (InNamedTypes) { | |||
2771 | if (!InNamedTypes->count(Entry.getKey())) { | |||
2772 | error("Node '" + std::string(Entry.getKey()) + | |||
2773 | "' in output pattern but not input pattern"); | |||
2774 | return true; | |||
2775 | } | |||
2776 | ||||
2777 | const SmallVectorImpl<TreePatternNode*> &InNodes = | |||
2778 | InNamedTypes->find(Entry.getKey())->second; | |||
2779 | ||||
2780 | // The input types should be fully resolved by now. | |||
2781 | for (TreePatternNode *Node : Nodes) { | |||
2782 | // If this node is a register class, and it is the root of the pattern | |||
2783 | // then we're mapping something onto an input register. We allow | |||
2784 | // changing the type of the input register in this case. This allows | |||
2785 | // us to match things like: | |||
2786 | // def : Pat<(v1i64 (bitconvert(v2i32 DPR:$src))), (v1i64 DPR:$src)>; | |||
2787 | if (Node == Trees[0] && Node->isLeaf()) { | |||
2788 | DefInit *DI = dyn_cast<DefInit>(Node->getLeafValue()); | |||
2789 | if (DI && (DI->getDef()->isSubClassOf("RegisterClass") || | |||
2790 | DI->getDef()->isSubClassOf("RegisterOperand"))) | |||
2791 | continue; | |||
2792 | } | |||
2793 | ||||
2794 | assert(Node->getNumTypes() == 1 &&(static_cast <bool> (Node->getNumTypes() == 1 && InNodes[0]->getNumTypes() == 1 && "FIXME: cannot name multiple result nodes yet" ) ? void (0) : __assert_fail ("Node->getNumTypes() == 1 && InNodes[0]->getNumTypes() == 1 && \"FIXME: cannot name multiple result nodes yet\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 2796, __extension__ __PRETTY_FUNCTION__)) | |||
2795 | InNodes[0]->getNumTypes() == 1 &&(static_cast <bool> (Node->getNumTypes() == 1 && InNodes[0]->getNumTypes() == 1 && "FIXME: cannot name multiple result nodes yet" ) ? void (0) : __assert_fail ("Node->getNumTypes() == 1 && InNodes[0]->getNumTypes() == 1 && \"FIXME: cannot name multiple result nodes yet\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 2796, __extension__ __PRETTY_FUNCTION__)) | |||
2796 | "FIXME: cannot name multiple result nodes yet")(static_cast <bool> (Node->getNumTypes() == 1 && InNodes[0]->getNumTypes() == 1 && "FIXME: cannot name multiple result nodes yet" ) ? void (0) : __assert_fail ("Node->getNumTypes() == 1 && InNodes[0]->getNumTypes() == 1 && \"FIXME: cannot name multiple result nodes yet\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 2796, __extension__ __PRETTY_FUNCTION__)); | |||
2797 | MadeChange |= Node->UpdateNodeType(0, InNodes[0]->getExtType(0), | |||
2798 | *this); | |||
2799 | } | |||
2800 | } | |||
2801 | ||||
2802 | // If there are multiple nodes with the same name, they must all have the | |||
2803 | // same type. | |||
2804 | if (Entry.second.size() > 1) { | |||
2805 | for (unsigned i = 0, e = Nodes.size()-1; i != e; ++i) { | |||
2806 | TreePatternNode *N1 = Nodes[i], *N2 = Nodes[i+1]; | |||
2807 | assert(N1->getNumTypes() == 1 && N2->getNumTypes() == 1 &&(static_cast <bool> (N1->getNumTypes() == 1 && N2->getNumTypes() == 1 && "FIXME: cannot name multiple result nodes yet" ) ? void (0) : __assert_fail ("N1->getNumTypes() == 1 && N2->getNumTypes() == 1 && \"FIXME: cannot name multiple result nodes yet\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 2808, __extension__ __PRETTY_FUNCTION__)) | |||
2808 | "FIXME: cannot name multiple result nodes yet")(static_cast <bool> (N1->getNumTypes() == 1 && N2->getNumTypes() == 1 && "FIXME: cannot name multiple result nodes yet" ) ? void (0) : __assert_fail ("N1->getNumTypes() == 1 && N2->getNumTypes() == 1 && \"FIXME: cannot name multiple result nodes yet\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 2808, __extension__ __PRETTY_FUNCTION__)); | |||
2809 | ||||
2810 | MadeChange |= N1->UpdateNodeType(0, N2->getExtType(0), *this); | |||
2811 | MadeChange |= N2->UpdateNodeType(0, N1->getExtType(0), *this); | |||
2812 | } | |||
2813 | } | |||
2814 | } | |||
2815 | } | |||
2816 | ||||
2817 | bool HasUnresolvedTypes = false; | |||
2818 | for (const TreePatternNode *Tree : Trees) | |||
2819 | HasUnresolvedTypes |= Tree->ContainsUnresolvedType(*this); | |||
2820 | return !HasUnresolvedTypes; | |||
2821 | } | |||
2822 | ||||
2823 | void TreePattern::print(raw_ostream &OS) const { | |||
2824 | OS << getRecord()->getName(); | |||
2825 | if (!Args.empty()) { | |||
2826 | OS << "(" << Args[0]; | |||
2827 | for (unsigned i = 1, e = Args.size(); i != e; ++i) | |||
2828 | OS << ", " << Args[i]; | |||
2829 | OS << ")"; | |||
2830 | } | |||
2831 | OS << ": "; | |||
2832 | ||||
2833 | if (Trees.size() > 1) | |||
2834 | OS << "[\n"; | |||
2835 | for (const TreePatternNode *Tree : Trees) { | |||
2836 | OS << "\t"; | |||
2837 | Tree->print(OS); | |||
2838 | OS << "\n"; | |||
2839 | } | |||
2840 | ||||
2841 | if (Trees.size() > 1) | |||
2842 | OS << "]\n"; | |||
2843 | } | |||
2844 | ||||
2845 | void TreePattern::dump() const { print(errs()); } | |||
2846 | ||||
2847 | //===----------------------------------------------------------------------===// | |||
2848 | // CodeGenDAGPatterns implementation | |||
2849 | // | |||
2850 | ||||
2851 | CodeGenDAGPatterns::CodeGenDAGPatterns(RecordKeeper &R, | |||
2852 | PatternRewriterFn PatternRewriter) | |||
2853 | : Records(R), Target(R), LegalVTS(Target.getLegalValueTypes()), | |||
2854 | PatternRewriter(PatternRewriter) { | |||
2855 | ||||
2856 | Intrinsics = CodeGenIntrinsicTable(Records, false); | |||
2857 | TgtIntrinsics = CodeGenIntrinsicTable(Records, true); | |||
2858 | ParseNodeInfo(); | |||
2859 | ParseNodeTransforms(); | |||
2860 | ParseComplexPatterns(); | |||
2861 | ParsePatternFragments(); | |||
2862 | ParseDefaultOperands(); | |||
2863 | ParseInstructions(); | |||
| ||||
2864 | ParsePatternFragments(/*OutFrags*/true); | |||
2865 | ParsePatterns(); | |||
2866 | ||||
2867 | // Break patterns with parameterized types into a series of patterns, | |||
2868 | // where each one has a fixed type and is predicated on the conditions | |||
2869 | // of the associated HW mode. | |||
2870 | ExpandHwModeBasedTypes(); | |||
2871 | ||||
2872 | // Generate variants. For example, commutative patterns can match | |||
2873 | // multiple ways. Add them to PatternsToMatch as well. | |||
2874 | GenerateVariants(); | |||
2875 | ||||
2876 | // Infer instruction flags. For example, we can detect loads, | |||
2877 | // stores, and side effects in many cases by examining an | |||
2878 | // instruction's pattern. | |||
2879 | InferInstructionFlags(); | |||
2880 | ||||
2881 | // Verify that instruction flags match the patterns. | |||
2882 | VerifyInstructionFlags(); | |||
2883 | } | |||
2884 | ||||
2885 | Record *CodeGenDAGPatterns::getSDNodeNamed(const std::string &Name) const { | |||
2886 | Record *N = Records.getDef(Name); | |||
2887 | if (!N || !N->isSubClassOf("SDNode")) | |||
2888 | PrintFatalError("Error getting SDNode '" + Name + "'!"); | |||
2889 | ||||
2890 | return N; | |||
2891 | } | |||
2892 | ||||
2893 | // Parse all of the SDNode definitions for the target, populating SDNodes. | |||
2894 | void CodeGenDAGPatterns::ParseNodeInfo() { | |||
2895 | std::vector<Record*> Nodes = Records.getAllDerivedDefinitions("SDNode"); | |||
2896 | const CodeGenHwModes &CGH = getTargetInfo().getHwModes(); | |||
2897 | ||||
2898 | while (!Nodes.empty()) { | |||
2899 | Record *R = Nodes.back(); | |||
2900 | SDNodes.insert(std::make_pair(R, SDNodeInfo(R, CGH))); | |||
2901 | Nodes.pop_back(); | |||
2902 | } | |||
2903 | ||||
2904 | // Get the builtin intrinsic nodes. | |||
2905 | intrinsic_void_sdnode = getSDNodeNamed("intrinsic_void"); | |||
2906 | intrinsic_w_chain_sdnode = getSDNodeNamed("intrinsic_w_chain"); | |||
2907 | intrinsic_wo_chain_sdnode = getSDNodeNamed("intrinsic_wo_chain"); | |||
2908 | } | |||
2909 | ||||
2910 | /// ParseNodeTransforms - Parse all SDNodeXForm instances into the SDNodeXForms | |||
2911 | /// map, and emit them to the file as functions. | |||
2912 | void CodeGenDAGPatterns::ParseNodeTransforms() { | |||
2913 | std::vector<Record*> Xforms = Records.getAllDerivedDefinitions("SDNodeXForm"); | |||
2914 | while (!Xforms.empty()) { | |||
2915 | Record *XFormNode = Xforms.back(); | |||
2916 | Record *SDNode = XFormNode->getValueAsDef("Opcode"); | |||
2917 | StringRef Code = XFormNode->getValueAsString("XFormFunction"); | |||
2918 | SDNodeXForms.insert(std::make_pair(XFormNode, NodeXForm(SDNode, Code))); | |||
2919 | ||||
2920 | Xforms.pop_back(); | |||
2921 | } | |||
2922 | } | |||
2923 | ||||
2924 | void CodeGenDAGPatterns::ParseComplexPatterns() { | |||
2925 | std::vector<Record*> AMs = Records.getAllDerivedDefinitions("ComplexPattern"); | |||
2926 | while (!AMs.empty()) { | |||
2927 | ComplexPatterns.insert(std::make_pair(AMs.back(), AMs.back())); | |||
2928 | AMs.pop_back(); | |||
2929 | } | |||
2930 | } | |||
2931 | ||||
2932 | ||||
2933 | /// ParsePatternFragments - Parse all of the PatFrag definitions in the .td | |||
2934 | /// file, building up the PatternFragments map. After we've collected them all, | |||
2935 | /// inline fragments together as necessary, so that there are no references left | |||
2936 | /// inside a pattern fragment to a pattern fragment. | |||
2937 | /// | |||
2938 | void CodeGenDAGPatterns::ParsePatternFragments(bool OutFrags) { | |||
2939 | std::vector<Record*> Fragments = Records.getAllDerivedDefinitions("PatFrag"); | |||
2940 | ||||
2941 | // First step, parse all of the fragments. | |||
2942 | for (Record *Frag : Fragments) { | |||
2943 | if (OutFrags != Frag->isSubClassOf("OutPatFrag")) | |||
2944 | continue; | |||
2945 | ||||
2946 | DagInit *Tree = Frag->getValueAsDag("Fragment"); | |||
2947 | TreePattern *P = | |||
2948 | (PatternFragments[Frag] = llvm::make_unique<TreePattern>( | |||
2949 | Frag, Tree, !Frag->isSubClassOf("OutPatFrag"), | |||
2950 | *this)).get(); | |||
2951 | ||||
2952 | // Validate the argument list, converting it to set, to discard duplicates. | |||
2953 | std::vector<std::string> &Args = P->getArgList(); | |||
2954 | // Copy the args so we can take StringRefs to them. | |||
2955 | auto ArgsCopy = Args; | |||
2956 | SmallDenseSet<StringRef, 4> OperandsSet; | |||
2957 | OperandsSet.insert(ArgsCopy.begin(), ArgsCopy.end()); | |||
2958 | ||||
2959 | if (OperandsSet.count("")) | |||
2960 | P->error("Cannot have unnamed 'node' values in pattern fragment!"); | |||
2961 | ||||
2962 | // Parse the operands list. | |||
2963 | DagInit *OpsList = Frag->getValueAsDag("Operands"); | |||
2964 | DefInit *OpsOp = dyn_cast<DefInit>(OpsList->getOperator()); | |||
2965 | // Special cases: ops == outs == ins. Different names are used to | |||
2966 | // improve readability. | |||
2967 | if (!OpsOp || | |||
2968 | (OpsOp->getDef()->getName() != "ops" && | |||
2969 | OpsOp->getDef()->getName() != "outs" && | |||
2970 | OpsOp->getDef()->getName() != "ins")) | |||
2971 | P->error("Operands list should start with '(ops ... '!"); | |||
2972 | ||||
2973 | // Copy over the arguments. | |||
2974 | Args.clear(); | |||
2975 | for (unsigned j = 0, e = OpsList->getNumArgs(); j != e; ++j) { | |||
2976 | if (!isa<DefInit>(OpsList->getArg(j)) || | |||
2977 | cast<DefInit>(OpsList->getArg(j))->getDef()->getName() != "node") | |||
2978 | P->error("Operands list should all be 'node' values."); | |||
2979 | if (!OpsList->getArgName(j)) | |||
2980 | P->error("Operands list should have names for each operand!"); | |||
2981 | StringRef ArgNameStr = OpsList->getArgNameStr(j); | |||
2982 | if (!OperandsSet.count(ArgNameStr)) | |||
2983 | P->error("'" + ArgNameStr + | |||
2984 | "' does not occur in pattern or was multiply specified!"); | |||
2985 | OperandsSet.erase(ArgNameStr); | |||
2986 | Args.push_back(ArgNameStr); | |||
2987 | } | |||
2988 | ||||
2989 | if (!OperandsSet.empty()) | |||
2990 | P->error("Operands list does not contain an entry for operand '" + | |||
2991 | *OperandsSet.begin() + "'!"); | |||
2992 | ||||
2993 | // If there is a code init for this fragment, keep track of the fact that | |||
2994 | // this fragment uses it. | |||
2995 | TreePredicateFn PredFn(P); | |||
2996 | if (!PredFn.isAlwaysTrue()) | |||
2997 | P->getOnlyTree()->addPredicateFn(PredFn); | |||
2998 | ||||
2999 | // If there is a node transformation corresponding to this, keep track of | |||
3000 | // it. | |||
3001 | Record *Transform = Frag->getValueAsDef("OperandTransform"); | |||
3002 | if (!getSDNodeTransform(Transform).second.empty()) // not noop xform? | |||
3003 | P->getOnlyTree()->setTransformFn(Transform); | |||
3004 | } | |||
3005 | ||||
3006 | // Now that we've parsed all of the tree fragments, do a closure on them so | |||
3007 | // that there are not references to PatFrags left inside of them. | |||
3008 | for (Record *Frag : Fragments) { | |||
3009 | if (OutFrags != Frag->isSubClassOf("OutPatFrag")) | |||
3010 | continue; | |||
3011 | ||||
3012 | TreePattern &ThePat = *PatternFragments[Frag]; | |||
3013 | ThePat.InlinePatternFragments(); | |||
3014 | ||||
3015 | // Infer as many types as possible. Don't worry about it if we don't infer | |||
3016 | // all of them, some may depend on the inputs of the pattern. | |||
3017 | ThePat.InferAllTypes(); | |||
3018 | ThePat.resetError(); | |||
3019 | ||||
3020 | // If debugging, print out the pattern fragment result. | |||
3021 | DEBUG(ThePat.dump())do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { ThePat.dump(); } } while (false); | |||
3022 | } | |||
3023 | } | |||
3024 | ||||
3025 | void CodeGenDAGPatterns::ParseDefaultOperands() { | |||
3026 | std::vector<Record*> DefaultOps; | |||
3027 | DefaultOps = Records.getAllDerivedDefinitions("OperandWithDefaultOps"); | |||
3028 | ||||
3029 | // Find some SDNode. | |||
3030 | assert(!SDNodes.empty() && "No SDNodes parsed?")(static_cast <bool> (!SDNodes.empty() && "No SDNodes parsed?" ) ? void (0) : __assert_fail ("!SDNodes.empty() && \"No SDNodes parsed?\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 3030, __extension__ __PRETTY_FUNCTION__)); | |||
3031 | Init *SomeSDNode = DefInit::get(SDNodes.begin()->first); | |||
3032 | ||||
3033 | for (unsigned i = 0, e = DefaultOps.size(); i != e; ++i) { | |||
3034 | DagInit *DefaultInfo = DefaultOps[i]->getValueAsDag("DefaultOps"); | |||
3035 | ||||
3036 | // Clone the DefaultInfo dag node, changing the operator from 'ops' to | |||
3037 | // SomeSDnode so that we can parse this. | |||
3038 | std::vector<std::pair<Init*, StringInit*> > Ops; | |||
3039 | for (unsigned op = 0, e = DefaultInfo->getNumArgs(); op != e; ++op) | |||
3040 | Ops.push_back(std::make_pair(DefaultInfo->getArg(op), | |||
3041 | DefaultInfo->getArgName(op))); | |||
3042 | DagInit *DI = DagInit::get(SomeSDNode, nullptr, Ops); | |||
3043 | ||||
3044 | // Create a TreePattern to parse this. | |||
3045 | TreePattern P(DefaultOps[i], DI, false, *this); | |||
3046 | assert(P.getNumTrees() == 1 && "This ctor can only produce one tree!")(static_cast <bool> (P.getNumTrees() == 1 && "This ctor can only produce one tree!" ) ? void (0) : __assert_fail ("P.getNumTrees() == 1 && \"This ctor can only produce one tree!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 3046, __extension__ __PRETTY_FUNCTION__)); | |||
3047 | ||||
3048 | // Copy the operands over into a DAGDefaultOperand. | |||
3049 | DAGDefaultOperand DefaultOpInfo; | |||
3050 | ||||
3051 | TreePatternNode *T = P.getTree(0); | |||
3052 | for (unsigned op = 0, e = T->getNumChildren(); op != e; ++op) { | |||
3053 | TreePatternNode *TPN = T->getChild(op); | |||
3054 | while (TPN->ApplyTypeConstraints(P, false)) | |||
3055 | /* Resolve all types */; | |||
3056 | ||||
3057 | if (TPN->ContainsUnresolvedType(P)) { | |||
3058 | PrintFatalError("Value #" + Twine(i) + " of OperandWithDefaultOps '" + | |||
3059 | DefaultOps[i]->getName() + | |||
3060 | "' doesn't have a concrete type!"); | |||
3061 | } | |||
3062 | DefaultOpInfo.DefaultOps.push_back(TPN); | |||
3063 | } | |||
3064 | ||||
3065 | // Insert it into the DefaultOperands map so we can find it later. | |||
3066 | DefaultOperands[DefaultOps[i]] = DefaultOpInfo; | |||
3067 | } | |||
3068 | } | |||
3069 | ||||
3070 | /// HandleUse - Given "Pat" a leaf in the pattern, check to see if it is an | |||
3071 | /// instruction input. Return true if this is a real use. | |||
3072 | static bool HandleUse(TreePattern *I, TreePatternNode *Pat, | |||
3073 | std::map<std::string, TreePatternNode*> &InstInputs) { | |||
3074 | // No name -> not interesting. | |||
3075 | if (Pat->getName().empty()) { | |||
3076 | if (Pat->isLeaf()) { | |||
3077 | DefInit *DI = dyn_cast<DefInit>(Pat->getLeafValue()); | |||
3078 | if (DI && (DI->getDef()->isSubClassOf("RegisterClass") || | |||
3079 | DI->getDef()->isSubClassOf("RegisterOperand"))) | |||
3080 | I->error("Input " + DI->getDef()->getName() + " must be named!"); | |||
3081 | } | |||
3082 | return false; | |||
3083 | } | |||
3084 | ||||
3085 | Record *Rec; | |||
3086 | if (Pat->isLeaf()) { | |||
3087 | DefInit *DI = dyn_cast<DefInit>(Pat->getLeafValue()); | |||
3088 | if (!DI) I->error("Input $" + Pat->getName() + " must be an identifier!"); | |||
3089 | Rec = DI->getDef(); | |||
3090 | } else { | |||
3091 | Rec = Pat->getOperator(); | |||
3092 | } | |||
3093 | ||||
3094 | // SRCVALUE nodes are ignored. | |||
3095 | if (Rec->getName() == "srcvalue") | |||
3096 | return false; | |||
3097 | ||||
3098 | TreePatternNode *&Slot = InstInputs[Pat->getName()]; | |||
3099 | if (!Slot) { | |||
3100 | Slot = Pat; | |||
3101 | return true; | |||
3102 | } | |||
3103 | Record *SlotRec; | |||
3104 | if (Slot->isLeaf()) { | |||
3105 | SlotRec = cast<DefInit>(Slot->getLeafValue())->getDef(); | |||
3106 | } else { | |||
3107 | assert(Slot->getNumChildren() == 0 && "can't be a use with children!")(static_cast <bool> (Slot->getNumChildren() == 0 && "can't be a use with children!") ? void (0) : __assert_fail ( "Slot->getNumChildren() == 0 && \"can't be a use with children!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 3107, __extension__ __PRETTY_FUNCTION__)); | |||
3108 | SlotRec = Slot->getOperator(); | |||
3109 | } | |||
3110 | ||||
3111 | // Ensure that the inputs agree if we've already seen this input. | |||
3112 | if (Rec != SlotRec) | |||
3113 | I->error("All $" + Pat->getName() + " inputs must agree with each other"); | |||
3114 | if (Slot->getExtTypes() != Pat->getExtTypes()) | |||
3115 | I->error("All $" + Pat->getName() + " inputs must agree with each other"); | |||
3116 | return true; | |||
3117 | } | |||
3118 | ||||
3119 | /// FindPatternInputsAndOutputs - Scan the specified TreePatternNode (which is | |||
3120 | /// part of "I", the instruction), computing the set of inputs and outputs of | |||
3121 | /// the pattern. Report errors if we see anything naughty. | |||
3122 | void CodeGenDAGPatterns:: | |||
3123 | FindPatternInputsAndOutputs(TreePattern *I, TreePatternNode *Pat, | |||
3124 | std::map<std::string, TreePatternNode*> &InstInputs, | |||
3125 | std::map<std::string, TreePatternNode*>&InstResults, | |||
3126 | std::vector<Record*> &InstImpResults) { | |||
3127 | if (Pat->isLeaf()) { | |||
3128 | bool isUse = HandleUse(I, Pat, InstInputs); | |||
3129 | if (!isUse && Pat->getTransformFn()) | |||
3130 | I->error("Cannot specify a transform function for a non-input value!"); | |||
3131 | return; | |||
3132 | } | |||
3133 | ||||
3134 | if (Pat->getOperator()->getName() == "implicit") { | |||
3135 | for (unsigned i = 0, e = Pat->getNumChildren(); i != e; ++i) { | |||
3136 | TreePatternNode *Dest = Pat->getChild(i); | |||
3137 | if (!Dest->isLeaf()) | |||
3138 | I->error("implicitly defined value should be a register!"); | |||
3139 | ||||
3140 | DefInit *Val = dyn_cast<DefInit>(Dest->getLeafValue()); | |||
3141 | if (!Val || !Val->getDef()->isSubClassOf("Register")) | |||
3142 | I->error("implicitly defined value should be a register!"); | |||
3143 | InstImpResults.push_back(Val->getDef()); | |||
3144 | } | |||
3145 | return; | |||
3146 | } | |||
3147 | ||||
3148 | if (Pat->getOperator()->getName() != "set") { | |||
3149 | // If this is not a set, verify that the children nodes are not void typed, | |||
3150 | // and recurse. | |||
3151 | for (unsigned i = 0, e = Pat->getNumChildren(); i != e; ++i) { | |||
3152 | if (Pat->getChild(i)->getNumTypes() == 0) | |||
3153 | I->error("Cannot have void nodes inside of patterns!"); | |||
3154 | FindPatternInputsAndOutputs(I, Pat->getChild(i), InstInputs, InstResults, | |||
3155 | InstImpResults); | |||
3156 | } | |||
3157 | ||||
3158 | // If this is a non-leaf node with no children, treat it basically as if | |||
3159 | // it were a leaf. This handles nodes like (imm). | |||
3160 | bool isUse = HandleUse(I, Pat, InstInputs); | |||
3161 | ||||
3162 | if (!isUse && Pat->getTransformFn()) | |||
3163 | I->error("Cannot specify a transform function for a non-input value!"); | |||
3164 | return; | |||
3165 | } | |||
3166 | ||||
3167 | // Otherwise, this is a set, validate and collect instruction results. | |||
3168 | if (Pat->getNumChildren() == 0) | |||
3169 | I->error("set requires operands!"); | |||
3170 | ||||
3171 | if (Pat->getTransformFn()) | |||
3172 | I->error("Cannot specify a transform function on a set node!"); | |||
3173 | ||||
3174 | // Check the set destinations. | |||
3175 | unsigned NumDests = Pat->getNumChildren()-1; | |||
3176 | for (unsigned i = 0; i != NumDests; ++i) { | |||
3177 | TreePatternNode *Dest = Pat->getChild(i); | |||
3178 | if (!Dest->isLeaf()) | |||
3179 | I->error("set destination should be a register!"); | |||
3180 | ||||
3181 | DefInit *Val = dyn_cast<DefInit>(Dest->getLeafValue()); | |||
3182 | if (!Val) { | |||
3183 | I->error("set destination should be a register!"); | |||
3184 | continue; | |||
3185 | } | |||
3186 | ||||
3187 | if (Val->getDef()->isSubClassOf("RegisterClass") || | |||
3188 | Val->getDef()->isSubClassOf("ValueType") || | |||
3189 | Val->getDef()->isSubClassOf("RegisterOperand") || | |||
3190 | Val->getDef()->isSubClassOf("PointerLikeRegClass")) { | |||
3191 | if (Dest->getName().empty()) | |||
3192 | I->error("set destination must have a name!"); | |||
3193 | if (InstResults.count(Dest->getName())) | |||
3194 | I->error("cannot set '" + Dest->getName() +"' multiple times"); | |||
3195 | InstResults[Dest->getName()] = Dest; | |||
3196 | } else if (Val->getDef()->isSubClassOf("Register")) { | |||
3197 | InstImpResults.push_back(Val->getDef()); | |||
3198 | } else { | |||
3199 | I->error("set destination should be a register!"); | |||
3200 | } | |||
3201 | } | |||
3202 | ||||
3203 | // Verify and collect info from the computation. | |||
3204 | FindPatternInputsAndOutputs(I, Pat->getChild(NumDests), | |||
3205 | InstInputs, InstResults, InstImpResults); | |||
3206 | } | |||
3207 | ||||
3208 | //===----------------------------------------------------------------------===// | |||
3209 | // Instruction Analysis | |||
3210 | //===----------------------------------------------------------------------===// | |||
3211 | ||||
3212 | class InstAnalyzer { | |||
3213 | const CodeGenDAGPatterns &CDP; | |||
3214 | public: | |||
3215 | bool hasSideEffects; | |||
3216 | bool mayStore; | |||
3217 | bool mayLoad; | |||
3218 | bool isBitcast; | |||
3219 | bool isVariadic; | |||
3220 | ||||
3221 | InstAnalyzer(const CodeGenDAGPatterns &cdp) | |||
3222 | : CDP(cdp), hasSideEffects(false), mayStore(false), mayLoad(false), | |||
3223 | isBitcast(false), isVariadic(false) {} | |||
3224 | ||||
3225 | void Analyze(const TreePattern *Pat) { | |||
3226 | // Assume only the first tree is the pattern. The others are clobber nodes. | |||
3227 | AnalyzeNode(Pat->getTree(0)); | |||
3228 | } | |||
3229 | ||||
3230 | void Analyze(const PatternToMatch &Pat) { | |||
3231 | AnalyzeNode(Pat.getSrcPattern()); | |||
3232 | } | |||
3233 | ||||
3234 | private: | |||
3235 | bool IsNodeBitcast(const TreePatternNode *N) const { | |||
3236 | if (hasSideEffects || mayLoad || mayStore || isVariadic) | |||
3237 | return false; | |||
3238 | ||||
3239 | if (N->getNumChildren() != 2) | |||
3240 | return false; | |||
3241 | ||||
3242 | const TreePatternNode *N0 = N->getChild(0); | |||
3243 | if (!N0->isLeaf() || !isa<DefInit>(N0->getLeafValue())) | |||
3244 | return false; | |||
3245 | ||||
3246 | const TreePatternNode *N1 = N->getChild(1); | |||
3247 | if (N1->isLeaf()) | |||
3248 | return false; | |||
3249 | if (N1->getNumChildren() != 1 || !N1->getChild(0)->isLeaf()) | |||
3250 | return false; | |||
3251 | ||||
3252 | const SDNodeInfo &OpInfo = CDP.getSDNodeInfo(N1->getOperator()); | |||
3253 | if (OpInfo.getNumResults() != 1 || OpInfo.getNumOperands() != 1) | |||
3254 | return false; | |||
3255 | return OpInfo.getEnumName() == "ISD::BITCAST"; | |||
3256 | } | |||
3257 | ||||
3258 | public: | |||
3259 | void AnalyzeNode(const TreePatternNode *N) { | |||
3260 | if (N->isLeaf()) { | |||
3261 | if (DefInit *DI = dyn_cast<DefInit>(N->getLeafValue())) { | |||
3262 | Record *LeafRec = DI->getDef(); | |||
3263 | // Handle ComplexPattern leaves. | |||
3264 | if (LeafRec->isSubClassOf("ComplexPattern")) { | |||
3265 | const ComplexPattern &CP = CDP.getComplexPattern(LeafRec); | |||
3266 | if (CP.hasProperty(SDNPMayStore)) mayStore = true; | |||
3267 | if (CP.hasProperty(SDNPMayLoad)) mayLoad = true; | |||
3268 | if (CP.hasProperty(SDNPSideEffect)) hasSideEffects = true; | |||
3269 | } | |||
3270 | } | |||
3271 | return; | |||
3272 | } | |||
3273 | ||||
3274 | // Analyze children. | |||
3275 | for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) | |||
3276 | AnalyzeNode(N->getChild(i)); | |||
3277 | ||||
3278 | // Ignore set nodes, which are not SDNodes. | |||
3279 | if (N->getOperator()->getName() == "set") { | |||
3280 | isBitcast = IsNodeBitcast(N); | |||
3281 | return; | |||
3282 | } | |||
3283 | ||||
3284 | // Notice properties of the node. | |||
3285 | if (N->NodeHasProperty(SDNPMayStore, CDP)) mayStore = true; | |||
3286 | if (N->NodeHasProperty(SDNPMayLoad, CDP)) mayLoad = true; | |||
3287 | if (N->NodeHasProperty(SDNPSideEffect, CDP)) hasSideEffects = true; | |||
3288 | if (N->NodeHasProperty(SDNPVariadic, CDP)) isVariadic = true; | |||
3289 | ||||
3290 | if (const CodeGenIntrinsic *IntInfo = N->getIntrinsicInfo(CDP)) { | |||
3291 | // If this is an intrinsic, analyze it. | |||
3292 | if (IntInfo->ModRef & CodeGenIntrinsic::MR_Ref) | |||
3293 | mayLoad = true;// These may load memory. | |||
3294 | ||||
3295 | if (IntInfo->ModRef & CodeGenIntrinsic::MR_Mod) | |||
3296 | mayStore = true;// Intrinsics that can write to memory are 'mayStore'. | |||
3297 | ||||
3298 | if (IntInfo->ModRef >= CodeGenIntrinsic::ReadWriteMem || | |||
3299 | IntInfo->hasSideEffects) | |||
3300 | // ReadWriteMem intrinsics can have other strange effects. | |||
3301 | hasSideEffects = true; | |||
3302 | } | |||
3303 | } | |||
3304 | ||||
3305 | }; | |||
3306 | ||||
3307 | static bool InferFromPattern(CodeGenInstruction &InstInfo, | |||
3308 | const InstAnalyzer &PatInfo, | |||
3309 | Record *PatDef) { | |||
3310 | bool Error = false; | |||
3311 | ||||
3312 | // Remember where InstInfo got its flags. | |||
3313 | if (InstInfo.hasUndefFlags()) | |||
3314 | InstInfo.InferredFrom = PatDef; | |||
3315 | ||||
3316 | // Check explicitly set flags for consistency. | |||
3317 | if (InstInfo.hasSideEffects != PatInfo.hasSideEffects && | |||
3318 | !InstInfo.hasSideEffects_Unset) { | |||
3319 | // Allow explicitly setting hasSideEffects = 1 on instructions, even when | |||
3320 | // the pattern has no side effects. That could be useful for div/rem | |||
3321 | // instructions that may trap. | |||
3322 | if (!InstInfo.hasSideEffects) { | |||
3323 | Error = true; | |||
3324 | PrintError(PatDef->getLoc(), "Pattern doesn't match hasSideEffects = " + | |||
3325 | Twine(InstInfo.hasSideEffects)); | |||
3326 | } | |||
3327 | } | |||
3328 | ||||
3329 | if (InstInfo.mayStore != PatInfo.mayStore && !InstInfo.mayStore_Unset) { | |||
3330 | Error = true; | |||
3331 | PrintError(PatDef->getLoc(), "Pattern doesn't match mayStore = " + | |||
3332 | Twine(InstInfo.mayStore)); | |||
3333 | } | |||
3334 | ||||
3335 | if (InstInfo.mayLoad != PatInfo.mayLoad && !InstInfo.mayLoad_Unset) { | |||
3336 | // Allow explicitly setting mayLoad = 1, even when the pattern has no loads. | |||
3337 | // Some targets translate immediates to loads. | |||
3338 | if (!InstInfo.mayLoad) { | |||
3339 | Error = true; | |||
3340 | PrintError(PatDef->getLoc(), "Pattern doesn't match mayLoad = " + | |||
3341 | Twine(InstInfo.mayLoad)); | |||
3342 | } | |||
3343 | } | |||
3344 | ||||
3345 | // Transfer inferred flags. | |||
3346 | InstInfo.hasSideEffects |= PatInfo.hasSideEffects; | |||
3347 | InstInfo.mayStore |= PatInfo.mayStore; | |||
3348 | InstInfo.mayLoad |= PatInfo.mayLoad; | |||
3349 | ||||
3350 | // These flags are silently added without any verification. | |||
3351 | InstInfo.isBitcast |= PatInfo.isBitcast; | |||
3352 | ||||
3353 | // Don't infer isVariadic. This flag means something different on SDNodes and | |||
3354 | // instructions. For example, a CALL SDNode is variadic because it has the | |||
3355 | // call arguments as operands, but a CALL instruction is not variadic - it | |||
3356 | // has argument registers as implicit, not explicit uses. | |||
3357 | ||||
3358 | return Error; | |||
3359 | } | |||
3360 | ||||
3361 | /// hasNullFragReference - Return true if the DAG has any reference to the | |||
3362 | /// null_frag operator. | |||
3363 | static bool hasNullFragReference(DagInit *DI) { | |||
3364 | DefInit *OpDef = dyn_cast<DefInit>(DI->getOperator()); | |||
3365 | if (!OpDef) return false; | |||
3366 | Record *Operator = OpDef->getDef(); | |||
3367 | ||||
3368 | // If this is the null fragment, return true. | |||
3369 | if (Operator->getName() == "null_frag") return true; | |||
3370 | // If any of the arguments reference the null fragment, return true. | |||
3371 | for (unsigned i = 0, e = DI->getNumArgs(); i != e; ++i) { | |||
3372 | DagInit *Arg = dyn_cast<DagInit>(DI->getArg(i)); | |||
3373 | if (Arg && hasNullFragReference(Arg)) | |||
3374 | return true; | |||
3375 | } | |||
3376 | ||||
3377 | return false; | |||
3378 | } | |||
3379 | ||||
3380 | /// hasNullFragReference - Return true if any DAG in the list references | |||
3381 | /// the null_frag operator. | |||
3382 | static bool hasNullFragReference(ListInit *LI) { | |||
3383 | for (Init *I : LI->getValues()) { | |||
3384 | DagInit *DI = dyn_cast<DagInit>(I); | |||
3385 | assert(DI && "non-dag in an instruction Pattern list?!")(static_cast <bool> (DI && "non-dag in an instruction Pattern list?!" ) ? void (0) : __assert_fail ("DI && \"non-dag in an instruction Pattern list?!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 3385, __extension__ __PRETTY_FUNCTION__)); | |||
3386 | if (hasNullFragReference(DI)) | |||
3387 | return true; | |||
3388 | } | |||
3389 | return false; | |||
3390 | } | |||
3391 | ||||
3392 | /// Get all the instructions in a tree. | |||
3393 | static void | |||
3394 | getInstructionsInTree(TreePatternNode *Tree, SmallVectorImpl<Record*> &Instrs) { | |||
3395 | if (Tree->isLeaf()) | |||
3396 | return; | |||
3397 | if (Tree->getOperator()->isSubClassOf("Instruction")) | |||
3398 | Instrs.push_back(Tree->getOperator()); | |||
3399 | for (unsigned i = 0, e = Tree->getNumChildren(); i != e; ++i) | |||
3400 | getInstructionsInTree(Tree->getChild(i), Instrs); | |||
3401 | } | |||
3402 | ||||
3403 | /// Check the class of a pattern leaf node against the instruction operand it | |||
3404 | /// represents. | |||
3405 | static bool checkOperandClass(CGIOperandList::OperandInfo &OI, | |||
3406 | Record *Leaf) { | |||
3407 | if (OI.Rec == Leaf) | |||
3408 | return true; | |||
3409 | ||||
3410 | // Allow direct value types to be used in instruction set patterns. | |||
3411 | // The type will be checked later. | |||
3412 | if (Leaf->isSubClassOf("ValueType")) | |||
| ||||
3413 | return true; | |||
3414 | ||||
3415 | // Patterns can also be ComplexPattern instances. | |||
3416 | if (Leaf->isSubClassOf("ComplexPattern")) | |||
3417 | return true; | |||
3418 | ||||
3419 | return false; | |||
3420 | } | |||
3421 | ||||
3422 | const DAGInstruction &CodeGenDAGPatterns::parseInstructionPattern( | |||
3423 | CodeGenInstruction &CGI, ListInit *Pat, DAGInstMap &DAGInsts) { | |||
3424 | ||||
3425 | assert(!DAGInsts.count(CGI.TheDef) && "Instruction already parsed!")(static_cast <bool> (!DAGInsts.count(CGI.TheDef) && "Instruction already parsed!") ? void (0) : __assert_fail ("!DAGInsts.count(CGI.TheDef) && \"Instruction already parsed!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 3425, __extension__ __PRETTY_FUNCTION__)); | |||
3426 | ||||
3427 | // Parse the instruction. | |||
3428 | TreePattern *I = new TreePattern(CGI.TheDef, Pat, true, *this); | |||
3429 | // Inline pattern fragments into it. | |||
3430 | I->InlinePatternFragments(); | |||
3431 | ||||
3432 | // Infer as many types as possible. If we cannot infer all of them, we can | |||
3433 | // never do anything with this instruction pattern: report it to the user. | |||
3434 | if (!I->InferAllTypes()) | |||
3435 | I->error("Could not infer all types in pattern!"); | |||
3436 | ||||
3437 | // InstInputs - Keep track of all of the inputs of the instruction, along | |||
3438 | // with the record they are declared as. | |||
3439 | std::map<std::string, TreePatternNode*> InstInputs; | |||
3440 | ||||
3441 | // InstResults - Keep track of all the virtual registers that are 'set' | |||
3442 | // in the instruction, including what reg class they are. | |||
3443 | std::map<std::string, TreePatternNode*> InstResults; | |||
3444 | ||||
3445 | std::vector<Record*> InstImpResults; | |||
3446 | ||||
3447 | // Verify that the top-level forms in the instruction are of void type, and | |||
3448 | // fill in the InstResults map. | |||
3449 | SmallString<32> TypesString; | |||
3450 | for (unsigned j = 0, e = I->getNumTrees(); j != e; ++j) { | |||
3451 | TypesString.clear(); | |||
3452 | TreePatternNode *Pat = I->getTree(j); | |||
3453 | if (Pat->getNumTypes() != 0) { | |||
3454 | raw_svector_ostream OS(TypesString); | |||
3455 | for (unsigned k = 0, ke = Pat->getNumTypes(); k != ke; ++k) { | |||
3456 | if (k > 0) | |||
3457 | OS << ", "; | |||
3458 | Pat->getExtType(k).writeToStream(OS); | |||
3459 | } | |||
3460 | I->error("Top-level forms in instruction pattern should have" | |||
3461 | " void types, has types " + | |||
3462 | OS.str()); | |||
3463 | } | |||
3464 | ||||
3465 | // Find inputs and outputs, and verify the structure of the uses/defs. | |||
3466 | FindPatternInputsAndOutputs(I, Pat, InstInputs, InstResults, | |||
3467 | InstImpResults); | |||
3468 | } | |||
3469 | ||||
3470 | // Now that we have inputs and outputs of the pattern, inspect the operands | |||
3471 | // list for the instruction. This determines the order that operands are | |||
3472 | // added to the machine instruction the node corresponds to. | |||
3473 | unsigned NumResults = InstResults.size(); | |||
3474 | ||||
3475 | // Parse the operands list from the (ops) list, validating it. | |||
3476 | assert(I->getArgList().empty() && "Args list should still be empty here!")(static_cast <bool> (I->getArgList().empty() && "Args list should still be empty here!") ? void (0) : __assert_fail ("I->getArgList().empty() && \"Args list should still be empty here!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 3476, __extension__ __PRETTY_FUNCTION__)); | |||
3477 | ||||
3478 | // Check that all of the results occur first in the list. | |||
3479 | std::vector<Record*> Results; | |||
3480 | SmallVector<TreePatternNode *, 2> ResNodes; | |||
3481 | for (unsigned i = 0; i != NumResults; ++i) { | |||
3482 | if (i == CGI.Operands.size()) | |||
3483 | I->error("'" + InstResults.begin()->first + | |||
3484 | "' set but does not appear in operand list!"); | |||
3485 | const std::string &OpName = CGI.Operands[i].Name; | |||
3486 | ||||
3487 | // Check that it exists in InstResults. | |||
3488 | TreePatternNode *RNode = InstResults[OpName]; | |||
3489 | if (!RNode) | |||
3490 | I->error("Operand $" + OpName + " does not exist in operand list!"); | |||
3491 | ||||
3492 | ResNodes.push_back(RNode); | |||
3493 | ||||
3494 | Record *R = cast<DefInit>(RNode->getLeafValue())->getDef(); | |||
3495 | if (!R) | |||
3496 | I->error("Operand $" + OpName + " should be a set destination: all " | |||
3497 | "outputs must occur before inputs in operand list!"); | |||
3498 | ||||
3499 | if (!checkOperandClass(CGI.Operands[i], R)) | |||
3500 | I->error("Operand $" + OpName + " class mismatch!"); | |||
3501 | ||||
3502 | // Remember the return type. | |||
3503 | Results.push_back(CGI.Operands[i].Rec); | |||
3504 | ||||
3505 | // Okay, this one checks out. | |||
3506 | InstResults.erase(OpName); | |||
3507 | } | |||
3508 | ||||
3509 | // Loop over the inputs next. Make a copy of InstInputs so we can destroy | |||
3510 | // the copy while we're checking the inputs. | |||
3511 | std::map<std::string, TreePatternNode*> InstInputsCheck(InstInputs); | |||
3512 | ||||
3513 | std::vector<TreePatternNode*> ResultNodeOperands; | |||
3514 | std::vector<Record*> Operands; | |||
3515 | for (unsigned i = NumResults, e = CGI.Operands.size(); i != e; ++i) { | |||
3516 | CGIOperandList::OperandInfo &Op = CGI.Operands[i]; | |||
3517 | const std::string &OpName = Op.Name; | |||
3518 | if (OpName.empty()) | |||
3519 | I->error("Operand #" + Twine(i) + " in operands list has no name!"); | |||
3520 | ||||
3521 | if (!InstInputsCheck.count(OpName)) { | |||
3522 | // If this is an operand with a DefaultOps set filled in, we can ignore | |||
3523 | // this. When we codegen it, we will do so as always executed. | |||
3524 | if (Op.Rec->isSubClassOf("OperandWithDefaultOps")) { | |||
3525 | // Does it have a non-empty DefaultOps field? If so, ignore this | |||
3526 | // operand. | |||
3527 | if (!getDefaultOperand(Op.Rec).DefaultOps.empty()) | |||
3528 | continue; | |||
3529 | } | |||
3530 | I->error("Operand $" + OpName + | |||
3531 | " does not appear in the instruction pattern"); | |||
3532 | } | |||
3533 | TreePatternNode *InVal = InstInputsCheck[OpName]; | |||
3534 | InstInputsCheck.erase(OpName); // It occurred, remove from map. | |||
3535 | ||||
3536 | if (InVal->isLeaf() && isa<DefInit>(InVal->getLeafValue())) { | |||
3537 | Record *InRec = static_cast<DefInit*>(InVal->getLeafValue())->getDef(); | |||
3538 | if (!checkOperandClass(Op, InRec)) | |||
3539 | I->error("Operand $" + OpName + "'s register class disagrees" | |||
3540 | " between the operand and pattern"); | |||
3541 | } | |||
3542 | Operands.push_back(Op.Rec); | |||
3543 | ||||
3544 | // Construct the result for the dest-pattern operand list. | |||
3545 | TreePatternNode *OpNode = InVal->clone(); | |||
3546 | ||||
3547 | // No predicate is useful on the result. | |||
3548 | OpNode->clearPredicateFns(); | |||
3549 | ||||
3550 | // Promote the xform function to be an explicit node if set. | |||
3551 | if (Record *Xform = OpNode->getTransformFn()) { | |||
3552 | OpNode->setTransformFn(nullptr); | |||
3553 | std::vector<TreePatternNode*> Children; | |||
3554 | Children.push_back(OpNode); | |||
3555 | OpNode = new TreePatternNode(Xform, Children, OpNode->getNumTypes()); | |||
3556 | } | |||
3557 | ||||
3558 | ResultNodeOperands.push_back(OpNode); | |||
3559 | } | |||
3560 | ||||
3561 | if (!InstInputsCheck.empty()) | |||
3562 | I->error("Input operand $" + InstInputsCheck.begin()->first + | |||
3563 | " occurs in pattern but not in operands list!"); | |||
3564 | ||||
3565 | TreePatternNode *ResultPattern = | |||
3566 | new TreePatternNode(I->getRecord(), ResultNodeOperands, | |||
3567 | GetNumNodeResults(I->getRecord(), *this)); | |||
3568 | // Copy fully inferred output node types to instruction result pattern. | |||
3569 | for (unsigned i = 0; i != NumResults; ++i) { | |||
3570 | assert(ResNodes[i]->getNumTypes() == 1 && "FIXME: Unhandled")(static_cast <bool> (ResNodes[i]->getNumTypes() == 1 && "FIXME: Unhandled") ? void (0) : __assert_fail ("ResNodes[i]->getNumTypes() == 1 && \"FIXME: Unhandled\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 3570, __extension__ __PRETTY_FUNCTION__)); | |||
3571 | ResultPattern->setType(i, ResNodes[i]->getExtType(0)); | |||
3572 | } | |||
3573 | ||||
3574 | // Create and insert the instruction. | |||
3575 | // FIXME: InstImpResults should not be part of DAGInstruction. | |||
3576 | DAGInstruction TheInst(I, Results, Operands, InstImpResults); | |||
3577 | DAGInsts.insert(std::make_pair(I->getRecord(), TheInst)); | |||
3578 | ||||
3579 | // Use a temporary tree pattern to infer all types and make sure that the | |||
3580 | // constructed result is correct. This depends on the instruction already | |||
3581 | // being inserted into the DAGInsts map. | |||
3582 | TreePattern Temp(I->getRecord(), ResultPattern, false, *this); | |||
3583 | Temp.InferAllTypes(&I->getNamedNodesMap()); | |||
3584 | ||||
3585 | DAGInstruction &TheInsertedInst = DAGInsts.find(I->getRecord())->second; | |||
3586 | TheInsertedInst.setResultPattern(Temp.getOnlyTree()); | |||
3587 | ||||
3588 | return TheInsertedInst; | |||
3589 | } | |||
3590 | ||||
3591 | /// ParseInstructions - Parse all of the instructions, inlining and resolving | |||
3592 | /// any fragments involved. This populates the Instructions list with fully | |||
3593 | /// resolved instructions. | |||
3594 | void CodeGenDAGPatterns::ParseInstructions() { | |||
3595 | std::vector<Record*> Instrs = Records.getAllDerivedDefinitions("Instruction"); | |||
3596 | ||||
3597 | for (Record *Instr : Instrs) { | |||
3598 | ListInit *LI = nullptr; | |||
3599 | ||||
3600 | if (isa<ListInit>(Instr->getValueInit("Pattern"))) | |||
3601 | LI = Instr->getValueAsListInit("Pattern"); | |||
3602 | ||||
3603 | // If there is no pattern, only collect minimal information about the | |||
3604 | // instruction for its operand list. We have to assume that there is one | |||
3605 | // result, as we have no detailed info. A pattern which references the | |||
3606 | // null_frag operator is as-if no pattern were specified. Normally this | |||
3607 | // is from a multiclass expansion w/ a SDPatternOperator passed in as | |||
3608 | // null_frag. | |||
3609 | if (!LI || LI->empty() || hasNullFragReference(LI)) { | |||
3610 | std::vector<Record*> Results; | |||
3611 | std::vector<Record*> Operands; | |||
3612 | ||||
3613 | CodeGenInstruction &InstInfo = Target.getInstruction(Instr); | |||
3614 | ||||
3615 | if (InstInfo.Operands.size() != 0) { | |||
3616 | for (unsigned j = 0, e = InstInfo.Operands.NumDefs; j < e; ++j) | |||
3617 | Results.push_back(InstInfo.Operands[j].Rec); | |||
3618 | ||||
3619 | // The rest are inputs. | |||
3620 | for (unsigned j = InstInfo.Operands.NumDefs, | |||
3621 | e = InstInfo.Operands.size(); j < e; ++j) | |||
3622 | Operands.push_back(InstInfo.Operands[j].Rec); | |||
3623 | } | |||
3624 | ||||
3625 | // Create and insert the instruction. | |||
3626 | std::vector<Record*> ImpResults; | |||
3627 | Instructions.insert(std::make_pair(Instr, | |||
3628 | DAGInstruction(nullptr, Results, Operands, ImpResults))); | |||
3629 | continue; // no pattern. | |||
3630 | } | |||
3631 | ||||
3632 | CodeGenInstruction &CGI = Target.getInstruction(Instr); | |||
3633 | const DAGInstruction &DI = parseInstructionPattern(CGI, LI, Instructions); | |||
3634 | ||||
3635 | (void)DI; | |||
3636 | DEBUG(DI.getPattern()->dump())do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { DI.getPattern()->dump(); } } while (false ); | |||
3637 | } | |||
3638 | ||||
3639 | // If we can, convert the instructions to be patterns that are matched! | |||
3640 | for (auto &Entry : Instructions) { | |||
3641 | DAGInstruction &TheInst = Entry.second; | |||
3642 | TreePattern *I = TheInst.getPattern(); | |||
3643 | if (!I) continue; // No pattern. | |||
3644 | ||||
3645 | if (PatternRewriter) | |||
3646 | PatternRewriter(I); | |||
3647 | // FIXME: Assume only the first tree is the pattern. The others are clobber | |||
3648 | // nodes. | |||
3649 | TreePatternNode *Pattern = I->getTree(0); | |||
3650 | TreePatternNode *SrcPattern; | |||
3651 | if (Pattern->getOperator()->getName() == "set") { | |||
3652 | SrcPattern = Pattern->getChild(Pattern->getNumChildren()-1)->clone(); | |||
3653 | } else{ | |||
3654 | // Not a set (store or something?) | |||
3655 | SrcPattern = Pattern; | |||
3656 | } | |||
3657 | ||||
3658 | Record *Instr = Entry.first; | |||
3659 | ListInit *Preds = Instr->getValueAsListInit("Predicates"); | |||
3660 | int Complexity = Instr->getValueAsInt("AddedComplexity"); | |||
3661 | AddPatternToMatch( | |||
3662 | I, | |||
3663 | PatternToMatch(Instr, makePredList(Preds), SrcPattern, | |||
3664 | TheInst.getResultPattern(), TheInst.getImpResults(), | |||
3665 | Complexity, Instr->getID())); | |||
3666 | } | |||
3667 | } | |||
3668 | ||||
3669 | ||||
3670 | typedef std::pair<const TreePatternNode*, unsigned> NameRecord; | |||
3671 | ||||
3672 | static void FindNames(const TreePatternNode *P, | |||
3673 | std::map<std::string, NameRecord> &Names, | |||
3674 | TreePattern *PatternTop) { | |||
3675 | if (!P->getName().empty()) { | |||
3676 | NameRecord &Rec = Names[P->getName()]; | |||
3677 | // If this is the first instance of the name, remember the node. | |||
3678 | if (Rec.second++ == 0) | |||
3679 | Rec.first = P; | |||
3680 | else if (Rec.first->getExtTypes() != P->getExtTypes()) | |||
3681 | PatternTop->error("repetition of value: $" + P->getName() + | |||
3682 | " where different uses have different types!"); | |||
3683 | } | |||
3684 | ||||
3685 | if (!P->isLeaf()) { | |||
3686 | for (unsigned i = 0, e = P->getNumChildren(); i != e; ++i) | |||
3687 | FindNames(P->getChild(i), Names, PatternTop); | |||
3688 | } | |||
3689 | } | |||
3690 | ||||
3691 | std::vector<Predicate> CodeGenDAGPatterns::makePredList(ListInit *L) { | |||
3692 | std::vector<Predicate> Preds; | |||
3693 | for (Init *I : L->getValues()) { | |||
3694 | if (DefInit *Pred = dyn_cast<DefInit>(I)) | |||
3695 | Preds.push_back(Pred->getDef()); | |||
3696 | else | |||
3697 | llvm_unreachable("Non-def on the list")::llvm::llvm_unreachable_internal("Non-def on the list", "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 3697); | |||
3698 | } | |||
3699 | ||||
3700 | // Sort so that different orders get canonicalized to the same string. | |||
3701 | llvm::sort(Preds.begin(), Preds.end()); | |||
3702 | return Preds; | |||
3703 | } | |||
3704 | ||||
3705 | void CodeGenDAGPatterns::AddPatternToMatch(TreePattern *Pattern, | |||
3706 | PatternToMatch &&PTM) { | |||
3707 | // Do some sanity checking on the pattern we're about to match. | |||
3708 | std::string Reason; | |||
3709 | if (!PTM.getSrcPattern()->canPatternMatch(Reason, *this)) { | |||
3710 | PrintWarning(Pattern->getRecord()->getLoc(), | |||
3711 | Twine("Pattern can never match: ") + Reason); | |||
3712 | return; | |||
3713 | } | |||
3714 | ||||
3715 | // If the source pattern's root is a complex pattern, that complex pattern | |||
3716 | // must specify the nodes it can potentially match. | |||
3717 | if (const ComplexPattern *CP = | |||
3718 | PTM.getSrcPattern()->getComplexPatternInfo(*this)) | |||
3719 | if (CP->getRootNodes().empty()) | |||
3720 | Pattern->error("ComplexPattern at root must specify list of opcodes it" | |||
3721 | " could match"); | |||
3722 | ||||
3723 | ||||
3724 | // Find all of the named values in the input and output, ensure they have the | |||
3725 | // same type. | |||
3726 | std::map<std::string, NameRecord> SrcNames, DstNames; | |||
3727 | FindNames(PTM.getSrcPattern(), SrcNames, Pattern); | |||
3728 | FindNames(PTM.getDstPattern(), DstNames, Pattern); | |||
3729 | ||||
3730 | // Scan all of the named values in the destination pattern, rejecting them if | |||
3731 | // they don't exist in the input pattern. | |||
3732 | for (const auto &Entry : DstNames) { | |||
3733 | if (SrcNames[Entry.first].first == nullptr) | |||
3734 | Pattern->error("Pattern has input without matching name in output: $" + | |||
3735 | Entry.first); | |||
3736 | } | |||
3737 | ||||
3738 | // Scan all of the named values in the source pattern, rejecting them if the | |||
3739 | // name isn't used in the dest, and isn't used to tie two values together. | |||
3740 | for (const auto &Entry : SrcNames) | |||
3741 | if (DstNames[Entry.first].first == nullptr && | |||
3742 | SrcNames[Entry.first].second == 1) | |||
3743 | Pattern->error("Pattern has dead named input: $" + Entry.first); | |||
3744 | ||||
3745 | PatternsToMatch.push_back(std::move(PTM)); | |||
3746 | } | |||
3747 | ||||
3748 | void CodeGenDAGPatterns::InferInstructionFlags() { | |||
3749 | ArrayRef<const CodeGenInstruction*> Instructions = | |||
3750 | Target.getInstructionsByEnumValue(); | |||
3751 | ||||
3752 | // First try to infer flags from the primary instruction pattern, if any. | |||
3753 | SmallVector<CodeGenInstruction*, 8> Revisit; | |||
3754 | unsigned Errors = 0; | |||
3755 | for (unsigned i = 0, e = Instructions.size(); i != e; ++i) { | |||
3756 | CodeGenInstruction &InstInfo = | |||
3757 | const_cast<CodeGenInstruction &>(*Instructions[i]); | |||
3758 | ||||
3759 | // Get the primary instruction pattern. | |||
3760 | const TreePattern *Pattern = getInstruction(InstInfo.TheDef).getPattern(); | |||
3761 | if (!Pattern) { | |||
3762 | if (InstInfo.hasUndefFlags()) | |||
3763 | Revisit.push_back(&InstInfo); | |||
3764 | continue; | |||
3765 | } | |||
3766 | InstAnalyzer PatInfo(*this); | |||
3767 | PatInfo.Analyze(Pattern); | |||
3768 | Errors += InferFromPattern(InstInfo, PatInfo, InstInfo.TheDef); | |||
3769 | } | |||
3770 | ||||
3771 | // Second, look for single-instruction patterns defined outside the | |||
3772 | // instruction. | |||
3773 | for (const PatternToMatch &PTM : ptms()) { | |||
3774 | // We can only infer from single-instruction patterns, otherwise we won't | |||
3775 | // know which instruction should get the flags. | |||
3776 | SmallVector<Record*, 8> PatInstrs; | |||
3777 | getInstructionsInTree(PTM.getDstPattern(), PatInstrs); | |||
3778 | if (PatInstrs.size() != 1) | |||
3779 | continue; | |||
3780 | ||||
3781 | // Get the single instruction. | |||
3782 | CodeGenInstruction &InstInfo = Target.getInstruction(PatInstrs.front()); | |||
3783 | ||||
3784 | // Only infer properties from the first pattern. We'll verify the others. | |||
3785 | if (InstInfo.InferredFrom) | |||
3786 | continue; | |||
3787 | ||||
3788 | InstAnalyzer PatInfo(*this); | |||
3789 | PatInfo.Analyze(PTM); | |||
3790 | Errors += InferFromPattern(InstInfo, PatInfo, PTM.getSrcRecord()); | |||
3791 | } | |||
3792 | ||||
3793 | if (Errors) | |||
3794 | PrintFatalError("pattern conflicts"); | |||
3795 | ||||
3796 | // Revisit instructions with undefined flags and no pattern. | |||
3797 | if (Target.guessInstructionProperties()) { | |||
3798 | for (CodeGenInstruction *InstInfo : Revisit) { | |||
3799 | if (InstInfo->InferredFrom) | |||
3800 | continue; | |||
3801 | // The mayLoad and mayStore flags default to false. | |||
3802 | // Conservatively assume hasSideEffects if it wasn't explicit. | |||
3803 | if (InstInfo->hasSideEffects_Unset) | |||
3804 | InstInfo->hasSideEffects = true; | |||
3805 | } | |||
3806 | return; | |||
3807 | } | |||
3808 | ||||
3809 | // Complain about any flags that are still undefined. | |||
3810 | for (CodeGenInstruction *InstInfo : Revisit) { | |||
3811 | if (InstInfo->InferredFrom) | |||
3812 | continue; | |||
3813 | if (InstInfo->hasSideEffects_Unset) | |||
3814 | PrintError(InstInfo->TheDef->getLoc(), | |||
3815 | "Can't infer hasSideEffects from patterns"); | |||
3816 | if (InstInfo->mayStore_Unset) | |||
3817 | PrintError(InstInfo->TheDef->getLoc(), | |||
3818 | "Can't infer mayStore from patterns"); | |||
3819 | if (InstInfo->mayLoad_Unset) | |||
3820 | PrintError(InstInfo->TheDef->getLoc(), | |||
3821 | "Can't infer mayLoad from patterns"); | |||
3822 | } | |||
3823 | } | |||
3824 | ||||
3825 | ||||
3826 | /// Verify instruction flags against pattern node properties. | |||
3827 | void CodeGenDAGPatterns::VerifyInstructionFlags() { | |||
3828 | unsigned Errors = 0; | |||
3829 | for (ptm_iterator I = ptm_begin(), E = ptm_end(); I != E; ++I) { | |||
3830 | const PatternToMatch &PTM = *I; | |||
3831 | SmallVector<Record*, 8> Instrs; | |||
3832 | getInstructionsInTree(PTM.getDstPattern(), Instrs); | |||
3833 | if (Instrs.empty()) | |||
3834 | continue; | |||
3835 | ||||
3836 | // Count the number of instructions with each flag set. | |||
3837 | unsigned NumSideEffects = 0; | |||
3838 | unsigned NumStores = 0; | |||
3839 | unsigned NumLoads = 0; | |||
3840 | for (const Record *Instr : Instrs) { | |||
3841 | const CodeGenInstruction &InstInfo = Target.getInstruction(Instr); | |||
3842 | NumSideEffects += InstInfo.hasSideEffects; | |||
3843 | NumStores += InstInfo.mayStore; | |||
3844 | NumLoads += InstInfo.mayLoad; | |||
3845 | } | |||
3846 | ||||
3847 | // Analyze the source pattern. | |||
3848 | InstAnalyzer PatInfo(*this); | |||
3849 | PatInfo.Analyze(PTM); | |||
3850 | ||||
3851 | // Collect error messages. | |||
3852 | SmallVector<std::string, 4> Msgs; | |||
3853 | ||||
3854 | // Check for missing flags in the output. | |||
3855 | // Permit extra flags for now at least. | |||
3856 | if (PatInfo.hasSideEffects && !NumSideEffects) | |||
3857 | Msgs.push_back("pattern has side effects, but hasSideEffects isn't set"); | |||
3858 | ||||
3859 | // Don't verify store flags on instructions with side effects. At least for | |||
3860 | // intrinsics, side effects implies mayStore. | |||
3861 | if (!PatInfo.hasSideEffects && PatInfo.mayStore && !NumStores) | |||
3862 | Msgs.push_back("pattern may store, but mayStore isn't set"); | |||
3863 | ||||
3864 | // Similarly, mayStore implies mayLoad on intrinsics. | |||
3865 | if (!PatInfo.mayStore && PatInfo.mayLoad && !NumLoads) | |||
3866 | Msgs.push_back("pattern may load, but mayLoad isn't set"); | |||
3867 | ||||
3868 | // Print error messages. | |||
3869 | if (Msgs.empty()) | |||
3870 | continue; | |||
3871 | ++Errors; | |||
3872 | ||||
3873 | for (const std::string &Msg : Msgs) | |||
3874 | PrintError(PTM.getSrcRecord()->getLoc(), Twine(Msg) + " on the " + | |||
3875 | (Instrs.size() == 1 ? | |||
3876 | "instruction" : "output instructions")); | |||
3877 | // Provide the location of the relevant instruction definitions. | |||
3878 | for (const Record *Instr : Instrs) { | |||
3879 | if (Instr != PTM.getSrcRecord()) | |||
3880 | PrintError(Instr->getLoc(), "defined here"); | |||
3881 | const CodeGenInstruction &InstInfo = Target.getInstruction(Instr); | |||
3882 | if (InstInfo.InferredFrom && | |||
3883 | InstInfo.InferredFrom != InstInfo.TheDef && | |||
3884 | InstInfo.InferredFrom != PTM.getSrcRecord()) | |||
3885 | PrintError(InstInfo.InferredFrom->getLoc(), "inferred from pattern"); | |||
3886 | } | |||
3887 | } | |||
3888 | if (Errors) | |||
3889 | PrintFatalError("Errors in DAG patterns"); | |||
3890 | } | |||
3891 | ||||
3892 | /// Given a pattern result with an unresolved type, see if we can find one | |||
3893 | /// instruction with an unresolved result type. Force this result type to an | |||
3894 | /// arbitrary element if it's possible types to converge results. | |||
3895 | static bool ForceArbitraryInstResultType(TreePatternNode *N, TreePattern &TP) { | |||
3896 | if (N->isLeaf()) | |||
3897 | return false; | |||
3898 | ||||
3899 | // Analyze children. | |||
3900 | for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) | |||
3901 | if (ForceArbitraryInstResultType(N->getChild(i), TP)) | |||
3902 | return true; | |||
3903 | ||||
3904 | if (!N->getOperator()->isSubClassOf("Instruction")) | |||
3905 | return false; | |||
3906 | ||||
3907 | // If this type is already concrete or completely unknown we can't do | |||
3908 | // anything. | |||
3909 | TypeInfer &TI = TP.getInfer(); | |||
3910 | for (unsigned i = 0, e = N->getNumTypes(); i != e; ++i) { | |||
3911 | if (N->getExtType(i).empty() || TI.isConcrete(N->getExtType(i), false)) | |||
3912 | continue; | |||
3913 | ||||
3914 | // Otherwise, force its type to an arbitrary choice. | |||
3915 | if (TI.forceArbitrary(N->getExtType(i))) | |||
3916 | return true; | |||
3917 | } | |||
3918 | ||||
3919 | return false; | |||
3920 | } | |||
3921 | ||||
3922 | void CodeGenDAGPatterns::ParsePatterns() { | |||
3923 | std::vector<Record*> Patterns = Records.getAllDerivedDefinitions("Pattern"); | |||
3924 | ||||
3925 | for (Record *CurPattern : Patterns) { | |||
3926 | DagInit *Tree = CurPattern->getValueAsDag("PatternToMatch"); | |||
3927 | ||||
3928 | // If the pattern references the null_frag, there's nothing to do. | |||
3929 | if (hasNullFragReference(Tree)) | |||
3930 | continue; | |||
3931 | ||||
3932 | TreePattern *Pattern = new TreePattern(CurPattern, Tree, true, *this); | |||
3933 | ||||
3934 | // Inline pattern fragments into it. | |||
3935 | Pattern->InlinePatternFragments(); | |||
3936 | ||||
3937 | ListInit *LI = CurPattern->getValueAsListInit("ResultInstrs"); | |||
3938 | if (LI->empty()) continue; // no pattern. | |||
3939 | ||||
3940 | // Parse the instruction. | |||
3941 | TreePattern Result(CurPattern, LI, false, *this); | |||
3942 | ||||
3943 | // Inline pattern fragments into it. | |||
3944 | Result.InlinePatternFragments(); | |||
3945 | ||||
3946 | if (Result.getNumTrees() != 1) | |||
3947 | Result.error("Cannot handle instructions producing instructions " | |||
3948 | "with temporaries yet!"); | |||
3949 | ||||
3950 | bool IterateInference; | |||
3951 | bool InferredAllPatternTypes, InferredAllResultTypes; | |||
3952 | do { | |||
3953 | // Infer as many types as possible. If we cannot infer all of them, we | |||
3954 | // can never do anything with this pattern: report it to the user. | |||
3955 | InferredAllPatternTypes = | |||
3956 | Pattern->InferAllTypes(&Pattern->getNamedNodesMap()); | |||
3957 | ||||
3958 | // Infer as many types as possible. If we cannot infer all of them, we | |||
3959 | // can never do anything with this pattern: report it to the user. | |||
3960 | InferredAllResultTypes = | |||
3961 | Result.InferAllTypes(&Pattern->getNamedNodesMap()); | |||
3962 | ||||
3963 | IterateInference = false; | |||
3964 | ||||
3965 | // Apply the type of the result to the source pattern. This helps us | |||
3966 | // resolve cases where the input type is known to be a pointer type (which | |||
3967 | // is considered resolved), but the result knows it needs to be 32- or | |||
3968 | // 64-bits. Infer the other way for good measure. | |||
3969 | for (unsigned i = 0, e = std::min(Result.getTree(0)->getNumTypes(), | |||
3970 | Pattern->getTree(0)->getNumTypes()); | |||
3971 | i != e; ++i) { | |||
3972 | IterateInference = Pattern->getTree(0)->UpdateNodeType( | |||
3973 | i, Result.getTree(0)->getExtType(i), Result); | |||
3974 | IterateInference |= Result.getTree(0)->UpdateNodeType( | |||
3975 | i, Pattern->getTree(0)->getExtType(i), Result); | |||
3976 | } | |||
3977 | ||||
3978 | // If our iteration has converged and the input pattern's types are fully | |||
3979 | // resolved but the result pattern is not fully resolved, we may have a | |||
3980 | // situation where we have two instructions in the result pattern and | |||
3981 | // the instructions require a common register class, but don't care about | |||
3982 | // what actual MVT is used. This is actually a bug in our modelling: | |||
3983 | // output patterns should have register classes, not MVTs. | |||
3984 | // | |||
3985 | // In any case, to handle this, we just go through and disambiguate some | |||
3986 | // arbitrary types to the result pattern's nodes. | |||
3987 | if (!IterateInference && InferredAllPatternTypes && | |||
3988 | !InferredAllResultTypes) | |||
3989 | IterateInference = | |||
3990 | ForceArbitraryInstResultType(Result.getTree(0), Result); | |||
3991 | } while (IterateInference); | |||
3992 | ||||
3993 | // Verify that we inferred enough types that we can do something with the | |||
3994 | // pattern and result. If these fire the user has to add type casts. | |||
3995 | if (!InferredAllPatternTypes) | |||
3996 | Pattern->error("Could not infer all types in pattern!"); | |||
3997 | if (!InferredAllResultTypes) { | |||
3998 | Pattern->dump(); | |||
3999 | Result.error("Could not infer all types in pattern result!"); | |||
4000 | } | |||
4001 | ||||
4002 | // Validate that the input pattern is correct. | |||
4003 | std::map<std::string, TreePatternNode*> InstInputs; | |||
4004 | std::map<std::string, TreePatternNode*> InstResults; | |||
4005 | std::vector<Record*> InstImpResults; | |||
4006 | for (unsigned j = 0, ee = Pattern->getNumTrees(); j != ee; ++j) | |||
4007 | FindPatternInputsAndOutputs(Pattern, Pattern->getTree(j), | |||
4008 | InstInputs, InstResults, | |||
4009 | InstImpResults); | |||
4010 | ||||
4011 | // Promote the xform function to be an explicit node if set. | |||
4012 | TreePatternNode *DstPattern = Result.getOnlyTree(); | |||
4013 | std::vector<TreePatternNode*> ResultNodeOperands; | |||
4014 | for (unsigned ii = 0, ee = DstPattern->getNumChildren(); ii != ee; ++ii) { | |||
4015 | TreePatternNode *OpNode = DstPattern->getChild(ii); | |||
4016 | if (Record *Xform = OpNode->getTransformFn()) { | |||
4017 | OpNode->setTransformFn(nullptr); | |||
4018 | std::vector<TreePatternNode*> Children; | |||
4019 | Children.push_back(OpNode); | |||
4020 | OpNode = new TreePatternNode(Xform, Children, OpNode->getNumTypes()); | |||
4021 | } | |||
4022 | ResultNodeOperands.push_back(OpNode); | |||
4023 | } | |||
4024 | DstPattern = Result.getOnlyTree(); | |||
4025 | if (!DstPattern->isLeaf()) | |||
4026 | DstPattern = new TreePatternNode(DstPattern->getOperator(), | |||
4027 | ResultNodeOperands, | |||
4028 | DstPattern->getNumTypes()); | |||
4029 | ||||
4030 | for (unsigned i = 0, e = Result.getOnlyTree()->getNumTypes(); i != e; ++i) | |||
4031 | DstPattern->setType(i, Result.getOnlyTree()->getExtType(i)); | |||
4032 | ||||
4033 | TreePattern Temp(Result.getRecord(), DstPattern, false, *this); | |||
4034 | Temp.InferAllTypes(); | |||
4035 | ||||
4036 | // A pattern may end up with an "impossible" type, i.e. a situation | |||
4037 | // where all types have been eliminated for some node in this pattern. | |||
4038 | // This could occur for intrinsics that only make sense for a specific | |||
4039 | // value type, and use a specific register class. If, for some mode, | |||
4040 | // that register class does not accept that type, the type inference | |||
4041 | // will lead to a contradiction, which is not an error however, but | |||
4042 | // a sign that this pattern will simply never match. | |||
4043 | if (Pattern->getTree(0)->hasPossibleType() && | |||
4044 | Temp.getOnlyTree()->hasPossibleType()) { | |||
4045 | ListInit *Preds = CurPattern->getValueAsListInit("Predicates"); | |||
4046 | int Complexity = CurPattern->getValueAsInt("AddedComplexity"); | |||
4047 | if (PatternRewriter) | |||
4048 | PatternRewriter(Pattern); | |||
4049 | AddPatternToMatch( | |||
4050 | Pattern, | |||
4051 | PatternToMatch( | |||
4052 | CurPattern, makePredList(Preds), Pattern->getTree(0), | |||
4053 | Temp.getOnlyTree(), std::move(InstImpResults), Complexity, | |||
4054 | CurPattern->getID())); | |||
4055 | } | |||
4056 | } | |||
4057 | } | |||
4058 | ||||
4059 | static void collectModes(std::set<unsigned> &Modes, const TreePatternNode *N) { | |||
4060 | for (const TypeSetByHwMode &VTS : N->getExtTypes()) | |||
4061 | for (const auto &I : VTS) | |||
4062 | Modes.insert(I.first); | |||
4063 | ||||
4064 | for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) | |||
4065 | collectModes(Modes, N->getChild(i)); | |||
4066 | } | |||
4067 | ||||
4068 | void CodeGenDAGPatterns::ExpandHwModeBasedTypes() { | |||
4069 | const CodeGenHwModes &CGH = getTargetInfo().getHwModes(); | |||
4070 | std::map<unsigned,std::vector<Predicate>> ModeChecks; | |||
4071 | std::vector<PatternToMatch> Copy = PatternsToMatch; | |||
4072 | PatternsToMatch.clear(); | |||
4073 | ||||
4074 | auto AppendPattern = [this,&ModeChecks](PatternToMatch &P, unsigned Mode) { | |||
4075 | TreePatternNode *NewSrc = P.SrcPattern->clone(); | |||
4076 | TreePatternNode *NewDst = P.DstPattern->clone(); | |||
4077 | if (!NewSrc->setDefaultMode(Mode) || !NewDst->setDefaultMode(Mode)) { | |||
4078 | delete NewSrc; | |||
4079 | delete NewDst; | |||
4080 | return; | |||
4081 | } | |||
4082 | ||||
4083 | std::vector<Predicate> Preds = P.Predicates; | |||
4084 | const std::vector<Predicate> &MC = ModeChecks[Mode]; | |||
4085 | Preds.insert(Preds.end(), MC.begin(), MC.end()); | |||
4086 | PatternsToMatch.emplace_back(P.getSrcRecord(), Preds, NewSrc, NewDst, | |||
4087 | P.getDstRegs(), P.getAddedComplexity(), | |||
4088 | Record::getNewUID(), Mode); | |||
4089 | }; | |||
4090 | ||||
4091 | for (PatternToMatch &P : Copy) { | |||
4092 | TreePatternNode *SrcP = nullptr, *DstP = nullptr; | |||
4093 | if (P.SrcPattern->hasProperTypeByHwMode()) | |||
4094 | SrcP = P.SrcPattern; | |||
4095 | if (P.DstPattern->hasProperTypeByHwMode()) | |||
4096 | DstP = P.DstPattern; | |||
4097 | if (!SrcP && !DstP) { | |||
4098 | PatternsToMatch.push_back(P); | |||
4099 | continue; | |||
4100 | } | |||
4101 | ||||
4102 | std::set<unsigned> Modes; | |||
4103 | if (SrcP) | |||
4104 | collectModes(Modes, SrcP); | |||
4105 | if (DstP) | |||
4106 | collectModes(Modes, DstP); | |||
4107 | ||||
4108 | // The predicate for the default mode needs to be constructed for each | |||
4109 | // pattern separately. | |||
4110 | // Since not all modes must be present in each pattern, if a mode m is | |||
4111 | // absent, then there is no point in constructing a check for m. If such | |||
4112 | // a check was created, it would be equivalent to checking the default | |||
4113 | // mode, except not all modes' predicates would be a part of the checking | |||
4114 | // code. The subsequently generated check for the default mode would then | |||
4115 | // have the exact same patterns, but a different predicate code. To avoid | |||
4116 | // duplicated patterns with different predicate checks, construct the | |||
4117 | // default check as a negation of all predicates that are actually present | |||
4118 | // in the source/destination patterns. | |||
4119 | std::vector<Predicate> DefaultPred; | |||
4120 | ||||
4121 | for (unsigned M : Modes) { | |||
4122 | if (M == DefaultMode) | |||
4123 | continue; | |||
4124 | if (ModeChecks.find(M) != ModeChecks.end()) | |||
4125 | continue; | |||
4126 | ||||
4127 | // Fill the map entry for this mode. | |||
4128 | const HwMode &HM = CGH.getMode(M); | |||
4129 | ModeChecks[M].emplace_back(Predicate(HM.Features, true)); | |||
4130 | ||||
4131 | // Add negations of the HM's predicates to the default predicate. | |||
4132 | DefaultPred.emplace_back(Predicate(HM.Features, false)); | |||
4133 | } | |||
4134 | ||||
4135 | for (unsigned M : Modes) { | |||
4136 | if (M == DefaultMode) | |||
4137 | continue; | |||
4138 | AppendPattern(P, M); | |||
4139 | } | |||
4140 | ||||
4141 | bool HasDefault = Modes.count(DefaultMode); | |||
4142 | if (HasDefault) | |||
4143 | AppendPattern(P, DefaultMode); | |||
4144 | } | |||
4145 | } | |||
4146 | ||||
4147 | /// Dependent variable map for CodeGenDAGPattern variant generation | |||
4148 | typedef StringMap<int> DepVarMap; | |||
4149 | ||||
4150 | static void FindDepVarsOf(TreePatternNode *N, DepVarMap &DepMap) { | |||
4151 | if (N->isLeaf()) { | |||
4152 | if (N->hasName() && isa<DefInit>(N->getLeafValue())) | |||
4153 | DepMap[N->getName()]++; | |||
4154 | } else { | |||
4155 | for (size_t i = 0, e = N->getNumChildren(); i != e; ++i) | |||
4156 | FindDepVarsOf(N->getChild(i), DepMap); | |||
4157 | } | |||
4158 | } | |||
4159 | ||||
4160 | /// Find dependent variables within child patterns | |||
4161 | static void FindDepVars(TreePatternNode *N, MultipleUseVarSet &DepVars) { | |||
4162 | DepVarMap depcounts; | |||
4163 | FindDepVarsOf(N, depcounts); | |||
4164 | for (const auto &Pair : depcounts) { | |||
4165 | if (Pair.getValue() > 1) | |||
4166 | DepVars.insert(Pair.getKey()); | |||
4167 | } | |||
4168 | } | |||
4169 | ||||
4170 | #ifndef NDEBUG | |||
4171 | /// Dump the dependent variable set: | |||
4172 | static void DumpDepVars(MultipleUseVarSet &DepVars) { | |||
4173 | if (DepVars.empty()) { | |||
4174 | DEBUG(errs() << "<empty set>")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { errs() << "<empty set>"; } } while (false); | |||
4175 | } else { | |||
4176 | DEBUG(errs() << "[ ")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { errs() << "[ "; } } while (false); | |||
4177 | for (const auto &DepVar : DepVars) { | |||
4178 | DEBUG(errs() << DepVar.getKey() << " ")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { errs() << DepVar.getKey() << " " ; } } while (false); | |||
4179 | } | |||
4180 | DEBUG(errs() << "]")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { errs() << "]"; } } while (false); | |||
4181 | } | |||
4182 | } | |||
4183 | #endif | |||
4184 | ||||
4185 | ||||
4186 | /// CombineChildVariants - Given a bunch of permutations of each child of the | |||
4187 | /// 'operator' node, put them together in all possible ways. | |||
4188 | static void CombineChildVariants(TreePatternNode *Orig, | |||
4189 | const std::vector<std::vector<TreePatternNode*> > &ChildVariants, | |||
4190 | std::vector<TreePatternNode*> &OutVariants, | |||
4191 | CodeGenDAGPatterns &CDP, | |||
4192 | const MultipleUseVarSet &DepVars) { | |||
4193 | // Make sure that each operand has at least one variant to choose from. | |||
4194 | for (const auto &Variants : ChildVariants) | |||
4195 | if (Variants.empty()) | |||
4196 | return; | |||
4197 | ||||
4198 | // The end result is an all-pairs construction of the resultant pattern. | |||
4199 | std::vector<unsigned> Idxs; | |||
4200 | Idxs.resize(ChildVariants.size()); | |||
4201 | bool NotDone; | |||
4202 | do { | |||
4203 | #ifndef NDEBUG | |||
4204 | DEBUG(if (!Idxs.empty()) {do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { if (!Idxs.empty()) { errs() << Orig ->getOperator()->getName() << ": Idxs = [ "; for ( unsigned Idx : Idxs) { errs() << Idx << " "; } errs () << "]\n"; }; } } while (false) | |||
4205 | errs() << Orig->getOperator()->getName() << ": Idxs = [ ";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { if (!Idxs.empty()) { errs() << Orig ->getOperator()->getName() << ": Idxs = [ "; for ( unsigned Idx : Idxs) { errs() << Idx << " "; } errs () << "]\n"; }; } } while (false) | |||
4206 | for (unsigned Idx : Idxs) {do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { if (!Idxs.empty()) { errs() << Orig ->getOperator()->getName() << ": Idxs = [ "; for ( unsigned Idx : Idxs) { errs() << Idx << " "; } errs () << "]\n"; }; } } while (false) | |||
4207 | errs() << Idx << " ";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { if (!Idxs.empty()) { errs() << Orig ->getOperator()->getName() << ": Idxs = [ "; for ( unsigned Idx : Idxs) { errs() << Idx << " "; } errs () << "]\n"; }; } } while (false) | |||
4208 | }do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { if (!Idxs.empty()) { errs() << Orig ->getOperator()->getName() << ": Idxs = [ "; for ( unsigned Idx : Idxs) { errs() << Idx << " "; } errs () << "]\n"; }; } } while (false) | |||
4209 | errs() << "]\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { if (!Idxs.empty()) { errs() << Orig ->getOperator()->getName() << ": Idxs = [ "; for ( unsigned Idx : Idxs) { errs() << Idx << " "; } errs () << "]\n"; }; } } while (false) | |||
4210 | })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { if (!Idxs.empty()) { errs() << Orig ->getOperator()->getName() << ": Idxs = [ "; for ( unsigned Idx : Idxs) { errs() << Idx << " "; } errs () << "]\n"; }; } } while (false); | |||
4211 | #endif | |||
4212 | // Create the variant and add it to the output list. | |||
4213 | std::vector<TreePatternNode*> NewChildren; | |||
4214 | for (unsigned i = 0, e = ChildVariants.size(); i != e; ++i) | |||
4215 | NewChildren.push_back(ChildVariants[i][Idxs[i]]); | |||
4216 | auto R = llvm::make_unique<TreePatternNode>( | |||
4217 | Orig->getOperator(), NewChildren, Orig->getNumTypes()); | |||
4218 | ||||
4219 | // Copy over properties. | |||
4220 | R->setName(Orig->getName()); | |||
4221 | R->setPredicateFns(Orig->getPredicateFns()); | |||
4222 | R->setTransformFn(Orig->getTransformFn()); | |||
4223 | for (unsigned i = 0, e = Orig->getNumTypes(); i != e; ++i) | |||
4224 | R->setType(i, Orig->getExtType(i)); | |||
4225 | ||||
4226 | // If this pattern cannot match, do not include it as a variant. | |||
4227 | std::string ErrString; | |||
4228 | // Scan to see if this pattern has already been emitted. We can get | |||
4229 | // duplication due to things like commuting: | |||
4230 | // (and GPRC:$a, GPRC:$b) -> (and GPRC:$b, GPRC:$a) | |||
4231 | // which are the same pattern. Ignore the dups. | |||
4232 | if (R->canPatternMatch(ErrString, CDP) && | |||
4233 | none_of(OutVariants, [&](TreePatternNode *Variant) { | |||
4234 | return R->isIsomorphicTo(Variant, DepVars); | |||
4235 | })) | |||
4236 | OutVariants.push_back(R.release()); | |||
4237 | ||||
4238 | // Increment indices to the next permutation by incrementing the | |||
4239 | // indices from last index backward, e.g., generate the sequence | |||
4240 | // [0, 0], [0, 1], [1, 0], [1, 1]. | |||
4241 | int IdxsIdx; | |||
4242 | for (IdxsIdx = Idxs.size() - 1; IdxsIdx >= 0; --IdxsIdx) { | |||
4243 | if (++Idxs[IdxsIdx] == ChildVariants[IdxsIdx].size()) | |||
4244 | Idxs[IdxsIdx] = 0; | |||
4245 | else | |||
4246 | break; | |||
4247 | } | |||
4248 | NotDone = (IdxsIdx >= 0); | |||
4249 | } while (NotDone); | |||
4250 | } | |||
4251 | ||||
4252 | /// CombineChildVariants - A helper function for binary operators. | |||
4253 | /// | |||
4254 | static void CombineChildVariants(TreePatternNode *Orig, | |||
4255 | const std::vector<TreePatternNode*> &LHS, | |||
4256 | const std::vector<TreePatternNode*> &RHS, | |||
4257 | std::vector<TreePatternNode*> &OutVariants, | |||
4258 | CodeGenDAGPatterns &CDP, | |||
4259 | const MultipleUseVarSet &DepVars) { | |||
4260 | std::vector<std::vector<TreePatternNode*> > ChildVariants; | |||
4261 | ChildVariants.push_back(LHS); | |||
4262 | ChildVariants.push_back(RHS); | |||
4263 | CombineChildVariants(Orig, ChildVariants, OutVariants, CDP, DepVars); | |||
4264 | } | |||
4265 | ||||
4266 | ||||
4267 | static void GatherChildrenOfAssociativeOpcode(TreePatternNode *N, | |||
4268 | std::vector<TreePatternNode *> &Children) { | |||
4269 | assert(N->getNumChildren()==2 &&"Associative but doesn't have 2 children!")(static_cast <bool> (N->getNumChildren()==2 && "Associative but doesn't have 2 children!") ? void (0) : __assert_fail ("N->getNumChildren()==2 &&\"Associative but doesn't have 2 children!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 4269, __extension__ __PRETTY_FUNCTION__)); | |||
4270 | Record *Operator = N->getOperator(); | |||
4271 | ||||
4272 | // Only permit raw nodes. | |||
4273 | if (!N->getName().empty() || !N->getPredicateFns().empty() || | |||
4274 | N->getTransformFn()) { | |||
4275 | Children.push_back(N); | |||
4276 | return; | |||
4277 | } | |||
4278 | ||||
4279 | if (N->getChild(0)->isLeaf() || N->getChild(0)->getOperator() != Operator) | |||
4280 | Children.push_back(N->getChild(0)); | |||
4281 | else | |||
4282 | GatherChildrenOfAssociativeOpcode(N->getChild(0), Children); | |||
4283 | ||||
4284 | if (N->getChild(1)->isLeaf() || N->getChild(1)->getOperator() != Operator) | |||
4285 | Children.push_back(N->getChild(1)); | |||
4286 | else | |||
4287 | GatherChildrenOfAssociativeOpcode(N->getChild(1), Children); | |||
4288 | } | |||
4289 | ||||
4290 | /// GenerateVariantsOf - Given a pattern N, generate all permutations we can of | |||
4291 | /// the (potentially recursive) pattern by using algebraic laws. | |||
4292 | /// | |||
4293 | static void GenerateVariantsOf(TreePatternNode *N, | |||
4294 | std::vector<TreePatternNode*> &OutVariants, | |||
4295 | CodeGenDAGPatterns &CDP, | |||
4296 | const MultipleUseVarSet &DepVars) { | |||
4297 | // We cannot permute leaves or ComplexPattern uses. | |||
4298 | if (N->isLeaf() || N->getOperator()->isSubClassOf("ComplexPattern")) { | |||
4299 | OutVariants.push_back(N); | |||
4300 | return; | |||
4301 | } | |||
4302 | ||||
4303 | // Look up interesting info about the node. | |||
4304 | const SDNodeInfo &NodeInfo = CDP.getSDNodeInfo(N->getOperator()); | |||
4305 | ||||
4306 | // If this node is associative, re-associate. | |||
4307 | if (NodeInfo.hasProperty(SDNPAssociative)) { | |||
4308 | // Re-associate by pulling together all of the linked operators | |||
4309 | std::vector<TreePatternNode*> MaximalChildren; | |||
4310 | GatherChildrenOfAssociativeOpcode(N, MaximalChildren); | |||
4311 | ||||
4312 | // Only handle child sizes of 3. Otherwise we'll end up trying too many | |||
4313 | // permutations. | |||
4314 | if (MaximalChildren.size() == 3) { | |||
4315 | // Find the variants of all of our maximal children. | |||
4316 | std::vector<TreePatternNode*> AVariants, BVariants, CVariants; | |||
4317 | GenerateVariantsOf(MaximalChildren[0], AVariants, CDP, DepVars); | |||
4318 | GenerateVariantsOf(MaximalChildren[1], BVariants, CDP, DepVars); | |||
4319 | GenerateVariantsOf(MaximalChildren[2], CVariants, CDP, DepVars); | |||
4320 | ||||
4321 | // There are only two ways we can permute the tree: | |||
4322 | // (A op B) op C and A op (B op C) | |||
4323 | // Within these forms, we can also permute A/B/C. | |||
4324 | ||||
4325 | // Generate legal pair permutations of A/B/C. | |||
4326 | std::vector<TreePatternNode*> ABVariants; | |||
4327 | std::vector<TreePatternNode*> BAVariants; | |||
4328 | std::vector<TreePatternNode*> ACVariants; | |||
4329 | std::vector<TreePatternNode*> CAVariants; | |||
4330 | std::vector<TreePatternNode*> BCVariants; | |||
4331 | std::vector<TreePatternNode*> CBVariants; | |||
4332 | CombineChildVariants(N, AVariants, BVariants, ABVariants, CDP, DepVars); | |||
4333 | CombineChildVariants(N, BVariants, AVariants, BAVariants, CDP, DepVars); | |||
4334 | CombineChildVariants(N, AVariants, CVariants, ACVariants, CDP, DepVars); | |||
4335 | CombineChildVariants(N, CVariants, AVariants, CAVariants, CDP, DepVars); | |||
4336 | CombineChildVariants(N, BVariants, CVariants, BCVariants, CDP, DepVars); | |||
4337 | CombineChildVariants(N, CVariants, BVariants, CBVariants, CDP, DepVars); | |||
4338 | ||||
4339 | // Combine those into the result: (x op x) op x | |||
4340 | CombineChildVariants(N, ABVariants, CVariants, OutVariants, CDP, DepVars); | |||
4341 | CombineChildVariants(N, BAVariants, CVariants, OutVariants, CDP, DepVars); | |||
4342 | CombineChildVariants(N, ACVariants, BVariants, OutVariants, CDP, DepVars); | |||
4343 | CombineChildVariants(N, CAVariants, BVariants, OutVariants, CDP, DepVars); | |||
4344 | CombineChildVariants(N, BCVariants, AVariants, OutVariants, CDP, DepVars); | |||
4345 | CombineChildVariants(N, CBVariants, AVariants, OutVariants, CDP, DepVars); | |||
4346 | ||||
4347 | // Combine those into the result: x op (x op x) | |||
4348 | CombineChildVariants(N, CVariants, ABVariants, OutVariants, CDP, DepVars); | |||
4349 | CombineChildVariants(N, CVariants, BAVariants, OutVariants, CDP, DepVars); | |||
4350 | CombineChildVariants(N, BVariants, ACVariants, OutVariants, CDP, DepVars); | |||
4351 | CombineChildVariants(N, BVariants, CAVariants, OutVariants, CDP, DepVars); | |||
4352 | CombineChildVariants(N, AVariants, BCVariants, OutVariants, CDP, DepVars); | |||
4353 | CombineChildVariants(N, AVariants, CBVariants, OutVariants, CDP, DepVars); | |||
4354 | return; | |||
4355 | } | |||
4356 | } | |||
4357 | ||||
4358 | // Compute permutations of all children. | |||
4359 | std::vector<std::vector<TreePatternNode*> > ChildVariants; | |||
4360 | ChildVariants.resize(N->getNumChildren()); | |||
4361 | for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) | |||
4362 | GenerateVariantsOf(N->getChild(i), ChildVariants[i], CDP, DepVars); | |||
4363 | ||||
4364 | // Build all permutations based on how the children were formed. | |||
4365 | CombineChildVariants(N, ChildVariants, OutVariants, CDP, DepVars); | |||
4366 | ||||
4367 | // If this node is commutative, consider the commuted order. | |||
4368 | bool isCommIntrinsic = N->isCommutativeIntrinsic(CDP); | |||
4369 | if (NodeInfo.hasProperty(SDNPCommutative) || isCommIntrinsic) { | |||
4370 | assert((N->getNumChildren()>=2 || isCommIntrinsic) &&(static_cast <bool> ((N->getNumChildren()>=2 || isCommIntrinsic ) && "Commutative but doesn't have 2 children!") ? void (0) : __assert_fail ("(N->getNumChildren()>=2 || isCommIntrinsic) && \"Commutative but doesn't have 2 children!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 4371, __extension__ __PRETTY_FUNCTION__)) | |||
4371 | "Commutative but doesn't have 2 children!")(static_cast <bool> ((N->getNumChildren()>=2 || isCommIntrinsic ) && "Commutative but doesn't have 2 children!") ? void (0) : __assert_fail ("(N->getNumChildren()>=2 || isCommIntrinsic) && \"Commutative but doesn't have 2 children!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 4371, __extension__ __PRETTY_FUNCTION__)); | |||
4372 | // Don't count children which are actually register references. | |||
4373 | unsigned NC = 0; | |||
4374 | for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) { | |||
4375 | TreePatternNode *Child = N->getChild(i); | |||
4376 | if (Child->isLeaf()) | |||
4377 | if (DefInit *DI = dyn_cast<DefInit>(Child->getLeafValue())) { | |||
4378 | Record *RR = DI->getDef(); | |||
4379 | if (RR->isSubClassOf("Register")) | |||
4380 | continue; | |||
4381 | } | |||
4382 | NC++; | |||
4383 | } | |||
4384 | // Consider the commuted order. | |||
4385 | if (isCommIntrinsic) { | |||
4386 | // Commutative intrinsic. First operand is the intrinsic id, 2nd and 3rd | |||
4387 | // operands are the commutative operands, and there might be more operands | |||
4388 | // after those. | |||
4389 | assert(NC >= 3 &&(static_cast <bool> (NC >= 3 && "Commutative intrinsic should have at least 3 children!" ) ? void (0) : __assert_fail ("NC >= 3 && \"Commutative intrinsic should have at least 3 children!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 4390, __extension__ __PRETTY_FUNCTION__)) | |||
4390 | "Commutative intrinsic should have at least 3 children!")(static_cast <bool> (NC >= 3 && "Commutative intrinsic should have at least 3 children!" ) ? void (0) : __assert_fail ("NC >= 3 && \"Commutative intrinsic should have at least 3 children!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 4390, __extension__ __PRETTY_FUNCTION__)); | |||
4391 | std::vector<std::vector<TreePatternNode*> > Variants; | |||
4392 | Variants.push_back(ChildVariants[0]); // Intrinsic id. | |||
4393 | Variants.push_back(ChildVariants[2]); | |||
4394 | Variants.push_back(ChildVariants[1]); | |||
4395 | for (unsigned i = 3; i != NC; ++i) | |||
4396 | Variants.push_back(ChildVariants[i]); | |||
4397 | CombineChildVariants(N, Variants, OutVariants, CDP, DepVars); | |||
4398 | } else if (NC == N->getNumChildren()) { | |||
4399 | std::vector<std::vector<TreePatternNode*> > Variants; | |||
4400 | Variants.push_back(ChildVariants[1]); | |||
4401 | Variants.push_back(ChildVariants[0]); | |||
4402 | for (unsigned i = 2; i != NC; ++i) | |||
4403 | Variants.push_back(ChildVariants[i]); | |||
4404 | CombineChildVariants(N, Variants, OutVariants, CDP, DepVars); | |||
4405 | } | |||
4406 | } | |||
4407 | } | |||
4408 | ||||
4409 | ||||
4410 | // GenerateVariants - Generate variants. For example, commutative patterns can | |||
4411 | // match multiple ways. Add them to PatternsToMatch as well. | |||
4412 | void CodeGenDAGPatterns::GenerateVariants() { | |||
4413 | DEBUG(errs() << "Generating instruction variants.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { errs() << "Generating instruction variants.\n" ; } } while (false); | |||
4414 | ||||
4415 | // Loop over all of the patterns we've collected, checking to see if we can | |||
4416 | // generate variants of the instruction, through the exploitation of | |||
4417 | // identities. This permits the target to provide aggressive matching without | |||
4418 | // the .td file having to contain tons of variants of instructions. | |||
4419 | // | |||
4420 | // Note that this loop adds new patterns to the PatternsToMatch list, but we | |||
4421 | // intentionally do not reconsider these. Any variants of added patterns have | |||
4422 | // already been added. | |||
4423 | // | |||
4424 | for (unsigned i = 0, e = PatternsToMatch.size(); i != e; ++i) { | |||
4425 | MultipleUseVarSet DepVars; | |||
4426 | std::vector<TreePatternNode*> Variants; | |||
4427 | FindDepVars(PatternsToMatch[i].getSrcPattern(), DepVars); | |||
4428 | DEBUG(errs() << "Dependent/multiply used variables: ")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { errs() << "Dependent/multiply used variables: " ; } } while (false); | |||
4429 | DEBUG(DumpDepVars(DepVars))do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { DumpDepVars(DepVars); } } while (false); | |||
4430 | DEBUG(errs() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { errs() << "\n"; } } while (false); | |||
4431 | GenerateVariantsOf(PatternsToMatch[i].getSrcPattern(), Variants, *this, | |||
4432 | DepVars); | |||
4433 | ||||
4434 | assert(!Variants.empty() && "Must create at least original variant!")(static_cast <bool> (!Variants.empty() && "Must create at least original variant!" ) ? void (0) : __assert_fail ("!Variants.empty() && \"Must create at least original variant!\"" , "/build/llvm-toolchain-snapshot-7~svn329677/utils/TableGen/CodeGenDAGPatterns.cpp" , 4434, __extension__ __PRETTY_FUNCTION__)); | |||
4435 | if (Variants.size() == 1) // No additional variants for this pattern. | |||
4436 | continue; | |||
4437 | ||||
4438 | DEBUG(errs() << "FOUND VARIANTS OF: ";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { errs() << "FOUND VARIANTS OF: "; PatternsToMatch [i].getSrcPattern()->dump(); errs() << "\n"; } } while (false) | |||
4439 | PatternsToMatch[i].getSrcPattern()->dump();do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { errs() << "FOUND VARIANTS OF: "; PatternsToMatch [i].getSrcPattern()->dump(); errs() << "\n"; } } while (false) | |||
4440 | errs() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { errs() << "FOUND VARIANTS OF: "; PatternsToMatch [i].getSrcPattern()->dump(); errs() << "\n"; } } while (false); | |||
4441 | ||||
4442 | for (unsigned v = 0, e = Variants.size(); v != e; ++v) { | |||
4443 | TreePatternNode *Variant = Variants[v]; | |||
4444 | ||||
4445 | DEBUG(errs() << " VAR#" << v << ": ";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { errs() << " VAR#" << v << ": "; Variant->dump(); errs() << "\n"; } } while (false ) | |||
4446 | Variant->dump();do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { errs() << " VAR#" << v << ": "; Variant->dump(); errs() << "\n"; } } while (false ) | |||
4447 | errs() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { errs() << " VAR#" << v << ": "; Variant->dump(); errs() << "\n"; } } while (false ); | |||
4448 | ||||
4449 | // Scan to see if an instruction or explicit pattern already matches this. | |||
4450 | bool AlreadyExists = false; | |||
4451 | for (unsigned p = 0, e = PatternsToMatch.size(); p != e; ++p) { | |||
4452 | // Skip if the top level predicates do not match. | |||
4453 | if (PatternsToMatch[i].getPredicates() != | |||
4454 | PatternsToMatch[p].getPredicates()) | |||
4455 | continue; | |||
4456 | // Check to see if this variant already exists. | |||
4457 | if (Variant->isIsomorphicTo(PatternsToMatch[p].getSrcPattern(), | |||
4458 | DepVars)) { | |||
4459 | DEBUG(errs() << " *** ALREADY EXISTS, ignoring variant.\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { errs() << " *** ALREADY EXISTS, ignoring variant.\n" ; } } while (false); | |||
4460 | AlreadyExists = true; | |||
4461 | break; | |||
4462 | } | |||
4463 | } | |||
4464 | // If we already have it, ignore the variant. | |||
4465 | if (AlreadyExists) continue; | |||
4466 | ||||
4467 | // Otherwise, add it to the list of patterns we have. | |||
4468 | PatternsToMatch.push_back(PatternToMatch( | |||
4469 | PatternsToMatch[i].getSrcRecord(), PatternsToMatch[i].getPredicates(), | |||
4470 | Variant, PatternsToMatch[i].getDstPattern(), | |||
4471 | PatternsToMatch[i].getDstRegs(), | |||
4472 | PatternsToMatch[i].getAddedComplexity(), Record::getNewUID())); | |||
4473 | } | |||
4474 | ||||
4475 | DEBUG(errs() << "\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("dag-patterns")) { errs() << "\n"; } } while (false); | |||
4476 | } | |||
4477 | } |