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
15using namespace llvm;
16
17LegalizeMutation LegalizeMutations::changeTo(unsigned TypeIdx, LLT Ty) {
18  return
19      [=](const LegalityQuery &Query) { return std::make_pair(TypeIdx, Ty); };
20}
21
22LegalizeMutation LegalizeMutations::changeTo(unsigned TypeIdx,
23                                             unsigned FromTypeIdx) {
24  return [=](const LegalityQuery &Query) {
25    return std::make_pair(TypeIdx, Query.Types[FromTypeIdx]);
26  };
27}
28
29LegalizeMutation 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
38LegalizeMutation 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
46LegalizeMutation 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
57LegalizeMutation 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
67LegalizeMutation 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
77LegalizeMutation 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
87LegalizeMutation
88LegalizeMutations::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
97LegalizeMutation 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
108LegalizeMutation LegalizeMutations::scalarize(unsigned TypeIdx) {
109  return [=](const LegalityQuery &Query) {
110    return std::make_pair(TypeIdx, Query.Types[TypeIdx].getElementType());
111  };
112}
113