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 LegalityPredicates::typeIs(unsigned TypeIdx, LLT Type) { 19 return 20 [=](const LegalityQuery &Query) { return Query.Types[TypeIdx] == Type; }; 21 } 22 23 LegalityPredicate 24 LegalityPredicates::typeInSet(unsigned TypeIdx, 25 std::initializer_list<LLT> TypesInit) { 26 SmallVector<LLT, 4> Types = TypesInit; 27 return [=](const LegalityQuery &Query) { 28 return std::find(Types.begin(), Types.end(), Query.Types[TypeIdx]) != Types.end(); 29 }; 30 } 31 32 LegalityPredicate LegalityPredicates::typePairInSet( 33 unsigned TypeIdx0, unsigned TypeIdx1, 34 std::initializer_list<std::pair<LLT, LLT>> TypesInit) { 35 SmallVector<std::pair<LLT, LLT>, 4> Types = TypesInit; 36 return [=](const LegalityQuery &Query) { 37 std::pair<LLT, LLT> Match = {Query.Types[TypeIdx0], Query.Types[TypeIdx1]}; 38 return std::find(Types.begin(), Types.end(), Match) != Types.end(); 39 }; 40 } 41 42 LegalityPredicate LegalityPredicates::typePairAndMemSizeInSet( 43 unsigned TypeIdx0, unsigned TypeIdx1, unsigned MMOIdx, 44 std::initializer_list<TypePairAndMemSize> TypesAndMemSizeInit) { 45 SmallVector<TypePairAndMemSize, 4> TypesAndMemSize = TypesAndMemSizeInit; 46 return [=](const LegalityQuery &Query) { 47 TypePairAndMemSize Match = {Query.Types[TypeIdx0], Query.Types[TypeIdx1], 48 Query.MMODescrs[MMOIdx].Size}; 49 return std::find(TypesAndMemSize.begin(), TypesAndMemSize.end(), Match) != 50 TypesAndMemSize.end(); 51 }; 52 } 53 54 LegalityPredicate LegalityPredicates::isScalar(unsigned TypeIdx) { 55 return [=](const LegalityQuery &Query) { 56 return Query.Types[TypeIdx].isScalar(); 57 }; 58 } 59 60 LegalityPredicate LegalityPredicates::narrowerThan(unsigned TypeIdx, 61 unsigned Size) { 62 return [=](const LegalityQuery &Query) { 63 const LLT &QueryTy = Query.Types[TypeIdx]; 64 return QueryTy.isScalar() && QueryTy.getSizeInBits() < Size; 65 }; 66 } 67 68 LegalityPredicate LegalityPredicates::widerThan(unsigned TypeIdx, 69 unsigned Size) { 70 return [=](const LegalityQuery &Query) { 71 const LLT &QueryTy = Query.Types[TypeIdx]; 72 return QueryTy.isScalar() && QueryTy.getSizeInBits() > Size; 73 }; 74 } 75 76 LegalityPredicate LegalityPredicates::sizeNotPow2(unsigned TypeIdx) { 77 return [=](const LegalityQuery &Query) { 78 const LLT &QueryTy = Query.Types[TypeIdx]; 79 return QueryTy.isScalar() && !isPowerOf2_32(QueryTy.getSizeInBits()); 80 }; 81 } 82 83 LegalityPredicate LegalityPredicates::memSizeInBytesNotPow2(unsigned MMOIdx) { 84 return [=](const LegalityQuery &Query) { 85 return !isPowerOf2_32(Query.MMODescrs[MMOIdx].Size /* In Bytes */); 86 }; 87 } 88 89 LegalityPredicate LegalityPredicates::numElementsNotPow2(unsigned TypeIdx) { 90 return [=](const LegalityQuery &Query) { 91 const LLT &QueryTy = Query.Types[TypeIdx]; 92 return QueryTy.isVector() && isPowerOf2_32(QueryTy.getNumElements()); 93 }; 94 } 95 96 LegalityPredicate LegalityPredicates::atomicOrderingAtLeastOrStrongerThan( 97 unsigned MMOIdx, AtomicOrdering Ordering) { 98 return [=](const LegalityQuery &Query) { 99 return isAtLeastOrStrongerThan(Query.MMODescrs[MMOIdx].Ordering, Ordering); 100 }; 101 } 102