LLVM  16.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 (const 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  // Global variables with '!exclude' should get the exclude section kind if
244  // they have an explicit section and no other metadata.
245  if (GVar->hasSection())
246  if (MDNode *MD = GVar->getMetadata(LLVMContext::MD_exclude))
247  if (!MD->getNumOperands())
248  return SectionKind::getExclude();
249 
250  // If the global is marked constant, we can put it into a mergable section,
251  // a mergable string section, or general .data if it contains relocations.
252  if (GVar->isConstant()) {
253  // If the initializer for the global contains something that requires a
254  // relocation, then we may have to drop this into a writable data section
255  // even though it is marked const.
256  const Constant *C = GVar->getInitializer();
257  if (!C->needsRelocation()) {
258  // If the global is required to have a unique address, it can't be put
259  // into a mergable section: just drop it into the general read-only
260  // section instead.
261  if (!GVar->hasGlobalUnnamedAddr())
262  return SectionKind::getReadOnly();
263 
264  // If initializer is a null-terminated string, put it in a "cstring"
265  // section of the right width.
266  if (ArrayType *ATy = dyn_cast<ArrayType>(C->getType())) {
267  if (IntegerType *ITy =
268  dyn_cast<IntegerType>(ATy->getElementType())) {
269  if ((ITy->getBitWidth() == 8 || ITy->getBitWidth() == 16 ||
270  ITy->getBitWidth() == 32) &&
272  if (ITy->getBitWidth() == 8)
274  if (ITy->getBitWidth() == 16)
276 
277  assert(ITy->getBitWidth() == 32 && "Unknown width");
279  }
280  }
281  }
282 
283  // Otherwise, just drop it into a mergable constant section. If we have
284  // a section for this size, use it, otherwise use the arbitrary sized
285  // mergable section.
286  switch (
287  GVar->getParent()->getDataLayout().getTypeAllocSize(C->getType())) {
288  case 4: return SectionKind::getMergeableConst4();
289  case 8: return SectionKind::getMergeableConst8();
290  case 16: return SectionKind::getMergeableConst16();
291  case 32: return SectionKind::getMergeableConst32();
292  default:
293  return SectionKind::getReadOnly();
294  }
295 
296  } else {
297  // In static, ROPI and RWPI relocation models, the linker will resolve
298  // all addresses, so the relocation entries will actually be constants by
299  // the time the app starts up. However, we can't put this into a
300  // mergable section, because the linker doesn't take relocations into
301  // consideration when it tries to merge entries in the section.
302  Reloc::Model ReloModel = TM.getRelocationModel();
303  if (ReloModel == Reloc::Static || ReloModel == Reloc::ROPI ||
304  ReloModel == Reloc::RWPI || ReloModel == Reloc::ROPI_RWPI ||
305  !C->needsDynamicRelocation())
306  return SectionKind::getReadOnly();
307 
308  // Otherwise, the dynamic linker needs to fix it up, put it in the
309  // writable data.rel section.
311  }
312  }
313 
314  // Okay, this isn't a constant.
315  return SectionKind::getData();
316 }
317 
318 /// This method computes the appropriate section to emit the specified global
319 /// variable or function definition. This should not be passed external (or
320 /// available externally) globals.
322  const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
323  // Select section name.
324  if (GO->hasSection())
325  return getExplicitSectionGlobal(GO, Kind, TM);
326 
327  if (auto *GVar = dyn_cast<GlobalVariable>(GO)) {
328  auto Attrs = GVar->getAttributes();
329  if ((Attrs.hasAttribute("bss-section") && Kind.isBSS()) ||
330  (Attrs.hasAttribute("data-section") && Kind.isData()) ||
331  (Attrs.hasAttribute("relro-section") && Kind.isReadOnlyWithRel()) ||
332  (Attrs.hasAttribute("rodata-section") && Kind.isReadOnly())) {
333  return getExplicitSectionGlobal(GO, Kind, TM);
334  }
335  }
336 
337  if (auto *F = dyn_cast<Function>(GO)) {
338  if (F->hasFnAttribute("implicit-section-name"))
339  return getExplicitSectionGlobal(GO, Kind, TM);
340  }
341 
342  // Use default section depending on the 'type' of global
343  return SelectSectionForGlobal(GO, Kind, TM);
344 }
345 
346 /// This method computes the appropriate section to emit the specified global
347 /// variable or function definition. This should not be passed external (or
348 /// available externally) globals.
349 MCSection *
351  const TargetMachine &TM) const {
352  return SectionForGlobal(GO, getKindForGlobal(GO, TM), TM);
353 }
354 
356  const Function &F, const TargetMachine &TM) const {
357  Align Alignment(1);
358  return getSectionForConstant(F.getParent()->getDataLayout(),
359  SectionKind::getReadOnly(), /*C=*/nullptr,
360  Alignment);
361 }
362 
364  bool UsesLabelDifference, const Function &F) const {
365  // In PIC mode, we need to emit the jump table to the same section as the
366  // function body itself, otherwise the label differences won't make sense.
367  // FIXME: Need a better predicate for this: what about custom entries?
368  if (UsesLabelDifference)
369  return true;
370 
371  // We should also do if the section name is NULL or function is declared
372  // in discardable section
373  // FIXME: this isn't the right predicate, should be based on the MCSection
374  // for the function.
375  return F.isWeakForLinker();
376 }
377 
378 /// Given a mergable constant with the specified size and relocation
379 /// information, return a section that it should be placed in.
381  const DataLayout &DL, SectionKind Kind, const Constant *C,
382  Align &Alignment) const {
383  if (Kind.isReadOnly() && ReadOnlySection != nullptr)
384  return ReadOnlySection;
385 
386  return DataSection;
387 }
388 
390  const Function &F, const MachineBasicBlock &MBB,
391  const TargetMachine &TM) const {
392  return nullptr;
393 }
394 
396  const Function &F, const TargetMachine &TM) const {
397  return nullptr;
398 }
399 
400 /// getTTypeGlobalReference - Return an MCExpr to use for a
401 /// reference to the specified global variable from exception
402 /// handling information.
404  const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
405  MachineModuleInfo *MMI, MCStreamer &Streamer) const {
406  const MCSymbolRefExpr *Ref =
408 
409  return getTTypeReference(Ref, Encoding, Streamer);
410 }
411 
413 getTTypeReference(const MCSymbolRefExpr *Sym, unsigned Encoding,
414  MCStreamer &Streamer) const {
415  switch (Encoding & 0x70) {
416  default:
417  report_fatal_error("We do not support this DWARF encoding yet!");
419  // Do nothing special
420  return Sym;
421  case dwarf::DW_EH_PE_pcrel: {
422  // Emit a label to the streamer for the current position. This gives us
423  // .-foo addressing.
424  MCSymbol *PCSym = getContext().createTempSymbol();
425  Streamer.emitLabel(PCSym);
426  const MCExpr *PC = MCSymbolRefExpr::create(PCSym, getContext());
427  return MCBinaryExpr::createSub(Sym, PC, getContext());
428  }
429  }
430 }
431 
433  // FIXME: It's not clear what, if any, default this should have - perhaps a
434  // null return could mean 'no location' & we should just do that here.
435  return MCSymbolRefExpr::create(Sym, getContext());
436 }
437 
439  SmallVectorImpl<char> &OutName, const GlobalValue *GV,
440  const TargetMachine &TM) const {
441  Mang->getNameWithPrefix(OutName, GV, /*CannotUsePrivateLabel=*/false);
442 }
i
i
Definition: README.txt:29
isSuitableForBSS
static bool isSuitableForBSS(const GlobalVariable *GV)
Definition: TargetLoweringObjectFile.cpp:81
llvm::SectionKind::getExclude
static SectionKind getExclude()
Definition: SectionKind.h:189
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:18
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:438
llvm::MCObjectFileInfo::ReadOnlySection
MCSection * ReadOnlySection
Section that is readonly and can contain arbitrary initialized data.
Definition: MCObjectFileInfo.h:69
llvm::MCContext
Context object for machine code objects.
Definition: MCContext.h:76
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:1181
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:321
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:432
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:245
llvm::TargetLoweringObjectFile::CallSiteEncoding
unsigned CallSiteEncoding
Definition: TargetLoweringObjectFile.h:60
F
#define F(x, y, z)
Definition: MD5.cpp:55
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:212
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:207
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:570
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::MDNode::operands
ArrayRef< MDOperand > operands() const
Definition: Metadata.h:1290
llvm::MCStreamer::emitLabel
virtual void emitLabel(MCSymbol *Symbol, SMLoc Loc=SMLoc())
Emit a label for Symbol into the current section.
Definition: MCStreamer.cpp:423
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:74
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:145
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:204
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:355
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:808
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::StringRef::empty
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
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::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:113
llvm::GlobalValue::getParent
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:650
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:413
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:944
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:1030
llvm::TargetLoweringObjectFile::shouldPutJumpTableInFunctionSection
virtual bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference, const Function &F) const
Definition: TargetLoweringObjectFile.cpp:363
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:50
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:389
llvm::MCContext::createTempSymbol
MCSymbol * createTempSymbol()
Create a temporary symbol with a unique name.
Definition: MCContext.cpp:324
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:395
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:191
llvm::MCObjectFileInfo::DataSection
MCSection * DataSection
Section directive for standard data.
Definition: MCObjectFileInfo.h:60
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::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:380
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:612
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::TargetMachine::getCodeModel
CodeModel::Model getCodeModel() const
Returns the code model.
Definition: TargetMachine.h:225
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:111
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:403
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