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