LLVM 19.0.0git
TargetLoweringObjectFile.h
Go to the documentation of this file.
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
18#include "llvm/MC/MCRegister.h"
19#include <cstdint>
20
21namespace llvm {
22
23struct Align;
24class Constant;
25class DataLayout;
26class Function;
27class GlobalObject;
28class GlobalValue;
29class MachineBasicBlock;
30class MachineModuleInfo;
31class Mangler;
32class MCContext;
33class MCExpr;
34class MCSection;
35class MCSymbol;
36class MCSymbolRefExpr;
37class MCStreamer;
38class MCValue;
39class Module;
40class SectionKind;
41class StringRef;
42class TargetMachine;
43class DSOLocalEquivalent;
44
46 /// Name-mangler for global names.
47 Mangler *Mang = nullptr;
48
49protected:
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.
64
65 /// This section contains the static destructor pointer list.
67
68 const TargetMachine *TM = nullptr;
69
70public:
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.
99 SectionKind Kind, const Constant *C,
100 Align &Alignment) const;
101
102 virtual MCSection *
104 const MachineBasicBlock &MBB,
105 const TargetMachine &TM) const;
106
107 virtual MCSection *
109 const TargetMachine &TM) const;
110
111 /// Classify the specified global variable into a set of target independent
112 /// categories embodied in SectionKind.
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.
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.
126 const TargetMachine &TM) const;
127
128 virtual void getNameWithPrefix(SmallVectorImpl<char> &OutName,
129 const GlobalValue *GV,
130 const TargetMachine &TM) const;
131
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 *
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,
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.
160 StringRef Suffix,
161 const TargetMachine &TM) const;
162
163 // The symbol that gets passed to .cfi_personality.
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
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.
200 }
201
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?
211 }
212
213 /// Target GOT "PC"-relative relocation supports encoding an additional
214 /// binary expression with an offset?
217 }
218
219 /// Target supports TLS offset relocation in debug section?
222 }
223
224 /// Returns the register used as static base in RWPI variants.
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
234 const MCSymbol *Sym,
235 const MCValue &MV,
236 int64_t Offset,
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.
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 *
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.
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 *
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.
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.
283 const TargetMachine &TM) const {
284 return nullptr;
285 }
286
287protected:
289 SectionKind Kind,
290 const TargetMachine &TM) const = 0;
291};
292
293} // end namespace llvm
294
295#endif // LLVM_TARGET_TARGETLOWERINGOBJECTFILE_H
MachineBasicBlock & MBB
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
uint64_t Align
Symbol * Sym
Definition: ELF_riscv.cpp:479
#define F(x, y, z)
Definition: MD5.cpp:55
Machine Check Debug Module
Value * RHS
Value * LHS
This is an important base class in LLVM.
Definition: Constant.h:41
Wrapper for a function that represents a value that functionally represents the original function.
Definition: Constants.h:934
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
Context object for machine code objects.
Definition: MCContext.h:76
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
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.
Definition: MCRegister.h:33
static constexpr unsigned NoRegister
Definition: MCRegister.h:52
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:39
Streaming machine code generation interface.
Definition: MCStreamer.h:212
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:192
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:40
This represents an "assembler immediate".
Definition: MCValue.h:36
This class contains meta information specific to a module.
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
SectionKind - This is a simple POD value that classifies the properties of a section.
Definition: SectionKind.h:22
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
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
virtual void emitPersonalityValue(MCStreamer &Streamer, const DataLayout &TM, const MCSymbol *Sym) 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.
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.
TargetLoweringObjectFile & operator=(const TargetLoweringObjectFile &)=delete
virtual void emitModuleMetadata(MCStreamer &Streamer, Module &M) const
Emit the module-level metadata that the platform cares about.
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...
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.
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
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 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...
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...
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...
TargetLoweringObjectFile(const TargetLoweringObjectFile &)=delete
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.
Definition: TargetMachine.h:76
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39