LLVM  16.0.0git
LegalizeMutations.cpp
Go to the documentation of this file.
1 //===- lib/CodeGen/GlobalISel/LegalizerMutations.cpp - Mutations ----------===//
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 // A library of mutation factories to use for LegalityMutation.
10 //
11 //===----------------------------------------------------------------------===//
12 
14 
15 using namespace llvm;
16 
18  return
19  [=](const LegalityQuery &Query) { return std::make_pair(TypeIdx, Ty); };
20 }
21 
23  unsigned FromTypeIdx) {
24  return [=](const LegalityQuery &Query) {
25  return std::make_pair(TypeIdx, Query.Types[FromTypeIdx]);
26  };
27 }
28 
30  unsigned FromTypeIdx) {
31  return [=](const LegalityQuery &Query) {
32  const LLT OldTy = Query.Types[TypeIdx];
33  const LLT NewTy = Query.Types[FromTypeIdx];
34  return std::make_pair(TypeIdx, OldTy.changeElementType(NewTy));
35  };
36 }
37 
39  LLT NewEltTy) {
40  return [=](const LegalityQuery &Query) {
41  const LLT OldTy = Query.Types[TypeIdx];
42  return std::make_pair(TypeIdx, OldTy.changeElementType(NewEltTy));
43  };
44 }
45 
47  unsigned FromTypeIdx) {
48  return [=](const LegalityQuery &Query) {
49  const LLT OldTy = Query.Types[TypeIdx];
50  const LLT NewTy = Query.Types[FromTypeIdx];
51  ElementCount NewEltCount =
52  NewTy.isVector() ? NewTy.getElementCount() : ElementCount::getFixed(1);
53  return std::make_pair(TypeIdx, OldTy.changeElementCount(NewEltCount));
54  };
55 }
56 
58  LLT NewEltTy) {
59  return [=](const LegalityQuery &Query) {
60  const LLT OldTy = Query.Types[TypeIdx];
61  ElementCount NewEltCount = NewEltTy.isVector() ? NewEltTy.getElementCount()
63  return std::make_pair(TypeIdx, OldTy.changeElementCount(NewEltCount));
64  };
65 }
66 
68  unsigned FromTypeIdx) {
69  return [=](const LegalityQuery &Query) {
70  const LLT OldTy = Query.Types[TypeIdx];
71  const LLT NewTy = Query.Types[FromTypeIdx];
72  const LLT NewEltTy = LLT::scalar(NewTy.getScalarSizeInBits());
73  return std::make_pair(TypeIdx, OldTy.changeElementType(NewEltTy));
74  };
75 }
76 
78  unsigned Min) {
79  return [=](const LegalityQuery &Query) {
80  const LLT Ty = Query.Types[TypeIdx];
81  unsigned NewEltSizeInBits =
82  std::max(1u << Log2_32_Ceil(Ty.getScalarSizeInBits()), Min);
83  return std::make_pair(TypeIdx, Ty.changeElementSize(NewEltSizeInBits));
84  };
85 }
86 
89  unsigned Size) {
90  return [=](const LegalityQuery &Query) {
91  const LLT Ty = Query.Types[TypeIdx];
92  unsigned NewEltSizeInBits = alignTo(Ty.getScalarSizeInBits(), Size);
93  return std::make_pair(TypeIdx, Ty.changeElementSize(NewEltSizeInBits));
94  };
95 }
96 
98  unsigned Min) {
99  return [=](const LegalityQuery &Query) {
100  const LLT VecTy = Query.Types[TypeIdx];
101  unsigned NewNumElements =
102  std::max(1u << Log2_32_Ceil(VecTy.getNumElements()), Min);
103  return std::make_pair(
104  TypeIdx, LLT::fixed_vector(NewNumElements, VecTy.getElementType()));
105  };
106 }
107 
109  return [=](const LegalityQuery &Query) {
110  return std::make_pair(TypeIdx, Query.Types[TypeIdx].getElementType());
111  };
112 }
llvm::alignTo
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:156
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::LLT::getScalarSizeInBits
unsigned getScalarSizeInBits() const
Definition: LowLevelTypeImpl.h:224
llvm::ElementCount
Definition: TypeSize.h:404
llvm::LegalizeMutations::widenScalarOrEltToNextMultipleOf
LegalizeMutation widenScalarOrEltToNextMultipleOf(unsigned TypeIdx, unsigned Size)
Widen the scalar type or vector element type for the given type index to next multiple of Size.
Definition: LegalizeMutations.cpp:88
llvm::LLT::changeElementCount
LLT changeElementCount(ElementCount EC) const
Return a vector or scalar with the same element type and the new element count.
Definition: LowLevelTypeImpl.h:189
llvm::max
Expected< ExpressionValue > max(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:337
llvm::LegalizeMutations::changeTo
LegalizeMutation changeTo(unsigned TypeIdx, LLT Ty)
Select this specific type for the given type index.
Definition: LegalizeMutations.cpp:17
LegalizerInfo.h
llvm::LLT::fixed_vector
static LLT fixed_vector(unsigned NumElements, unsigned ScalarSizeInBits)
Get a low-level fixed-width vector of some number of elements and element width.
Definition: LowLevelTypeImpl.h:74
llvm::LinearPolySize< ElementCount >::getFixed
static ElementCount getFixed(ScalarTy MinVal)
Definition: TypeSize.h:283
llvm::Log2_32_Ceil
unsigned Log2_32_Ceil(uint32_t Value)
Return the ceil log base 2 of the specified value, 32 if the value is zero.
Definition: MathExtras.h:623
llvm::LegalizeMutations::scalarize
LegalizeMutation scalarize(unsigned TypeIdx)
Break up the vector type for the given type index into the element type.
Definition: LegalizeMutations.cpp:108
llvm::LegalizeMutations::changeElementSizeTo
LegalizeMutation changeElementSizeTo(unsigned TypeIdx, unsigned FromTypeIdx)
Change the scalar size or element size to have the same scalar size as type index FromIndex.
Definition: LegalizeMutations.cpp:67
llvm::LegalizeMutations::changeElementCountTo
LegalizeMutation changeElementCountTo(unsigned TypeIdx, unsigned FromTypeIdx)
Keep the same scalar or element type as TypeIdx, but take the number of elements from FromTypeIdx.
Definition: LegalizeMutations.cpp:46
llvm::LLT::isVector
bool isVector() const
Definition: LowLevelTypeImpl.h:122
llvm::LLT::getNumElements
uint16_t getNumElements() const
Returns the number of elements in a vector LLT.
Definition: LowLevelTypeImpl.h:126
llvm::LegalityQuery
The LegalityQuery object bundles together all the information that's needed to decide whether a given...
Definition: LegalizerInfo.h:108
llvm::LegalizeMutations::changeElementTo
LegalizeMutation changeElementTo(unsigned TypeIdx, unsigned FromTypeIdx)
Keep the same scalar or element type as the given type index.
Definition: LegalizeMutations.cpp:29
llvm::LegalizeMutations::widenScalarOrEltToNextPow2
LegalizeMutation widenScalarOrEltToNextPow2(unsigned TypeIdx, unsigned Min=0)
Widen the scalar type or vector element type for the given type index to the next power of 2.
Definition: LegalizeMutations.cpp:77
llvm::LLT::changeElementType
LLT changeElementType(LLT NewEltTy) const
If this type is a vector, return a vector with the same number of elements but the new element type.
Definition: LowLevelTypeImpl.h:173
llvm::LLT::getElementCount
ElementCount getElementCount() const
Definition: LowLevelTypeImpl.h:143
llvm::LegalizeMutation
std::function< std::pair< unsigned, LLT >(const LegalityQuery &)> LegalizeMutation
Definition: LegalizerInfo.h:201
llvm::LegalizeMutations::moreElementsToNextPow2
LegalizeMutation moreElementsToNextPow2(unsigned TypeIdx, unsigned Min=0)
Add more elements to the type for the given type index to the next power of.
Definition: LegalizeMutations.cpp:97
llvm::LLT::getElementType
LLT getElementType() const
Returns the vector's element type. Only valid for vector types.
Definition: LowLevelTypeImpl.h:248
llvm::LLT::scalar
static LLT scalar(unsigned SizeInBits)
Get a low-level scalar or aggregate "bag of bits".
Definition: LowLevelTypeImpl.h:42
llvm::LLT::changeElementSize
LLT changeElementSize(unsigned NewEltSize) const
If this type is a vector, return a vector with the same number of elements but the new element size.
Definition: LowLevelTypeImpl.h:180
llvm::LLT
Definition: LowLevelTypeImpl.h:39