LLVM  15.0.0git
TargetLoweringObjectFile.cpp
Go to the documentation of this file.
1 //===-- llvm/Target/TargetLoweringObjectFile.cpp - Object File Info -------===//
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 
16 #include "llvm/IR/Constants.h"
17 #include "llvm/IR/DataLayout.h"
18 #include "llvm/IR/DerivedTypes.h"
19 #include "llvm/IR/Function.h"
20 #include "llvm/IR/GlobalVariable.h"
21 #include "llvm/IR/Mangler.h"
22 #include "llvm/IR/Module.h"
23 #include "llvm/MC/MCAsmInfo.h"
24 #include "llvm/MC/MCContext.h"
25 #include "llvm/MC/MCExpr.h"
26 #include "llvm/MC/MCStreamer.h"
27 #include "llvm/MC/SectionKind.h"
31 using namespace llvm;
32 
33 //===----------------------------------------------------------------------===//
34 // Generic Code
35 //===----------------------------------------------------------------------===//
36 
37 /// Initialize - this method must be called before any actual lowering is
38 /// done. This specifies the current context for codegen, and gives the
39 /// lowering implementations a chance to set up their default sections.
41  const TargetMachine &TM) {
42  // `Initialize` can be called more than once.
43  delete Mang;
44  Mang = new Mangler();
47 
48  // Reset various EH DWARF encodings.
51 
52  this->TM = &TM;
53 }
54 
56  delete Mang;
57 }
58 
60  // If target does not have LEB128 directives, we would need the
61  // call site encoding to be udata4 so that the alternative path
62  // for not having LEB128 directives could work.
63  if (!getContext().getAsmInfo()->hasLEB128Directives())
65  return CallSiteEncoding;
66 }
67 
68 static bool isNullOrUndef(const Constant *C) {
69  // Check that the constant isn't all zeros or undefs.
70  if (C->isNullValue() || isa<UndefValue>(C))
71  return true;
72  if (!isa<ConstantAggregate>(C))
73  return false;
74  for (auto Operand : C->operand_values()) {
75  if (!isNullOrUndef(cast<Constant>(Operand)))
76  return false;
77  }
78  return true;
79 }
80 
81 static bool isSuitableForBSS(const GlobalVariable *GV) {
82  const Constant *C = GV->getInitializer();
83 
84  // Must have zero initializer.
85  if (!isNullOrUndef(C))
86  return false;
87 
88  // Leave constant zeros in readonly constant sections, so they can be shared.
89  if (GV->isConstant())
90  return false;
91 
92  // If the global has an explicit section specified, don't put it in BSS.
93  if (GV->hasSection())
94  return false;
95 
96  // Otherwise, put it in BSS!
97  return true;
98 }
99 
100 /// IsNullTerminatedString - Return true if the specified constant (which is
101 /// known to have a type that is an array of 1/2/4 byte elements) ends with a
102 /// nul value and contains no other nuls in it. Note that this is more general
103 /// than ConstantDataSequential::isString because we allow 2 & 4 byte strings.
104 static bool IsNullTerminatedString(const Constant *C) {
105  // First check: is we have constant array terminated with zero
106  if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(C)) {
107  unsigned NumElts = CDS->getNumElements();
108  assert(NumElts != 0 && "Can't have an empty CDS");
109 
110  if (CDS->getElementAsInteger(NumElts-1) != 0)
111  return false; // Not null terminated.
112 
113  // Verify that the null doesn't occur anywhere else in the string.
114  for (unsigned i = 0; i != NumElts-1; ++i)
115  if (CDS->getElementAsInteger(i) == 0)
116  return false;
117  return true;
118  }
119 
120  // Another possibility: [1 x i8] zeroinitializer
121  if (isa<ConstantAggregateZero>(C))
122  return cast<ArrayType>(C->getType())->getNumElements() == 1;
123 
124  return false;
125 }
126 
128  const GlobalValue *GV, StringRef Suffix, const TargetMachine &TM) const {
129  assert(!Suffix.empty());
130 
131  SmallString<60> NameStr;
132  NameStr += GV->getParent()->getDataLayout().getPrivateGlobalPrefix();
133  TM.getNameWithPrefix(NameStr, GV, *Mang);
134  NameStr.append(Suffix.begin(), Suffix.end());
135  return getContext().getOrCreateSymbol(NameStr);
136 }
137 
139  const GlobalValue *GV, const TargetMachine &TM,
140  MachineModuleInfo *MMI) const {
141  return TM.getSymbol(GV);
142 }
143 
145  const DataLayout &,
146  const MCSymbol *Sym) const {
147 }
148 
150  Module &M) const {
151  MCContext &C = getContext();
153  M.getModuleFlagsMetadata(ModuleFlags);
154 
155  MDNode *CFGProfile = nullptr;
156 
157  for (const auto &MFE : ModuleFlags) {
158  StringRef Key = MFE.Key->getString();
159  if (Key == "CG Profile") {
160  CFGProfile = cast<MDNode>(MFE.Val);
161  break;
162  }
163  }
164 
165  if (!CFGProfile)
166  return;
167 
168  auto GetSym = [this](const MDOperand &MDO) -> MCSymbol * {
169  if (!MDO)
170  return nullptr;
171  auto *V = cast<ValueAsMetadata>(MDO);
172  const Function *F = cast<Function>(V->getValue()->stripPointerCasts());
173  if (F->hasDLLImportStorageClass())
174  return nullptr;
175  return TM->getSymbol(F);
176  };
177 
178  for (const auto &Edge : CFGProfile->operands()) {
179  MDNode *E = cast<MDNode>(Edge);
180  const MCSymbol *From = GetSym(E->getOperand(0));
181  const MCSymbol *To = GetSym(E->getOperand(1));
182  // Skip null functions. This can happen if functions are dead stripped after
183  // the CGProfile pass has been run.
184  if (!From || !To)
185  continue;
186  uint64_t Count = cast<ConstantAsMetadata>(E->getOperand(2))
187  ->getValue()
188  ->getUniqueInteger()
189  .getZExtValue();
190  Streamer.emitCGProfileEntry(
193  }
194 }
195 
196 /// getKindForGlobal - This is a top-level target-independent classifier for
197 /// a global object. Given a global variable and information from the TM, this
198 /// function classifies the global in a target independent manner. This function
199 /// may be overridden by the target implementation.
201  const TargetMachine &TM){
203  "Can only be used for global definitions");
204 
205  // Functions are classified as text sections.
206  if (isa<Function>(GO))
207  return SectionKind::getText();
208 
209  // Basic blocks are classified as text sections.
210  if (isa<BasicBlock>(GO))
211  return SectionKind::getText();
212 
213  // Global variables require more detailed analysis.
214  const auto *GVar = cast<GlobalVariable>(GO);
215 
216  // Handle thread-local data first.
217  if (GVar->isThreadLocal()) {
218  if (isSuitableForBSS(GVar) && !TM.Options.NoZerosInBSS) {
219  // Zero-initialized TLS variables with local linkage always get classified
220  // as ThreadBSSLocal.
221  if (GVar->hasLocalLinkage()) {
223  }
224  return SectionKind::getThreadBSS();
225  }
227  }
228 
229  // Variables with common linkage always get classified as common.
230  if (GVar->hasCommonLinkage())
231  return SectionKind::getCommon();
232 
233  // Most non-mergeable zero data can be put in the BSS section unless otherwise
234  // specified.
235  if (isSuitableForBSS(GVar) && !TM.Options.NoZerosInBSS) {
236  if (GVar->hasLocalLinkage())
237  return SectionKind::getBSSLocal();
238  else if (GVar->hasExternalLinkage())
239  return SectionKind::getBSSExtern();
240  return SectionKind::getBSS();
241  }
242 
243  // If the global is marked constant, we can put it into a mergable section,
244  // a mergable string section, or general .data if it contains relocations.
245  if (GVar->isConstant()) {
246  // If the initializer for the global contains something that requires a
247  // relocation, then we may have to drop this into a writable data section
248  // even though it is marked const.
249  const Constant *C = GVar->getInitializer();
250  if (!C->needsRelocation()) {
251  // If the global is required to have a unique address, it can't be put
252  // into a mergable section: just drop it into the general read-only
253  // section instead.
254  if (!GVar->hasGlobalUnnamedAddr())
255  return SectionKind::getReadOnly();
256 
257  // If initializer is a null-terminated string, put it in a "cstring"
258  // section of the right width.
259  if (ArrayType *ATy = dyn_cast<ArrayType>(C->getType())) {
260  if (IntegerType *ITy =
261  dyn_cast<IntegerType>(ATy->getElementType())) {
262  if ((ITy->getBitWidth() == 8 || ITy->getBitWidth() == 16 ||
263  ITy->getBitWidth() == 32) &&
265  if (ITy->getBitWidth() == 8)
267  if (ITy->getBitWidth() == 16)
269 
270  assert(ITy->getBitWidth() == 32 && "Unknown width");
272  }
273  }
274  }
275 
276  // Otherwise, just drop it into a mergable constant section. If we have
277  // a section for this size, use it, otherwise use the arbitrary sized
278  // mergable section.
279  switch (
280  GVar->getParent()->getDataLayout().getTypeAllocSize(C->getType())) {
281  case 4: return SectionKind::getMergeableConst4();
282  case 8: return SectionKind::getMergeableConst8();
283  case 16: return SectionKind::getMergeableConst16();
284  case 32: return SectionKind::getMergeableConst32();
285  default:
286  return SectionKind::getReadOnly();
287  }
288 
289  } else {
290  // In static, ROPI and RWPI relocation models, the linker will resolve
291  // all addresses, so the relocation entries will actually be constants by
292  // the time the app starts up. However, we can't put this into a
293  // mergable section, because the linker doesn't take relocations into
294  // consideration when it tries to merge entries in the section.
295  Reloc::Model ReloModel = TM.getRelocationModel();
296  if (ReloModel == Reloc::Static || ReloModel == Reloc::ROPI ||
297  ReloModel == Reloc::RWPI || ReloModel == Reloc::ROPI_RWPI ||
298  !C->needsDynamicRelocation())
299  return SectionKind::getReadOnly();
300 
301  // Otherwise, the dynamic linker needs to fix it up, put it in the
302  // writable data.rel section.
304  }
305  }
306 
307  // Okay, this isn't a constant.
308  return SectionKind::getData();
309 }
310 
311 /// This method computes the appropriate section to emit the specified global
312 /// variable or function definition. This should not be passed external (or
313 /// available externally) globals.
315  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
316  // Select section name.
317  if (GO->hasSection())
318  return getExplicitSectionGlobal(GO, Kind, TM);
319 
320  if (auto *GVar = dyn_cast<GlobalVariable>(GO)) {
321  auto Attrs = GVar->getAttributes();
322  if ((Attrs.hasAttribute("bss-section") && Kind.isBSS()) ||
323  (Attrs.hasAttribute("data-section") && Kind.isData()) ||
324  (Attrs.hasAttribute("relro-section") && Kind.isReadOnlyWithRel()) ||
325  (Attrs.hasAttribute("rodata-section") && Kind.isReadOnly())) {
326  return getExplicitSectionGlobal(GO, Kind, TM);
327  }
328  }
329 
330  if (auto *F = dyn_cast<Function>(GO)) {
331  if (F->hasFnAttribute("implicit-section-name"))
332  return getExplicitSectionGlobal(GO, Kind, TM);
333  }
334 
335  // Use default section depending on the 'type' of global
336  return SelectSectionForGlobal(GO, Kind, TM);
337 }
338 
339 /// This method computes the appropriate section to emit the specified global
340 /// variable or function definition. This should not be passed external (or
341 /// available externally) globals.
342 MCSection *
344  const TargetMachine &TM) const {
345  return SectionForGlobal(GO, getKindForGlobal(GO, TM), TM);
346 }
347 
349  const Function &F, const TargetMachine &TM) const {
350  Align Alignment(1);
351  return getSectionForConstant(F.getParent()->getDataLayout(),
352  SectionKind::getReadOnly(), /*C=*/nullptr,
353  Alignment);
354 }
355 
357  bool UsesLabelDifference, const Function &F) const {
358  // In PIC mode, we need to emit the jump table to the same section as the
359  // function body itself, otherwise the label differences won't make sense.
360  // FIXME: Need a better predicate for this: what about custom entries?
361  if (UsesLabelDifference)
362  return true;
363 
364  // We should also do if the section name is NULL or function is declared
365  // in discardable section
366  // FIXME: this isn't the right predicate, should be based on the MCSection
367  // for the function.
368  return F.isWeakForLinker();
369 }
370 
371 /// Given a mergable constant with the specified size and relocation
372 /// information, return a section that it should be placed in.
374  const DataLayout &DL, SectionKind Kind, const Constant *C,
375  Align &Alignment) const {
376  if (Kind.isReadOnly() && ReadOnlySection != nullptr)
377  return ReadOnlySection;
378 
379  return DataSection;
380 }
381 
383  const Function &F, const MachineBasicBlock &MBB,
384  const TargetMachine &TM) const {
385  return nullptr;
386 }
387 
389  const Function &F, const TargetMachine &TM) const {
390  return nullptr;
391 }
392 
393 /// getTTypeGlobalReference - Return an MCExpr to use for a
394 /// reference to the specified global variable from exception
395 /// handling information.
397  const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
398  MachineModuleInfo *MMI, MCStreamer &Streamer) const {
399  const MCSymbolRefExpr *Ref =
401 
402  return getTTypeReference(Ref, Encoding, Streamer);
403 }
404 
406 getTTypeReference(const MCSymbolRefExpr *Sym, unsigned Encoding,
407  MCStreamer &Streamer) const {
408  switch (Encoding & 0x70) {
409  default:
410  report_fatal_error("We do not support this DWARF encoding yet!");
412  // Do nothing special
413  return Sym;
414  case dwarf::DW_EH_PE_pcrel: {
415  // Emit a label to the streamer for the current position. This gives us
416  // .-foo addressing.
417  MCSymbol *PCSym = getContext().createTempSymbol();
418  Streamer.emitLabel(PCSym);
419  const MCExpr *PC = MCSymbolRefExpr::create(PCSym, getContext());
420  return MCBinaryExpr::createSub(Sym, PC, getContext());
421  }
422  }
423 }
424 
426  // FIXME: It's not clear what, if any, default this should have - perhaps a
427  // null return could mean 'no location' & we should just do that here.
428  return MCSymbolRefExpr::create(Sym, getContext());
429 }
430 
432  SmallVectorImpl<char> &OutName, const GlobalValue *GV,
433  const TargetMachine &TM) const {
434  Mang->getNameWithPrefix(OutName, GV, /*CannotUsePrivateLabel=*/false);
435 }
i
i
Definition: README.txt:29
isSuitableForBSS
static bool isSuitableForBSS(const GlobalVariable *GV)
Definition: TargetLoweringObjectFile.cpp:81
Attrs
Function Attrs
Definition: README_ALTIVEC.txt:215
llvm::SectionKind::getReadOnlyWithRel
static SectionKind getReadOnlyWithRel()
Definition: SectionKind.h:214
llvm::SectionKind::getMergeable2ByteCString
static SectionKind getMergeable2ByteCString()
Definition: SectionKind.h:196
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::SectionKind::getBSSExtern
static SectionKind getBSSExtern()
Definition: SectionKind.h:211
llvm::MCSymbol
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:113
llvm::TargetOptions::NoZerosInBSS
unsigned NoZerosInBSS
NoZerosInBSS - By default some codegens place zero-initialized data to .bss section.
Definition: TargetOptions.h:213
llvm::TargetLoweringObjectFile::getNameWithPrefix
virtual void getNameWithPrefix(SmallVectorImpl< char > &OutName, const GlobalValue *GV, const TargetMachine &TM) const
Definition: TargetLoweringObjectFile.cpp:431
llvm::MCObjectFileInfo::ReadOnlySection
MCSection * ReadOnlySection
Section that is readonly and can contain arbitrary initialized data.
Definition: MCObjectFileInfo.h:68
llvm::MCContext
Context object for machine code objects.
Definition: MCContext.h:74
llvm::Function
Definition: Function.h:60
llvm::TargetLoweringObjectFile::getSymbolWithGlobalValueBase
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...
Definition: TargetLoweringObjectFile.cpp:127
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1185
llvm::SectionKind::getThreadBSSLocal
static SectionKind getThreadBSSLocal()
Definition: SectionKind.h:208
ErrorHandling.h
llvm::TargetLoweringObjectFile::SectionForGlobal
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...
Definition: TargetLoweringObjectFile.cpp:314
llvm::GlobalVariable
Definition: GlobalVariable.h:39
llvm::TargetLoweringObjectFile::getDebugThreadLocalSymbol
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.
Definition: TargetLoweringObjectFile.cpp:425
llvm::TargetMachine::getRelocationModel
Reloc::Model getRelocationModel() const
Returns the code generation relocation model.
Definition: TargetMachine.cpp:68
Module.h
llvm::SectionKind::getMergeableConst16
static SectionKind getMergeableConst16()
Definition: SectionKind.h:204
llvm::Reloc::ROPI_RWPI
@ ROPI_RWPI
Definition: CodeGen.h:22
llvm::ArrayType
Class to represent array types.
Definition: DerivedTypes.h:357
llvm::Mangler
Definition: Mangler.h:27
llvm::MCObjectFileInfo::getContext
MCContext & getContext() const
Definition: MCObjectFileInfo.h:244
llvm::TargetLoweringObjectFile::CallSiteEncoding
unsigned CallSiteEncoding
Definition: TargetLoweringObjectFile.h:60
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::MDNode::operands
op_range operands() const
Definition: Metadata.h:1191
llvm::Reloc::Model
Model
Definition: CodeGen.h:22
llvm::SectionKind::getReadOnly
static SectionKind getReadOnly()
Definition: SectionKind.h:192
llvm::MCStreamer
Streaming machine code generation interface.
Definition: MCStreamer.h:201
llvm::SectionKind::getBSSLocal
static SectionKind getBSSLocal()
Definition: SectionKind.h:210
llvm::MCContext::getOrCreateSymbol
MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition: MCContext.cpp:204
llvm::SectionKind::getThreadBSS
static SectionKind getThreadBSS()
Definition: SectionKind.h:206
llvm::ConstantDataSequential
ConstantDataSequential - A vector or array constant whose element type is a simple 1/2/4/8-byte integ...
Definition: Constants.h:569
TargetMachine.h
llvm::ModRefInfo::Ref
@ Ref
The access may reference the value stored in memory.
Constants.h
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::GlobalObject
Definition: GlobalObject.h:27
MCContext.h
llvm::MCStreamer::emitLabel
virtual void emitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc())
Emit a label for Symbol into the current section.
Definition: MCStreamer.cpp:416
llvm::AMDGPU::PALMD::Key
Key
PAL metadata keys.
Definition: AMDGPUMetadata.h:486
llvm::SectionKind::getBSS
static SectionKind getBSS()
Definition: SectionKind.h:209
llvm::Mangler::getNameWithPrefix
void getNameWithPrefix(raw_ostream &OS, const GlobalValue *GV, bool CannotUsePrivateLabel) const
Print the appropriate prefix and the specified global variable's name.
Definition: Mangler.cpp:119
llvm::IntegerType
Class to represent integer types.
Definition: DerivedTypes.h:40
llvm::MachineModuleInfo
This class contains meta information specific to a module.
Definition: MachineModuleInfo.h:75
llvm::report_fatal_error
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:143
llvm::TargetLoweringObjectFile::emitCGProfileMetadata
void emitCGProfileMetadata(MCStreamer &Streamer, Module &M) const
Emit Call Graph Profile metadata.
Definition: TargetLoweringObjectFile.cpp:149
llvm::TargetLoweringObjectFile::Initialize
virtual void Initialize(MCContext &ctx, const TargetMachine &TM)
This method must be called before any actual lowering is done.
Definition: TargetLoweringObjectFile.cpp:40
llvm::TargetMachine::getSymbol
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition: TargetMachine.cpp:208
llvm::SectionKind::getText
static SectionKind getText()
Definition: SectionKind.h:190
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::TargetLoweringObjectFile::getSectionForJumpTable
virtual MCSection * getSectionForJumpTable(const Function &F, const TargetMachine &TM) const
Definition: TargetLoweringObjectFile.cpp:348
llvm::lltok::Kind
Kind
Definition: LLToken.h:18
llvm::TargetLoweringObjectFile::getKindForGlobal
static SectionKind getKindForGlobal(const GlobalObject *GO, const TargetMachine &TM)
Classify the specified global variable into a set of target independent categories embodied in Sectio...
Definition: TargetLoweringObjectFile.cpp:200
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:94
llvm::SmallString
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
llvm::TargetMachine::isPositionIndependent
bool isPositionIndependent() const
Definition: TargetMachine.cpp:41
llvm::TargetLoweringObjectFile::emitPersonalityValue
virtual void emitPersonalityValue(MCStreamer &Streamer, const DataLayout &TM, const MCSymbol *Sym) const
Definition: TargetLoweringObjectFile.cpp:144
llvm::dwarf::DW_EH_PE_udata4
@ DW_EH_PE_udata4
Definition: Dwarf.h:441
llvm::MCStreamer::emitCGProfileEntry
virtual void emitCGProfileEntry(const MCSymbolRefExpr *From, const MCSymbolRefExpr *To, uint64_t Count)
Definition: MCStreamer.cpp:801
llvm::TargetLoweringObjectFile::TM
const TargetMachine * TM
Definition: TargetLoweringObjectFile.h:68
llvm::Function::getAttributes
AttributeList getAttributes() const
Return the attribute list for this Function.
Definition: Function.h:314
llvm::TargetLoweringObjectFile::getCallSiteEncoding
unsigned getCallSiteEncoding() const
Definition: TargetLoweringObjectFile.cpp:59
llvm::SmallString::append
void append(StringRef RHS)
Append from a StringRef.
Definition: SmallString.h:68
llvm::SectionKind::getCommon
static SectionKind getCommon()
Definition: SectionKind.h:212
llvm::GlobalObject::hasSection
bool hasSection() const
Check if this global has a custom object file section.
Definition: GlobalObject.h:103
llvm::SectionKind::getMergeable1ByteCString
static SectionKind getMergeable1ByteCString()
Definition: SectionKind.h:193
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::GlobalVariable::getInitializer
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
Definition: GlobalVariable.h:135
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::StringRef::empty
constexpr LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:153
llvm::TargetLoweringObjectFile::SelectSectionForGlobal
virtual MCSection * SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const =0
uint64_t
llvm::dwarf::DW_EH_PE_pcrel
@ DW_EH_PE_pcrel
Definition: Dwarf.h:448
llvm::StringRef::end
iterator end() const
Definition: StringRef.h:130
llvm::GlobalValue::getParent
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:577
llvm::SectionKind::getMergeable4ByteCString
static SectionKind getMergeable4ByteCString()
Definition: SectionKind.h:199
llvm::TargetMachine::Options
TargetOptions Options
Definition: TargetMachine.h:118
llvm::TargetLoweringObjectFile::getTTypeReference
const MCExpr * getTTypeReference(const MCSymbolRefExpr *Sym, unsigned Encoding, MCStreamer &Streamer) const
Definition: TargetLoweringObjectFile.cpp:406
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::TargetMachine
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:77
llvm::MCBinaryExpr::createSub
static const MCBinaryExpr * createSub(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:610
llvm::Reloc::ROPI
@ ROPI
Definition: CodeGen.h:22
llvm::SectionKind::getThreadData
static SectionKind getThreadData()
Definition: SectionKind.h:207
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::MDNode
Metadata node.
Definition: Metadata.h:926
llvm::MCSymbolRefExpr
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:192
llvm::MCObjectFileInfo::initMCObjectFileInfo
void initMCObjectFileInfo(MCContext &MCCtx, bool PIC, bool LargeCodeModel=false)
Definition: MCObjectFileInfo.cpp:1013
llvm::TargetLoweringObjectFile::shouldPutJumpTableInFunctionSection
virtual bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference, const Function &F) const
Definition: TargetLoweringObjectFile.cpp:356
Mangler.h
llvm::TargetLoweringObjectFile::~TargetLoweringObjectFile
virtual ~TargetLoweringObjectFile()
Definition: TargetLoweringObjectFile.cpp:55
TargetOptions.h
llvm::Reloc::RWPI
@ RWPI
Definition: CodeGen.h:22
llvm::dwarf::DW_EH_PE_uleb128
@ DW_EH_PE_uleb128
Definition: Dwarf.h:439
MCAsmInfo.h
DataLayout.h
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
Dwarf.h
TargetLoweringObjectFile.h
llvm::Reloc::Static
@ Static
Definition: CodeGen.h:22
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::MCSection
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:39
IsNullTerminatedString
static bool IsNullTerminatedString(const Constant *C)
IsNullTerminatedString - Return true if the specified constant (which is known to have a type that is...
Definition: TargetLoweringObjectFile.cpp:104
llvm::TargetLoweringObjectFile::getSectionForMachineBasicBlock
virtual MCSection * getSectionForMachineBasicBlock(const Function &F, const MachineBasicBlock &MBB, const TargetMachine &TM) const
Definition: TargetLoweringObjectFile.cpp:382
llvm::MCContext::createTempSymbol
MCSymbol * createTempSymbol()
Create a temporary symbol with a unique name.
Definition: MCContext.cpp:321
llvm::TargetLoweringObjectFile::PersonalityEncoding
unsigned PersonalityEncoding
PersonalityEncoding, LSDAEncoding, TTypeEncoding - Some encoding values for EH.
Definition: TargetLoweringObjectFile.h:57
llvm::TargetLoweringObjectFile::getUniqueSectionForFunction
virtual MCSection * getUniqueSectionForFunction(const Function &F, const TargetMachine &TM) const
Definition: TargetLoweringObjectFile.cpp:388
llvm::SectionKind::getData
static SectionKind getData()
Definition: SectionKind.h:213
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
llvm::dwarf::DW_EH_PE_absptr
@ DW_EH_PE_absptr
Definition: Dwarf.h:437
llvm::SectionKind::getMergeableConst8
static SectionKind getMergeableConst8()
Definition: SectionKind.h:203
llvm::SectionKind
SectionKind - This is a simple POD value that classifies the properties of a section.
Definition: SectionKind.h:22
llvm::TargetMachine::getNameWithPrefix
void getNameWithPrefix(SmallVectorImpl< char > &Name, const GlobalValue *GV, Mangler &Mang, bool MayAlwaysUsePrivate=false) const
Definition: TargetMachine.cpp:195
llvm::MCObjectFileInfo::DataSection
MCSection * DataSection
Section directive for standard data.
Definition: MCObjectFileInfo.h:59
llvm::DataLayout::getPrivateGlobalPrefix
StringRef getPrivateGlobalPrefix() const
Definition: DataLayout.h:334
GlobalVariable.h
isNullOrUndef
static bool isNullOrUndef(const Constant *C)
Definition: TargetLoweringObjectFile.cpp:68
Function.h
llvm::TargetMachine::getCodeModel
CodeModel::Model getCodeModel() const
Returns the code model.
Definition: TargetMachine.cpp:72
llvm::MCSymbolRefExpr::create
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:386
SectionKind.h
llvm::TargetLoweringObjectFile::getSectionForConstant
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.
Definition: TargetLoweringObjectFile.cpp:373
llvm::CodeModel::Large
@ Large
Definition: CodeGen.h:28
llvm::TargetLoweringObjectFile::LSDAEncoding
unsigned LSDAEncoding
Definition: TargetLoweringObjectFile.h:58
llvm::GlobalVariable::isConstant
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
Definition: GlobalVariable.h:152
llvm::SectionKind::getMergeableConst4
static SectionKind getMergeableConst4()
Definition: SectionKind.h:202
MCStreamer.h
llvm::TargetLoweringObjectFile::getCFIPersonalitySymbol
virtual MCSymbol * getCFIPersonalitySymbol(const GlobalValue *GV, const TargetMachine &TM, MachineModuleInfo *MMI) const
Definition: TargetLoweringObjectFile.cpp:138
llvm::GlobalValue::isDeclarationForLinker
bool isDeclarationForLinker() const
Definition: GlobalValue.h:539
llvm::SmallVectorImpl< char >
llvm::Module::getDataLayout
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:398
DerivedTypes.h
TM
const char LLVMTargetMachineRef TM
Definition: PassBuilderBindings.cpp:47
llvm::TargetLoweringObjectFile::TTypeEncoding
unsigned TTypeEncoding
Definition: TargetLoweringObjectFile.h:59
llvm::MCSymbolRefExpr::VK_None
@ VK_None
Definition: MCExpr.h:195
llvm::TargetLoweringObjectFile::getExplicitSectionGlobal
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...
From
BlockVerifier::State From
Definition: BlockVerifier.cpp:55
llvm::SectionKind::getMergeableConst32
static SectionKind getMergeableConst32()
Definition: SectionKind.h:205
llvm::StringRef::begin
iterator begin() const
Definition: StringRef.h:128
MCExpr.h
llvm::TargetLoweringObjectFile::getTTypeGlobalReference
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...
Definition: TargetLoweringObjectFile.cpp:396
llvm::MCExpr
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
llvm::MDOperand
Tracking metadata reference owned by Metadata.
Definition: Metadata.h:773