1//===-- llvm/Target/TargetLoweringObjectFile.h - Object Info ----*- C++ -*-===// 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 7//===----------------------------------------------------------------------===// 9// This file implements classes used to handle lowerings specific to common 10// object file formats. 12//===----------------------------------------------------------------------===// 14#ifndef LLVM_TARGET_TARGETLOWERINGOBJECTFILE_H 15#define LLVM_TARGET_TARGETLOWERINGOBJECTFILE_H 29classMachineBasicBlock;
30classMachineModuleInfo;
43classDSOLocalEquivalent;
46 /// Name-mangler for global names. 55 /// PersonalityEncoding, LSDAEncoding, TTypeEncoding - Some encoding values 62 /// This section contains the static constructor pointer list. 65 /// This section contains the static destructor pointer list. 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. 88 /// Emit the module-level metadata that the platform cares about. 91 /// Emit Call Graph Profile metadata. 94 /// Process linker options metadata and emit platform-specific bits. 97 /// Get the module-level metadata that the platform cares about. 100 /// Given a constant with the SectionKind, return a section that it should be 104Align &Alignment)
const;
115 /// Classify the specified global variable into a set of target independent 116 /// categories embodied in SectionKind. 120 /// This method computes the appropriate section to emit the specified global 121 /// variable or function definition. This should not be passed external (or 122 /// available externally) globals. 126 /// This method computes the appropriate section to emit the specified global 127 /// variable or function definition. This should not be passed external (or 128 /// available externally) globals. 146 /// Targets should implement this method to assign a section to globals with 147 /// an explicit section specfied. The implementation of this method can 148 /// assume that GO->hasSection() is true. 153 /// Return an MCExpr to use for a reference to the specified global variable 154 /// from exception handling information. 161 /// Return the MCSymbol for a private symbol with global value name as its 162 /// base, with the specified suffix. 167// The symbol that gets passed to .cfi_personality. 190 /// Create a symbol reference to describe the given TLS variable when 191 /// emitting the address in debug info. 200 /// Target supports a native lowering of a dso_local_equivalent constant 201 /// without needing to replace it with equivalent IR. 211 /// Target supports replacing a data "PC"-relative access to a symbol 212 /// through another symbol, by accessing the later via a GOT entry instead? 217 /// Target GOT "PC"-relative relocation supports encoding an additional 218 /// binary expression with an offset? 223 /// Target supports TLS offset relocation in debug section? 228 /// Returns the register used as static base in RWPI variants. 231 /// Get the target specific RWPI relocation. 236 /// Get the target specific PC relative GOT entry relocation 246 /// If supported, return the section to use for the llvm.commandline 247 /// metadata. Otherwise, return nullptr. 252 /// On targets that use separate function descriptor symbols, return a section 253 /// for the descriptor given its symbol. Use only with defined functions. 260 /// On targets that support TOC entries, return a section for the entry given 261 /// the symbol it refers to. 262 /// TODO: Implement this interface for existing ELF targets. 268 /// On targets that associate external references with a section, return such 269 /// a section for the given external global. 276 /// Targets that have a special convention for their symbols could use 277 /// this hook to return a specialized symbol. 283 /// If supported, return the function entry point symbol. 284 /// Otherwise, returns nullptr. 285 /// Func must be a function or an alias which has a function as base object. 297}
// end namespace llvm 299#endif// LLVM_TARGET_TARGETLOWERINGOBJECTFILE_H MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Machine Check Debug Module
This is an important base class in LLVM.
Wrapper for a function that represents a value that functionally represents the original function.
A parsed version of the target data layout string in and methods for querying it.
Context object for machine code objects.
Base class for the full range of assembler expressions which are needed for parsing.
MCSection * LSDASection
If exception handling is supported by the target, this is the section the Language Specific Data Area...
Wrapper class representing physical registers. Should be passed by value.
static constexpr unsigned NoRegister
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Streaming machine code generation interface.
Represent a reference to a symbol from inside an expression.
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
This represents an "assembler immediate".
This class contains meta information specific to a module.
A Module instance is used to store all the information related to an LLVM module.
SectionKind - This is a simple POD value that classifies the properties of a section.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
StringRef - Represent a constant reference to a string, i.e.
void emitCGProfileMetadata(MCStreamer &Streamer, Module &M) const
Emit Call Graph Profile metadata.
virtual void getNameWithPrefix(SmallVectorImpl< char > &OutName, const GlobalValue *GV, const TargetMachine &TM) const
MCSection * StaticDtorSection
This section contains the static destructor pointer list.
virtual MCRegister getStaticBase() const
Returns the register used as static base in RWPI variants.
virtual MCSection * getSectionForCommandLines() const
If supported, return the section to use for the llvm.commandline metadata.
unsigned PersonalityEncoding
PersonalityEncoding, LSDAEncoding, TTypeEncoding - Some encoding values for EH.
bool SupportGOTPCRelWithOffset
Mangler & getMangler() const
unsigned getCallSiteEncoding() const
bool SupportIndirectSymViaGOTPCRel
static SectionKind getKindForGlobal(const GlobalObject *GO, const TargetMachine &TM)
Classify the specified global variable into a set of target independent categories embodied in Sectio...
virtual MCSection * getSectionForJumpTable(const Function &F, const TargetMachine &TM) const
virtual MCSection * getStaticDtorSection(unsigned Priority, const MCSymbol *KeySym) const
virtual bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference, const Function &F) const
virtual const MCExpr * getIndirectSymViaGOTPCRel(const GlobalValue *GV, const MCSymbol *Sym, const MCValue &MV, int64_t Offset, MachineModuleInfo *MMI, MCStreamer &Streamer) const
Get the target specific PC relative GOT entry relocation.
bool SupportDebugThreadLocalLocation
TargetLoweringObjectFile & operator=(const TargetLoweringObjectFile &)=delete
virtual void emitModuleMetadata(MCStreamer &Streamer, Module &M) const
Emit the module-level metadata that the platform cares about.
unsigned getLSDAEncoding() const
virtual MCSection * getSectionForExternalReference(const GlobalObject *GO, const TargetMachine &TM) const
On targets that associate external references with a section, return such a section for the given ext...
virtual MCSymbol * getCFIPersonalitySymbol(const GlobalValue *GV, const TargetMachine &TM, MachineModuleInfo *MMI) const
bool supportDSOLocalEquivalentLowering() const
Target supports a native lowering of a dso_local_equivalent constant without needing to replace it wi...
unsigned getTTypeEncoding() const
virtual void Initialize(MCContext &ctx, const TargetMachine &TM)
This method must be called before any actual lowering is done.
virtual void getModuleMetadata(Module &M)
Get the module-level metadata that the platform cares about.
unsigned getPersonalityEncoding() const
bool supportDebugThreadLocalLocation() const
Target supports TLS offset relocation in debug section?
MCSection * StaticCtorSection
This section contains the static constructor pointer list.
virtual MCSection * SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const =0
bool SupportDSOLocalEquivalentLowering
virtual const MCExpr * getIndirectSymViaRWPI(const MCSymbol *Sym) const
Get the target specific RWPI relocation.
virtual MCSection * getSectionForConstant(const DataLayout &DL, SectionKind Kind, const Constant *C, Align &Alignment) const
Given a constant with the SectionKind, return a section that it should be placed in.
MCSymbol * getSymbolWithGlobalValueBase(const GlobalValue *GV, StringRef Suffix, const TargetMachine &TM) const
Return the MCSymbol for a private symbol with global value name as its base, with the specified suffi...
virtual MCSection * getStaticCtorSection(unsigned Priority, const MCSymbol *KeySym) const
virtual const MCExpr * lowerDSOLocalEquivalent(const DSOLocalEquivalent *Equiv, const TargetMachine &TM) const
virtual MCSection * getSectionForMachineBasicBlock(const Function &F, const MachineBasicBlock &MBB, const TargetMachine &TM) const
virtual MCSection * getSectionForTOCEntry(const MCSymbol *S, const TargetMachine &TM) const
On targets that support TOC entries, return a section for the entry given the symbol it refers to.
bool supportGOTPCRelWithOffset() const
Target GOT "PC"-relative relocation supports encoding an additional binary expression with an offset?
virtual ~TargetLoweringObjectFile()
virtual const MCExpr * getDebugThreadLocalSymbol(const MCSymbol *Sym) const
Create a symbol reference to describe the given TLS variable when emitting the address in debug info.
virtual MCSection * getSectionForLSDA(const Function &, const MCSymbol &, const TargetMachine &) const
bool supportIndirectSymViaGOTPCRel() const
Target supports replacing a data "PC"-relative access to a symbol through another symbol,...
virtual const MCExpr * getTTypeGlobalReference(const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM, MachineModuleInfo *MMI, MCStreamer &Streamer) const
Return an MCExpr to use for a reference to the specified global variable from exception handling info...
unsigned CallSiteEncoding
virtual MCSection * getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const =0
Targets should implement this method to assign a section to globals with an explicit section specfied...
TargetLoweringObjectFile()=default
const MCExpr * getTTypeReference(const MCSymbolRefExpr *Sym, unsigned Encoding, MCStreamer &Streamer) const
virtual MCSymbol * getFunctionEntryPointSymbol(const GlobalValue *Func, const TargetMachine &TM) const
If supported, return the function entry point symbol.
virtual MCSection * getSectionForFunctionDescriptor(const Function *F, const TargetMachine &TM) const
On targets that use separate function descriptor symbols, return a section for the descriptor given i...
virtual void emitLinkerDirectives(MCStreamer &Streamer, Module &M) const
Process linker options metadata and emit platform-specific bits.
TargetLoweringObjectFile(const TargetLoweringObjectFile &)=delete
virtual void emitPersonalityValue(MCStreamer &Streamer, const DataLayout &TM, const MCSymbol *Sym, const MachineModuleInfo *MMI) const
virtual MCSymbol * getTargetSymbol(const GlobalValue *GV, const TargetMachine &TM) const
Targets that have a special convention for their symbols could use this hook to return a specialized ...
virtual const MCExpr * lowerRelativeReference(const GlobalValue *LHS, const GlobalValue *RHS, const TargetMachine &TM) const
virtual MCSection * getUniqueSectionForFunction(const Function &F, const TargetMachine &TM) const
MCSection * SectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const
This method computes the appropriate section to emit the specified global variable or function defini...
Primary interface to the complete machine description for the target machine.
@ C
The default llvm calling convention, compatible with C.
This is an optimization pass for GlobalISel generic memory operations.
This struct is a compact representation of a valid (non-zero power of two) alignment.
