1 //===- lib/CodeGen/GlobalISel/LegalizerPredicates.cpp - Predicates --------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // A library of predicate factories to use for LegalityPredicate.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
15 
16 using namespace llvm;
17 
18 LegalityPredicate
19 LegalityPredicates::all(LegalityPredicate P0, LegalityPredicate P1) {
20   return [=](const LegalityQuery &Query) {
21     return P0(Query) && P1(Query);
22   };
23 }
24 
25 LegalityPredicate
26 LegalityPredicates::typeInSet(unsigned TypeIdx,
27                               std::initializer_list<LLT> TypesInit) {
28   SmallVector<LLT, 4> Types = TypesInit;
29   return [=](const LegalityQuery &Query) {
30     return std::find(Types.begin(), Types.end(), Query.Types[TypeIdx]) != Types.end();
31   };
32 }
33 
34 LegalityPredicate LegalityPredicates::typePairInSet(
35     unsigned TypeIdx0, unsigned TypeIdx1,
36     std::initializer_list<std::pair<LLT, LLT>> TypesInit) {
37   SmallVector<std::pair<LLT, LLT>, 4> Types = TypesInit;
38   return [=](const LegalityQuery &Query) {
39     std::pair<LLT, LLT> Match = {Query.Types[TypeIdx0], Query.Types[TypeIdx1]};
40     return std::find(Types.begin(), Types.end(), Match) != Types.end();
41   };
42 }
43 
44 LegalityPredicate LegalityPredicates::typePairAndMemSizeInSet(
45     unsigned TypeIdx0, unsigned TypeIdx1, unsigned MMOIdx,
46     std::initializer_list<std::tuple<LLT, LLT, unsigned>> TypesAndMemSizeInit) {
47   SmallVector<std::tuple<LLT, LLT, unsigned>, 4> TypesAndMemSize = TypesAndMemSizeInit;
48   return [=](const LegalityQuery &Query) {
49     std::tuple<LLT, LLT, unsigned> Match =
50         std::make_tuple(Query.Types[TypeIdx0], Query.Types[TypeIdx1],
51                         Query.MMODescrs[MMOIdx].Size);
52     return std::find(TypesAndMemSize.begin(), TypesAndMemSize.end(), Match) !=
53            TypesAndMemSize.end();
54   };
55 }
56 
57 LegalityPredicate LegalityPredicates::isScalar(unsigned TypeIdx) {
58   return [=](const LegalityQuery &Query) {
59     return Query.Types[TypeIdx].isScalar();
60   };
61 }
62 
63 LegalityPredicate LegalityPredicates::narrowerThan(unsigned TypeIdx,
64                                                    unsigned Size) {
65   return [=](const LegalityQuery &Query) {
66     const LLT &QueryTy = Query.Types[TypeIdx];
67     return QueryTy.isScalar() && QueryTy.getSizeInBits() < Size;
68   };
69 }
70 
71 LegalityPredicate LegalityPredicates::widerThan(unsigned TypeIdx,
72                                                 unsigned Size) {
73   return [=](const LegalityQuery &Query) {
74     const LLT &QueryTy = Query.Types[TypeIdx];
75     return QueryTy.isScalar() && QueryTy.getSizeInBits() > Size;
76   };
77 }
78 
79 LegalityPredicate LegalityPredicates::sizeNotPow2(unsigned TypeIdx) {
80   return [=](const LegalityQuery &Query) {
81     const LLT &QueryTy = Query.Types[TypeIdx];
82     return QueryTy.isScalar() && !isPowerOf2_32(QueryTy.getSizeInBits());
83   };
84 }
85 
86 LegalityPredicate LegalityPredicates::memSizeInBytesNotPow2(unsigned MMOIdx) {
87   return [=](const LegalityQuery &Query) {
88     return !isPowerOf2_32(Query.MMODescrs[MMOIdx].Size /* In Bytes */);
89   };
90 }
91 
92 LegalityPredicate LegalityPredicates::numElementsNotPow2(unsigned TypeIdx) {
93   return [=](const LegalityQuery &Query) {
94     const LLT &QueryTy = Query.Types[TypeIdx];
95     return QueryTy.isVector() && isPowerOf2_32(QueryTy.getNumElements());
96   };
97 }
98