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 reg operand of a PHI, return the number of total 71 /// operands in the PHI that are the same as \p Op, including itself. 72 unsigned getNumPhiUses(MachineOperand &Op) const; 73 74 /// Do inter-block localization from the entry block. 75 bool localizeInterBlock(MachineFunction &MF, 76 LocalizedSetVecT &LocalizedInstrs); 77 78 /// Do intra-block localization of already localized instructions. 79 bool localizeIntraBlock(LocalizedSetVecT &LocalizedInstrs); 80 81 public: 82 Localizer(); 83 Localizer(std::function<bool(const MachineFunction &)>); 84 85 StringRef getPassName() const override { return "Localizer"; } 86 87 MachineFunctionProperties getRequiredProperties() const override { 88 return MachineFunctionProperties() 89 .set(MachineFunctionProperties::Property::IsSSA); 90 } 91 92 void getAnalysisUsage(AnalysisUsage &AU) const override; 93 94 bool runOnMachineFunction(MachineFunction &MF) override; 95 }; 96 97 } // End namespace llvm. 98 99 #endif 100