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