1 //===-- llvm/CodeGen/MachineModuleInfo.h ------------------------*- 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 // Collect meta information for a module. This information should be in a 10 // neutral form that can be used by different debugging and exception handling 11 // schemes. 12 // 13 // The organization of information is primarily clustered around the source 14 // compile units. The main exception is source line correspondence where 15 // inlining may interleave code from various compile units. 16 // 17 // The following information can be retrieved from the MachineModuleInfo. 18 // 19 // -- Source directories - Directories are uniqued based on their canonical 20 // string and assigned a sequential numeric ID (base 1.) 21 // -- Source files - Files are also uniqued based on their name and directory 22 // ID. A file ID is sequential number (base 1.) 23 // -- Source line correspondence - A vector of file ID, line#, column# triples. 24 // A DEBUG_LOCATION instruction is generated by the DAG Legalizer 25 // corresponding to each entry in the source line list. This allows a debug 26 // emitter to generate labels referenced by debug information tables. 27 // 28 //===----------------------------------------------------------------------===// 29 30 #ifndef LLVM_CODEGEN_MACHINEMODULEINFO_H 31 #define LLVM_CODEGEN_MACHINEMODULEINFO_H 32 33 #include "llvm/ADT/DenseMap.h" 34 #include "llvm/ADT/PointerIntPair.h" 35 #include "llvm/IR/PassManager.h" 36 #include "llvm/MC/MCContext.h" 37 #include "llvm/Pass.h" 38 #include <memory> 39 #include <utility> 40 #include <vector> 41 42 namespace llvm { 43 44 class BasicBlock; 45 class Function; 46 class LLVMTargetMachine; 47 class MachineFunction; 48 class Module; 49 class MCSymbol; 50 51 //===----------------------------------------------------------------------===// 52 /// This class can be derived from and used by targets to hold private 53 /// target-specific information for each Module. Objects of type are 54 /// accessed/created with MachineModuleInfo::getObjFileInfo and destroyed when 55 /// the MachineModuleInfo is destroyed. 56 /// 57 class MachineModuleInfoImpl { 58 public: 59 using StubValueTy = PointerIntPair<MCSymbol *, 1, bool>; 60 using SymbolListTy = std::vector<std::pair<MCSymbol *, StubValueTy>>; 61 62 virtual ~MachineModuleInfoImpl(); 63 64 protected: 65 /// Return the entries from a DenseMap in a deterministic sorted orer. 66 /// Clears the map. 67 static SymbolListTy getSortedStubs(DenseMap<MCSymbol*, StubValueTy>&); 68 }; 69 70 //===----------------------------------------------------------------------===// 71 /// This class contains meta information specific to a module. Queries can be 72 /// made by different debugging and exception handling schemes and reformated 73 /// for specific use. 74 /// 75 class MachineModuleInfo { 76 friend class MachineModuleInfoWrapperPass; 77 friend class MachineModuleAnalysis; 78 79 const LLVMTargetMachine &TM; 80 81 /// This is the MCContext used for the entire code generator. 82 MCContext Context; 83 // This is an external context, that if assigned, will be used instead of the 84 // internal context. 85 MCContext *ExternalContext = nullptr; 86 87 /// This is the LLVM Module being worked on. 88 const Module *TheModule; 89 90 /// This is the object-file-format-specific implementation of 91 /// MachineModuleInfoImpl, which lets targets accumulate whatever info they 92 /// want. 93 MachineModuleInfoImpl *ObjFileMMI; 94 95 /// \name Exception Handling 96 /// \{ 97 98 /// Vector of all personality functions ever seen. Used to emit common EH 99 /// frames. 100 std::vector<const Function *> Personalities; 101 102 /// The current call site index being processed, if any. 0 if none. 103 unsigned CurCallSite; 104 105 /// \} 106 107 // TODO: Ideally, what we'd like is to have a switch that allows emitting 108 // synchronous (precise at call-sites only) CFA into .eh_frame. However, 109 // even under this switch, we'd like .debug_frame to be precise when using 110 // -g. At this moment, there's no way to specify that some CFI directives 111 // go into .eh_frame only, while others go into .debug_frame only. 112 113 /// True if debugging information is available in this module. 114 bool DbgInfoAvailable; 115 116 /// True if this module is being built for windows/msvc, and uses floating 117 /// point. This is used to emit an undefined reference to _fltused. 118 bool UsesMSVCFloatingPoint; 119 120 /// Maps IR Functions to their corresponding MachineFunctions. 121 DenseMap<const Function*, std::unique_ptr<MachineFunction>> MachineFunctions; 122 /// Next unique number available for a MachineFunction. 123 unsigned NextFnNum = 0; 124 const Function *LastRequest = nullptr; ///< Used for shortcut/cache. 125 MachineFunction *LastResult = nullptr; ///< Used for shortcut/cache. 126 127 MachineModuleInfo &operator=(MachineModuleInfo &&MMII) = delete; 128 129 public: 130 explicit MachineModuleInfo(const LLVMTargetMachine *TM = nullptr); 131 132 explicit MachineModuleInfo(const LLVMTargetMachine *TM, 133 MCContext *ExtContext); 134 135 MachineModuleInfo(MachineModuleInfo &&MMII); 136 137 ~MachineModuleInfo(); 138 139 void initialize(); 140 void finalize(); 141 142 const LLVMTargetMachine &getTarget() const { return TM; } 143 144 const MCContext &getContext() const { 145 return ExternalContext ? *ExternalContext : Context; 146 } 147 MCContext &getContext() { 148 return ExternalContext ? *ExternalContext : Context; 149 } 150 151 const Module *getModule() const { return TheModule; } 152 153 /// Returns the MachineFunction constructed for the IR function \p F. 154 /// Creates a new MachineFunction if none exists yet. 155 MachineFunction &getOrCreateMachineFunction(Function &F); 156 157 /// \brief Returns the MachineFunction associated to IR function \p F if there 158 /// is one, otherwise nullptr. 159 MachineFunction *getMachineFunction(const Function &F) const; 160 161 /// Delete the MachineFunction \p MF and reset the link in the IR Function to 162 /// Machine Function map. 163 void deleteMachineFunctionFor(Function &F); 164 165 /// Add an externally created MachineFunction \p MF for \p F. 166 void insertFunction(const Function &F, std::unique_ptr<MachineFunction> &&MF); 167 168 /// Keep track of various per-module pieces of information for backends 169 /// that would like to do so. 170 template<typename Ty> 171 Ty &getObjFileInfo() { 172 if (ObjFileMMI == nullptr) 173 ObjFileMMI = new Ty(*this); 174 return *static_cast<Ty*>(ObjFileMMI); 175 } 176 177 template<typename Ty> 178 const Ty &getObjFileInfo() const { 179 return const_cast<MachineModuleInfo*>(this)->getObjFileInfo<Ty>(); 180 } 181 182 /// Returns true if valid debug info is present. 183 bool hasDebugInfo() const { return DbgInfoAvailable; } 184 185 bool usesMSVCFloatingPoint() const { return UsesMSVCFloatingPoint; } 186 187 void setUsesMSVCFloatingPoint(bool b) { UsesMSVCFloatingPoint = b; } 188 189 /// \name Exception Handling 190 /// \{ 191 192 /// Set the call site currently being processed. 193 void setCurrentCallSite(unsigned Site) { CurCallSite = Site; } 194 195 /// Get the call site currently being processed, if any. return zero if 196 /// none. 197 unsigned getCurrentCallSite() { return CurCallSite; } 198 199 /// Provide the personality function for the exception information. 200 void addPersonality(const Function *Personality); 201 202 /// Return array of personality functions ever seen. 203 const std::vector<const Function *>& getPersonalities() const { 204 return Personalities; 205 } 206 /// \} 207 208 // MMI owes MCContext. It should never be invalidated. 209 bool invalidate(Module &, const PreservedAnalyses &, 210 ModuleAnalysisManager::Invalidator &) { 211 return false; 212 } 213 }; // End class MachineModuleInfo 214 215 class MachineModuleInfoWrapperPass : public ImmutablePass { 216 MachineModuleInfo MMI; 217 218 public: 219 static char ID; // Pass identification, replacement for typeid 220 explicit MachineModuleInfoWrapperPass(const LLVMTargetMachine *TM = nullptr); 221 222 explicit MachineModuleInfoWrapperPass(const LLVMTargetMachine *TM, 223 MCContext *ExtContext); 224 225 // Initialization and Finalization 226 bool doInitialization(Module &) override; 227 bool doFinalization(Module &) override; 228 229 MachineModuleInfo &getMMI() { return MMI; } 230 const MachineModuleInfo &getMMI() const { return MMI; } 231 }; 232 233 /// An analysis that produces \c MachineInfo for a module. 234 class MachineModuleAnalysis : public AnalysisInfoMixin<MachineModuleAnalysis> { 235 friend AnalysisInfoMixin<MachineModuleAnalysis>; 236 static AnalysisKey Key; 237 238 const LLVMTargetMachine *TM; 239 240 public: 241 /// Provide the result type for this analysis pass. 242 using Result = MachineModuleInfo; 243 244 MachineModuleAnalysis(const LLVMTargetMachine *TM) : TM(TM) {} 245 246 /// Run the analysis pass and produce machine module information. 247 MachineModuleInfo run(Module &M, ModuleAnalysisManager &); 248 }; 249 250 } // end namespace llvm 251 252 #endif // LLVM_CODEGEN_MACHINEMODULEINFO_H 253