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