1 //== llvm/CodeGen/GlobalISel/Localizer.h - Localizer -------------*- C++ -*-==//
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 /// \file This file describes the interface of the Localizer pass.
10 /// This pass moves/duplicates constant-like instructions close to their uses.
11 /// Its primarily goal is to workaround the deficiencies of the fast register
12 /// allocator.
13 /// With GlobalISel constants are all materialized in the entry block of
14 /// a function. However, the fast allocator cannot rematerialize constants and
15 /// has a lot more live-ranges to deal with and will most likely end up
16 /// spilling a lot.
17 /// By pushing the constants close to their use, we only create small
18 /// live-ranges.
19 //===----------------------------------------------------------------------===//
20 
21 #ifndef LLVM_CODEGEN_GLOBALISEL_LOCALIZER_H
22 #define LLVM_CODEGEN_GLOBALISEL_LOCALIZER_H
23 
24 #include "llvm/ADT/SetVector.h"
25 #include "llvm/CodeGen/MachineFunctionPass.h"
26 
27 namespace llvm {
28 // Forward declarations.
29 class AnalysisUsage;
30 class MachineBasicBlock;
31 class MachineInstr;
32 class MachineOperand;
33 class MachineRegisterInfo;
34 class TargetTransformInfo;
35 
36 /// This pass implements the localization mechanism described at the
37 /// top of this file. One specificity of the implementation is that
38 /// it will materialize one and only one instance of a constant per
39 /// basic block, thus enabling reuse of that constant within that block.
40 /// Moreover, it only materializes constants in blocks where they
41 /// are used. PHI uses are considered happening at the end of the
42 /// related predecessor.
43 class Localizer : public MachineFunctionPass {
44 public:
45   static char ID;
46 
47 private:
48   /// An input function to decide if the pass should run or not
49   /// on the given MachineFunction.
50   std::function<bool(const MachineFunction &)> DoNotRunPass;
51 
52   /// MRI contains all the register class/bank information that this
53   /// pass uses and updates.
54   MachineRegisterInfo *MRI = nullptr;
55   /// TTI used for getting remat costs for instructions.
56   TargetTransformInfo *TTI = nullptr;
57 
58   /// Check if \p MOUse is used in the same basic block as \p Def.
59   /// If the use is in the same block, we say it is local.
60   /// When the use is not local, \p InsertMBB will contain the basic
61   /// block when to insert \p Def to have a local use.
62   static bool isLocalUse(MachineOperand &MOUse, const MachineInstr &Def,
63                          MachineBasicBlock *&InsertMBB);
64 
65   /// Initialize the field members using \p MF.
66   void init(MachineFunction &MF);
67 
68   typedef SmallSetVector<MachineInstr *, 32> LocalizedSetVecT;
69 
70   /// If \p Op is a phi operand and not unique in that phi, that is,
71   /// there are other operands in the phi with the same register,
72   /// return true.
73   bool isNonUniquePhiValue(MachineOperand &Op) const;
74 
75   /// Do inter-block localization from the entry block.
76   bool localizeInterBlock(MachineFunction &MF,
77                           LocalizedSetVecT &LocalizedInstrs);
78 
79   /// Do intra-block localization of already localized instructions.
80   bool localizeIntraBlock(LocalizedSetVecT &LocalizedInstrs);
81 
82 public:
83   Localizer();
84   Localizer(std::function<bool(const MachineFunction &)>);
85 
86   StringRef getPassName() const override { return "Localizer"; }
87 
88   MachineFunctionProperties getRequiredProperties() const override {
89     return MachineFunctionProperties()
90         .set(MachineFunctionProperties::Property::IsSSA);
91   }
92 
93   void getAnalysisUsage(AnalysisUsage &AU) const override;
94 
95   bool runOnMachineFunction(MachineFunction &MF) override;
96 };
97 
98 } // End namespace llvm.
99 
100 #endif
101