1 //===-- llvm/Target/TargetLoweringObjectFile.h - Object Info ----*- 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 // This file implements classes used to handle lowerings specific to common 10 // object file formats. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_TARGET_TARGETLOWERINGOBJECTFILE_H 15 #define LLVM_TARGET_TARGETLOWERINGOBJECTFILE_H 16 17 #include "llvm/MC/MCObjectFileInfo.h" 18 #include "llvm/MC/MCRegister.h" 19 #include <cstdint> 20 21 namespace llvm { 22 23 struct Align; 24 class Constant; 25 class DataLayout; 26 class Function; 27 class GlobalObject; 28 class GlobalValue; 29 class MachineBasicBlock; 30 class MachineModuleInfo; 31 class Mangler; 32 class MCContext; 33 class MCExpr; 34 class MCSection; 35 class MCSymbol; 36 class MCSymbolRefExpr; 37 class MCStreamer; 38 class MCValue; 39 class Module; 40 class SectionKind; 41 class StringRef; 42 class TargetMachine; 43 class DSOLocalEquivalent; 44 45 class TargetLoweringObjectFile : public MCObjectFileInfo { 46 /// Name-mangler for global names. 47 Mangler *Mang = nullptr; 48 49 protected: 50 bool SupportIndirectSymViaGOTPCRel = false; 51 bool SupportGOTPCRelWithOffset = true; 52 bool SupportDebugThreadLocalLocation = true; 53 bool SupportDSOLocalEquivalentLowering = false; 54 55 /// PersonalityEncoding, LSDAEncoding, TTypeEncoding - Some encoding values 56 /// for EH. 57 unsigned PersonalityEncoding = 0; 58 unsigned LSDAEncoding = 0; 59 unsigned TTypeEncoding = 0; 60 unsigned CallSiteEncoding = 0; 61 62 /// This section contains the static constructor pointer list. 63 MCSection *StaticCtorSection = nullptr; 64 65 /// This section contains the static destructor pointer list. 66 MCSection *StaticDtorSection = nullptr; 67 68 const TargetMachine *TM = nullptr; 69 70 public: 71 TargetLoweringObjectFile() = default; 72 TargetLoweringObjectFile(const TargetLoweringObjectFile &) = delete; 73 TargetLoweringObjectFile & 74 operator=(const TargetLoweringObjectFile &) = delete; 75 virtual ~TargetLoweringObjectFile(); 76 77 Mangler &getMangler() const { return *Mang; } 78 79 /// This method must be called before any actual lowering is done. This 80 /// specifies the current context for codegen, and gives the lowering 81 /// implementations a chance to set up their default sections. 82 virtual void Initialize(MCContext &ctx, const TargetMachine &TM); 83 84 virtual void emitPersonalityValue(MCStreamer &Streamer, const DataLayout &TM, 85 const MCSymbol *Sym) const; 86 87 /// Emit the module-level metadata that the platform cares about. 88 virtual void emitModuleMetadata(MCStreamer &Streamer, Module &M) const {} 89 90 /// Emit Call Graph Profile metadata. 91 void emitCGProfileMetadata(MCStreamer &Streamer, Module &M) const; 92 93 /// Get the module-level metadata that the platform cares about. 94 virtual void getModuleMetadata(Module &M) {} 95 96 /// Given a constant with the SectionKind, return a section that it should be 97 /// placed in. 98 virtual MCSection *getSectionForConstant(const DataLayout &DL, 99 SectionKind Kind, const Constant *C, 100 Align &Alignment) const; 101 102 virtual MCSection * 103 getSectionForMachineBasicBlock(const Function &F, 104 const MachineBasicBlock &MBB, 105 const TargetMachine &TM) const; 106 107 virtual MCSection * 108 getUniqueSectionForFunction(const Function &F, 109 const TargetMachine &TM) const; 110 111 /// Classify the specified global variable into a set of target independent 112 /// categories embodied in SectionKind. 113 static SectionKind getKindForGlobal(const GlobalObject *GO, 114 const TargetMachine &TM); 115 116 /// This method computes the appropriate section to emit the specified global 117 /// variable or function definition. This should not be passed external (or 118 /// available externally) globals. 119 MCSection *SectionForGlobal(const GlobalObject *GO, SectionKind Kind, 120 const TargetMachine &TM) const; 121 122 /// This method computes the appropriate section to emit the specified global 123 /// variable or function definition. This should not be passed external (or 124 /// available externally) globals. 125 MCSection *SectionForGlobal(const GlobalObject *GO, 126 const TargetMachine &TM) const; 127 128 virtual void getNameWithPrefix(SmallVectorImpl<char> &OutName, 129 const GlobalValue *GV, 130 const TargetMachine &TM) const; 131 132 virtual MCSection *getSectionForJumpTable(const Function &F, 133 const TargetMachine &TM) const; 134 virtual MCSection *getSectionForLSDA(const Function &, const MCSymbol &, 135 const TargetMachine &) const { 136 return LSDASection; 137 } 138 139 virtual bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference, 140 const Function &F) const; 141 142 /// Targets should implement this method to assign a section to globals with 143 /// an explicit section specfied. The implementation of this method can 144 /// assume that GO->hasSection() is true. 145 virtual MCSection * 146 getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind, 147 const TargetMachine &TM) const = 0; 148 149 /// Return an MCExpr to use for a reference to the specified global variable 150 /// from exception handling information. 151 virtual const MCExpr *getTTypeGlobalReference(const GlobalValue *GV, 152 unsigned Encoding, 153 const TargetMachine &TM, 154 MachineModuleInfo *MMI, 155 MCStreamer &Streamer) const; 156 157 /// Return the MCSymbol for a private symbol with global value name as its 158 /// base, with the specified suffix. 159 MCSymbol *getSymbolWithGlobalValueBase(const GlobalValue *GV, 160 StringRef Suffix, 161 const TargetMachine &TM) const; 162 163 // The symbol that gets passed to .cfi_personality. 164 virtual MCSymbol *getCFIPersonalitySymbol(const GlobalValue *GV, 165 const TargetMachine &TM, 166 MachineModuleInfo *MMI) const; 167 168 unsigned getPersonalityEncoding() const { return PersonalityEncoding; } 169 unsigned getLSDAEncoding() const { return LSDAEncoding; } 170 unsigned getTTypeEncoding() const { return TTypeEncoding; } 171 unsigned getCallSiteEncoding() const; 172 173 const MCExpr *getTTypeReference(const MCSymbolRefExpr *Sym, unsigned Encoding, 174 MCStreamer &Streamer) const; 175 176 virtual MCSection *getStaticCtorSection(unsigned Priority, 177 const MCSymbol *KeySym) const { 178 return StaticCtorSection; 179 } 180 181 virtual MCSection *getStaticDtorSection(unsigned Priority, 182 const MCSymbol *KeySym) const { 183 return StaticDtorSection; 184 } 185 186 /// Create a symbol reference to describe the given TLS variable when 187 /// emitting the address in debug info. 188 virtual const MCExpr *getDebugThreadLocalSymbol(const MCSymbol *Sym) const; 189 190 virtual const MCExpr *lowerRelativeReference(const GlobalValue *LHS, 191 const GlobalValue *RHS, 192 const TargetMachine &TM) const { 193 return nullptr; 194 } 195 196 /// Target supports a native lowering of a dso_local_equivalent constant 197 /// without needing to replace it with equivalent IR. 198 bool supportDSOLocalEquivalentLowering() const { 199 return SupportDSOLocalEquivalentLowering; 200 } 201 202 virtual const MCExpr *lowerDSOLocalEquivalent(const DSOLocalEquivalent *Equiv, 203 const TargetMachine &TM) const { 204 return nullptr; 205 } 206 207 /// Target supports replacing a data "PC"-relative access to a symbol 208 /// through another symbol, by accessing the later via a GOT entry instead? 209 bool supportIndirectSymViaGOTPCRel() const { 210 return SupportIndirectSymViaGOTPCRel; 211 } 212 213 /// Target GOT "PC"-relative relocation supports encoding an additional 214 /// binary expression with an offset? 215 bool supportGOTPCRelWithOffset() const { 216 return SupportGOTPCRelWithOffset; 217 } 218 219 /// Target supports TLS offset relocation in debug section? 220 bool supportDebugThreadLocalLocation() const { 221 return SupportDebugThreadLocalLocation; 222 } 223 224 /// Returns the register used as static base in RWPI variants. 225 virtual MCRegister getStaticBase() const { return MCRegister::NoRegister; } 226 227 /// Get the target specific RWPI relocation. 228 virtual const MCExpr *getIndirectSymViaRWPI(const MCSymbol *Sym) const { 229 return nullptr; 230 } 231 232 /// Get the target specific PC relative GOT entry relocation 233 virtual const MCExpr *getIndirectSymViaGOTPCRel(const GlobalValue *GV, 234 const MCSymbol *Sym, 235 const MCValue &MV, 236 int64_t Offset, 237 MachineModuleInfo *MMI, 238 MCStreamer &Streamer) const { 239 return nullptr; 240 } 241 242 /// If supported, return the section to use for the llvm.commandline 243 /// metadata. Otherwise, return nullptr. 244 virtual MCSection *getSectionForCommandLines() const { 245 return nullptr; 246 } 247 248 /// On targets that use separate function descriptor symbols, return a section 249 /// for the descriptor given its symbol. Use only with defined functions. 250 virtual MCSection * 251 getSectionForFunctionDescriptor(const Function *F, 252 const TargetMachine &TM) const { 253 return nullptr; 254 } 255 256 /// On targets that support TOC entries, return a section for the entry given 257 /// the symbol it refers to. 258 /// TODO: Implement this interface for existing ELF targets. 259 virtual MCSection *getSectionForTOCEntry(const MCSymbol *S, 260 const TargetMachine &TM) const { 261 return nullptr; 262 } 263 264 /// On targets that associate external references with a section, return such 265 /// a section for the given external global. 266 virtual MCSection * 267 getSectionForExternalReference(const GlobalObject *GO, 268 const TargetMachine &TM) const { 269 return nullptr; 270 } 271 272 /// Targets that have a special convention for their symbols could use 273 /// this hook to return a specialized symbol. 274 virtual MCSymbol *getTargetSymbol(const GlobalValue *GV, 275 const TargetMachine &TM) const { 276 return nullptr; 277 } 278 279 /// If supported, return the function entry point symbol. 280 /// Otherwise, returns nullptr. 281 /// Func must be a function or an alias which has a function as base object. 282 virtual MCSymbol *getFunctionEntryPointSymbol(const GlobalValue *Func, 283 const TargetMachine &TM) const { 284 return nullptr; 285 } 286 287 protected: 288 virtual MCSection *SelectSectionForGlobal(const GlobalObject *GO, 289 SectionKind Kind, 290 const TargetMachine &TM) const = 0; 291 }; 292 293 } // end namespace llvm 294 295 #endif // LLVM_TARGET_TARGETLOWERINGOBJECTFILE_H 296