llvm/lib/CodeGen/GlobalISel/LegalizeMutations.cpp

   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
  13 #include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
  14
  15 using namespace llvm;
  16
  17 LegalizeMutation LegalizeMutations::changeTo(unsigned TypeIdx, LLT Ty) {
  18   return
  19       [=](const LegalityQuery &Query) { return std::make_pair(TypeIdx, Ty); };
  20 }
  21
  22 LegalizeMutation LegalizeMutations::changeTo(unsigned TypeIdx,
  23                                              unsigned FromTypeIdx) {
  24   return [=](const LegalityQuery &Query) {
  25     return std::make_pair(TypeIdx, Query.Types[FromTypeIdx]);
  26   };
  27 }
  28
  29 LegalizeMutation LegalizeMutations::changeElementTo(unsigned TypeIdx,
  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
  38 LegalizeMutation LegalizeMutations::changeElementTo(unsigned TypeIdx,
  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
  46 LegalizeMutation LegalizeMutations::changeElementCountTo(unsigned TypeIdx,
  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
  57 LegalizeMutation LegalizeMutations::changeElementCountTo(unsigned TypeIdx,
  58                                                          LLT NewEltTy) {
  59   return [=](const LegalityQuery &Query) {
  60     const LLT OldTy = Query.Types[TypeIdx];
  61     ElementCount NewEltCount = NewEltTy.isVector() ? NewEltTy.getElementCount()
  62                                                    : ElementCount::getFixed(1);
  63     return std::make_pair(TypeIdx, OldTy.changeElementCount(NewEltCount));
  64   };
  65 }
  66
  67 LegalizeMutation LegalizeMutations::changeElementSizeTo(unsigned TypeIdx,
  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
  77 LegalizeMutation LegalizeMutations::widenScalarOrEltToNextPow2(unsigned TypeIdx,
  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
  87 LegalizeMutation
  88 LegalizeMutations::widenScalarOrEltToNextMultipleOf(unsigned TypeIdx,
  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
  97 LegalizeMutation LegalizeMutations::moreElementsToNextPow2(unsigned TypeIdx,
  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
 108 LegalizeMutation LegalizeMutations::scalarize(unsigned TypeIdx) {
 109   return [=](const LegalityQuery &Query) {
 110     return std::make_pair(TypeIdx, Query.Types[TypeIdx].getElementType());
 111   };
 112 }