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 Query.Types[TypeIdx0], Query.Types[TypeIdx1], Query.MMODescrs[MMOIdx].Size}; 51 return std::find(TypesAndMemSize.begin(), TypesAndMemSize.end(), Match) != 52 TypesAndMemSize.end(); 53 }; 54 } 55 56 LegalityPredicate LegalityPredicates::isScalar(unsigned TypeIdx) { 57 return [=](const LegalityQuery &Query) { 58 return Query.Types[TypeIdx].isScalar(); 59 }; 60 } 61 62 LegalityPredicate LegalityPredicates::narrowerThan(unsigned TypeIdx, 63 unsigned Size) { 64 return [=](const LegalityQuery &Query) { 65 const LLT &QueryTy = Query.Types[TypeIdx]; 66 return QueryTy.isScalar() && QueryTy.getSizeInBits() < Size; 67 }; 68 } 69 70 LegalityPredicate LegalityPredicates::widerThan(unsigned TypeIdx, 71 unsigned Size) { 72 return [=](const LegalityQuery &Query) { 73 const LLT &QueryTy = Query.Types[TypeIdx]; 74 return QueryTy.isScalar() && QueryTy.getSizeInBits() > Size; 75 }; 76 } 77 78 LegalityPredicate LegalityPredicates::sizeNotPow2(unsigned TypeIdx) { 79 return [=](const LegalityQuery &Query) { 80 const LLT &QueryTy = Query.Types[TypeIdx]; 81 return QueryTy.isScalar() && !isPowerOf2_32(QueryTy.getSizeInBits()); 82 }; 83 } 84 85 LegalityPredicate LegalityPredicates::memSizeInBytesNotPow2(unsigned MMOIdx) { 86 return [=](const LegalityQuery &Query) { 87 return !isPowerOf2_32(Query.MMODescrs[MMOIdx].Size /* In Bytes */); 88 }; 89 } 90 91 LegalityPredicate LegalityPredicates::numElementsNotPow2(unsigned TypeIdx) { 92 return [=](const LegalityQuery &Query) { 93 const LLT &QueryTy = Query.Types[TypeIdx]; 94 return QueryTy.isVector() && isPowerOf2_32(QueryTy.getNumElements()); 95 }; 96 } 97