LLVM 20.0.0git
AsmPrinter.cpp
Go to the documentation of this file.
1//===- AsmPrinter.cpp - Common AsmPrinter code ----------------------------===//
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 the AsmPrinter class.
10//
11//===----------------------------------------------------------------------===//
12
14#include "CodeViewDebug.h"
15#include "DwarfDebug.h"
16#include "DwarfException.h"
17#include "PseudoProbePrinter.h"
18#include "WasmException.h"
19#include "WinCFGuard.h"
20#include "WinException.h"
21#include "llvm/ADT/APFloat.h"
22#include "llvm/ADT/APInt.h"
23#include "llvm/ADT/DenseMap.h"
24#include "llvm/ADT/STLExtras.h"
28#include "llvm/ADT/Statistic.h"
30#include "llvm/ADT/StringRef.h"
32#include "llvm/ADT/Twine.h"
64#include "llvm/Config/config.h"
65#include "llvm/IR/BasicBlock.h"
66#include "llvm/IR/Comdat.h"
67#include "llvm/IR/Constant.h"
68#include "llvm/IR/Constants.h"
69#include "llvm/IR/DataLayout.h"
73#include "llvm/IR/Function.h"
74#include "llvm/IR/GCStrategy.h"
75#include "llvm/IR/GlobalAlias.h"
76#include "llvm/IR/GlobalIFunc.h"
78#include "llvm/IR/GlobalValue.h"
80#include "llvm/IR/Instruction.h"
81#include "llvm/IR/Mangler.h"
82#include "llvm/IR/Metadata.h"
83#include "llvm/IR/Module.h"
84#include "llvm/IR/Operator.h"
85#include "llvm/IR/PseudoProbe.h"
86#include "llvm/IR/Type.h"
87#include "llvm/IR/Value.h"
88#include "llvm/IR/ValueHandle.h"
89#include "llvm/MC/MCAsmInfo.h"
90#include "llvm/MC/MCContext.h"
92#include "llvm/MC/MCExpr.h"
93#include "llvm/MC/MCInst.h"
94#include "llvm/MC/MCSchedule.h"
95#include "llvm/MC/MCSection.h"
100#include "llvm/MC/MCStreamer.h"
102#include "llvm/MC/MCSymbol.h"
103#include "llvm/MC/MCSymbolELF.h"
105#include "llvm/MC/MCValue.h"
106#include "llvm/MC/SectionKind.h"
107#include "llvm/Object/ELFTypes.h"
108#include "llvm/Pass.h"
110#include "llvm/Support/Casting.h"
115#include "llvm/Support/Format.h"
117#include "llvm/Support/Path.h"
118#include "llvm/Support/VCSRevision.h"
124#include <algorithm>
125#include <cassert>
126#include <cinttypes>
127#include <cstdint>
128#include <iterator>
129#include <memory>
130#include <optional>
131#include <string>
132#include <utility>
133#include <vector>
134
135using namespace llvm;
136
137#define DEBUG_TYPE "asm-printer"
138
139// This is a replication of fields of object::PGOAnalysisMap::Features. It
140// should match the order of the fields so that
141// `object::PGOAnalysisMap::Features::decode(PgoAnalysisMapFeatures.getBits())`
142// succeeds.
144 None,
146 BBFreq,
147 BrProb,
148 All,
149};
151 "pgo-analysis-map", cl::Hidden, cl::CommaSeparated,
153 clEnumValN(PGOMapFeaturesEnum::None, "none", "Disable all options"),
155 "Function Entry Count"),
157 "Basic Block Frequency"),
158 clEnumValN(PGOMapFeaturesEnum::BrProb, "br-prob", "Branch Probability"),
159 clEnumValN(PGOMapFeaturesEnum::All, "all", "Enable all options")),
160 cl::desc(
161 "Enable extended information within the SHT_LLVM_BB_ADDR_MAP that is "
162 "extracted from PGO related analysis."));
163
165 "basic-block-address-map-skip-bb-entries",
166 cl::desc("Skip emitting basic block entries in the SHT_LLVM_BB_ADDR_MAP "
167 "section. It's used to save binary size when BB entries are "
168 "unnecessary for some PGOAnalysisMap features."),
169 cl::Hidden, cl::init(false));
170
172 "emit-jump-table-sizes-section",
173 cl::desc("Emit a section containing jump table addresses and sizes"),
174 cl::Hidden, cl::init(false));
175
176// This isn't turned on by default, since several of the scheduling models are
177// not completely accurate, and we don't want to be misleading.
179 "asm-print-latency",
180 cl::desc("Print instruction latencies as verbose asm comments"), cl::Hidden,
181 cl::init(false));
182
183STATISTIC(EmittedInsts, "Number of machine instrs printed");
184
185char AsmPrinter::ID = 0;
186
187namespace {
188class AddrLabelMapCallbackPtr final : CallbackVH {
189 AddrLabelMap *Map = nullptr;
190
191public:
192 AddrLabelMapCallbackPtr() = default;
193 AddrLabelMapCallbackPtr(Value *V) : CallbackVH(V) {}
194
195 void setPtr(BasicBlock *BB) {
197 }
198
199 void setMap(AddrLabelMap *map) { Map = map; }
200
201 void deleted() override;
202 void allUsesReplacedWith(Value *V2) override;
203};
204} // namespace
205
207 MCContext &Context;
208 struct AddrLabelSymEntry {
209 /// The symbols for the label.
211
212 Function *Fn; // The containing function of the BasicBlock.
213 unsigned Index; // The index in BBCallbacks for the BasicBlock.
214 };
215
216 DenseMap<AssertingVH<BasicBlock>, AddrLabelSymEntry> AddrLabelSymbols;
217
218 /// Callbacks for the BasicBlock's that we have entries for. We use this so
219 /// we get notified if a block is deleted or RAUWd.
220 std::vector<AddrLabelMapCallbackPtr> BBCallbacks;
221
222 /// This is a per-function list of symbols whose corresponding BasicBlock got
223 /// deleted. These symbols need to be emitted at some point in the file, so
224 /// AsmPrinter emits them after the function body.
225 DenseMap<AssertingVH<Function>, std::vector<MCSymbol *>>
226 DeletedAddrLabelsNeedingEmission;
227
228public:
229 AddrLabelMap(MCContext &context) : Context(context) {}
230
232 assert(DeletedAddrLabelsNeedingEmission.empty() &&
233 "Some labels for deleted blocks never got emitted");
234 }
235
237
239 std::vector<MCSymbol *> &Result);
240
243};
244
246 assert(BB->hasAddressTaken() &&
247 "Shouldn't get label for block without address taken");
248 AddrLabelSymEntry &Entry = AddrLabelSymbols[BB];
249
250 // If we already had an entry for this block, just return it.
251 if (!Entry.Symbols.empty()) {
252 assert(BB->getParent() == Entry.Fn && "Parent changed");
253 return Entry.Symbols;
254 }
255
256 // Otherwise, this is a new entry, create a new symbol for it and add an
257 // entry to BBCallbacks so we can be notified if the BB is deleted or RAUWd.
258 BBCallbacks.emplace_back(BB);
259 BBCallbacks.back().setMap(this);
260 Entry.Index = BBCallbacks.size() - 1;
261 Entry.Fn = BB->getParent();
263 : Context.createTempSymbol();
264 Entry.Symbols.push_back(Sym);
265 return Entry.Symbols;
266}
267
268/// If we have any deleted symbols for F, return them.
270 Function *F, std::vector<MCSymbol *> &Result) {
271 DenseMap<AssertingVH<Function>, std::vector<MCSymbol *>>::iterator I =
272 DeletedAddrLabelsNeedingEmission.find(F);
273
274 // If there are no entries for the function, just return.
275 if (I == DeletedAddrLabelsNeedingEmission.end())
276 return;
277
278 // Otherwise, take the list.
279 std::swap(Result, I->second);
280 DeletedAddrLabelsNeedingEmission.erase(I);
281}
282
283//===- Address of Block Management ----------------------------------------===//
284
287 // Lazily create AddrLabelSymbols.
288 if (!AddrLabelSymbols)
289 AddrLabelSymbols = std::make_unique<AddrLabelMap>(OutContext);
290 return AddrLabelSymbols->getAddrLabelSymbolToEmit(
291 const_cast<BasicBlock *>(BB));
292}
293
295 const Function *F, std::vector<MCSymbol *> &Result) {
296 // If no blocks have had their addresses taken, we're done.
297 if (!AddrLabelSymbols)
298 return;
299 return AddrLabelSymbols->takeDeletedSymbolsForFunction(
300 const_cast<Function *>(F), Result);
301}
302
304 // If the block got deleted, there is no need for the symbol. If the symbol
305 // was already emitted, we can just forget about it, otherwise we need to
306 // queue it up for later emission when the function is output.
307 AddrLabelSymEntry Entry = std::move(AddrLabelSymbols[BB]);
308 AddrLabelSymbols.erase(BB);
309 assert(!Entry.Symbols.empty() && "Didn't have a symbol, why a callback?");
310 BBCallbacks[Entry.Index] = nullptr; // Clear the callback.
311
312#if !LLVM_MEMORY_SANITIZER_BUILD
313 // BasicBlock is destroyed already, so this access is UB detectable by msan.
314 assert((BB->getParent() == nullptr || BB->getParent() == Entry.Fn) &&
315 "Block/parent mismatch");
316#endif
317
318 for (MCSymbol *Sym : Entry.Symbols) {
319 if (Sym->isDefined())
320 return;
321
322 // If the block is not yet defined, we need to emit it at the end of the
323 // function. Add the symbol to the DeletedAddrLabelsNeedingEmission list
324 // for the containing Function. Since the block is being deleted, its
325 // parent may already be removed, we have to get the function from 'Entry'.
326 DeletedAddrLabelsNeedingEmission[Entry.Fn].push_back(Sym);
327 }
328}
329
331 // Get the entry for the RAUW'd block and remove it from our map.
332 AddrLabelSymEntry OldEntry = std::move(AddrLabelSymbols[Old]);
333 AddrLabelSymbols.erase(Old);
334 assert(!OldEntry.Symbols.empty() && "Didn't have a symbol, why a callback?");
335
336 AddrLabelSymEntry &NewEntry = AddrLabelSymbols[New];
337
338 // If New is not address taken, just move our symbol over to it.
339 if (NewEntry.Symbols.empty()) {
340 BBCallbacks[OldEntry.Index].setPtr(New); // Update the callback.
341 NewEntry = std::move(OldEntry); // Set New's entry.
342 return;
343 }
344
345 BBCallbacks[OldEntry.Index] = nullptr; // Update the callback.
346
347 // Otherwise, we need to add the old symbols to the new block's set.
348 llvm::append_range(NewEntry.Symbols, OldEntry.Symbols);
349}
350
351void AddrLabelMapCallbackPtr::deleted() {
352 Map->UpdateForDeletedBlock(cast<BasicBlock>(getValPtr()));
353}
354
355void AddrLabelMapCallbackPtr::allUsesReplacedWith(Value *V2) {
356 Map->UpdateForRAUWBlock(cast<BasicBlock>(getValPtr()), cast<BasicBlock>(V2));
357}
358
359/// getGVAlignment - Return the alignment to use for the specified global
360/// value. This rounds up to the preferred alignment if possible and legal.
362 Align InAlign) {
363 Align Alignment;
364 if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV))
365 Alignment = DL.getPreferredAlign(GVar);
366
367 // If InAlign is specified, round it to it.
368 if (InAlign > Alignment)
369 Alignment = InAlign;
370
371 // If the GV has a specified alignment, take it into account.
372 const MaybeAlign GVAlign(GV->getAlign());
373 if (!GVAlign)
374 return Alignment;
375
376 assert(GVAlign && "GVAlign must be set");
377
378 // If the GVAlign is larger than NumBits, or if we are required to obey
379 // NumBits because the GV has an assigned section, obey it.
380 if (*GVAlign > Alignment || GV->hasSection())
381 Alignment = *GVAlign;
382 return Alignment;
383}
384
385AsmPrinter::AsmPrinter(TargetMachine &tm, std::unique_ptr<MCStreamer> Streamer)
386 : MachineFunctionPass(ID), TM(tm), MAI(tm.getMCAsmInfo()),
387 OutContext(Streamer->getContext()), OutStreamer(std::move(Streamer)),
388 SM(*this) {
389 VerboseAsm = OutStreamer->isVerboseAsm();
390 DwarfUsesRelocationsAcrossSections =
392}
393
395 assert(!DD && Handlers.size() == NumUserHandlers &&
396 "Debug/EH info didn't get finalized");
397}
398
400 return TM.isPositionIndependent();
401}
402
403/// getFunctionNumber - Return a unique ID for the current function.
405 return MF->getFunctionNumber();
406}
407
409 return *TM.getObjFileLowering();
410}
411
413 assert(MMI && "MMI could not be nullptr!");
414 return MMI->getModule()->getDataLayout();
415}
416
417// Do not use the cached DataLayout because some client use it without a Module
418// (dsymutil, llvm-dwarfdump).
420 return TM.getPointerSize(0); // FIXME: Default address space
421}
422
424 assert(MF && "getSubtargetInfo requires a valid MachineFunction!");
426}
427
430}
431
433 if (DD) {
434 assert(OutStreamer->hasRawTextSupport() &&
435 "Expected assembly output mode.");
436 // This is NVPTX specific and it's unclear why.
437 // PR51079: If we have code without debug information we need to give up.
439 if (!MFSP)
440 return;
441 (void)DD->emitInitialLocDirective(MF, /*CUID=*/0);
442 }
443}
444
445/// getCurrentSection() - Return the current section we are emitting to.
447 return OutStreamer->getCurrentSectionOnly();
448}
449
451 AU.setPreservesAll();
457}
458
460 auto *MMIWP = getAnalysisIfAvailable<MachineModuleInfoWrapperPass>();
461 MMI = MMIWP ? &MMIWP->getMMI() : nullptr;
462 HasSplitStack = false;
463 HasNoSplitStack = false;
464 DbgInfoAvailable = !M.debug_compile_units().empty();
465
466 AddrLabelSymbols = nullptr;
467
468 // Initialize TargetLoweringObjectFile.
470 .Initialize(OutContext, TM);
471
473 .getModuleMetadata(M);
474
475 // On AIX, we delay emitting any section information until
476 // after emitting the .file pseudo-op. This allows additional
477 // information (such as the embedded command line) to be associated
478 // with all sections in the object file rather than a single section.
480 OutStreamer->initSections(false, *TM.getMCSubtargetInfo());
481
482 // Emit the version-min deployment target directive if needed.
483 //
484 // FIXME: If we end up with a collection of these sorts of Darwin-specific
485 // or ELF-specific things, it may make sense to have a platform helper class
486 // that will work with the target helper class. For now keep it here, as the
487 // alternative is duplicated code in each of the target asm printers that
488 // use the directive, where it would need the same conditionalization
489 // anyway.
490 const Triple &Target = TM.getTargetTriple();
491 if (Target.isOSBinFormatMachO() && Target.isOSDarwin()) {
492 Triple TVT(M.getDarwinTargetVariantTriple());
493 OutStreamer->emitVersionForTarget(
494 Target, M.getSDKVersion(),
495 M.getDarwinTargetVariantTriple().empty() ? nullptr : &TVT,
496 M.getDarwinTargetVariantSDKVersion());
497 }
498
499 // Allow the target to emit any magic that it wants at the start of the file.
501
502 // Very minimal debug info. It is ignored if we emit actual debug info. If we
503 // don't, this at least helps the user find where a global came from.
505 // .file "foo.c"
506 if (MAI->isAIX()) {
507 const char VerStr[] =
508#ifdef PACKAGE_VENDOR
509 PACKAGE_VENDOR " "
510#endif
511 PACKAGE_NAME " version " PACKAGE_VERSION
512#ifdef LLVM_REVISION
513 " (" LLVM_REVISION ")"
514#endif
515 ;
516 // TODO: Add timestamp and description.
517 OutStreamer->emitFileDirective(M.getSourceFileName(), VerStr, "", "");
518 } else {
519 OutStreamer->emitFileDirective(
520 llvm::sys::path::filename(M.getSourceFileName()));
521 }
522 }
523
524 // On AIX, emit bytes for llvm.commandline metadata after .file so that the
525 // C_INFO symbol is preserved if any csect is kept by the linker.
527 emitModuleCommandLines(M);
528 // Now we can generate section information.
529 OutStreamer->switchSection(
531
532 // To work around an AIX assembler and/or linker bug, generate
533 // a rename for the default text-section symbol name. This call has
534 // no effect when generating object code directly.
535 MCSection *TextSection =
536 OutStreamer->getContext().getObjectFileInfo()->getTextSection();
537 MCSymbolXCOFF *XSym =
538 static_cast<MCSectionXCOFF *>(TextSection)->getQualNameSymbol();
539 if (XSym->hasRename())
540 OutStreamer->emitXCOFFRenameDirective(XSym, XSym->getSymbolTableName());
541 }
542
543 GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>();
544 assert(MI && "AsmPrinter didn't require GCModuleInfo?");
545 for (const auto &I : *MI)
546 if (GCMetadataPrinter *MP = getOrCreateGCPrinter(*I))
547 MP->beginAssembly(M, *MI, *this);
548
549 // Emit module-level inline asm if it exists.
550 if (!M.getModuleInlineAsm().empty()) {
551 OutStreamer->AddComment("Start of file scope inline assembly");
552 OutStreamer->addBlankLine();
553 emitInlineAsm(
554 M.getModuleInlineAsm() + "\n", *TM.getMCSubtargetInfo(),
555 TM.Options.MCOptions, nullptr,
557 OutStreamer->AddComment("End of file scope inline assembly");
558 OutStreamer->addBlankLine();
559 }
560
562 bool EmitCodeView = M.getCodeViewFlag();
563 if (EmitCodeView && TM.getTargetTriple().isOSWindows())
564 Handlers.push_back(std::make_unique<CodeViewDebug>(this));
565 if (!EmitCodeView || M.getDwarfVersion()) {
566 if (hasDebugInfo()) {
567 DD = new DwarfDebug(this);
568 Handlers.push_back(std::unique_ptr<DwarfDebug>(DD));
569 }
570 }
571 }
572
573 if (M.getNamedMetadata(PseudoProbeDescMetadataName))
574 PP = std::make_unique<PseudoProbeHandler>(this);
575
576 switch (MAI->getExceptionHandlingType()) {
578 // We may want to emit CFI for debug.
579 [[fallthrough]];
583 for (auto &F : M.getFunctionList()) {
585 ModuleCFISection = getFunctionCFISectionType(F);
586 // If any function needsUnwindTableEntry(), it needs .eh_frame and hence
587 // the module needs .eh_frame. If we have found that case, we are done.
588 if (ModuleCFISection == CFISection::EH)
589 break;
590 }
592 usesCFIWithoutEH() || ModuleCFISection != CFISection::EH);
593 break;
594 default:
595 break;
596 }
597
598 EHStreamer *ES = nullptr;
599 switch (MAI->getExceptionHandlingType()) {
601 if (!usesCFIWithoutEH())
602 break;
603 [[fallthrough]];
607 ES = new DwarfCFIException(this);
608 break;
610 ES = new ARMException(this);
611 break;
613 switch (MAI->getWinEHEncodingType()) {
614 default: llvm_unreachable("unsupported unwinding information encoding");
616 break;
619 ES = new WinException(this);
620 break;
621 }
622 break;
624 ES = new WasmException(this);
625 break;
627 ES = new AIXException(this);
628 break;
629 }
630 if (ES)
631 Handlers.push_back(std::unique_ptr<EHStreamer>(ES));
632
633 // Emit tables for any value of cfguard flag (i.e. cfguard=1 or cfguard=2).
634 if (mdconst::extract_or_null<ConstantInt>(M.getModuleFlag("cfguard")))
635 EHHandlers.push_back(std::make_unique<WinCFGuard>(this));
636
637 for (auto &Handler : Handlers)
638 Handler->beginModule(&M);
639 for (auto &Handler : EHHandlers)
640 Handler->beginModule(&M);
641
642 return false;
643}
644
645static bool canBeHidden(const GlobalValue *GV, const MCAsmInfo &MAI) {
647 return false;
648
649 return GV->canBeOmittedFromSymbolTable();
650}
651
652void AsmPrinter::emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const {
654 switch (Linkage) {
660 if (MAI->isMachO()) {
661 // .globl _foo
662 OutStreamer->emitSymbolAttribute(GVSym, MCSA_Global);
663
664 if (!canBeHidden(GV, *MAI))
665 // .weak_definition _foo
666 OutStreamer->emitSymbolAttribute(GVSym, MCSA_WeakDefinition);
667 else
668 OutStreamer->emitSymbolAttribute(GVSym, MCSA_WeakDefAutoPrivate);
669 } else if (MAI->avoidWeakIfComdat() && GV->hasComdat()) {
670 // .globl _foo
671 OutStreamer->emitSymbolAttribute(GVSym, MCSA_Global);
672 //NOTE: linkonce is handled by the section the symbol was assigned to.
673 } else {
674 // .weak _foo
675 OutStreamer->emitSymbolAttribute(GVSym, MCSA_Weak);
676 }
677 return;
679 OutStreamer->emitSymbolAttribute(GVSym, MCSA_Global);
680 return;
683 return;
687 llvm_unreachable("Should never emit this");
688 }
689 llvm_unreachable("Unknown linkage type!");
690}
691
693 const GlobalValue *GV) const {
694 TM.getNameWithPrefix(Name, GV, getObjFileLowering().getMangler());
695}
696
698 return TM.getSymbol(GV);
699}
700
702 // On ELF, use .Lfoo$local if GV is a non-interposable GlobalObject with an
703 // exact definion (intersection of GlobalValue::hasExactDefinition() and
704 // !isInterposable()). These linkages include: external, appending, internal,
705 // private. It may be profitable to use a local alias for external. The
706 // assembler would otherwise be conservative and assume a global default
707 // visibility symbol can be interposable, even if the code generator already
708 // assumed it.
710 const Module &M = *GV.getParent();
712 M.getPIELevel() == PIELevel::Default && GV.isDSOLocal())
713 return getSymbolWithGlobalValueBase(&GV, "$local");
714 }
715 return TM.getSymbol(&GV);
716}
717
718/// EmitGlobalVariable - Emit the specified global variable to the .s file.
720 bool IsEmuTLSVar = TM.useEmulatedTLS() && GV->isThreadLocal();
721 assert(!(IsEmuTLSVar && GV->hasCommonLinkage()) &&
722 "No emulated TLS variables in the common section");
723
724 // Never emit TLS variable xyz in emulated TLS model.
725 // The initialization value is in __emutls_t.xyz instead of xyz.
726 if (IsEmuTLSVar)
727 return;
728
729 if (GV->hasInitializer()) {
730 // Check to see if this is a special global used by LLVM, if so, emit it.
731 if (emitSpecialLLVMGlobal(GV))
732 return;
733
734 // Skip the emission of global equivalents. The symbol can be emitted later
735 // on by emitGlobalGOTEquivs in case it turns out to be needed.
736 if (GlobalGOTEquivs.count(getSymbol(GV)))
737 return;
738
739 if (isVerbose()) {
740 // When printing the control variable __emutls_v.*,
741 // we don't need to print the original TLS variable name.
742 GV->printAsOperand(OutStreamer->getCommentOS(),
743 /*PrintType=*/false, GV->getParent());
744 OutStreamer->getCommentOS() << '\n';
745 }
746 }
747
748 MCSymbol *GVSym = getSymbol(GV);
749 MCSymbol *EmittedSym = GVSym;
750
751 // getOrCreateEmuTLSControlSym only creates the symbol with name and default
752 // attributes.
753 // GV's or GVSym's attributes will be used for the EmittedSym.
754 emitVisibility(EmittedSym, GV->getVisibility(), !GV->isDeclaration());
755
756 if (GV->isTagged()) {
758
759 if (T.getArch() != Triple::aarch64 || !T.isAndroid())
761 "tagged symbols (-fsanitize=memtag-globals) are "
762 "only supported on AArch64 Android");
763 OutStreamer->emitSymbolAttribute(EmittedSym, MAI->getMemtagAttr());
764 }
765
766 if (!GV->hasInitializer()) // External globals require no extra code.
767 return;
768
769 GVSym->redefineIfPossible();
770 if (GVSym->isDefined() || GVSym->isVariable())
771 OutContext.reportError(SMLoc(), "symbol '" + Twine(GVSym->getName()) +
772 "' is already defined");
773
775 OutStreamer->emitSymbolAttribute(EmittedSym, MCSA_ELF_TypeObject);
776
778
779 const DataLayout &DL = GV->getDataLayout();
780 uint64_t Size = DL.getTypeAllocSize(GV->getValueType());
781
782 // If the alignment is specified, we *must* obey it. Overaligning a global
783 // with a specified alignment is a prompt way to break globals emitted to
784 // sections and expected to be contiguous (e.g. ObjC metadata).
785 const Align Alignment = getGVAlignment(GV, DL);
786
787 for (auto &Handler : Handlers)
788 Handler->setSymbolSize(GVSym, Size);
789
790 // Handle common symbols
791 if (GVKind.isCommon()) {
792 if (Size == 0) Size = 1; // .comm Foo, 0 is undefined, avoid it.
793 // .comm _foo, 42, 4
794 OutStreamer->emitCommonSymbol(GVSym, Size, Alignment);
795 return;
796 }
797
798 // Determine to which section this global should be emitted.
799 MCSection *TheSection = getObjFileLowering().SectionForGlobal(GV, GVKind, TM);
800
801 // If we have a bss global going to a section that supports the
802 // zerofill directive, do so here.
803 if (GVKind.isBSS() && MAI->isMachO() && TheSection->isVirtualSection()) {
804 if (Size == 0)
805 Size = 1; // zerofill of 0 bytes is undefined.
806 emitLinkage(GV, GVSym);
807 // .zerofill __DATA, __bss, _foo, 400, 5
808 OutStreamer->emitZerofill(TheSection, GVSym, Size, Alignment);
809 return;
810 }
811
812 // If this is a BSS local symbol and we are emitting in the BSS
813 // section use .lcomm/.comm directive.
814 if (GVKind.isBSSLocal() &&
815 getObjFileLowering().getBSSSection() == TheSection) {
816 if (Size == 0)
817 Size = 1; // .comm Foo, 0 is undefined, avoid it.
818
819 // Use .lcomm only if it supports user-specified alignment.
820 // Otherwise, while it would still be correct to use .lcomm in some
821 // cases (e.g. when Align == 1), the external assembler might enfore
822 // some -unknown- default alignment behavior, which could cause
823 // spurious differences between external and integrated assembler.
824 // Prefer to simply fall back to .local / .comm in this case.
826 // .lcomm _foo, 42
827 OutStreamer->emitLocalCommonSymbol(GVSym, Size, Alignment);
828 return;
829 }
830
831 // .local _foo
832 OutStreamer->emitSymbolAttribute(GVSym, MCSA_Local);
833 // .comm _foo, 42, 4
834 OutStreamer->emitCommonSymbol(GVSym, Size, Alignment);
835 return;
836 }
837
838 // Handle thread local data for mach-o which requires us to output an
839 // additional structure of data and mangle the original symbol so that we
840 // can reference it later.
841 //
842 // TODO: This should become an "emit thread local global" method on TLOF.
843 // All of this macho specific stuff should be sunk down into TLOFMachO and
844 // stuff like "TLSExtraDataSection" should no longer be part of the parent
845 // TLOF class. This will also make it more obvious that stuff like
846 // MCStreamer::EmitTBSSSymbol is macho specific and only called from macho
847 // specific code.
848 if (GVKind.isThreadLocal() && MAI->isMachO()) {
849 // Emit the .tbss symbol
850 MCSymbol *MangSym =
851 OutContext.getOrCreateSymbol(GVSym->getName() + Twine("$tlv$init"));
852
853 if (GVKind.isThreadBSS()) {
854 TheSection = getObjFileLowering().getTLSBSSSection();
855 OutStreamer->emitTBSSSymbol(TheSection, MangSym, Size, Alignment);
856 } else if (GVKind.isThreadData()) {
857 OutStreamer->switchSection(TheSection);
858
859 emitAlignment(Alignment, GV);
860 OutStreamer->emitLabel(MangSym);
861
863 GV->getInitializer());
864 }
865
866 OutStreamer->addBlankLine();
867
868 // Emit the variable struct for the runtime.
870
871 OutStreamer->switchSection(TLVSect);
872 // Emit the linkage here.
873 emitLinkage(GV, GVSym);
874 OutStreamer->emitLabel(GVSym);
875
876 // Three pointers in size:
877 // - __tlv_bootstrap - used to make sure support exists
878 // - spare pointer, used when mapped by the runtime
879 // - pointer to mangled symbol above with initializer
880 unsigned PtrSize = DL.getPointerTypeSize(GV->getType());
881 OutStreamer->emitSymbolValue(GetExternalSymbolSymbol("_tlv_bootstrap"),
882 PtrSize);
883 OutStreamer->emitIntValue(0, PtrSize);
884 OutStreamer->emitSymbolValue(MangSym, PtrSize);
885
886 OutStreamer->addBlankLine();
887 return;
888 }
889
890 MCSymbol *EmittedInitSym = GVSym;
891
892 OutStreamer->switchSection(TheSection);
893
894 emitLinkage(GV, EmittedInitSym);
895 emitAlignment(Alignment, GV);
896
897 OutStreamer->emitLabel(EmittedInitSym);
898 MCSymbol *LocalAlias = getSymbolPreferLocal(*GV);
899 if (LocalAlias != EmittedInitSym)
900 OutStreamer->emitLabel(LocalAlias);
901
903
905 // .size foo, 42
906 OutStreamer->emitELFSize(EmittedInitSym,
908
909 OutStreamer->addBlankLine();
910}
911
912/// Emit the directive and value for debug thread local expression
913///
914/// \p Value - The value to emit.
915/// \p Size - The size of the integer (in bytes) to emit.
916void AsmPrinter::emitDebugValue(const MCExpr *Value, unsigned Size) const {
917 OutStreamer->emitValue(Value, Size);
918}
919
920void AsmPrinter::emitFunctionHeaderComment() {}
921
922void AsmPrinter::emitFunctionPrefix(ArrayRef<const Constant *> Prefix) {
923 const Function &F = MF->getFunction();
925 for (auto &C : Prefix)
926 emitGlobalConstant(F.getDataLayout(), C);
927 return;
928 }
929 // Preserving prefix-like data on platforms which use subsections-via-symbols
930 // is a bit tricky. Here we introduce a symbol for the prefix-like data
931 // and use the .alt_entry attribute to mark the function's real entry point
932 // as an alternative entry point to the symbol that precedes the function..
934
935 for (auto &C : Prefix) {
936 emitGlobalConstant(F.getDataLayout(), C);
937 }
938
939 // Emit an .alt_entry directive for the actual function symbol.
940 OutStreamer->emitSymbolAttribute(CurrentFnSym, MCSA_AltEntry);
941}
942
943/// EmitFunctionHeader - This method emits the header for the current
944/// function.
945void AsmPrinter::emitFunctionHeader() {
946 const Function &F = MF->getFunction();
947
948 if (isVerbose())
949 OutStreamer->getCommentOS()
950 << "-- Begin function "
951 << GlobalValue::dropLLVMManglingEscape(F.getName()) << '\n';
952
953 // Print out constants referenced by the function
955
956 // Print the 'header' of function.
957 // If basic block sections are desired, explicitly request a unique section
958 // for this function's entry block.
959 if (MF->front().isBeginSection())
960 MF->setSection(getObjFileLowering().getUniqueSectionForFunction(F, TM));
961 else
962 MF->setSection(getObjFileLowering().SectionForGlobal(&F, TM));
963 OutStreamer->switchSection(MF->getSection());
964
965 if (MAI->isAIX())
967 else
968 emitVisibility(CurrentFnSym, F.getVisibility());
969
973
975 OutStreamer->emitSymbolAttribute(CurrentFnSym, MCSA_ELF_TypeFunction);
976
977 if (F.hasFnAttribute(Attribute::Cold))
978 OutStreamer->emitSymbolAttribute(CurrentFnSym, MCSA_Cold);
979
980 // Emit the prefix data.
981 if (F.hasPrefixData())
982 emitFunctionPrefix({F.getPrefixData()});
983
984 // Emit KCFI type information before patchable-function-prefix nops.
986
987 // Emit M NOPs for -fpatchable-function-entry=N,M where M>0. We arbitrarily
988 // place prefix data before NOPs.
989 unsigned PatchableFunctionPrefix = 0;
990 unsigned PatchableFunctionEntry = 0;
991 (void)F.getFnAttribute("patchable-function-prefix")
992 .getValueAsString()
993 .getAsInteger(10, PatchableFunctionPrefix);
994 (void)F.getFnAttribute("patchable-function-entry")
995 .getValueAsString()
996 .getAsInteger(10, PatchableFunctionEntry);
997 if (PatchableFunctionPrefix) {
1001 emitNops(PatchableFunctionPrefix);
1002 } else if (PatchableFunctionEntry) {
1003 // May be reassigned when emitting the body, to reference the label after
1004 // the initial BTI (AArch64) or endbr32/endbr64 (x86).
1006 }
1007
1008 // Emit the function prologue data for the indirect call sanitizer.
1009 if (const MDNode *MD = F.getMetadata(LLVMContext::MD_func_sanitize)) {
1010 assert(MD->getNumOperands() == 2);
1011
1012 auto *PrologueSig = mdconst::extract<Constant>(MD->getOperand(0));
1013 auto *TypeHash = mdconst::extract<Constant>(MD->getOperand(1));
1014 emitFunctionPrefix({PrologueSig, TypeHash});
1015 }
1016
1017 if (isVerbose()) {
1018 F.printAsOperand(OutStreamer->getCommentOS(),
1019 /*PrintType=*/false, F.getParent());
1020 emitFunctionHeaderComment();
1021 OutStreamer->getCommentOS() << '\n';
1022 }
1023
1024 // Emit the function descriptor. This is a virtual function to allow targets
1025 // to emit their specific function descriptor. Right now it is only used by
1026 // the AIX target. The PowerPC 64-bit V1 ELF target also uses function
1027 // descriptors and should be converted to use this hook as well.
1028 if (MAI->isAIX())
1030
1031 // Emit the CurrentFnSym. This is a virtual function to allow targets to do
1032 // their wild and crazy things as required.
1034
1035 // If the function had address-taken blocks that got deleted, then we have
1036 // references to the dangling symbols. Emit them at the start of the function
1037 // so that we don't get references to undefined symbols.
1038 std::vector<MCSymbol*> DeadBlockSyms;
1039 takeDeletedSymbolsForFunction(&F, DeadBlockSyms);
1040 for (MCSymbol *DeadBlockSym : DeadBlockSyms) {
1041 OutStreamer->AddComment("Address taken block that was later removed");
1042 OutStreamer->emitLabel(DeadBlockSym);
1043 }
1044
1045 if (CurrentFnBegin) {
1048 OutStreamer->emitLabel(CurPos);
1049 OutStreamer->emitAssignment(CurrentFnBegin,
1051 } else {
1052 OutStreamer->emitLabel(CurrentFnBegin);
1053 }
1054 }
1055
1056 // Emit pre-function debug and/or EH information.
1057 for (auto &Handler : Handlers) {
1058 Handler->beginFunction(MF);
1059 Handler->beginBasicBlockSection(MF->front());
1060 }
1061 for (auto &Handler : EHHandlers) {
1062 Handler->beginFunction(MF);
1063 Handler->beginBasicBlockSection(MF->front());
1064 }
1065
1066 // Emit the prologue data.
1067 if (F.hasPrologueData())
1068 emitGlobalConstant(F.getDataLayout(), F.getPrologueData());
1069}
1070
1071/// EmitFunctionEntryLabel - Emit the label that is the entrypoint for the
1072/// function. This can be overridden by targets as required to do custom stuff.
1075
1076 // The function label could have already been emitted if two symbols end up
1077 // conflicting due to asm renaming. Detect this and emit an error.
1078 if (CurrentFnSym->isVariable())
1080 "' is a protected alias");
1081
1082 OutStreamer->emitLabel(CurrentFnSym);
1083
1086 if (Sym != CurrentFnSym) {
1087 cast<MCSymbolELF>(Sym)->setType(ELF::STT_FUNC);
1089 OutStreamer->emitLabel(Sym);
1091 OutStreamer->emitSymbolAttribute(Sym, MCSA_ELF_TypeFunction);
1092 }
1093 }
1094}
1095
1096/// emitComments - Pretty-print comments for instructions.
1097static void emitComments(const MachineInstr &MI, const MCSubtargetInfo *STI,
1098 raw_ostream &CommentOS) {
1099 const MachineFunction *MF = MI.getMF();
1101
1102 // Check for spills and reloads
1103
1104 // We assume a single instruction only has a spill or reload, not
1105 // both.
1106 std::optional<LocationSize> Size;
1107 if ((Size = MI.getRestoreSize(TII))) {
1108 CommentOS << Size->getValue() << "-byte Reload\n";
1109 } else if ((Size = MI.getFoldedRestoreSize(TII))) {
1110 if (!Size->hasValue())
1111 CommentOS << "Unknown-size Folded Reload\n";
1112 else if (Size->getValue())
1113 CommentOS << Size->getValue() << "-byte Folded Reload\n";
1114 } else if ((Size = MI.getSpillSize(TII))) {
1115 CommentOS << Size->getValue() << "-byte Spill\n";
1116 } else if ((Size = MI.getFoldedSpillSize(TII))) {
1117 if (!Size->hasValue())
1118 CommentOS << "Unknown-size Folded Spill\n";
1119 else if (Size->getValue())
1120 CommentOS << Size->getValue() << "-byte Folded Spill\n";
1121 }
1122
1123 // Check for spill-induced copies
1124 if (MI.getAsmPrinterFlag(MachineInstr::ReloadReuse))
1125 CommentOS << " Reload Reuse\n";
1126
1127 if (PrintLatency) {
1129 const MCSchedModel &SCModel = STI->getSchedModel();
1132 *STI, *TII, MI);
1133 // Report only interesting latencies.
1134 if (1 < Latency)
1135 CommentOS << " Latency: " << Latency << "\n";
1136 }
1137}
1138
1139/// emitImplicitDef - This method emits the specified machine instruction
1140/// that is an implicit def.
1142 Register RegNo = MI->getOperand(0).getReg();
1143
1144 SmallString<128> Str;
1146 OS << "implicit-def: "
1147 << printReg(RegNo, MF->getSubtarget().getRegisterInfo());
1148
1149 OutStreamer->AddComment(OS.str());
1150 OutStreamer->addBlankLine();
1151}
1152
1153static void emitKill(const MachineInstr *MI, AsmPrinter &AP) {
1154 std::string Str;
1156 OS << "kill:";
1157 for (const MachineOperand &Op : MI->operands()) {
1158 assert(Op.isReg() && "KILL instruction must have only register operands");
1159 OS << ' ' << (Op.isDef() ? "def " : "killed ")
1160 << printReg(Op.getReg(), AP.MF->getSubtarget().getRegisterInfo());
1161 }
1162 AP.OutStreamer->AddComment(Str);
1163 AP.OutStreamer->addBlankLine();
1164}
1165
1166static void emitFakeUse(const MachineInstr *MI, AsmPrinter &AP) {
1167 std::string Str;
1169 OS << "fake_use:";
1170 for (const MachineOperand &Op : MI->operands()) {
1171 // In some circumstances we can end up with fake uses of constants; skip
1172 // these.
1173 if (!Op.isReg())
1174 continue;
1175 OS << ' ' << printReg(Op.getReg(), AP.MF->getSubtarget().getRegisterInfo());
1176 }
1177 AP.OutStreamer->AddComment(OS.str());
1178 AP.OutStreamer->addBlankLine();
1179}
1180
1181/// emitDebugValueComment - This method handles the target-independent form
1182/// of DBG_VALUE, returning true if it was able to do so. A false return
1183/// means the target will need to handle MI in EmitInstruction.
1185 // This code handles only the 4-operand target-independent form.
1186 if (MI->isNonListDebugValue() && MI->getNumOperands() != 4)
1187 return false;
1188
1189 SmallString<128> Str;
1191 OS << "DEBUG_VALUE: ";
1192
1193 const DILocalVariable *V = MI->getDebugVariable();
1194 if (auto *SP = dyn_cast<DISubprogram>(V->getScope())) {
1195 StringRef Name = SP->getName();
1196 if (!Name.empty())
1197 OS << Name << ":";
1198 }
1199 OS << V->getName();
1200 OS << " <- ";
1201
1202 const DIExpression *Expr = MI->getDebugExpression();
1203 // First convert this to a non-variadic expression if possible, to simplify
1204 // the output.
1205 if (auto NonVariadicExpr = DIExpression::convertToNonVariadicExpression(Expr))
1206 Expr = *NonVariadicExpr;
1207 // Then, output the possibly-simplified expression.
1208 if (Expr->getNumElements()) {
1209 OS << '[';
1210 ListSeparator LS;
1211 for (auto &Op : Expr->expr_ops()) {
1212 OS << LS << dwarf::OperationEncodingString(Op.getOp());
1213 for (unsigned I = 0; I < Op.getNumArgs(); ++I)
1214 OS << ' ' << Op.getArg(I);
1215 }
1216 OS << "] ";
1217 }
1218
1219 // Register or immediate value. Register 0 means undef.
1220 for (const MachineOperand &Op : MI->debug_operands()) {
1221 if (&Op != MI->debug_operands().begin())
1222 OS << ", ";
1223 switch (Op.getType()) {
1225 APFloat APF = APFloat(Op.getFPImm()->getValueAPF());
1226 Type *ImmTy = Op.getFPImm()->getType();
1227 if (ImmTy->isBFloatTy() || ImmTy->isHalfTy() || ImmTy->isFloatTy() ||
1228 ImmTy->isDoubleTy()) {
1229 OS << APF.convertToDouble();
1230 } else {
1231 // There is no good way to print long double. Convert a copy to
1232 // double. Ah well, it's only a comment.
1233 bool ignored;
1235 &ignored);
1236 OS << "(long double) " << APF.convertToDouble();
1237 }
1238 break;
1239 }
1241 OS << Op.getImm();
1242 break;
1243 }
1245 Op.getCImm()->getValue().print(OS, false /*isSigned*/);
1246 break;
1247 }
1249 OS << "!target-index(" << Op.getIndex() << "," << Op.getOffset() << ")";
1250 break;
1251 }
1254 Register Reg;
1255 std::optional<StackOffset> Offset;
1256 if (Op.isReg()) {
1257 Reg = Op.getReg();
1258 } else {
1259 const TargetFrameLowering *TFI =
1261 Offset = TFI->getFrameIndexReference(*AP.MF, Op.getIndex(), Reg);
1262 }
1263 if (!Reg) {
1264 // Suppress offset, it is not meaningful here.
1265 OS << "undef";
1266 break;
1267 }
1268 // The second operand is only an offset if it's an immediate.
1269 if (MI->isIndirectDebugValue())
1270 Offset = StackOffset::getFixed(MI->getDebugOffset().getImm());
1271 if (Offset)
1272 OS << '[';
1273 OS << printReg(Reg, AP.MF->getSubtarget().getRegisterInfo());
1274 if (Offset)
1275 OS << '+' << Offset->getFixed() << ']';
1276 break;
1277 }
1278 default:
1279 llvm_unreachable("Unknown operand type");
1280 }
1281 }
1282
1283 // NOTE: Want this comment at start of line, don't emit with AddComment.
1284 AP.OutStreamer->emitRawComment(Str);
1285 return true;
1286}
1287
1288/// This method handles the target-independent form of DBG_LABEL, returning
1289/// true if it was able to do so. A false return means the target will need
1290/// to handle MI in EmitInstruction.
1292 if (MI->getNumOperands() != 1)
1293 return false;
1294
1295 SmallString<128> Str;
1297 OS << "DEBUG_LABEL: ";
1298
1299 const DILabel *V = MI->getDebugLabel();
1300 if (auto *SP = dyn_cast<DISubprogram>(
1301 V->getScope()->getNonLexicalBlockFileScope())) {
1302 StringRef Name = SP->getName();
1303 if (!Name.empty())
1304 OS << Name << ":";
1305 }
1306 OS << V->getName();
1307
1308 // NOTE: Want this comment at start of line, don't emit with AddComment.
1309 AP.OutStreamer->emitRawComment(OS.str());
1310 return true;
1311}
1312
1315 // Ignore functions that won't get emitted.
1316 if (F.isDeclarationForLinker())
1317 return CFISection::None;
1318
1320 F.needsUnwindTableEntry())
1321 return CFISection::EH;
1322
1323 if (MAI->usesCFIWithoutEH() && F.hasUWTable())
1324 return CFISection::EH;
1325
1327 return CFISection::Debug;
1328
1329 return CFISection::None;
1330}
1331
1335}
1336
1339}
1340
1342 return MAI->usesCFIWithoutEH() && ModuleCFISection != CFISection::None;
1343}
1344
1346 ExceptionHandling ExceptionHandlingType = MAI->getExceptionHandlingType();
1347 if (!usesCFIWithoutEH() &&
1348 ExceptionHandlingType != ExceptionHandling::DwarfCFI &&
1349 ExceptionHandlingType != ExceptionHandling::ARM)
1350 return;
1351
1353 return;
1354
1355 // If there is no "real" instruction following this CFI instruction, skip
1356 // emitting it; it would be beyond the end of the function's FDE range.
1357 auto *MBB = MI.getParent();
1358 auto I = std::next(MI.getIterator());
1359 while (I != MBB->end() && I->isTransient())
1360 ++I;
1361 if (I == MBB->instr_end() &&
1363 return;
1364
1365 const std::vector<MCCFIInstruction> &Instrs = MF->getFrameInstructions();
1366 unsigned CFIIndex = MI.getOperand(0).getCFIIndex();
1367 const MCCFIInstruction &CFI = Instrs[CFIIndex];
1368 emitCFIInstruction(CFI);
1369}
1370
1372 // The operands are the MCSymbol and the frame offset of the allocation.
1373 MCSymbol *FrameAllocSym = MI.getOperand(0).getMCSymbol();
1374 int FrameOffset = MI.getOperand(1).getImm();
1375
1376 // Emit a symbol assignment.
1377 OutStreamer->emitAssignment(FrameAllocSym,
1378 MCConstantExpr::create(FrameOffset, OutContext));
1379}
1380
1381/// Returns the BB metadata to be emitted in the SHT_LLVM_BB_ADDR_MAP section
1382/// for a given basic block. This can be used to capture more precise profile
1383/// information.
1388 MBB.isEHPad(), const_cast<MachineBasicBlock &>(MBB).canFallThrough(),
1389 !MBB.empty() && MBB.rbegin()->isIndirectBranch()}
1390 .encode();
1391}
1392
1394getBBAddrMapFeature(const MachineFunction &MF, int NumMBBSectionRanges) {
1395 // Ensure that the user has not passed in additional options while also
1396 // specifying all or none.
1397 if ((PgoAnalysisMapFeatures.isSet(PGOMapFeaturesEnum::None) ||
1398 PgoAnalysisMapFeatures.isSet(PGOMapFeaturesEnum::All)) &&
1399 popcount(PgoAnalysisMapFeatures.getBits()) != 1) {
1401 "-pgo-anaylsis-map can accept only all or none with no additional "
1402 "values.");
1403 }
1404
1405 bool NoFeatures = PgoAnalysisMapFeatures.isSet(PGOMapFeaturesEnum::None);
1406 bool AllFeatures = PgoAnalysisMapFeatures.isSet(PGOMapFeaturesEnum::All);
1407 bool FuncEntryCountEnabled =
1408 AllFeatures || (!NoFeatures && PgoAnalysisMapFeatures.isSet(
1409 PGOMapFeaturesEnum::FuncEntryCount));
1410 bool BBFreqEnabled =
1411 AllFeatures ||
1412 (!NoFeatures && PgoAnalysisMapFeatures.isSet(PGOMapFeaturesEnum::BBFreq));
1413 bool BrProbEnabled =
1414 AllFeatures ||
1415 (!NoFeatures && PgoAnalysisMapFeatures.isSet(PGOMapFeaturesEnum::BrProb));
1416
1417 if ((BBFreqEnabled || BrProbEnabled) && BBAddrMapSkipEmitBBEntries) {
1419 "BB entries info is required for BBFreq and BrProb "
1420 "features");
1421 }
1422 return {FuncEntryCountEnabled, BBFreqEnabled, BrProbEnabled,
1423 MF.hasBBSections() && NumMBBSectionRanges > 1,
1424 static_cast<bool>(BBAddrMapSkipEmitBBEntries)};
1425}
1426
1428 MCSection *BBAddrMapSection =
1430 assert(BBAddrMapSection && ".llvm_bb_addr_map section is not initialized.");
1431
1432 const MCSymbol *FunctionSymbol = getFunctionBegin();
1433
1434 OutStreamer->pushSection();
1435 OutStreamer->switchSection(BBAddrMapSection);
1436 OutStreamer->AddComment("version");
1437 uint8_t BBAddrMapVersion = OutStreamer->getContext().getBBAddrMapVersion();
1438 OutStreamer->emitInt8(BBAddrMapVersion);
1439 OutStreamer->AddComment("feature");
1440 auto Features = getBBAddrMapFeature(MF, MBBSectionRanges.size());
1441 OutStreamer->emitInt8(Features.encode());
1442 // Emit BB Information for each basic block in the function.
1443 if (Features.MultiBBRange) {
1444 OutStreamer->AddComment("number of basic block ranges");
1445 OutStreamer->emitULEB128IntValue(MBBSectionRanges.size());
1446 }
1447 // Number of blocks in each MBB section.
1448 MapVector<MBBSectionID, unsigned> MBBSectionNumBlocks;
1449 const MCSymbol *PrevMBBEndSymbol = nullptr;
1450 if (!Features.MultiBBRange) {
1451 OutStreamer->AddComment("function address");
1452 OutStreamer->emitSymbolValue(FunctionSymbol, getPointerSize());
1453 OutStreamer->AddComment("number of basic blocks");
1454 OutStreamer->emitULEB128IntValue(MF.size());
1455 PrevMBBEndSymbol = FunctionSymbol;
1456 } else {
1457 unsigned BBCount = 0;
1458 for (const MachineBasicBlock &MBB : MF) {
1459 BBCount++;
1460 if (MBB.isEndSection()) {
1461 // Store each section's basic block count when it ends.
1462 MBBSectionNumBlocks[MBB.getSectionID()] = BBCount;
1463 // Reset the count for the next section.
1464 BBCount = 0;
1465 }
1466 }
1467 }
1468 // Emit the BB entry for each basic block in the function.
1469 for (const MachineBasicBlock &MBB : MF) {
1470 const MCSymbol *MBBSymbol =
1471 MBB.isEntryBlock() ? FunctionSymbol : MBB.getSymbol();
1472 bool IsBeginSection =
1473 Features.MultiBBRange && (MBB.isBeginSection() || MBB.isEntryBlock());
1474 if (IsBeginSection) {
1475 OutStreamer->AddComment("base address");
1476 OutStreamer->emitSymbolValue(MBBSymbol, getPointerSize());
1477 OutStreamer->AddComment("number of basic blocks");
1478 OutStreamer->emitULEB128IntValue(MBBSectionNumBlocks[MBB.getSectionID()]);
1479 PrevMBBEndSymbol = MBBSymbol;
1480 }
1481
1482 if (!Features.OmitBBEntries) {
1483 // TODO: Remove this check when version 1 is deprecated.
1484 if (BBAddrMapVersion > 1) {
1485 OutStreamer->AddComment("BB id");
1486 // Emit the BB ID for this basic block.
1487 // We only emit BaseID since CloneID is unset for
1488 // -basic-block-adress-map.
1489 // TODO: Emit the full BBID when labels and sections can be mixed
1490 // together.
1491 OutStreamer->emitULEB128IntValue(MBB.getBBID()->BaseID);
1492 }
1493 // Emit the basic block offset relative to the end of the previous block.
1494 // This is zero unless the block is padded due to alignment.
1495 emitLabelDifferenceAsULEB128(MBBSymbol, PrevMBBEndSymbol);
1496 // Emit the basic block size. When BBs have alignments, their size cannot
1497 // always be computed from their offsets.
1499 // Emit the Metadata.
1500 OutStreamer->emitULEB128IntValue(getBBAddrMapMetadata(MBB));
1501 }
1502
1503 PrevMBBEndSymbol = MBB.getEndSymbol();
1504 }
1505
1506 if (Features.hasPGOAnalysis()) {
1507 assert(BBAddrMapVersion >= 2 &&
1508 "PGOAnalysisMap only supports version 2 or later");
1509
1510 if (Features.FuncEntryCount) {
1511 OutStreamer->AddComment("function entry count");
1512 auto MaybeEntryCount = MF.getFunction().getEntryCount();
1513 OutStreamer->emitULEB128IntValue(
1514 MaybeEntryCount ? MaybeEntryCount->getCount() : 0);
1515 }
1516 const MachineBlockFrequencyInfo *MBFI =
1517 Features.BBFreq
1518 ? &getAnalysis<LazyMachineBlockFrequencyInfoPass>().getBFI()
1519 : nullptr;
1520 const MachineBranchProbabilityInfo *MBPI =
1521 Features.BrProb
1522 ? &getAnalysis<MachineBranchProbabilityInfoWrapperPass>().getMBPI()
1523 : nullptr;
1524
1525 if (Features.BBFreq || Features.BrProb) {
1526 for (const MachineBasicBlock &MBB : MF) {
1527 if (Features.BBFreq) {
1528 OutStreamer->AddComment("basic block frequency");
1529 OutStreamer->emitULEB128IntValue(
1530 MBFI->getBlockFreq(&MBB).getFrequency());
1531 }
1532 if (Features.BrProb) {
1533 unsigned SuccCount = MBB.succ_size();
1534 OutStreamer->AddComment("basic block successor count");
1535 OutStreamer->emitULEB128IntValue(SuccCount);
1536 for (const MachineBasicBlock *SuccMBB : MBB.successors()) {
1537 OutStreamer->AddComment("successor BB ID");
1538 OutStreamer->emitULEB128IntValue(SuccMBB->getBBID()->BaseID);
1539 OutStreamer->AddComment("successor branch probability");
1540 OutStreamer->emitULEB128IntValue(
1541 MBPI->getEdgeProbability(&MBB, SuccMBB).getNumerator());
1542 }
1543 }
1544 }
1545 }
1546 }
1547
1548 OutStreamer->popSection();
1549}
1550
1552 const MCSymbol *Symbol) {
1553 MCSection *Section =
1555 if (!Section)
1556 return;
1557
1558 OutStreamer->pushSection();
1559 OutStreamer->switchSection(Section);
1560
1562 OutStreamer->emitLabel(Loc);
1563 OutStreamer->emitAbsoluteSymbolDiff(Symbol, Loc, 4);
1564
1565 OutStreamer->popSection();
1566}
1567
1569 const Function &F = MF.getFunction();
1570 if (const MDNode *MD = F.getMetadata(LLVMContext::MD_kcfi_type))
1571 emitGlobalConstant(F.getDataLayout(),
1572 mdconst::extract<ConstantInt>(MD->getOperand(0)));
1573}
1574
1576 if (PP) {
1577 auto GUID = MI.getOperand(0).getImm();
1578 auto Index = MI.getOperand(1).getImm();
1579 auto Type = MI.getOperand(2).getImm();
1580 auto Attr = MI.getOperand(3).getImm();
1581 DILocation *DebugLoc = MI.getDebugLoc();
1582 PP->emitPseudoProbe(GUID, Index, Type, Attr, DebugLoc);
1583 }
1584}
1585
1588 return;
1589
1590 MCSection *StackSizeSection =
1592 if (!StackSizeSection)
1593 return;
1594
1595 const MachineFrameInfo &FrameInfo = MF.getFrameInfo();
1596 // Don't emit functions with dynamic stack allocations.
1597 if (FrameInfo.hasVarSizedObjects())
1598 return;
1599
1600 OutStreamer->pushSection();
1601 OutStreamer->switchSection(StackSizeSection);
1602
1603 const MCSymbol *FunctionSymbol = getFunctionBegin();
1604 uint64_t StackSize =
1605 FrameInfo.getStackSize() + FrameInfo.getUnsafeStackSize();
1606 OutStreamer->emitSymbolValue(FunctionSymbol, TM.getProgramPointerSize());
1607 OutStreamer->emitULEB128IntValue(StackSize);
1608
1609 OutStreamer->popSection();
1610}
1611
1613 const std::string &OutputFilename = MF.getTarget().Options.StackUsageOutput;
1614
1615 // OutputFilename empty implies -fstack-usage is not passed.
1616 if (OutputFilename.empty())
1617 return;
1618
1619 const MachineFrameInfo &FrameInfo = MF.getFrameInfo();
1620 uint64_t StackSize =
1621 FrameInfo.getStackSize() + FrameInfo.getUnsafeStackSize();
1622
1623 if (StackUsageStream == nullptr) {
1624 std::error_code EC;
1625 StackUsageStream =
1626 std::make_unique<raw_fd_ostream>(OutputFilename, EC, sys::fs::OF_Text);
1627 if (EC) {
1628 errs() << "Could not open file: " << EC.message();
1629 return;
1630 }
1631 }
1632
1633 if (const DISubprogram *DSP = MF.getFunction().getSubprogram())
1634 *StackUsageStream << DSP->getFilename() << ':' << DSP->getLine();
1635 else
1636 *StackUsageStream << MF.getFunction().getParent()->getName();
1637
1638 *StackUsageStream << ':' << MF.getName() << '\t' << StackSize << '\t';
1639 if (FrameInfo.hasVarSizedObjects())
1640 *StackUsageStream << "dynamic\n";
1641 else
1642 *StackUsageStream << "static\n";
1643}
1644
1646 const MDNode &MD) {
1647 MCSymbol *S = MF.getContext().createTempSymbol("pcsection");
1648 OutStreamer->emitLabel(S);
1649 PCSectionsSymbols[&MD].emplace_back(S);
1650}
1651
1653 const Function &F = MF.getFunction();
1654 if (PCSectionsSymbols.empty() && !F.hasMetadata(LLVMContext::MD_pcsections))
1655 return;
1656
1658 const unsigned RelativeRelocSize =
1660 : 4;
1661
1662 // Switch to PCSection, short-circuiting the common case where the current
1663 // section is still valid (assume most MD_pcsections contain just 1 section).
1664 auto SwitchSection = [&, Prev = StringRef()](const StringRef &Sec) mutable {
1665 if (Sec == Prev)
1666 return;
1668 assert(S && "PC section is not initialized");
1669 OutStreamer->switchSection(S);
1670 Prev = Sec;
1671 };
1672 // Emit symbols into sections and data as specified in the pcsections MDNode.
1673 auto EmitForMD = [&](const MDNode &MD, ArrayRef<const MCSymbol *> Syms,
1674 bool Deltas) {
1675 // Expect the first operand to be a section name. After that, a tuple of
1676 // constants may appear, which will simply be emitted into the current
1677 // section (the user of MD_pcsections decides the format of encoded data).
1678 assert(isa<MDString>(MD.getOperand(0)) && "first operand not a string");
1679 bool ConstULEB128 = false;
1680 for (const MDOperand &MDO : MD.operands()) {
1681 if (auto *S = dyn_cast<MDString>(MDO)) {
1682 // Found string, start of new section!
1683 // Find options for this section "<section>!<opts>" - supported options:
1684 // C = Compress constant integers of size 2-8 bytes as ULEB128.
1685 const StringRef SecWithOpt = S->getString();
1686 const size_t OptStart = SecWithOpt.find('!'); // likely npos
1687 const StringRef Sec = SecWithOpt.substr(0, OptStart);
1688 const StringRef Opts = SecWithOpt.substr(OptStart); // likely empty
1689 ConstULEB128 = Opts.contains('C');
1690#ifndef NDEBUG
1691 for (char O : Opts)
1692 assert((O == '!' || O == 'C') && "Invalid !pcsections options");
1693#endif
1694 SwitchSection(Sec);
1695 const MCSymbol *Prev = Syms.front();
1696 for (const MCSymbol *Sym : Syms) {
1697 if (Sym == Prev || !Deltas) {
1698 // Use the entry itself as the base of the relative offset.
1699 MCSymbol *Base = MF.getContext().createTempSymbol("pcsection_base");
1700 OutStreamer->emitLabel(Base);
1701 // Emit relative relocation `addr - base`, which avoids a dynamic
1702 // relocation in the final binary. User will get the address with
1703 // `base + addr`.
1704 emitLabelDifference(Sym, Base, RelativeRelocSize);
1705 } else {
1706 // Emit delta between symbol and previous symbol.
1707 if (ConstULEB128)
1709 else
1710 emitLabelDifference(Sym, Prev, 4);
1711 }
1712 Prev = Sym;
1713 }
1714 } else {
1715 // Emit auxiliary data after PC.
1716 assert(isa<MDNode>(MDO) && "expecting either string or tuple");
1717 const auto *AuxMDs = cast<MDNode>(MDO);
1718 for (const MDOperand &AuxMDO : AuxMDs->operands()) {
1719 assert(isa<ConstantAsMetadata>(AuxMDO) && "expecting a constant");
1720 const Constant *C = cast<ConstantAsMetadata>(AuxMDO)->getValue();
1721 const DataLayout &DL = F.getDataLayout();
1722 const uint64_t Size = DL.getTypeStoreSize(C->getType());
1723
1724 if (auto *CI = dyn_cast<ConstantInt>(C);
1725 CI && ConstULEB128 && Size > 1 && Size <= 8) {
1726 emitULEB128(CI->getZExtValue());
1727 } else {
1729 }
1730 }
1731 }
1732 }
1733 };
1734
1735 OutStreamer->pushSection();
1736 // Emit PCs for function start and function size.
1737 if (const MDNode *MD = F.getMetadata(LLVMContext::MD_pcsections))
1738 EmitForMD(*MD, {getFunctionBegin(), getFunctionEnd()}, true);
1739 // Emit PCs for instructions collected.
1740 for (const auto &MS : PCSectionsSymbols)
1741 EmitForMD(*MS.first, MS.second, false);
1742 OutStreamer->popSection();
1743 PCSectionsSymbols.clear();
1744}
1745
1746/// Returns true if function begin and end labels should be emitted.
1747static bool needFuncLabels(const MachineFunction &MF, const AsmPrinter &Asm) {
1748 if (Asm.hasDebugInfo() || !MF.getLandingPads().empty() ||
1749 MF.hasEHFunclets() ||
1750 MF.getFunction().hasMetadata(LLVMContext::MD_pcsections))
1751 return true;
1752
1753 // We might emit an EH table that uses function begin and end labels even if
1754 // we don't have any landingpads.
1755 if (!MF.getFunction().hasPersonalityFn())
1756 return false;
1757 return !isNoOpWithoutInvoke(
1759}
1760
1761// Return the mnemonic of a MachineInstr if available, or the MachineInstr
1762// opcode name otherwise.
1764 const TargetInstrInfo *TII =
1765 MI.getParent()->getParent()->getSubtarget().getInstrInfo();
1766 MCInst MCI;
1767 MCI.setOpcode(MI.getOpcode());
1768 if (StringRef Name = Streamer.getMnemonic(MCI); !Name.empty())
1769 return Name;
1770 StringRef Name = TII->getName(MI.getOpcode());
1771 assert(!Name.empty() && "Missing mnemonic and name for opcode");
1772 return Name;
1773}
1774
1775/// EmitFunctionBody - This method emits the body and trailer for a
1776/// function.
1778 emitFunctionHeader();
1779
1780 // Emit target-specific gunk before the function body.
1782
1783 if (isVerbose()) {
1784 // Get MachineDominatorTree or compute it on the fly if it's unavailable
1785 auto MDTWrapper = getAnalysisIfAvailable<MachineDominatorTreeWrapperPass>();
1786 MDT = MDTWrapper ? &MDTWrapper->getDomTree() : nullptr;
1787 if (!MDT) {
1788 OwnedMDT = std::make_unique<MachineDominatorTree>();
1789 OwnedMDT->recalculate(*MF);
1790 MDT = OwnedMDT.get();
1791 }
1792
1793 // Get MachineLoopInfo or compute it on the fly if it's unavailable
1794 auto *MLIWrapper = getAnalysisIfAvailable<MachineLoopInfoWrapperPass>();
1795 MLI = MLIWrapper ? &MLIWrapper->getLI() : nullptr;
1796 if (!MLI) {
1797 OwnedMLI = std::make_unique<MachineLoopInfo>();
1798 OwnedMLI->analyze(*MDT);
1799 MLI = OwnedMLI.get();
1800 }
1801 }
1802
1803 // Print out code for the function.
1804 bool HasAnyRealCode = false;
1805 int NumInstsInFunction = 0;
1806 bool IsEHa = MMI->getModule()->getModuleFlag("eh-asynch");
1807
1808 const MCSubtargetInfo *STI = nullptr;
1809 if (this->MF)
1810 STI = &getSubtargetInfo();
1811 else
1812 STI = TM.getMCSubtargetInfo();
1813
1814 bool CanDoExtraAnalysis = ORE->allowExtraAnalysis(DEBUG_TYPE);
1815 // Create a slot for the entry basic block section so that the section
1816 // order is preserved when iterating over MBBSectionRanges.
1817 if (!MF->empty())
1820
1821 for (auto &MBB : *MF) {
1822 // Print a label for the basic block.
1824 DenseMap<StringRef, unsigned> MnemonicCounts;
1825 for (auto &MI : MBB) {
1826 // Print the assembly for the instruction.
1827 if (!MI.isPosition() && !MI.isImplicitDef() && !MI.isKill() &&
1828 !MI.isDebugInstr()) {
1829 HasAnyRealCode = true;
1830 }
1831
1832 // If there is a pre-instruction symbol, emit a label for it here.
1833 if (MCSymbol *S = MI.getPreInstrSymbol())
1834 OutStreamer->emitLabel(S);
1835
1836 if (MDNode *MD = MI.getPCSections())
1837 emitPCSectionsLabel(*MF, *MD);
1838
1839 for (auto &Handler : Handlers)
1840 Handler->beginInstruction(&MI);
1841
1842 if (isVerbose())
1843 emitComments(MI, STI, OutStreamer->getCommentOS());
1844
1845 switch (MI.getOpcode()) {
1846 case TargetOpcode::CFI_INSTRUCTION:
1848 break;
1849 case TargetOpcode::LOCAL_ESCAPE:
1851 break;
1852 case TargetOpcode::ANNOTATION_LABEL:
1853 case TargetOpcode::GC_LABEL:
1854 OutStreamer->emitLabel(MI.getOperand(0).getMCSymbol());
1855 break;
1856 case TargetOpcode::EH_LABEL:
1857 OutStreamer->emitLabel(MI.getOperand(0).getMCSymbol());
1858 // For AsynchEH, insert a Nop if followed by a trap inst
1859 // Or the exception won't be caught.
1860 // (see MCConstantExpr::create(1,..) in WinException.cpp)
1861 // Ignore SDiv/UDiv because a DIV with Const-0 divisor
1862 // must have being turned into an UndefValue.
1863 // Div with variable opnds won't be the first instruction in
1864 // an EH region as it must be led by at least a Load
1865 {
1866 auto MI2 = std::next(MI.getIterator());
1867 if (IsEHa && MI2 != MBB.end() &&
1868 (MI2->mayLoadOrStore() || MI2->mayRaiseFPException()))
1869 emitNops(1);
1870 }
1871 break;
1872 case TargetOpcode::INLINEASM:
1873 case TargetOpcode::INLINEASM_BR:
1874 emitInlineAsm(&MI);
1875 break;
1876 case TargetOpcode::DBG_VALUE:
1877 case TargetOpcode::DBG_VALUE_LIST:
1878 if (isVerbose()) {
1879 if (!emitDebugValueComment(&MI, *this))
1881 }
1882 break;
1883 case TargetOpcode::DBG_INSTR_REF:
1884 // This instruction reference will have been resolved to a machine
1885 // location, and a nearby DBG_VALUE created. We can safely ignore
1886 // the instruction reference.
1887 break;
1888 case TargetOpcode::DBG_PHI:
1889 // This instruction is only used to label a program point, it's purely
1890 // meta information.
1891 break;
1892 case TargetOpcode::DBG_LABEL:
1893 if (isVerbose()) {
1894 if (!emitDebugLabelComment(&MI, *this))
1896 }
1897 break;
1898 case TargetOpcode::IMPLICIT_DEF:
1899 if (isVerbose()) emitImplicitDef(&MI);
1900 break;
1901 case TargetOpcode::KILL:
1902 if (isVerbose()) emitKill(&MI, *this);
1903 break;
1904 case TargetOpcode::FAKE_USE:
1905 if (isVerbose())
1906 emitFakeUse(&MI, *this);
1907 break;
1908 case TargetOpcode::PSEUDO_PROBE:
1910 break;
1911 case TargetOpcode::ARITH_FENCE:
1912 if (isVerbose())
1913 OutStreamer->emitRawComment("ARITH_FENCE");
1914 break;
1915 case TargetOpcode::MEMBARRIER:
1916 OutStreamer->emitRawComment("MEMBARRIER");
1917 break;
1918 case TargetOpcode::JUMP_TABLE_DEBUG_INFO:
1919 // This instruction is only used to note jump table debug info, it's
1920 // purely meta information.
1921 break;
1922 case TargetOpcode::INIT_UNDEF:
1923 // This is only used to influence register allocation behavior, no
1924 // actual initialization is needed.
1925 break;
1926 default:
1928
1929 auto CountInstruction = [&](const MachineInstr &MI) {
1930 // Skip Meta instructions inside bundles.
1931 if (MI.isMetaInstruction())
1932 return;
1933 ++NumInstsInFunction;
1934 if (CanDoExtraAnalysis) {
1936 ++MnemonicCounts[Name];
1937 }
1938 };
1939 if (!MI.isBundle()) {
1940 CountInstruction(MI);
1941 break;
1942 }
1943 // Separately count all the instructions in a bundle.
1944 for (auto It = std::next(MI.getIterator());
1945 It != MBB.end() && It->isInsideBundle(); ++It) {
1946 CountInstruction(*It);
1947 }
1948 break;
1949 }
1950
1951 // If there is a post-instruction symbol, emit a label for it here.
1952 if (MCSymbol *S = MI.getPostInstrSymbol())
1953 OutStreamer->emitLabel(S);
1954
1955 for (auto &Handler : Handlers)
1956 Handler->endInstruction();
1957 }
1958
1959 // We must emit temporary symbol for the end of this basic block, if either
1960 // we have BBLabels enabled or if this basic blocks marks the end of a
1961 // section.
1962 if (MF->getTarget().Options.BBAddrMap ||
1964 OutStreamer->emitLabel(MBB.getEndSymbol());
1965
1966 if (MBB.isEndSection()) {
1967 // The size directive for the section containing the entry block is
1968 // handled separately by the function section.
1969 if (!MBB.sameSection(&MF->front())) {
1971 // Emit the size directive for the basic block section.
1972 const MCExpr *SizeExp = MCBinaryExpr::createSub(
1974 MCSymbolRefExpr::create(CurrentSectionBeginSym, OutContext),
1975 OutContext);
1976 OutStreamer->emitELFSize(CurrentSectionBeginSym, SizeExp);
1977 }
1978 assert(!MBBSectionRanges.contains(MBB.getSectionID()) &&
1979 "Overwrite section range");
1981 MBBSectionRange{CurrentSectionBeginSym, MBB.getEndSymbol()};
1982 }
1983 }
1985
1986 if (CanDoExtraAnalysis) {
1987 // Skip empty blocks.
1988 if (MBB.empty())
1989 continue;
1990
1992 MBB.begin()->getDebugLoc(), &MBB);
1993
1994 // Generate instruction mix remark. First, sort counts in descending order
1995 // by count and name.
1997 for (auto &KV : MnemonicCounts)
1998 MnemonicVec.emplace_back(KV.first, KV.second);
1999
2000 sort(MnemonicVec, [](const std::pair<StringRef, unsigned> &A,
2001 const std::pair<StringRef, unsigned> &B) {
2002 if (A.second > B.second)
2003 return true;
2004 if (A.second == B.second)
2005 return StringRef(A.first) < StringRef(B.first);
2006 return false;
2007 });
2008 R << "BasicBlock: " << ore::NV("BasicBlock", MBB.getName()) << "\n";
2009 for (auto &KV : MnemonicVec) {
2010 auto Name = (Twine("INST_") + getToken(KV.first.trim()).first).str();
2011 R << KV.first << ": " << ore::NV(Name, KV.second) << "\n";
2012 }
2013 ORE->emit(R);
2014 }
2015 }
2016
2017 EmittedInsts += NumInstsInFunction;
2018 MachineOptimizationRemarkAnalysis R(DEBUG_TYPE, "InstructionCount",
2020 &MF->front());
2021 R << ore::NV("NumInstructions", NumInstsInFunction)
2022 << " instructions in function";
2023 ORE->emit(R);
2024
2025 // If the function is empty and the object file uses .subsections_via_symbols,
2026 // then we need to emit *something* to the function body to prevent the
2027 // labels from collapsing together. Just emit a noop.
2028 // Similarly, don't emit empty functions on Windows either. It can lead to
2029 // duplicate entries (two functions with the same RVA) in the Guard CF Table
2030 // after linking, causing the kernel not to load the binary:
2031 // https://developercommunity.visualstudio.com/content/problem/45366/vc-linker-creates-invalid-dll-with-clang-cl.html
2032 // FIXME: Hide this behind some API in e.g. MCAsmInfo or MCTargetStreamer.
2033 const Triple &TT = TM.getTargetTriple();
2034 if (!HasAnyRealCode && (MAI->hasSubsectionsViaSymbols() ||
2035 (TT.isOSWindows() && TT.isOSBinFormatCOFF()))) {
2036 MCInst Noop = MF->getSubtarget().getInstrInfo()->getNop();
2037
2038 // Targets can opt-out of emitting the noop here by leaving the opcode
2039 // unspecified.
2040 if (Noop.getOpcode()) {
2041 OutStreamer->AddComment("avoids zero-length function");
2042 emitNops(1);
2043 }
2044 }
2045
2046 // Switch to the original section in case basic block sections was used.
2047 OutStreamer->switchSection(MF->getSection());
2048
2049 const Function &F = MF->getFunction();
2050 for (const auto &BB : F) {
2051 if (!BB.hasAddressTaken())
2052 continue;
2054 if (Sym->isDefined())
2055 continue;
2056 OutStreamer->AddComment("Address of block that was removed by CodeGen");
2057 OutStreamer->emitLabel(Sym);
2058 }
2059
2060 // Emit target-specific gunk after the function body.
2062
2063 // Even though wasm supports .type and .size in general, function symbols
2064 // are automatically sized.
2065 bool EmitFunctionSize = MAI->hasDotTypeDotSizeDirective() && !TT.isWasm();
2066
2067 // SPIR-V supports label instructions only inside a block, not after the
2068 // function body.
2069 if (TT.getObjectFormat() != Triple::SPIRV &&
2070 (EmitFunctionSize || needFuncLabels(*MF, *this))) {
2071 // Create a symbol for the end of function.
2072 CurrentFnEnd = createTempSymbol("func_end");
2073 OutStreamer->emitLabel(CurrentFnEnd);
2074 }
2075
2076 // If the target wants a .size directive for the size of the function, emit
2077 // it.
2078 if (EmitFunctionSize) {
2079 // We can get the size as difference between the function label and the
2080 // temp label.
2081 const MCExpr *SizeExp = MCBinaryExpr::createSub(
2082 MCSymbolRefExpr::create(CurrentFnEnd, OutContext),
2084 OutStreamer->emitELFSize(CurrentFnSym, SizeExp);
2086 OutStreamer->emitELFSize(CurrentFnBeginLocal, SizeExp);
2087 }
2088
2089 // Call endBasicBlockSection on the last block now, if it wasn't already
2090 // called.
2091 if (!MF->back().isEndSection()) {
2092 for (auto &Handler : Handlers)
2093 Handler->endBasicBlockSection(MF->back());
2094 for (auto &Handler : EHHandlers)
2095 Handler->endBasicBlockSection(MF->back());
2096 }
2097 for (auto &Handler : Handlers)
2098 Handler->markFunctionEnd();
2099 for (auto &Handler : EHHandlers)
2100 Handler->markFunctionEnd();
2101 // Update the end label of the entry block's section.
2102 MBBSectionRanges[MF->front().getSectionID()].EndLabel = CurrentFnEnd;
2103
2104 // Print out jump tables referenced by the function.
2106
2107 // Emit post-function debug and/or EH information.
2108 for (auto &Handler : Handlers)
2109 Handler->endFunction(MF);
2110 for (auto &Handler : EHHandlers)
2111 Handler->endFunction(MF);
2112
2113 // Emit section containing BB address offsets and their metadata, when
2114 // BB labels are requested for this function. Skip empty functions.
2115 if (HasAnyRealCode) {
2118 else if (PgoAnalysisMapFeatures.getBits() != 0)
2120 SMLoc(), "pgo-analysis-map is enabled for function " + MF->getName() +
2121 " but it does not have labels");
2122 }
2123
2124 // Emit sections containing instruction and function PCs.
2126
2127 // Emit section containing stack size metadata.
2129
2130 // Emit .su file containing function stack size information.
2132
2134
2135 if (isVerbose())
2136 OutStreamer->getCommentOS() << "-- End function\n";
2137
2138 OutStreamer->addBlankLine();
2139}
2140
2141/// Compute the number of Global Variables that uses a Constant.
2142static unsigned getNumGlobalVariableUses(const Constant *C) {
2143 if (!C)
2144 return 0;
2145
2146 if (isa<GlobalVariable>(C))
2147 return 1;
2148
2149 unsigned NumUses = 0;
2150 for (const auto *CU : C->users())
2151 NumUses += getNumGlobalVariableUses(dyn_cast<Constant>(CU));
2152
2153 return NumUses;
2154}
2155
2156/// Only consider global GOT equivalents if at least one user is a
2157/// cstexpr inside an initializer of another global variables. Also, don't
2158/// handle cstexpr inside instructions. During global variable emission,
2159/// candidates are skipped and are emitted later in case at least one cstexpr
2160/// isn't replaced by a PC relative GOT entry access.
2162 unsigned &NumGOTEquivUsers) {
2163 // Global GOT equivalents are unnamed private globals with a constant
2164 // pointer initializer to another global symbol. They must point to a
2165 // GlobalVariable or Function, i.e., as GlobalValue.
2166 if (!GV->hasGlobalUnnamedAddr() || !GV->hasInitializer() ||
2167 !GV->isConstant() || !GV->isDiscardableIfUnused() ||
2168 !isa<GlobalValue>(GV->getOperand(0)))
2169 return false;
2170
2171 // To be a got equivalent, at least one of its users need to be a constant
2172 // expression used by another global variable.
2173 for (const auto *U : GV->users())
2174 NumGOTEquivUsers += getNumGlobalVariableUses(dyn_cast<Constant>(U));
2175
2176 return NumGOTEquivUsers > 0;
2177}
2178
2179/// Unnamed constant global variables solely contaning a pointer to
2180/// another globals variable is equivalent to a GOT table entry; it contains the
2181/// the address of another symbol. Optimize it and replace accesses to these
2182/// "GOT equivalents" by using the GOT entry for the final global instead.
2183/// Compute GOT equivalent candidates among all global variables to avoid
2184/// emitting them if possible later on, after it use is replaced by a GOT entry
2185/// access.
2187 if (!getObjFileLowering().supportIndirectSymViaGOTPCRel())
2188 return;
2189
2190 for (const auto &G : M.globals()) {
2191 unsigned NumGOTEquivUsers = 0;
2192 if (!isGOTEquivalentCandidate(&G, NumGOTEquivUsers))
2193 continue;
2194
2195 const MCSymbol *GOTEquivSym = getSymbol(&G);
2196 GlobalGOTEquivs[GOTEquivSym] = std::make_pair(&G, NumGOTEquivUsers);
2197 }
2198}
2199
2200/// Constant expressions using GOT equivalent globals may not be eligible
2201/// for PC relative GOT entry conversion, in such cases we need to emit such
2202/// globals we previously omitted in EmitGlobalVariable.
2204 if (!getObjFileLowering().supportIndirectSymViaGOTPCRel())
2205 return;
2206
2208 for (auto &I : GlobalGOTEquivs) {
2209 const GlobalVariable *GV = I.second.first;
2210 unsigned Cnt = I.second.second;
2211 if (Cnt)
2212 FailedCandidates.push_back(GV);
2213 }
2214 GlobalGOTEquivs.clear();
2215
2216 for (const auto *GV : FailedCandidates)
2218}
2219
2221 MCSymbol *Name = getSymbol(&GA);
2222 bool IsFunction = GA.getValueType()->isFunctionTy();
2223 // Treat bitcasts of functions as functions also. This is important at least
2224 // on WebAssembly where object and function addresses can't alias each other.
2225 if (!IsFunction)
2226 IsFunction = isa<Function>(GA.getAliasee()->stripPointerCasts());
2227
2228 // AIX's assembly directive `.set` is not usable for aliasing purpose,
2229 // so AIX has to use the extra-label-at-definition strategy. At this
2230 // point, all the extra label is emitted, we just have to emit linkage for
2231 // those labels.
2233 // Linkage for alias of global variable has been emitted.
2234 if (isa<GlobalVariable>(GA.getAliaseeObject()))
2235 return;
2236
2237 emitLinkage(&GA, Name);
2238 // If it's a function, also emit linkage for aliases of function entry
2239 // point.
2240 if (IsFunction)
2241 emitLinkage(&GA,
2242 getObjFileLowering().getFunctionEntryPointSymbol(&GA, TM));
2243 return;
2244 }
2245
2247 OutStreamer->emitSymbolAttribute(Name, MCSA_Global);
2248 else if (GA.hasWeakLinkage() || GA.hasLinkOnceLinkage())
2249 OutStreamer->emitSymbolAttribute(Name, MCSA_WeakReference);
2250 else
2251 assert(GA.hasLocalLinkage() && "Invalid alias linkage");
2252
2253 // Set the symbol type to function if the alias has a function type.
2254 // This affects codegen when the aliasee is not a function.
2255 if (IsFunction) {
2256 OutStreamer->emitSymbolAttribute(Name, MCSA_ELF_TypeFunction);
2258 OutStreamer->beginCOFFSymbolDef(Name);
2259 OutStreamer->emitCOFFSymbolStorageClass(
2264 OutStreamer->endCOFFSymbolDef();
2265 }
2266 }
2267
2269
2270 const MCExpr *Expr = lowerConstant(GA.getAliasee());
2271
2272 if (MAI->isMachO() && isa<MCBinaryExpr>(Expr))
2273 OutStreamer->emitSymbolAttribute(Name, MCSA_AltEntry);
2274
2275 // Emit the directives as assignments aka .set:
2276 OutStreamer->emitAssignment(Name, Expr);
2277 MCSymbol *LocalAlias = getSymbolPreferLocal(GA);
2278 if (LocalAlias != Name)
2279 OutStreamer->emitAssignment(LocalAlias, Expr);
2280
2281 // If the aliasee does not correspond to a symbol in the output, i.e. the
2282 // alias is not of an object or the aliased object is private, then set the
2283 // size of the alias symbol from the type of the alias. We don't do this in
2284 // other situations as the alias and aliasee having differing types but same
2285 // size may be intentional.
2286 const GlobalObject *BaseObject = GA.getAliaseeObject();
2288 (!BaseObject || BaseObject->hasPrivateLinkage())) {
2289 const DataLayout &DL = M.getDataLayout();
2290 uint64_t Size = DL.getTypeAllocSize(GA.getValueType());
2292 }
2293}
2294
2295void AsmPrinter::emitGlobalIFunc(Module &M, const GlobalIFunc &GI) {
2297 "IFunc is not supported on AIX.");
2298
2299 auto EmitLinkage = [&](MCSymbol *Sym) {
2301 OutStreamer->emitSymbolAttribute(Sym, MCSA_Global);
2302 else if (GI.hasWeakLinkage() || GI.hasLinkOnceLinkage())
2303 OutStreamer->emitSymbolAttribute(Sym, MCSA_WeakReference);
2304 else
2305 assert(GI.hasLocalLinkage() && "Invalid ifunc linkage");
2306 };
2307
2309 MCSymbol *Name = getSymbol(&GI);
2310 EmitLinkage(Name);
2311 OutStreamer->emitSymbolAttribute(Name, MCSA_ELF_TypeIndFunction);
2313
2314 // Emit the directives as assignments aka .set:
2315 const MCExpr *Expr = lowerConstant(GI.getResolver());
2316 OutStreamer->emitAssignment(Name, Expr);
2317 MCSymbol *LocalAlias = getSymbolPreferLocal(GI);
2318 if (LocalAlias != Name)
2319 OutStreamer->emitAssignment(LocalAlias, Expr);
2320
2321 return;
2322 }
2323
2325 llvm::report_fatal_error("IFuncs are not supported on this platform");
2326
2327 // On Darwin platforms, emit a manually-constructed .symbol_resolver that
2328 // implements the symbol resolution duties of the IFunc.
2329 //
2330 // Normally, this would be handled by linker magic, but unfortunately there
2331 // are a few limitations in ld64 and ld-prime's implementation of
2332 // .symbol_resolver that mean we can't always use them:
2333 //
2334 // * resolvers cannot be the target of an alias
2335 // * resolvers cannot have private linkage
2336 // * resolvers cannot have linkonce linkage
2337 // * resolvers cannot appear in executables
2338 // * resolvers cannot appear in bundles
2339 //
2340 // This works around that by emitting a close approximation of what the
2341 // linker would have done.
2342
2343 MCSymbol *LazyPointer =
2344 GetExternalSymbolSymbol(GI.getName() + ".lazy_pointer");
2345 MCSymbol *StubHelper = GetExternalSymbolSymbol(GI.getName() + ".stub_helper");
2346
2348
2349 const DataLayout &DL = M.getDataLayout();
2350 emitAlignment(Align(DL.getPointerSize()));
2351 OutStreamer->emitLabel(LazyPointer);
2352 emitVisibility(LazyPointer, GI.getVisibility());
2353 OutStreamer->emitValue(MCSymbolRefExpr::create(StubHelper, OutContext), 8);
2354
2356
2357 const TargetSubtargetInfo *STI =
2359 const TargetLowering *TLI = STI->getTargetLowering();
2360 Align TextAlign(TLI->getMinFunctionAlignment());
2361
2362 MCSymbol *Stub = getSymbol(&GI);
2363 EmitLinkage(Stub);
2364 OutStreamer->emitCodeAlignment(TextAlign, getIFuncMCSubtargetInfo());
2365 OutStreamer->emitLabel(Stub);
2366 emitVisibility(Stub, GI.getVisibility());
2367 emitMachOIFuncStubBody(M, GI, LazyPointer);
2368
2369 OutStreamer->emitCodeAlignment(TextAlign, getIFuncMCSubtargetInfo());
2370 OutStreamer->emitLabel(StubHelper);
2371 emitVisibility(StubHelper, GI.getVisibility());
2372 emitMachOIFuncStubHelperBody(M, GI, LazyPointer);
2373}
2374
2376 if (!RS.needsSection())
2377 return;
2378
2379 remarks::RemarkSerializer &RemarkSerializer = RS.getSerializer();
2380
2381 std::optional<SmallString<128>> Filename;
2382 if (std::optional<StringRef> FilenameRef = RS.getFilename()) {
2383 Filename = *FilenameRef;
2384 sys::fs::make_absolute(*Filename);
2385 assert(!Filename->empty() && "The filename can't be empty.");
2386 }
2387
2388 std::string Buf;
2390 std::unique_ptr<remarks::MetaSerializer> MetaSerializer =
2391 Filename ? RemarkSerializer.metaSerializer(OS, Filename->str())
2392 : RemarkSerializer.metaSerializer(OS);
2393 MetaSerializer->emit();
2394
2395 // Switch to the remarks section.
2396 MCSection *RemarksSection =
2398 OutStreamer->switchSection(RemarksSection);
2399
2400 OutStreamer->emitBinaryData(Buf);
2401}
2402
2404 Constant *Initializer = G->getInitializer();
2405 uint64_t SizeInBytes =
2406 M.getDataLayout().getTypeAllocSize(Initializer->getType());
2407
2408 uint64_t NewSize = alignTo(SizeInBytes, 16);
2409 if (SizeInBytes != NewSize) {
2410 // Pad the initializer out to the next multiple of 16 bytes.
2411 llvm::SmallVector<uint8_t> Init(NewSize - SizeInBytes, 0);
2412 Constant *Padding = ConstantDataArray::get(M.getContext(), Init);
2413 Initializer = ConstantStruct::getAnon({Initializer, Padding});
2414 auto *NewGV = new GlobalVariable(
2415 M, Initializer->getType(), G->isConstant(), G->getLinkage(),
2416 Initializer, "", G, G->getThreadLocalMode(), G->getAddressSpace());
2417 NewGV->copyAttributesFrom(G);
2418 NewGV->setComdat(G->getComdat());
2419 NewGV->copyMetadata(G, 0);
2420
2421 NewGV->takeName(G);
2422 G->replaceAllUsesWith(NewGV);
2423 G->eraseFromParent();
2424 G = NewGV;
2425 }
2426
2427 if (G->getAlign().valueOrOne() < 16)
2428 G->setAlignment(Align(16));
2429
2430 // Ensure that tagged globals don't get merged by ICF - as they should have
2431 // different tags at runtime.
2432 G->setUnnamedAddr(GlobalValue::UnnamedAddr::None);
2433}
2434
2436 // Set the MachineFunction to nullptr so that we can catch attempted
2437 // accesses to MF specific features at the module level and so that
2438 // we can conditionalize accesses based on whether or not it is nullptr.
2439 MF = nullptr;
2440
2441 std::vector<GlobalVariable *> GlobalsToTag;
2442 for (GlobalVariable &G : M.globals()) {
2443 if (G.isDeclaration() || !G.isTagged())
2444 continue;
2445 GlobalsToTag.push_back(&G);
2446 }
2447 for (GlobalVariable *G : GlobalsToTag)
2449
2450 // Gather all GOT equivalent globals in the module. We really need two
2451 // passes over the globals: one to compute and another to avoid its emission
2452 // in EmitGlobalVariable, otherwise we would not be able to handle cases
2453 // where the got equivalent shows up before its use.
2455
2456 // Emit global variables.
2457 for (const auto &G : M.globals())
2459
2460 // Emit remaining GOT equivalent globals.
2462
2464
2465 // Emit linkage(XCOFF) and visibility info for declarations
2466 for (const Function &F : M) {
2467 if (!F.isDeclarationForLinker())
2468 continue;
2469
2470 MCSymbol *Name = getSymbol(&F);
2471 // Function getSymbol gives us the function descriptor symbol for XCOFF.
2472
2474 GlobalValue::VisibilityTypes V = F.getVisibility();
2476 continue;
2477
2478 emitVisibility(Name, V, false);
2479 continue;
2480 }
2481
2482 if (F.isIntrinsic())
2483 continue;
2484
2485 // Handle the XCOFF case.
2486 // Variable `Name` is the function descriptor symbol (see above). Get the
2487 // function entry point symbol.
2488 MCSymbol *FnEntryPointSym = TLOF.getFunctionEntryPointSymbol(&F, TM);
2489 // Emit linkage for the function entry point.
2490 emitLinkage(&F, FnEntryPointSym);
2491
2492 // If a function's address is taken, which means it may be called via a
2493 // function pointer, we need the function descriptor for it.
2494 if (F.hasAddressTaken())
2495 emitLinkage(&F, Name);
2496 }
2497
2498 // Emit the remarks section contents.
2499 // FIXME: Figure out when is the safest time to emit this section. It should
2500 // not come after debug info.
2501 if (remarks::RemarkStreamer *RS = M.getContext().getMainRemarkStreamer())
2502 emitRemarksSection(*RS);
2503
2505
2508
2509 // Output stubs for external and common global variables.
2511 if (!Stubs.empty()) {
2512 OutStreamer->switchSection(TLOF.getDataSection());
2513 const DataLayout &DL = M.getDataLayout();
2514
2515 emitAlignment(Align(DL.getPointerSize()));
2516 for (const auto &Stub : Stubs) {
2517 OutStreamer->emitLabel(Stub.first);
2518 OutStreamer->emitSymbolValue(Stub.second.getPointer(),
2519 DL.getPointerSize());
2520 }
2521 }
2522 }
2523
2525 MachineModuleInfoCOFF &MMICOFF =
2527
2528 // Output stubs for external and common global variables.
2530 if (!Stubs.empty()) {
2531 const DataLayout &DL = M.getDataLayout();
2532
2533 for (const auto &Stub : Stubs) {
2535 SectionName += Stub.first->getName();
2536 OutStreamer->switchSection(OutContext.getCOFFSection(
2540 Stub.first->getName(), COFF::IMAGE_COMDAT_SELECT_ANY));
2541 emitAlignment(Align(DL.getPointerSize()));
2542 OutStreamer->emitSymbolAttribute(Stub.first, MCSA_Global);
2543 OutStreamer->emitLabel(Stub.first);
2544 OutStreamer->emitSymbolValue(Stub.second.getPointer(),
2545 DL.getPointerSize());
2546 }
2547 }
2548 }
2549
2550 // This needs to happen before emitting debug information since that can end
2551 // arbitrary sections.
2552 if (auto *TS = OutStreamer->getTargetStreamer())
2553 TS->emitConstantPools();
2554
2555 // Emit Stack maps before any debug info. Mach-O requires that no data or
2556 // text sections come after debug info has been emitted. This matters for
2557 // stack maps as they are arbitrary data, and may even have a custom format
2558 // through user plugins.
2559 emitStackMaps();
2560
2561 // Print aliases in topological order, that is, for each alias a = b,
2562 // b must be printed before a.
2563 // This is because on some targets (e.g. PowerPC) linker expects aliases in
2564 // such an order to generate correct TOC information.
2567 for (const auto &Alias : M.aliases()) {
2568 if (Alias.hasAvailableExternallyLinkage())
2569 continue;
2570 for (const GlobalAlias *Cur = &Alias; Cur;
2571 Cur = dyn_cast<GlobalAlias>(Cur->getAliasee())) {
2572 if (!AliasVisited.insert(Cur).second)
2573 break;
2574 AliasStack.push_back(Cur);
2575 }
2576 for (const GlobalAlias *AncestorAlias : llvm::reverse(AliasStack))
2577 emitGlobalAlias(M, *AncestorAlias);
2578 AliasStack.clear();
2579 }
2580
2581 // IFuncs must come before deubginfo in case the backend decides to emit them
2582 // as actual functions, since on Mach-O targets, we cannot create regular
2583 // sections after DWARF.
2584 for (const auto &IFunc : M.ifuncs())
2585 emitGlobalIFunc(M, IFunc);
2586
2587 // Finalize debug and EH information.
2588 for (auto &Handler : Handlers)
2589 Handler->endModule();
2590 for (auto &Handler : EHHandlers)
2591 Handler->endModule();
2592
2593 // This deletes all the ephemeral handlers that AsmPrinter added, while
2594 // keeping all the user-added handlers alive until the AsmPrinter is
2595 // destroyed.
2596 EHHandlers.clear();
2597 Handlers.erase(Handlers.begin() + NumUserHandlers, Handlers.end());
2598 DD = nullptr;
2599
2600 // If the target wants to know about weak references, print them all.
2601 if (MAI->getWeakRefDirective()) {
2602 // FIXME: This is not lazy, it would be nice to only print weak references
2603 // to stuff that is actually used. Note that doing so would require targets
2604 // to notice uses in operands (due to constant exprs etc). This should
2605 // happen with the MC stuff eventually.
2606
2607 // Print out module-level global objects here.
2608 for (const auto &GO : M.global_objects()) {
2609 if (!GO.hasExternalWeakLinkage())
2610 continue;
2611 OutStreamer->emitSymbolAttribute(getSymbol(&GO), MCSA_WeakReference);
2612 }
2614 auto SymbolName = "swift_async_extendedFramePointerFlags";
2615 auto Global = M.getGlobalVariable(SymbolName);
2616 if (!Global) {
2617 auto PtrTy = PointerType::getUnqual(M.getContext());
2618 Global = new GlobalVariable(M, PtrTy, false,
2620 SymbolName);
2621 OutStreamer->emitSymbolAttribute(getSymbol(Global), MCSA_WeakReference);
2622 }
2623 }
2624 }
2625
2626 GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>();
2627 assert(MI && "AsmPrinter didn't require GCModuleInfo?");
2628 for (GCModuleInfo::iterator I = MI->end(), E = MI->begin(); I != E; )
2629 if (GCMetadataPrinter *MP = getOrCreateGCPrinter(**--I))
2630 MP->finishAssembly(M, *MI, *this);
2631
2632 // Emit llvm.ident metadata in an '.ident' directive.
2633 emitModuleIdents(M);
2634
2635 // Emit bytes for llvm.commandline metadata.
2636 // The command line metadata is emitted earlier on XCOFF.
2638 emitModuleCommandLines(M);
2639
2640 // Emit .note.GNU-split-stack and .note.GNU-no-split-stack sections if
2641 // split-stack is used.
2642 if (TM.getTargetTriple().isOSBinFormatELF() && HasSplitStack) {
2643 OutStreamer->switchSection(OutContext.getELFSection(".note.GNU-split-stack",
2644 ELF::SHT_PROGBITS, 0));
2645 if (HasNoSplitStack)
2646 OutStreamer->switchSection(OutContext.getELFSection(
2647 ".note.GNU-no-split-stack", ELF::SHT_PROGBITS, 0));
2648 }
2649
2650 // If we don't have any trampolines, then we don't require stack memory
2651 // to be executable. Some targets have a directive to declare this.
2652 Function *InitTrampolineIntrinsic = M.getFunction("llvm.init.trampoline");
2653 if (!InitTrampolineIntrinsic || InitTrampolineIntrinsic->use_empty())
2655 OutStreamer->switchSection(S);
2656
2657 if (TM.Options.EmitAddrsig) {
2658 // Emit address-significance attributes for all globals.
2659 OutStreamer->emitAddrsig();
2660 for (const GlobalValue &GV : M.global_values()) {
2661 if (!GV.use_empty() && !GV.isThreadLocal() &&
2662 !GV.hasDLLImportStorageClass() &&
2663 !GV.getName().starts_with("llvm.") &&
2664 !GV.hasAtLeastLocalUnnamedAddr())
2665 OutStreamer->emitAddrsigSym(getSymbol(&GV));
2666 }
2667 }
2668
2669 // Emit symbol partition specifications (ELF only).
2671 unsigned UniqueID = 0;
2672 for (const GlobalValue &GV : M.global_values()) {
2673 if (!GV.hasPartition() || GV.isDeclarationForLinker() ||
2674 GV.getVisibility() != GlobalValue::DefaultVisibility)
2675 continue;
2676
2677 OutStreamer->switchSection(
2678 OutContext.getELFSection(".llvm_sympart", ELF::SHT_LLVM_SYMPART, 0, 0,
2679 "", false, ++UniqueID, nullptr));
2680 OutStreamer->emitBytes(GV.getPartition());
2681 OutStreamer->emitZeros(1);
2682 OutStreamer->emitValue(
2685 }
2686 }
2687
2688 // Allow the target to emit any magic that it wants at the end of the file,
2689 // after everything else has gone out.
2691
2692 MMI = nullptr;
2693 AddrLabelSymbols = nullptr;
2694
2695 OutStreamer->finish();
2696 OutStreamer->reset();
2697 OwnedMLI.reset();
2698 OwnedMDT.reset();
2699
2700 return false;
2701}
2702
2704 auto Res = MBBSectionExceptionSyms.try_emplace(MBB.getSectionID());
2705 if (Res.second)
2706 Res.first->second = createTempSymbol("exception");
2707 return Res.first->second;
2708}
2709
2711 this->MF = &MF;
2712 const Function &F = MF.getFunction();
2713
2714 // Record that there are split-stack functions, so we will emit a special
2715 // section to tell the linker.
2716 if (MF.shouldSplitStack()) {
2717 HasSplitStack = true;
2718
2720 HasNoSplitStack = true;
2721 } else
2722 HasNoSplitStack = true;
2723
2724 // Get the function symbol.
2725 if (!MAI->isAIX()) {
2727 } else {
2729 "Only AIX uses the function descriptor hooks.");
2730 // AIX is unique here in that the name of the symbol emitted for the
2731 // function body does not have the same name as the source function's
2732 // C-linkage name.
2733 assert(CurrentFnDescSym && "The function descriptor symbol needs to be"
2734 " initalized first.");
2735
2736 // Get the function entry point symbol.
2738 }
2739
2741 CurrentFnBegin = nullptr;
2742 CurrentFnBeginLocal = nullptr;
2743 CurrentSectionBeginSym = nullptr;
2744 MBBSectionRanges.clear();
2745 MBBSectionExceptionSyms.clear();
2746 bool NeedsLocalForSize = MAI->needsLocalForSize();
2747 if (F.hasFnAttribute("patchable-function-entry") ||
2748 F.hasFnAttribute("function-instrument") ||
2749 F.hasFnAttribute("xray-instruction-threshold") ||
2750 needFuncLabels(MF, *this) || NeedsLocalForSize ||
2753 CurrentFnBegin = createTempSymbol("func_begin");
2754 if (NeedsLocalForSize)
2756 }
2757
2758 ORE = &getAnalysis<MachineOptimizationRemarkEmitterPass>().getORE();
2759}
2760
2761namespace {
2762
2763// Keep track the alignment, constpool entries per Section.
2764 struct SectionCPs {
2765 MCSection *S;
2766 Align Alignment;
2768
2769 SectionCPs(MCSection *s, Align a) : S(s), Alignment(a) {}
2770 };
2771
2772} // end anonymous namespace
2773
2774/// EmitConstantPool - Print to the current output stream assembly
2775/// representations of the constants in the constant pool MCP. This is
2776/// used to print out constants which have been "spilled to memory" by
2777/// the code generator.
2779 const MachineConstantPool *MCP = MF->getConstantPool();
2780 const std::vector<MachineConstantPoolEntry> &CP = MCP->getConstants();
2781 if (CP.empty()) return;
2782
2783 // Calculate sections for constant pool entries. We collect entries to go into
2784 // the same section together to reduce amount of section switch statements.
2785 SmallVector<SectionCPs, 4> CPSections;
2786 for (unsigned i = 0, e = CP.size(); i != e; ++i) {
2787 const MachineConstantPoolEntry &CPE = CP[i];
2788 Align Alignment = CPE.getAlign();
2789
2791
2792 const Constant *C = nullptr;
2793 if (!CPE.isMachineConstantPoolEntry())
2794 C = CPE.Val.ConstVal;
2795
2797 getDataLayout(), Kind, C, Alignment);
2798
2799 // The number of sections are small, just do a linear search from the
2800 // last section to the first.
2801 bool Found = false;
2802 unsigned SecIdx = CPSections.size();
2803 while (SecIdx != 0) {
2804 if (CPSections[--SecIdx].S == S) {
2805 Found = true;
2806 break;
2807 }
2808 }
2809 if (!Found) {
2810 SecIdx = CPSections.size();
2811 CPSections.push_back(SectionCPs(S, Alignment));
2812 }
2813
2814 if (Alignment > CPSections[SecIdx].Alignment)
2815 CPSections[SecIdx].Alignment = Alignment;
2816 CPSections[SecIdx].CPEs.push_back(i);
2817 }
2818
2819 // Now print stuff into the calculated sections.
2820 const MCSection *CurSection = nullptr;
2821 unsigned Offset = 0;
2822 for (unsigned i = 0, e = CPSections.size(); i != e; ++i) {
2823 for (unsigned j = 0, ee = CPSections[i].CPEs.size(); j != ee; ++j) {
2824 unsigned CPI = CPSections[i].CPEs[j];
2825 MCSymbol *Sym = GetCPISymbol(CPI);
2826 if (!Sym->isUndefined())
2827 continue;
2828
2829 if (CurSection != CPSections[i].S) {
2830 OutStreamer->switchSection(CPSections[i].S);
2831 emitAlignment(Align(CPSections[i].Alignment));
2832 CurSection = CPSections[i].S;
2833 Offset = 0;
2834 }
2835
2836 MachineConstantPoolEntry CPE = CP[CPI];
2837
2838 // Emit inter-object padding for alignment.
2839 unsigned NewOffset = alignTo(Offset, CPE.getAlign());
2840 OutStreamer->emitZeros(NewOffset - Offset);
2841
2842 Offset = NewOffset + CPE.getSizeInBytes(getDataLayout());
2843
2844 OutStreamer->emitLabel(Sym);
2847 else
2849 }
2850 }
2851}
2852
2853// Print assembly representations of the jump tables used by the current
2854// function.
2856 const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo();
2857 if (!MJTI) return;
2858 if (MJTI->getEntryKind() == MachineJumpTableInfo::EK_Inline) return;
2859 const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
2860 if (JT.empty()) return;
2861
2862 // Pick the directive to use to print the jump table entries, and switch to
2863 // the appropriate section.
2864 const Function &F = MF->getFunction();
2866 bool JTInDiffSection = !TLOF.shouldPutJumpTableInFunctionSection(
2869 F);
2870
2871 SmallVector<unsigned> JumpTableIndices;
2872 for (unsigned JTI = 0, JTSize = JT.size(); JTI < JTSize; ++JTI) {
2873 JumpTableIndices.push_back(JTI);
2874 }
2875 emitJumpTableImpl(*MJTI, JumpTableIndices, JTInDiffSection);
2876}
2877
2878void AsmPrinter::emitJumpTableImpl(const MachineJumpTableInfo &MJTI,
2879 ArrayRef<unsigned> JumpTableIndices,
2880 bool JTInDiffSection) {
2881 if (JumpTableIndices.empty())
2882 return;
2883
2885 const Function &F = MF->getFunction();
2886 const std::vector<MachineJumpTableEntry> &JT = MJTI.getJumpTables();
2887 MCSection *JumpTableSection = TLOF.getSectionForJumpTable(F, TM);
2888
2889 const DataLayout &DL = MF->getDataLayout();
2890 if (JTInDiffSection) {
2891 OutStreamer->switchSection(JumpTableSection);
2892 }
2893
2895
2896 // Jump tables in code sections are marked with a data_region directive
2897 // where that's supported.
2898 if (!JTInDiffSection)
2899 OutStreamer->emitDataRegion(MCDR_DataRegionJT32);
2900
2901 for (const unsigned JumpTableIndex : JumpTableIndices) {
2902 ArrayRef<MachineBasicBlock *> JTBBs = JT[JumpTableIndex].MBBs;
2903
2904 // If this jump table was deleted, ignore it.
2905 if (JTBBs.empty())
2906 continue;
2907
2908 // For the EK_LabelDifference32 entry, if using .set avoids a relocation,
2909 /// emit a .set directive for each unique entry.
2914 const MCExpr *Base =
2915 TLI->getPICJumpTableRelocBaseExpr(MF, JumpTableIndex, OutContext);
2916 for (const MachineBasicBlock *MBB : JTBBs) {
2917 if (!EmittedSets.insert(MBB).second)
2918 continue;
2919
2920 // .set LJTSet, LBB32-base
2921 const MCExpr *LHS =
2923 OutStreamer->emitAssignment(
2924 GetJTSetSymbol(JumpTableIndex, MBB->getNumber()),
2926 }
2927 }
2928
2929 // On some targets (e.g. Darwin) we want to emit two consecutive labels
2930 // before each jump table. The first label is never referenced, but tells
2931 // the assembler and linker the extents of the jump table object. The
2932 // second label is actually referenced by the code.
2933 if (JTInDiffSection && DL.hasLinkerPrivateGlobalPrefix())
2934 // FIXME: This doesn't have to have any specific name, just any randomly
2935 // named and numbered local label started with 'l' would work. Simplify
2936 // GetJTISymbol.
2937 OutStreamer->emitLabel(GetJTISymbol(JumpTableIndex, true));
2938
2939 MCSymbol *JTISymbol = GetJTISymbol(JumpTableIndex);
2940 OutStreamer->emitLabel(JTISymbol);
2941
2942 // Defer MCAssembler based constant folding due to a performance issue. The
2943 // label differences will be evaluated at write time.
2944 for (const MachineBasicBlock *MBB : JTBBs)
2945 emitJumpTableEntry(MJTI, MBB, JumpTableIndex);
2946 }
2947
2949 emitJumpTableSizesSection(MJTI, MF->getFunction());
2950
2951 if (!JTInDiffSection)
2952 OutStreamer->emitDataRegion(MCDR_DataRegionEnd);
2953}
2954
2955void AsmPrinter::emitJumpTableSizesSection(const MachineJumpTableInfo &MJTI,
2956 const Function &F) const {
2957 const std::vector<MachineJumpTableEntry> &JT = MJTI.getJumpTables();
2958
2959 if (JT.empty())
2960 return;
2961
2962 StringRef GroupName = F.hasComdat() ? F.getComdat()->getName() : "";
2963 MCSection *JumpTableSizesSection = nullptr;
2964 StringRef sectionName = ".llvm_jump_table_sizes";
2965
2966 bool isElf = TM.getTargetTriple().isOSBinFormatELF();
2967 bool isCoff = TM.getTargetTriple().isOSBinFormatCOFF();
2968
2969 if (!isCoff && !isElf)
2970 return;
2971
2972 if (isElf) {
2973 MCSymbolELF *LinkedToSym = dyn_cast<MCSymbolELF>(CurrentFnSym);
2974 int Flags = F.hasComdat() ? static_cast<int>(ELF::SHF_GROUP) : 0;
2975
2976 JumpTableSizesSection = OutContext.getELFSection(
2977 sectionName, ELF::SHT_LLVM_JT_SIZES, Flags, 0, GroupName, F.hasComdat(),
2978 MCSection::NonUniqueID, LinkedToSym);
2979 } else if (isCoff) {
2980 if (F.hasComdat()) {
2981 JumpTableSizesSection = OutContext.getCOFFSection(
2982 sectionName,
2985 F.getComdat()->getName(), COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE);
2986 } else {
2987 JumpTableSizesSection = OutContext.getCOFFSection(
2991 }
2992 }
2993
2994 OutStreamer->switchSection(JumpTableSizesSection);
2995
2996 for (unsigned JTI = 0, E = JT.size(); JTI != E; ++JTI) {
2997 const std::vector<MachineBasicBlock *> &JTBBs = JT[JTI].MBBs;
2998 OutStreamer->emitSymbolValue(GetJTISymbol(JTI), TM.getProgramPointerSize());
2999 OutStreamer->emitIntValue(JTBBs.size(), TM.getProgramPointerSize());
3000 }
3001}
3002
3003/// EmitJumpTableEntry - Emit a jump table entry for the specified MBB to the
3004/// current stream.
3005void AsmPrinter::emitJumpTableEntry(const MachineJumpTableInfo &MJTI,
3006 const MachineBasicBlock *MBB,
3007 unsigned UID) const {
3008 assert(MBB && MBB->getNumber() >= 0 && "Invalid basic block");
3009 const MCExpr *Value = nullptr;
3010 switch (MJTI.getEntryKind()) {
3012 llvm_unreachable("Cannot emit EK_Inline jump table entry");
3015 &MJTI, MBB, UID, OutContext);
3016 break;
3018 // EK_BlockAddress - Each entry is a plain address of block, e.g.:
3019 // .word LBB123
3021 break;
3023 // EK_GPRel32BlockAddress - Each entry is an address of block, encoded
3024 // with a relocation as gp-relative, e.g.:
3025 // .gprel32 LBB123
3026 MCSymbol *MBBSym = MBB->getSymbol();
3027 OutStreamer->emitGPRel32Value(MCSymbolRefExpr::create(MBBSym, OutContext));
3028 return;
3029 }
3030
3032 // EK_GPRel64BlockAddress - Each entry is an address of block, encoded
3033 // with a relocation as gp-relative, e.g.:
3034 // .gpdword LBB123
3035 MCSymbol *MBBSym = MBB->getSymbol();
3036 OutStreamer->emitGPRel64Value(MCSymbolRefExpr::create(MBBSym, OutContext));
3037 return;
3038 }
3039
3042 // Each entry is the address of the block minus the address of the jump
3043 // table. This is used for PIC jump tables where gprel32 is not supported.
3044 // e.g.:
3045 // .word LBB123 - LJTI1_2
3046 // If the .set directive avoids relocations, this is emitted as:
3047 // .set L4_5_set_123, LBB123 - LJTI1_2
3048 // .word L4_5_set_123
3052 OutContext);
3053 break;
3054 }
3059 break;
3060 }
3061 }
3062
3063 assert(Value && "Unknown entry kind!");
3064
3065 unsigned EntrySize = MJTI.getEntrySize(getDataLayout());
3066 OutStreamer->emitValue(Value, EntrySize);
3067}
3068
3069/// EmitSpecialLLVMGlobal - Check to see if the specified global is a
3070/// special global used by LLVM. If so, emit it and return true, otherwise
3071/// do nothing and return false.
3073 if (GV->getName() == "llvm.used") {
3074 if (MAI->hasNoDeadStrip()) // No need to emit this at all.
3075 emitLLVMUsedList(cast<ConstantArray>(GV->getInitializer()));
3076 return true;
3077 }
3078
3079 // Ignore debug and non-emitted data. This handles llvm.compiler.used.
3080 if (GV->getSection() == "llvm.metadata" ||
3082 return true;
3083
3084 if (GV->getName() == "llvm.arm64ec.symbolmap") {
3085 // For ARM64EC, print the table that maps between symbols and the
3086 // corresponding thunks to translate between x64 and AArch64 code.
3087 // This table is generated by AArch64Arm64ECCallLowering.
3088 OutStreamer->switchSection(
3090 auto *Arr = cast<ConstantArray>(GV->getInitializer());
3091 for (auto &U : Arr->operands()) {
3092 auto *C = cast<Constant>(U);
3093 auto *Src = cast<GlobalValue>(C->getOperand(0)->stripPointerCasts());
3094 auto *Dst = cast<GlobalValue>(C->getOperand(1)->stripPointerCasts());
3095 int Kind = cast<ConstantInt>(C->getOperand(2))->getZExtValue();
3096
3097 if (Src->hasDLLImportStorageClass()) {
3098 // For now, we assume dllimport functions aren't directly called.
3099 // (We might change this later to match MSVC.)
3100 OutStreamer->emitCOFFSymbolIndex(
3101 OutContext.getOrCreateSymbol("__imp_" + Src->getName()));
3102 OutStreamer->emitCOFFSymbolIndex(getSymbol(Dst));
3103 OutStreamer->emitInt32(Kind);
3104 } else {
3105 // FIXME: For non-dllimport functions, MSVC emits the same entry
3106 // twice, for reasons I don't understand. I have to assume the linker
3107 // ignores the redundant entry; there aren't any reasonable semantics
3108 // to attach to it.
3109 OutStreamer->emitCOFFSymbolIndex(getSymbol(Src));
3110 OutStreamer->emitCOFFSymbolIndex(getSymbol(Dst));
3111 OutStreamer->emitInt32(Kind);
3112 }
3113 }
3114 return true;
3115 }
3116
3117 if (!GV->hasAppendingLinkage()) return false;
3118
3119 assert(GV->hasInitializer() && "Not a special LLVM global!");
3120
3121 if (GV->getName() == "llvm.global_ctors") {
3123 /* isCtor */ true);
3124
3125 return true;
3126 }
3127
3128 if (GV->getName() == "llvm.global_dtors") {
3130 /* isCtor */ false);
3131
3132 return true;
3133 }
3134
3135 report_fatal_error("unknown special variable with appending linkage");
3136}
3137
3138/// EmitLLVMUsedList - For targets that define a MAI::UsedDirective, mark each
3139/// global in the specified llvm.used list.
3140void AsmPrinter::emitLLVMUsedList(const ConstantArray *InitList) {
3141 // Should be an array of 'i8*'.
3142 for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) {
3143 const GlobalValue *GV =
3144 dyn_cast<GlobalValue>(InitList->getOperand(i)->stripPointerCasts());
3145 if (GV)
3146 OutStreamer->emitSymbolAttribute(getSymbol(GV), MCSA_NoDeadStrip);
3147 }
3148}
3149
3151 const Constant *List,
3152 SmallVector<Structor, 8> &Structors) {
3153 // Should be an array of '{ i32, void ()*, i8* }' structs. The first value is
3154 // the init priority.
3155 if (!isa<ConstantArray>(List))
3156 return;
3157
3158 // Gather the structors in a form that's convenient for sorting by priority.
3159 for (Value *O : cast<ConstantArray>(List)->operands()) {
3160 auto *CS = cast<ConstantStruct>(O);
3161 if (CS->getOperand(1)->isNullValue())
3162 break; // Found a null terminator, skip the rest.
3163 ConstantInt *Priority = dyn_cast<ConstantInt>(CS->getOperand(0));
3164 if (!Priority)
3165 continue; // Malformed.
3166 Structors.push_back(Structor());
3167 Structor &S = Structors.back();
3168 S.Priority = Priority->getLimitedValue(65535);
3169 S.Func = CS->getOperand(1);
3170 if (!CS->getOperand(2)->isNullValue()) {
3171 if (TM.getTargetTriple().isOSAIX())
3173 "associated data of XXStructor list is not yet supported on AIX");
3174 S.ComdatKey =
3175 dyn_cast<GlobalValue>(CS->getOperand(2)->stripPointerCasts());
3176 }
3177 }
3178
3179 // Emit the function pointers in the target-specific order
3180 llvm::stable_sort(Structors, [](const Structor &L, const Structor &R) {
3181 return L.Priority < R.Priority;
3182 });
3183}
3184
3185/// EmitXXStructorList - Emit the ctor or dtor list taking into account the init
3186/// priority.
3188 bool IsCtor) {
3189 SmallVector<Structor, 8> Structors;
3190 preprocessXXStructorList(DL, List, Structors);
3191 if (Structors.empty())
3192 return;
3193
3194 // Emit the structors in reverse order if we are using the .ctor/.dtor
3195 // initialization scheme.
3196 if (!TM.Options.UseInitArray)
3197 std::reverse(Structors.begin(), Structors.end());
3198
3199 const Align Align = DL.getPointerPrefAlignment();
3200 for (Structor &S : Structors) {
3202 const MCSymbol *KeySym = nullptr;
3203 if (GlobalValue *GV = S.ComdatKey) {
3204 if (GV->isDeclarationForLinker())
3205 // If the associated variable is not defined in this module
3206 // (it might be available_externally, or have been an
3207 // available_externally definition that was dropped by the
3208 // EliminateAvailableExternally pass), some other TU
3209 // will provide its dynamic initializer.
3210 continue;
3211
3212 KeySym = getSymbol(GV);
3213 }
3214
3215 MCSection *OutputSection =
3216 (IsCtor ? Obj.getStaticCtorSection(S.Priority, KeySym)
3217 : Obj.getStaticDtorSection(S.Priority, KeySym));
3218 OutStreamer->switchSection(OutputSection);
3219 if (OutStreamer->getCurrentSection() != OutStreamer->getPreviousSection())
3221 emitXXStructor(DL, S.Func);
3222 }
3223}
3224
3225void AsmPrinter::emitModuleIdents(Module &M) {
3226 if (!MAI->hasIdentDirective())
3227 return;
3228
3229 if (const NamedMDNode *NMD = M.getNamedMetadata("llvm.ident")) {
3230 for (const MDNode *N : NMD->operands()) {
3231 assert(N->getNumOperands() == 1 &&
3232 "llvm.ident metadata entry can have only one operand");
3233 const MDString *S = cast<MDString>(N->getOperand(0));
3234 OutStreamer->emitIdent(S->getString());
3235 }
3236 }
3237}
3238
3239void AsmPrinter::emitModuleCommandLines(Module &M) {
3241 if (!CommandLine)
3242 return;
3243
3244 const NamedMDNode *NMD = M.getNamedMetadata("llvm.commandline");
3245 if (!NMD || !NMD->getNumOperands())
3246 return;
3247
3248 OutStreamer->pushSection();
3249 OutStreamer->switchSection(CommandLine);
3250 OutStreamer->emitZeros(1);
3251 for (const MDNode *N : NMD->operands()) {
3252 assert(N->getNumOperands() == 1 &&
3253 "llvm.commandline metadata entry can have only one operand");
3254 const MDString *S = cast<MDString>(N->getOperand(0));
3255 OutStreamer->emitBytes(S->getString());
3256 OutStreamer->emitZeros(1);
3257 }
3258 OutStreamer->popSection();
3259}
3260
3261//===--------------------------------------------------------------------===//
3262// Emission and print routines
3263//
3264
3265/// Emit a byte directive and value.
3266///
3267void AsmPrinter::emitInt8(int Value) const { OutStreamer->emitInt8(Value); }
3268
3269/// Emit a short directive and value.
3270void AsmPrinter::emitInt16(int Value) const { OutStreamer->emitInt16(Value); }
3271
3272/// Emit a long directive and value.
3273void AsmPrinter::emitInt32(int Value) const { OutStreamer->emitInt32(Value); }
3274
3275/// EmitSLEB128 - emit the specified signed leb128 value.
3276void AsmPrinter::emitSLEB128(int64_t Value, const char *Desc) const {
3277 if (isVerbose() && Desc)
3278 OutStreamer->AddComment(Desc);
3279
3280 OutStreamer->emitSLEB128IntValue(Value);
3281}
3282
3284 unsigned PadTo) const {
3285 if (isVerbose() && Desc)
3286 OutStreamer->AddComment(Desc);
3287
3288 OutStreamer->emitULEB128IntValue(Value, PadTo);
3289}
3290
3291/// Emit a long long directive and value.
3293 OutStreamer->emitInt64(Value);
3294}
3295
3296/// Emit something like ".long Hi-Lo" where the size in bytes of the directive
3297/// is specified by Size and Hi/Lo specify the labels. This implicitly uses
3298/// .set if it avoids relocations.
3300 unsigned Size) const {
3301 OutStreamer->emitAbsoluteSymbolDiff(Hi, Lo, Size);
3302}
3303
3304/// Emit something like ".uleb128 Hi-Lo".
3306 const MCSymbol *Lo) const {
3307 OutStreamer->emitAbsoluteSymbolDiffAsULEB128(Hi, Lo);
3308}
3309
3310/// EmitLabelPlusOffset - Emit something like ".long Label+Offset"
3311/// where the size in bytes of the directive is specified by Size and Label
3312/// specifies the label. This implicitly uses .set if it is available.
3314 unsigned Size,
3315 bool IsSectionRelative) const {
3316 if (MAI->needsDwarfSectionOffsetDirective() && IsSectionRelative) {
3317 OutStreamer->emitCOFFSecRel32(Label, Offset);
3318 if (Size > 4)
3319 OutStreamer->emitZeros(Size - 4);
3320 return;
3321 }
3322
3323 // Emit Label+Offset (or just Label if Offset is zero)
3324 const MCExpr *Expr = MCSymbolRefExpr::create(Label, OutContext);
3325 if (Offset)
3328
3329 OutStreamer->emitValue(Expr, Size);
3330}
3331
3332//===----------------------------------------------------------------------===//
3333
3334// EmitAlignment - Emit an alignment directive to the specified power of
3335// two boundary. If a global value is specified, and if that global has
3336// an explicit alignment requested, it will override the alignment request
3337// if required for correctness.
3339 unsigned MaxBytesToEmit) const {
3340 if (GV)
3341 Alignment = getGVAlignment(GV, GV->getDataLayout(), Alignment);
3342
3343 if (Alignment == Align(1))
3344 return; // 1-byte aligned: no need to emit alignment.
3345
3346 if (getCurrentSection()->isText()) {
3347 const MCSubtargetInfo *STI = nullptr;
3348 if (this->MF)
3349 STI = &getSubtargetInfo();
3350 else
3351 STI = TM.getMCSubtargetInfo();
3352 OutStreamer->emitCodeAlignment(Alignment, STI, MaxBytesToEmit);
3353 } else
3354 OutStreamer->emitValueToAlignment(Alignment, 0, 1, MaxBytesToEmit);
3355}
3356
3357//===----------------------------------------------------------------------===//
3358// Constant emission.
3359//===----------------------------------------------------------------------===//
3360
3362 MCContext &Ctx = OutContext;
3363
3364 if (CV->isNullValue() || isa<UndefValue>(CV))
3365 return MCConstantExpr::create(0, Ctx);
3366
3367 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV))
3368 return MCConstantExpr::create(CI->getZExtValue(), Ctx);
3369
3370 if (const ConstantPtrAuth *CPA = dyn_cast<ConstantPtrAuth>(CV))
3371 return lowerConstantPtrAuth(*CPA);
3372
3373 if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV))
3374 return MCSymbolRefExpr::create(getSymbol(GV), Ctx);
3375
3376 if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV))
3377 return lowerBlockAddressConstant(*BA);
3378
3379 if (const auto *Equiv = dyn_cast<DSOLocalEquivalent>(CV))
3381
3382 if (const NoCFIValue *NC = dyn_cast<NoCFIValue>(CV))
3383 return MCSymbolRefExpr::create(getSymbol(NC->getGlobalValue()), Ctx);
3384
3385 const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV);
3386 if (!CE) {
3387 llvm_unreachable("Unknown constant value to lower!");
3388 }
3389
3390 // The constant expression opcodes are limited to those that are necessary
3391 // to represent relocations on supported targets. Expressions involving only
3392 // constant addresses are constant folded instead.
3393 switch (CE->getOpcode()) {
3394 default:
3395 break; // Error
3396 case Instruction::AddrSpaceCast: {
3397 const Constant *Op = CE->getOperand(0);
3398 unsigned DstAS = CE->getType()->getPointerAddressSpace();
3399 unsigned SrcAS = Op->getType()->getPointerAddressSpace();
3400 if (TM.isNoopAddrSpaceCast(SrcAS, DstAS))
3401 return lowerConstant(Op);
3402
3403 break; // Error
3404 }
3405 case Instruction::GetElementPtr: {
3406 // Generate a symbolic expression for the byte address
3407 APInt OffsetAI(getDataLayout().getPointerTypeSizeInBits(CE->getType()), 0);
3408 cast<GEPOperator>(CE)->accumulateConstantOffset(getDataLayout(), OffsetAI);
3409
3410 const MCExpr *Base = lowerConstant(CE->getOperand(0));
3411 if (!OffsetAI)
3412 return Base;
3413
3414 int64_t Offset = OffsetAI.getSExtValue();
3416 Ctx);
3417 }
3418
3419 case Instruction::Trunc:
3420 // We emit the value and depend on the assembler to truncate the generated
3421 // expression properly. This is important for differences between
3422 // blockaddress labels. Since the two labels are in the same function, it
3423 // is reasonable to treat their delta as a 32-bit value.
3424 [[fallthrough]];
3425 case Instruction::BitCast:
3426 return lowerConstant(CE->getOperand(0));
3427
3428 case Instruction::IntToPtr: {
3429 const DataLayout &DL = getDataLayout();
3430
3431 // Handle casts to pointers by changing them into casts to the appropriate
3432 // integer type. This promotes constant folding and simplifies this code.
3433 Constant *Op = CE->getOperand(0);
3434 Op = ConstantFoldIntegerCast(Op, DL.getIntPtrType(CV->getType()),
3435 /*IsSigned*/ false, DL);
3436 if (Op)
3437 return lowerConstant(Op);
3438
3439 break; // Error
3440 }
3441
3442 case Instruction::PtrToInt: {
3443 const DataLayout &DL = getDataLayout();
3444
3445 // Support only foldable casts to/from pointers that can be eliminated by
3446 // changing the pointer to the appropriately sized integer type.
3447 Constant *Op = CE->getOperand(0);
3448 Type *Ty = CE->getType();
3449
3450 const MCExpr *OpExpr = lowerConstant(Op);
3451
3452 // We can emit the pointer value into this slot if the slot is an
3453 // integer slot equal to the size of the pointer.
3454 //
3455 // If the pointer is larger than the resultant integer, then
3456 // as with Trunc just depend on the assembler to truncate it.
3457 if (DL.getTypeAllocSize(Ty).getFixedValue() <=
3458 DL.getTypeAllocSize(Op->getType()).getFixedValue())
3459 return OpExpr;
3460
3461 break; // Error
3462 }
3463
3464 case Instruction::Sub: {
3465 GlobalValue *LHSGV;
3466 APInt LHSOffset;
3467 DSOLocalEquivalent *DSOEquiv;
3468 if (IsConstantOffsetFromGlobal(CE->getOperand(0), LHSGV, LHSOffset,
3469 getDataLayout(), &DSOEquiv)) {
3470 GlobalValue *RHSGV;
3471 APInt RHSOffset;
3472 if (IsConstantOffsetFromGlobal(CE->getOperand(1), RHSGV, RHSOffset,
3473 getDataLayout())) {
3474 const MCExpr *RelocExpr =
3476 if (!RelocExpr) {
3477 const MCExpr *LHSExpr =
3479 if (DSOEquiv &&
3480 getObjFileLowering().supportDSOLocalEquivalentLowering())
3481 LHSExpr =
3483 RelocExpr = MCBinaryExpr::createSub(
3484 LHSExpr, MCSymbolRefExpr::create(getSymbol(RHSGV), Ctx), Ctx);
3485 }
3486 int64_t Addend = (LHSOffset - RHSOffset).getSExtValue();
3487 if (Addend != 0)
3488 RelocExpr = MCBinaryExpr::createAdd(
3489 RelocExpr, MCConstantExpr::create(Addend, Ctx), Ctx);
3490 return RelocExpr;
3491 }
3492 }
3493
3494 const MCExpr *LHS = lowerConstant(CE->getOperand(0));
3495 const MCExpr *RHS = lowerConstant(CE->getOperand(1));
3496 return MCBinaryExpr::createSub(LHS, RHS, Ctx);
3497 break;
3498 }
3499
3500 case Instruction::Add: {
3501 const MCExpr *LHS = lowerConstant(CE->getOperand(0));
3502 const MCExpr *RHS = lowerConstant(CE->getOperand(1));
3503 return MCBinaryExpr::createAdd(LHS, RHS, Ctx);
3504 }
3505 }
3506
3507 // If the code isn't optimized, there may be outstanding folding
3508 // opportunities. Attempt to fold the expression using DataLayout as a
3509 // last resort before giving up.
3511 if (C != CE)
3512 return lowerConstant(C);
3513
3514 // Otherwise report the problem to the user.
3515 std::string S;
3517 OS << "Unsupported expression in static initializer: ";
3518 CE->printAsOperand(OS, /*PrintType=*/false,
3519 !MF ? nullptr : MF->getFunction().getParent());
3521}
3522
3523static void emitGlobalConstantImpl(const DataLayout &DL, const Constant *C,
3524 AsmPrinter &AP,
3525 const Constant *BaseCV = nullptr,
3526 uint64_t Offset = 0,
3527 AsmPrinter::AliasMapTy *AliasList = nullptr);
3528
3529static void emitGlobalConstantFP(const ConstantFP *CFP, AsmPrinter &AP);
3530static void emitGlobalConstantFP(APFloat APF, Type *ET, AsmPrinter &AP);
3531
3532/// isRepeatedByteSequence - Determine whether the given value is
3533/// composed of a repeated sequence of identical bytes and return the
3534/// byte value. If it is not a repeated sequence, return -1.
3536 StringRef Data = V->getRawDataValues();
3537 assert(!Data.empty() && "Empty aggregates should be CAZ node");
3538 char C = Data[0];
3539 for (unsigned i = 1, e = Data.size(); i != e; ++i)
3540 if (Data[i] != C) return -1;
3541 return static_cast<uint8_t>(C); // Ensure 255 is not returned as -1.
3542}
3543
3544/// isRepeatedByteSequence - Determine whether the given value is
3545/// composed of a repeated sequence of identical bytes and return the
3546/// byte value. If it is not a repeated sequence, return -1.
3547static int isRepeatedByteSequence(const Value *V, const DataLayout &DL) {
3548 if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
3549 uint64_t Size = DL.getTypeAllocSizeInBits(V->getType());
3550 assert(Size % 8 == 0);
3551
3552 // Extend the element to take zero padding into account.
3553 APInt Value = CI->getValue().zext(Size);
3554 if (!Value.isSplat(8))
3555 return -1;
3556
3557 return Value.zextOrTrunc(8).getZExtValue();
3558 }
3559 if (const ConstantArray *CA = dyn_cast<ConstantArray>(V)) {
3560 // Make sure all array elements are sequences of the same repeated
3561 // byte.
3562 assert(CA->getNumOperands() != 0 && "Should be a CAZ");
3563 Constant *Op0 = CA->getOperand(0);
3564 int Byte = isRepeatedByteSequence(Op0, DL);
3565 if (Byte == -1)
3566 return -1;
3567
3568 // All array elements must be equal.
3569 for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i)
3570 if (CA->getOperand(i) != Op0)
3571 return -1;
3572 return Byte;
3573 }
3574
3575 if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(V))
3576 return isRepeatedByteSequence(CDS);
3577
3578 return -1;
3579}
3580
3582 AsmPrinter::AliasMapTy *AliasList) {
3583 if (AliasList) {
3584 auto AliasIt = AliasList->find(Offset);
3585 if (AliasIt != AliasList->end()) {
3586 for (const GlobalAlias *GA : AliasIt->second)
3587 AP.OutStreamer->emitLabel(AP.getSymbol(GA));
3588 AliasList->erase(Offset);
3589 }
3590 }
3591}
3592
3594 const DataLayout &DL, const ConstantDataSequential *CDS, AsmPrinter &AP,
3595 AsmPrinter::AliasMapTy *AliasList) {
3596 // See if we can aggregate this into a .fill, if so, emit it as such.
3597 int Value = isRepeatedByteSequence(CDS, DL);
3598 if (Value != -1) {
3599 uint64_t Bytes = DL.getTypeAllocSize(CDS->getType());
3600 // Don't emit a 1-byte object as a .fill.
3601 if (Bytes > 1)
3602 return AP.OutStreamer->emitFill(Bytes, Value);
3603 }
3604
3605 // If this can be emitted with .ascii/.asciz, emit it as such.
3606 if (CDS->isString())
3607 return AP.OutStreamer->emitBytes(CDS->getAsString());
3608
3609 // Otherwise, emit the values in successive locations.
3610 unsigned ElementByteSize = CDS->getElementByteSize();
3611 if (isa<IntegerType>(CDS->getElementType())) {
3612 for (unsigned I = 0, E = CDS->getNumElements(); I != E; ++I) {
3613 emitGlobalAliasInline(AP, ElementByteSize * I, AliasList);
3614 if (AP.isVerbose())
3615 AP.OutStreamer->getCommentOS()
3616 << format("0x%" PRIx64 "\n", CDS->getElementAsInteger(I));
3617 AP.OutStreamer->emitIntValue(CDS->getElementAsInteger(I),
3618 ElementByteSize);
3619 }
3620 } else {
3621 Type *ET = CDS->getElementType();
3622 for (unsigned I = 0, E = CDS->getNumElements(); I != E; ++I) {
3623 emitGlobalAliasInline(AP, ElementByteSize * I, AliasList);
3625 }
3626 }
3627
3628 unsigned Size = DL.getTypeAllocSize(CDS->getType());
3629 unsigned EmittedSize =
3630 DL.getTypeAllocSize(CDS->getElementType()) * CDS->getNumElements();
3631 assert(EmittedSize <= Size && "Size cannot be less than EmittedSize!");
3632 if (unsigned Padding = Size - EmittedSize)
3633 AP.OutStreamer->emitZeros(Padding);
3634}
3635
3637 const ConstantArray *CA, AsmPrinter &AP,
3638 const Constant *BaseCV, uint64_t Offset,
3639 AsmPrinter::AliasMapTy *AliasList) {
3640 // See if we can aggregate some values. Make sure it can be
3641 // represented as a series of bytes of the constant value.
3642 int Value = isRepeatedByteSequence(CA, DL);
3643
3644 if (Value != -1) {
3645 uint64_t Bytes = DL.getTypeAllocSize(CA->getType());
3646 AP.OutStreamer->emitFill(Bytes, Value);
3647 } else {
3648 for (unsigned I = 0, E = CA->getNumOperands(); I != E; ++I) {
3649 emitGlobalConstantImpl(DL, CA->getOperand(I), AP, BaseCV, Offset,
3650 AliasList);
3651 Offset += DL.getTypeAllocSize(CA->getOperand(I)->getType());
3652 }
3653 }
3654}
3655
3656static void emitGlobalConstantLargeInt(const ConstantInt *CI, AsmPrinter &AP);
3657
3658static void emitGlobalConstantVector(const DataLayout &DL, const Constant *CV,
3659 AsmPrinter &AP,
3660 AsmPrinter::AliasMapTy *AliasList) {
3661 auto *VTy = cast<FixedVectorType>(CV->getType());
3662 Type *ElementType = VTy->getElementType();
3663 uint64_t ElementSizeInBits = DL.getTypeSizeInBits(ElementType);
3664 uint64_t ElementAllocSizeInBits = DL.getTypeAllocSizeInBits(ElementType);
3665 uint64_t EmittedSize;
3666 if (ElementSizeInBits != ElementAllocSizeInBits) {
3667 // If the allocation size of an element is different from the size in bits,
3668 // printing each element separately will insert incorrect padding.
3669 //
3670 // The general algorithm here is complicated; instead of writing it out
3671 // here, just use the existing code in ConstantFolding.
3672 Type *IntT =
3673 IntegerType::get(CV->getContext(), DL.getTypeSizeInBits(CV->getType()));
3674 ConstantInt *CI = dyn_cast_or_null<ConstantInt>(ConstantFoldConstant(
3675 ConstantExpr::getBitCast(const_cast<Constant *>(CV), IntT), DL));
3676 if (!CI) {
3678 "Cannot lower vector global with unusual element type");
3679 }
3680 emitGlobalAliasInline(AP, 0, AliasList);
3682 EmittedSize = DL.getTypeStoreSize(CV->getType());
3683 } else {
3684 for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) {
3685 emitGlobalAliasInline(AP, DL.getTypeAllocSize(CV->getType()) * I, AliasList);
3687 }
3688 EmittedSize = DL.getTypeAllocSize(ElementType) * VTy->getNumElements();
3689 }
3690
3691 unsigned Size = DL.getTypeAllocSize(CV->getType());
3692 if (unsigned Padding = Size - EmittedSize)
3693 AP.OutStreamer->emitZeros(Padding);
3694}
3695
3697 const ConstantStruct *CS, AsmPrinter &AP,
3698 const Constant *BaseCV, uint64_t Offset,
3699 AsmPrinter::AliasMapTy *AliasList) {
3700 // Print the fields in successive locations. Pad to align if needed!
3701 uint64_t Size = DL.getTypeAllocSize(CS->getType());
3702 const StructLayout *Layout = DL.getStructLayout(CS->getType());
3703 uint64_t SizeSoFar = 0;
3704 for (unsigned I = 0, E = CS->getNumOperands(); I != E; ++I) {
3705 const Constant *Field = CS->getOperand(I);
3706
3707 // Print the actual field value.
3708 emitGlobalConstantImpl(DL, Field, AP, BaseCV, Offset + SizeSoFar,
3709 AliasList);
3710
3711 // Check if padding is needed and insert one or more 0s.
3712 uint64_t FieldSize = DL.getTypeAllocSize(Field->getType());
3713 uint64_t PadSize = ((I == E - 1 ? Size : Layout->getElementOffset(I + 1)) -
3714 Layout->getElementOffset(I)) -
3715 FieldSize;
3716 SizeSoFar += FieldSize + PadSize;
3717
3718 // Insert padding - this may include padding to increase the size of the
3719 // current field up to the ABI size (if the struct is not packed) as well
3720 // as padding to ensure that the next field starts at the right offset.
3721 AP.OutStreamer->emitZeros(PadSize);
3722 }
3723 assert(SizeSoFar == Layout->getSizeInBytes() &&
3724 "Layout of constant struct may be incorrect!");
3725}
3726
3727static void emitGlobalConstantFP(APFloat APF, Type *ET, AsmPrinter &AP) {
3728 assert(ET && "Unknown float type");
3729 APInt API = APF.bitcastToAPInt();
3730
3731 // First print a comment with what we think the original floating-point value
3732 // should have been.
3733 if (AP.isVerbose()) {
3734 SmallString<8> StrVal;
3735 APF.toString(StrVal);
3736 ET->print(AP.OutStreamer->getCommentOS());
3737 AP.OutStreamer->getCommentOS() << ' ' << StrVal << '\n';
3738 }
3739
3740 // Now iterate through the APInt chunks, emitting them in endian-correct
3741 // order, possibly with a smaller chunk at beginning/end (e.g. for x87 80-bit
3742 // floats).
3743 unsigned NumBytes = API.getBitWidth() / 8;
3744 unsigned TrailingBytes = NumBytes % sizeof(uint64_t);
3745 const uint64_t *p = API.getRawData();
3746
3747 // PPC's long double has odd notions of endianness compared to how LLVM
3748 // handles it: p[0] goes first for *big* endian on PPC.
3749 if (AP.getDataLayout().isBigEndian() && !ET->isPPC_FP128Ty()) {
3750 int Chunk = API.getNumWords() - 1;
3751
3752 if (TrailingBytes)
3753 AP.OutStreamer->emitIntValueInHexWithPadding(p[Chunk--], TrailingBytes);
3754
3755 for (; Chunk >= 0; --Chunk)
3756 AP.OutStreamer->emitIntValueInHexWithPadding(p[Chunk], sizeof(uint64_t));
3757 } else {
3758 unsigned Chunk;
3759 for (Chunk = 0; Chunk < NumBytes / sizeof(uint64_t); ++Chunk)
3760 AP.OutStreamer->emitIntValueInHexWithPadding(p[Chunk], sizeof(uint64_t));
3761
3762 if (TrailingBytes)
3763 AP.OutStreamer->emitIntValueInHexWithPadding(p[Chunk], TrailingBytes);
3764 }
3765
3766 // Emit the tail padding for the long double.
3767 const DataLayout &DL = AP.getDataLayout();
3768 AP.OutStreamer->emitZeros(DL.getTypeAllocSize(ET) - DL.getTypeStoreSize(ET));
3769}
3770
3771static void emitGlobalConstantFP(const ConstantFP *CFP, AsmPrinter &AP) {
3772 emitGlobalConstantFP(CFP->getValueAPF(), CFP->getType(), AP);
3773}
3774
3776 const DataLayout &DL = AP.getDataLayout();
3777 unsigned BitWidth = CI->getBitWidth();
3778
3779 // Copy the value as we may massage the layout for constants whose bit width
3780 // is not a multiple of 64-bits.
3781 APInt Realigned(CI->getValue());
3782 uint64_t ExtraBits = 0;
3783 unsigned ExtraBitsSize = BitWidth & 63;
3784
3785 if (ExtraBitsSize) {
3786 // The bit width of the data is not a multiple of 64-bits.
3787 // The extra bits are expected to be at the end of the chunk of the memory.
3788 // Little endian:
3789 // * Nothing to be done, just record the extra bits to emit.
3790 // Big endian:
3791 // * Record the extra bits to emit.
3792 // * Realign the raw data to emit the chunks of 64-bits.
3793 if (DL.isBigEndian()) {
3794 // Basically the structure of the raw data is a chunk of 64-bits cells:
3795 // 0 1 BitWidth / 64
3796 // [chunk1][chunk2] ... [chunkN].
3797 // The most significant chunk is chunkN and it should be emitted first.
3798 // However, due to the alignment issue chunkN contains useless bits.
3799 // Realign the chunks so that they contain only useful information:
3800 // ExtraBits 0 1 (BitWidth / 64) - 1
3801 // chu[nk1 chu][nk2 chu] ... [nkN-1 chunkN]
3802 ExtraBitsSize = alignTo(ExtraBitsSize, 8);
3803 ExtraBits = Realigned.getRawData()[0] &
3804 (((uint64_t)-1) >> (64 - ExtraBitsSize));
3805 if (BitWidth >= 64)
3806 Realigned.lshrInPlace(ExtraBitsSize);
3807 } else
3808 ExtraBits = Realigned.getRawData()[BitWidth / 64];
3809 }
3810
3811 // We don't expect assemblers to support integer data directives
3812 // for more than 64 bits, so we emit the data in at most 64-bit
3813 // quantities at a time.
3814 const uint64_t *RawData = Realigned.getRawData();
3815 for (unsigned i = 0, e = BitWidth / 64; i != e; ++i) {
3816 uint64_t Val = DL.isBigEndian() ? RawData[e - i - 1] : RawData[i];
3817 AP.OutStreamer->emitIntValue(Val, 8);
3818 }
3819
3820 if (ExtraBitsSize) {
3821 // Emit the extra bits after the 64-bits chunks.
3822
3823 // Emit a directive that fills the expected size.
3825 Size -= (BitWidth / 64) * 8;
3826 assert(Size && Size * 8 >= ExtraBitsSize &&
3827 (ExtraBits & (((uint64_t)-1) >> (64 - ExtraBitsSize)))
3828 == ExtraBits && "Directive too small for extra bits.");
3829 AP.OutStreamer->emitIntValue(ExtraBits, Size);
3830 }
3831}
3832
3833/// Transform a not absolute MCExpr containing a reference to a GOT
3834/// equivalent global, by a target specific GOT pc relative access to the
3835/// final symbol.
3837 const Constant *BaseCst,
3838 uint64_t Offset) {
3839 // The global @foo below illustrates a global that uses a got equivalent.
3840 //
3841 // @bar = global i32 42
3842 // @gotequiv = private unnamed_addr constant i32* @bar
3843 // @foo = i32 trunc (i64 sub (i64 ptrtoint (i32** @gotequiv to i64),
3844 // i64 ptrtoint (i32* @foo to i64))
3845 // to i32)
3846 //
3847 // The cstexpr in @foo is converted into the MCExpr `ME`, where we actually
3848 // check whether @foo is suitable to use a GOTPCREL. `ME` is usually in the
3849 // form:
3850 //
3851 // foo = cstexpr, where
3852 // cstexpr := <gotequiv> - "." + <cst>
3853 // cstexpr := <gotequiv> - (<foo> - <offset from @foo base>) + <cst>
3854 //
3855 // After canonicalization by evaluateAsRelocatable `ME` turns into:
3856 //
3857 // cstexpr := <gotequiv> - <foo> + gotpcrelcst, where
3858 // gotpcrelcst := <offset from @foo base> + <cst>
3859 MCValue MV;
3860 if (!(*ME)->evaluateAsRelocatable(MV, nullptr, nullptr) || MV.isAbsolute())
3861 return;
3862 const MCSymbolRefExpr *SymA = MV.getSymA();
3863 if (!SymA)
3864 return;
3865
3866 // Check that GOT equivalent symbol is cached.
3867 const MCSymbol *GOTEquivSym = &SymA->getSymbol();
3868 if (!AP.GlobalGOTEquivs.count(GOTEquivSym))
3869 return;
3870
3871 const GlobalValue *BaseGV = dyn_cast_or_null<GlobalValue>(BaseCst);
3872 if (!BaseGV)
3873 return;
3874
3875 // Check for a valid base symbol
3876 const MCSymbol *BaseSym = AP.getSymbol(BaseGV);
3877 const MCSymbolRefExpr *SymB = MV.getSymB();
3878
3879 if (!SymB || BaseSym != &SymB->getSymbol())
3880 return;
3881
3882 // Make sure to match:
3883 //
3884 // gotpcrelcst := <offset from @foo base> + <cst>
3885 //
3886 int64_t GOTPCRelCst = Offset + MV.getConstant();
3887 if (!AP.getObjFileLowering().supportGOTPCRelWithOffset() && GOTPCRelCst != 0)
3888 return;
3889
3890 // Emit the GOT PC relative to replace the got equivalent global, i.e.:
3891 //
3892 // bar:
3893 // .long 42
3894 // gotequiv:
3895 // .quad bar
3896 // foo:
3897 // .long gotequiv - "." + <cst>
3898 //
3899 // is replaced by the target specific equivalent to:
3900 //
3901 // bar:
3902 // .long 42
3903 // foo:
3904 // .long bar@GOTPCREL+<gotpcrelcst>
3905 AsmPrinter::GOTEquivUsePair Result = AP.GlobalGOTEquivs[GOTEquivSym];
3906 const GlobalVariable *GV = Result.first;
3907 int NumUses = (int)Result.second;
3908 const GlobalValue *FinalGV = dyn_cast<GlobalValue>(GV->getOperand(0));
3909 const MCSymbol *FinalSym = AP.getSymbol(FinalGV);
3911 FinalGV, FinalSym, MV, Offset, AP.MMI, *AP.OutStreamer);
3912
3913 // Update GOT equivalent usage information
3914 --NumUses;
3915 if (NumUses >= 0)
3916 AP.GlobalGOTEquivs[GOTEquivSym] = std::make_pair(GV, NumUses);
3917}
3918
3919static void emitGlobalConstantImpl(const DataLayout &DL, const Constant *CV,
3920 AsmPrinter &AP, const Constant *BaseCV,
3922 AsmPrinter::AliasMapTy *AliasList) {
3923 assert((!AliasList || AP.TM.getTargetTriple().isOSBinFormatXCOFF()) &&
3924 "AliasList only expected for XCOFF");
3925 emitGlobalAliasInline(AP, Offset, AliasList);
3926 uint64_t Size = DL.getTypeAllocSize(CV->getType());
3927
3928 // Globals with sub-elements such as combinations of arrays and structs
3929 // are handled recursively by emitGlobalConstantImpl. Keep track of the
3930 // constant symbol base and the current position with BaseCV and Offset.
3931 if (!BaseCV && CV->hasOneUse())
3932 BaseCV = dyn_cast<Constant>(CV->user_back());
3933
3934 if (isa<ConstantAggregateZero>(CV)) {
3935 StructType *structType;
3936 if (AliasList && (structType = llvm::dyn_cast<StructType>(CV->getType()))) {
3937 unsigned numElements = {structType->getNumElements()};
3938 if (numElements != 0) {
3939 // Handle cases of aliases to direct struct elements
3940 const StructLayout *Layout = DL.getStructLayout(structType);
3941 uint64_t SizeSoFar = 0;
3942 for (unsigned int i = 0; i < numElements - 1; ++i) {
3943 uint64_t GapToNext = Layout->getElementOffset(i + 1) - SizeSoFar;
3944 AP.OutStreamer->emitZeros(GapToNext);
3945 SizeSoFar += GapToNext;
3946 emitGlobalAliasInline(AP, Offset + SizeSoFar, AliasList);
3947 }
3948 AP.OutStreamer->emitZeros(Size - SizeSoFar);
3949 return;
3950 }
3951 }
3952 return AP.OutStreamer->emitZeros(Size);
3953 }
3954
3955 if (isa<UndefValue>(CV))
3956 return AP.OutStreamer->emitZeros(Size);
3957
3958 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
3959 if (isa<VectorType>(CV->getType()))
3960 return emitGlobalConstantVector(DL, CV, AP, AliasList);
3961
3962 const uint64_t StoreSize = DL.getTypeStoreSize(CV->getType());
3963 if (StoreSize <= 8) {
3964 if (AP.isVerbose())
3965 AP.OutStreamer->getCommentOS()
3966 << format("0x%" PRIx64 "\n", CI->getZExtValue());
3967 AP.OutStreamer->emitIntValue(CI->getZExtValue(), StoreSize);
3968 } else {
3970 }
3971
3972 // Emit tail padding if needed
3973 if (Size != StoreSize)
3974 AP.OutStreamer->emitZeros(Size - StoreSize);
3975
3976 return;
3977 }
3978
3979 if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
3980 if (isa<VectorType>(CV->getType()))
3981 return emitGlobalConstantVector(DL, CV, AP, AliasList);
3982 else
3983 return emitGlobalConstantFP(CFP, AP);
3984 }
3985
3986 if (isa<ConstantPointerNull>(CV)) {
3987 AP.OutStreamer->emitIntValue(0, Size);
3988 return;
3989 }
3990
3991 if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(CV))
3992 return emitGlobalConstantDataSequential(DL, CDS, AP, AliasList);
3993
3994 if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV))
3995 return emitGlobalConstantArray(DL, CVA, AP, BaseCV, Offset, AliasList);
3996
3997 if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV))
3998 return emitGlobalConstantStruct(DL, CVS, AP, BaseCV, Offset, AliasList);
3999
4000 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
4001 // Look through bitcasts, which might not be able to be MCExpr'ized (e.g. of
4002 // vectors).
4003 if (CE->getOpcode() == Instruction::BitCast)
4004 return emitGlobalConstantImpl(DL, CE->getOperand(0), AP);
4005
4006 if (Size > 8) {
4007 // If the constant expression's size is greater than 64-bits, then we have
4008 // to emit the value in chunks. Try to constant fold the value and emit it
4009 // that way.
4010 Constant *New = ConstantFoldConstant(CE, DL);
4011 if (New != CE)
4012 return emitGlobalConstantImpl(DL, New, AP);
4013 }
4014 }
4015
4016 if (isa<ConstantVector>(CV))
4017 return emitGlobalConstantVector(DL, CV, AP, AliasList);
4018
4019 // Otherwise, it must be a ConstantExpr. Lower it to an MCExpr, then emit it
4020 // thread the streamer with EmitValue.
4021 const MCExpr *ME = AP.lowerConstant(CV);
4022
4023 // Since lowerConstant already folded and got rid of all IR pointer and
4024 // integer casts, detect GOT equivalent accesses by looking into the MCExpr
4025 // directly.
4027 handleIndirectSymViaGOTPCRel(AP, &ME, BaseCV, Offset);
4028
4029 AP.OutStreamer->emitValue(ME, Size);
4030}
4031
4032/// EmitGlobalConstant - Print a general LLVM constant to the .s file.
4034 AliasMapTy *AliasList) {
4035 uint64_t Size = DL.getTypeAllocSize(CV->getType());
4036 if (Size)
4037 emitGlobalConstantImpl(DL, CV, *this, nullptr, 0, AliasList);
4038 else if (MAI->hasSubsectionsViaSymbols()) {
4039 // If the global has zero size, emit a single byte so that two labels don't
4040 // look like they are at the same location.
4041 OutStreamer->emitIntValue(0, 1);
4042 }
4043 if (!AliasList)
4044 return;
4045 // TODO: These remaining aliases are not emitted in the correct location. Need
4046 // to handle the case where the alias offset doesn't refer to any sub-element.
4047 for (auto &AliasPair : *AliasList) {
4048 for (const GlobalAlias *GA : AliasPair.second)
4049 OutStreamer->emitLabel(getSymbol(GA));
4050 }
4051}
4052
4054 // Target doesn't support this yet!
4055 llvm_unreachable("Target does not support EmitMachineConstantPoolValue");
4056}
4057
4059 if (Offset > 0)
4060 OS << '+' << Offset;
4061 else if (Offset < 0)
4062 OS << Offset;
4063}
4064
4065void AsmPrinter::emitNops(unsigned N) {
4067 for (; N; --N)
4069}
4070
4071//===----------------------------------------------------------------------===//
4072// Symbol Lowering Routines.
4073//===----------------------------------------------------------------------===//
4074
4076 return OutContext.createTempSymbol(Name, true);
4077}
4078
4080 return const_cast<AsmPrinter *>(this)->getAddrLabelSymbol(
4081 BA->getBasicBlock());
4082}
4083
4085 return const_cast<AsmPrinter *>(this)->getAddrLabelSymbol(BB);
4086}
4087
4090}
4091
4092/// GetCPISymbol - Return the symbol for the specified constant pool entry.
4093MCSymbol *AsmPrinter::GetCPISymbol(unsigned CPID) const {
4094 if (getSubtargetInfo().getTargetTriple().isWindowsMSVCEnvironment()) {
4095 const MachineConstantPoolEntry &CPE =
4096 MF->getConstantPool()->getConstants()[CPID];
4097 if (!CPE.isMachineConstantPoolEntry()) {
4098 const DataLayout &DL = MF->getDataLayout();
4099 SectionKind Kind = CPE.getSectionKind(&DL);
4100 const Constant *C = CPE.Val.ConstVal;
4101 Align Alignment = CPE.Alignment;
4102 if (const MCSectionCOFF *S = dyn_cast<MCSectionCOFF>(
4103 getObjFileLowering().getSectionForConstant(DL, Kind, C,
4104 Alignment))) {
4105 if (MCSymbol *Sym = S->getCOMDATSymbol()) {
4106 if (Sym->isUndefined())
4107 OutStreamer->emitSymbolAttribute(Sym, MCSA_Global);
4108 return Sym;
4109 }
4110 }
4111 }
4112 }
4113
4114 const DataLayout &DL = getDataLayout();
4115 return OutContext.getOrCreateSymbol(Twine(DL.getPrivateGlobalPrefix()) +
4116 "CPI" + Twine(getFunctionNumber()) + "_" +
4117 Twine(CPID));
4118}
4119
4120/// GetJTISymbol - Return the symbol for the specified jump table entry.
4121MCSymbol *AsmPrinter::GetJTISymbol(unsigned JTID, bool isLinkerPrivate) const {
4122 return MF->getJTISymbol(JTID, OutContext, isLinkerPrivate);
4123}
4124
4125/// GetJTSetSymbol - Return the symbol for the specified jump table .set
4126/// FIXME: privatize to AsmPrinter.
4127MCSymbol *AsmPrinter::GetJTSetSymbol(unsigned UID, unsigned MBBID) const {
4128 const DataLayout &DL = getDataLayout();
4129 return OutContext.getOrCreateSymbol(Twine(DL.getPrivateGlobalPrefix()) +
4130 Twine(getFunctionNumber()) + "_" +
4131 Twine(UID) + "_set_" + Twine(MBBID));
4132}
4133
4135 StringRef Suffix) const {
4137}
4138
4139/// Return the MCSymbol for the specified ExternalSymbol.
4141 SmallString<60> NameStr;
4143 return OutContext.getOrCreateSymbol(NameStr);
4144}
4145
4146/// PrintParentLoopComment - Print comments about parent loops of this one.
4148 unsigned FunctionNumber) {
4149 if (!Loop) return;
4150 PrintParentLoopComment(OS, Loop->getParentLoop(), FunctionNumber);
4152 << "Parent Loop BB" << FunctionNumber << "_"
4153 << Loop->getHeader()->getNumber()
4154 << " Depth=" << Loop->getLoopDepth() << '\n';
4155}
4156
4157/// PrintChildLoopComment - Print comments about child loops within
4158/// the loop for this basic block, with nesting.
4160 unsigned FunctionNumber) {
4161 // Add child loop information
4162 for (const MachineLoop *CL : *Loop) {
4163 OS.indent(CL->getLoopDepth()*2)
4164 << "Child Loop BB" << FunctionNumber << "_"
4165 << CL->getHeader()->getNumber() << " Depth " << CL->getLoopDepth()
4166 << '\n';
4167 PrintChildLoopComment(OS, CL, FunctionNumber);
4168 }
4169}
4170
4171/// emitBasicBlockLoopComments - Pretty-print comments for basic blocks.
4173 const MachineLoopInfo *LI,
4174 const AsmPrinter &AP) {
4175 // Add loop depth information
4176 const MachineLoop *Loop = LI->getLoopFor(&MBB);
4177 if (!Loop) return;
4178
4179 MachineBasicBlock *Header = Loop->getHeader();
4180 assert(Header && "No header for loop");
4181
4182 // If this block is not a loop header, just print out what is the loop header
4183 // and return.
4184 if (Header != &MBB) {
4185 AP.OutStreamer->AddComment(" in Loop: Header=BB" +
4186 Twine(AP.getFunctionNumber())+"_" +
4188 " Depth="+Twine(Loop->getLoopDepth()));
4189 return;
4190 }
4191
4192 // Otherwise, it is a loop header. Print out information about child and
4193 // parent loops.
4194 raw_ostream &OS = AP.OutStreamer->getCommentOS();
4195
4197
4198 OS << "=>";
4199 OS.indent(Loop->getLoopDepth()*2-2);
4200
4201 OS << "This ";
4202 if (Loop->isInnermost())
4203 OS << "Inner ";
4204 OS << "Loop Header: Depth=" + Twine(Loop->getLoopDepth()) << '\n';
4205
4207}
4208
4209/// emitBasicBlockStart - This method prints the label for the specified
4210/// MachineBasicBlock, an alignment (if present) and a comment describing
4211/// it if appropriate.
4213 // End the previous funclet and start a new one.
4214 if (MBB.isEHFuncletEntry()) {
4215 for (auto &Handler : Handlers) {
4216 Handler->endFunclet();
4217 Handler->beginFunclet(MBB);
4218 }
4219 for (auto &Handler : EHHandlers) {
4220 Handler->endFunclet();
4221 Handler->beginFunclet(MBB);
4222 }
4223 }
4224
4225 // Switch to a new section if this basic block must begin a section. The
4226 // entry block is always placed in the function section and is handled
4227 // separately.
4228 if (MBB.isBeginSection() && !MBB.isEntryBlock()) {
4229 OutStreamer->switchSection(
4230 getObjFileLowering().getSectionForMachineBasicBlock(MF->getFunction(),
4231 MBB, TM));
4232 CurrentSectionBeginSym = MBB.getSymbol();
4233 }
4234
4235 for (auto &Handler : Handlers)
4236 Handler->beginCodeAlignment(MBB);
4237
4238 // Emit an alignment directive for this block, if needed.
4239 const Align Alignment = MBB.getAlignment();
4240 if (Alignment != Align(1))
4241 emitAlignment(Alignment, nullptr, MBB.getMaxBytesForAlignment());
4242
4243 // If the block has its address taken, emit any labels that were used to
4244 // reference the block. It is possible that there is more than one label
4245 // here, because multiple LLVM BB's may have been RAUW'd to this block after
4246 // the references were generated.
4247 if (MBB.isIRBlockAddressTaken()) {
4248 if (isVerbose())
4249 OutStreamer->AddComment("Block address taken");
4250
4252 assert(BB && BB->hasAddressTaken() && "Missing BB");
4254 OutStreamer->emitLabel(Sym);
4255 } else if (isVerbose() && MBB.isMachineBlockAddressTaken()) {
4256 OutStreamer->AddComment("Block address taken");
4257 }
4258
4259 // Print some verbose block comments.
4260 if (isVerbose()) {
4261 if (const BasicBlock *BB = MBB.getBasicBlock()) {
4262 if (BB->hasName()) {
4263 BB->printAsOperand(OutStreamer->getCommentOS(),
4264 /*PrintType=*/false, BB->getModule());
4265 OutStreamer->getCommentOS() << '\n';
4266 }
4267 }
4268
4269 assert(MLI != nullptr && "MachineLoopInfo should has been computed");
4271 }
4272
4273 // Print the main label for the block.
4274 if (shouldEmitLabelForBasicBlock(MBB)) {
4276 OutStreamer->AddComment("Label of block must be emitted");
4277 OutStreamer->emitLabel(MBB.getSymbol());
4278 } else {
4279 if (isVerbose()) {
4280 // NOTE: Want this comment at start of line, don't emit with AddComment.
4281 OutStreamer->emitRawComment(" %bb." + Twine(MBB.getNumber()) + ":",
4282 false);
4283 }
4284 }
4285
4286 if (MBB.isEHCatchretTarget() &&
4288 OutStreamer->emitLabel(MBB.getEHCatchretSymbol());
4289 }
4290
4291 // With BB sections, each basic block must handle CFI information on its own
4292 // if it begins a section (Entry block call is handled separately, next to
4293 // beginFunction).
4294 if (MBB.isBeginSection() && !MBB.isEntryBlock()) {
4295 for (auto &Handler : Handlers)
4296 Handler->beginBasicBlockSection(MBB);
4297 for (auto &Handler : EHHandlers)
4298 Handler->beginBasicBlockSection(MBB);
4299 }
4300}
4301
4303 // Check if CFI information needs to be updated for this MBB with basic block
4304 // sections.
4305 if (MBB.isEndSection()) {
4306 for (auto &Handler : Handlers)
4307 Handler->endBasicBlockSection(MBB);
4308 for (auto &Handler : EHHandlers)
4309 Handler->endBasicBlockSection(MBB);
4310 }
4311}
4312
4313void AsmPrinter::emitVisibility(MCSymbol *Sym, unsigned Visibility,
4314 bool IsDefinition) const {
4316
4317 switch (Visibility) {
4318 default: break;
4320 if (IsDefinition)
4321 Attr = MAI->getHiddenVisibilityAttr();
4322 else
4324 break;
4327 break;
4328 }
4329
4330 if (Attr != MCSA_Invalid)
4331 OutStreamer->emitSymbolAttribute(Sym, Attr);
4332}
4333
4334bool AsmPrinter::shouldEmitLabelForBasicBlock(
4335 const MachineBasicBlock &MBB) const {
4336 // With `-fbasic-block-sections=`, a label is needed for every non-entry block
4337 // in the labels mode (option `=labels`) and every section beginning in the
4338 // sections mode (`=all` and `=list=`).
4340 !MBB.isEntryBlock())
4341 return true;
4342 // A label is needed for any block with at least one predecessor (when that
4343 // predecessor is not the fallthrough predecessor, or if it is an EH funclet
4344 // entry, or if a label is forced).
4345 return !MBB.pred_empty() &&
4348}
4349
4350/// isBlockOnlyReachableByFallthough - Return true if the basic block has
4351/// exactly one predecessor and the control transfer mechanism between
4352/// the predecessor and this block is a fall-through.
4355 // If this is a landing pad, it isn't a fall through. If it has no preds,
4356 // then nothing falls through to it.
4357 if (MBB->isEHPad() || MBB->pred_empty())
4358 return false;
4359
4360 // If there isn't exactly one predecessor, it can't be a fall through.
4361 if (MBB->pred_size() > 1)
4362 return false;
4363
4364 // The predecessor has to be immediately before this block.
4365 MachineBasicBlock *Pred = *MBB->pred_begin();
4366 if (!Pred->isLayoutSuccessor(MBB))
4367 return false;
4368
4369 // If the block is completely empty, then it definitely does fall through.
4370 if (Pred->empty())
4371 return true;
4372
4373 // Check the terminators in the previous blocks
4374 for (const auto &MI : Pred->terminators()) {
4375 // If it is not a simple branch, we are in a table somewhere.
4376 if (!MI.isBranch() || MI.isIndirectBranch())
4377 return false;
4378
4379 // If we are the operands of one of the branches, this is not a fall
4380 // through. Note that targets with delay slots will usually bundle
4381 // terminators with the delay slot instruction.
4382 for (ConstMIBundleOperands OP(MI); OP.isValid(); ++OP) {
4383 if (OP->isJTI())
4384 return false;
4385 if (OP->isMBB() && OP->getMBB() == MBB)
4386 return false;
4387 }
4388 }
4389
4390 return true;
4391}
4392
4393GCMetadataPrinter *AsmPrinter::getOrCreateGCPrinter(GCStrategy &S) {
4394 if (!S.usesMetadata())
4395 return nullptr;
4396
4397 auto [GCPI, Inserted] = GCMetadataPrinters.insert({&S, nullptr});
4398 if (!Inserted)
4399 return GCPI->second.get();
4400
4401 auto Name = S.getName();
4402
4403 for (const GCMetadataPrinterRegistry::entry &GCMetaPrinter :
4405 if (Name == GCMetaPrinter.getName()) {
4406 std::unique_ptr<GCMetadataPrinter> GMP = GCMetaPrinter.instantiate();
4407 GMP->S = &S;
4408 GCPI->second = std::move(GMP);
4409 return GCPI->second.get();
4410 }
4411
4412 report_fatal_error("no GCMetadataPrinter registered for GC: " + Twine(Name));
4413}
4414
4416 GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>();
4417 assert(MI && "AsmPrinter didn't require GCModuleInfo?");
4418 bool NeedsDefault = false;
4419 if (MI->begin() == MI->end())
4420 // No GC strategy, use the default format.
4421 NeedsDefault = true;
4422 else
4423 for (const auto &I : *MI) {
4424 if (GCMetadataPrinter *MP = getOrCreateGCPrinter(*I))
4425 if (MP->emitStackMaps(SM, *this))
4426 continue;
4427 // The strategy doesn't have printer or doesn't emit custom stack maps.
4428 // Use the default format.
4429 NeedsDefault = true;
4430 }
4431
4432 if (NeedsDefault)
4434}
4435
4437 std::unique_ptr<AsmPrinterHandler> Handler) {
4438 Handlers.insert(Handlers.begin(), std::move(Handler));
4440}
4441
4442/// Pin vtables to this file.
4444
4446
4447// In the binary's "xray_instr_map" section, an array of these function entries
4448// describes each instrumentation point. When XRay patches your code, the index
4449// into this table will be given to your handler as a patch point identifier.
4451 auto Kind8 = static_cast<uint8_t>(Kind);
4452 Out->emitBinaryData(StringRef(reinterpret_cast<const char *>(&Kind8), 1));
4453 Out->emitBinaryData(
4454 StringRef(reinterpret_cast<const char *>(&AlwaysInstrument), 1));
4455 Out->emitBinaryData(StringRef(reinterpret_cast<const char *>(&Version), 1));
4456 auto Padding = (4 * Bytes) - ((2 * Bytes) + 3);
4457 assert(Padding >= 0 && "Instrumentation map entry > 4 * Word Size");
4458 Out->emitZeros(Padding);
4459}
4460
4462 if (Sleds.empty())
4463 return;
4464
4465 auto PrevSection = OutStreamer->getCurrentSectionOnly();
4466 const Function &F = MF->getFunction();
4467 MCSection *InstMap = nullptr;
4468 MCSection *FnSledIndex = nullptr;
4469 const Triple &TT = TM.getTargetTriple();
4470 // Use PC-relative addresses on all targets.
4471 if (TT.isOSBinFormatELF()) {
4472 auto LinkedToSym = cast<MCSymbolELF>(CurrentFnSym);
4473 auto Flags = ELF::SHF_ALLOC | ELF::SHF_LINK_ORDER;
4474 StringRef GroupName;
4475 if (F.hasComdat()) {
4476 Flags |= ELF::SHF_GROUP;
4477 GroupName = F.getComdat()->getName();
4478 }
4479 InstMap = OutContext.getELFSection("xray_instr_map", ELF::SHT_PROGBITS,
4480 Flags, 0, GroupName, F.hasComdat(),
4481 MCSection::NonUniqueID, LinkedToSym);
4482
4484 FnSledIndex = OutContext.getELFSection(
4485 "xray_fn_idx", ELF::SHT_PROGBITS, Flags, 0, GroupName, F.hasComdat(),
4486 MCSection::NonUniqueID, LinkedToSym);
4488 InstMap = OutContext.getMachOSection("__DATA", "xray_instr_map",
4492 FnSledIndex = OutContext.getMachOSection("__DATA", "xray_fn_idx",
4495 } else {
4496 llvm_unreachable("Unsupported target");
4497 }
4498
4499 auto WordSizeBytes = MAI->getCodePointerSize();
4500
4501 // Now we switch to the instrumentation map section. Because this is done
4502 // per-function, we are able to create an index entry that will represent the
4503 // range of sleds associated with a function.
4504 auto &Ctx = OutContext;
4505 MCSymbol *SledsStart =
4506 OutContext.createLinkerPrivateSymbol("xray_sleds_start");
4507 OutStreamer->switchSection(InstMap);
4508 OutStreamer->emitLabel(SledsStart);
4509 for (const auto &Sled : Sleds) {
4510 MCSymbol *Dot = Ctx.createTempSymbol();
4511 OutStreamer->emitLabel(Dot);
4512 OutStreamer->emitValueImpl(
4514 MCSymbolRefExpr::create(Dot, Ctx), Ctx),
4515 WordSizeBytes);
4516 OutStreamer->emitValueImpl(
4520 MCConstantExpr::create(WordSizeBytes, Ctx),
4521 Ctx),
4522 Ctx),
4523 WordSizeBytes);
4524 Sled.emit(WordSizeBytes, OutStreamer.get());
4525 }
4526 MCSymbol *SledsEnd = OutContext.createTempSymbol("xray_sleds_end", true);
4527 OutStreamer->emitLabel(SledsEnd);
4528
4529 // We then emit a single entry in the index per function. We use the symbols
4530 // that bound the instrumentation map as the range for a specific function.
4531 // Each entry here will be 2 * word size aligned, as we're writing down two
4532 // pointers. This should work for both 32-bit and 64-bit platforms.
4533 if (FnSledIndex) {
4534 OutStreamer->switchSection(FnSledIndex);
4535 OutStreamer->emitCodeAlignment(Align(2 * WordSizeBytes),
4536 &getSubtargetInfo());
4537 // For Mach-O, use an "l" symbol as the atom of this subsection. The label
4538 // difference uses a SUBTRACTOR external relocation which references the
4539 // symbol.
4540 MCSymbol *Dot = Ctx.createLinkerPrivateSymbol("xray_fn_idx");
4541 OutStreamer->emitLabel(Dot);
4542 OutStreamer->emitValueImpl(
4544 MCSymbolRefExpr::create(Dot, Ctx), Ctx),
4545 WordSizeBytes);
4546 OutStreamer->emitValueImpl(MCConstantExpr::create(Sleds.size(), Ctx),
4547 WordSizeBytes);
4548 OutStreamer->switchSection(PrevSection);
4549 }
4550 Sleds.clear();
4551}
4552
4554 SledKind Kind, uint8_t Version) {
4555 const Function &F = MI.getMF()->getFunction();
4556 auto Attr = F.getFnAttribute("function-instrument");
4557 bool LogArgs = F.hasFnAttribute("xray-log-args");
4558 bool AlwaysInstrument =
4559 Attr.isStringAttribute() && Attr.getValueAsString() == "xray-always";
4560 if (Kind == SledKind::FUNCTION_ENTER && LogArgs)
4562 Sleds.emplace_back(XRayFunctionEntry{Sled, CurrentFnSym, Kind,
4563 AlwaysInstrument, &F, Version});
4564}
4565
4567 const Function &F = MF->getFunction();
4568 unsigned PatchableFunctionPrefix = 0, PatchableFunctionEntry = 0;
4569 (void)F.getFnAttribute("patchable-function-prefix")
4570 .getValueAsString()
4571 .getAsInteger(10, PatchableFunctionPrefix);
4572 (void)F.getFnAttribute("patchable-function-entry")
4573 .getValueAsString()
4574 .getAsInteger(10, PatchableFunctionEntry);
4575 if (!PatchableFunctionPrefix && !PatchableFunctionEntry)
4576 return;
4577 const unsigned PointerSize = getPointerSize();
4579 auto Flags = ELF::SHF_WRITE | ELF::SHF_ALLOC;
4580 const MCSymbolELF *LinkedToSym = nullptr;
4581 StringRef GroupName;
4582
4583 // GNU as < 2.35 did not support section flag 'o'. GNU ld < 2.36 did not
4584 // support mixed SHF_LINK_ORDER and non-SHF_LINK_ORDER sections.
4585 if (MAI->useIntegratedAssembler() || MAI->binutilsIsAtLeast(2, 36)) {
4586 Flags |= ELF::SHF_LINK_ORDER;
4587 if (F.hasComdat()) {
4588 Flags |= ELF::SHF_GROUP;
4589 GroupName = F.getComdat()->getName();
4590 }
4591 LinkedToSym = cast<MCSymbolELF>(CurrentFnSym);
4592 }
4593 OutStreamer->switchSection(OutContext.getELFSection(
4594 "__patchable_function_entries", ELF::SHT_PROGBITS, Flags, 0, GroupName,
4595 F.hasComdat(), MCSection::NonUniqueID, LinkedToSym));
4596 emitAlignment(Align(PointerSize));
4597 OutStreamer->emitSymbolValue(CurrentPatchableFunctionEntrySym, PointerSize);
4598 }
4599}
4600
4602 return OutStreamer->getContext().getDwarfVersion();
4603}
4604
4606 OutStreamer->getContext().setDwarfVersion(Version);
4607}
4608
4610 return OutStreamer->getContext().getDwarfFormat() == dwarf::DWARF64;
4611}
4612
4615 OutStreamer->getContext().getDwarfFormat());
4616}
4617
4620 OutStreamer->getContext().getDwarfFormat(),
4622}
4623
4626 OutStreamer->getContext().getDwarfFormat());
4627}
4628
4629std::tuple<const MCSymbol *, uint64_t, const MCSymbol *,
4632 const MCSymbol *BranchLabel) const {
4633 const auto TLI = MF->getSubtarget().getTargetLowering();
4634 const auto BaseExpr =
4636 const auto Base = &cast<MCSymbolRefExpr>(BaseExpr)->getSymbol();
4637
4638 // By default, for the architectures that support CodeView,
4639 // EK_LabelDifference32 is implemented as an Int32 from the base address.
4640 return std::make_tuple(Base, 0, BranchLabel,
4642}
This file declares a class to represent arbitrary precision floating point values and provide a varie...
This file implements a class to represent arbitrary precision integral constant values and operations...
MachineBasicBlock & MBB
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static bool emitDebugValueComment(const MachineInstr *MI, AsmPrinter &AP)
emitDebugValueComment - This method handles the target-independent form of DBG_VALUE,...
static llvm::object::BBAddrMap::Features getBBAddrMapFeature(const MachineFunction &MF, int NumMBBSectionRanges)
static uint32_t getBBAddrMapMetadata(const MachineBasicBlock &MBB)
Returns the BB metadata to be emitted in the SHT_LLVM_BB_ADDR_MAP section for a given basic block.
static cl::opt< bool > BBAddrMapSkipEmitBBEntries("basic-block-address-map-skip-bb-entries", cl::desc("Skip emitting basic block entries in the SHT_LLVM_BB_ADDR_MAP " "section. It's used to save binary size when BB entries are " "unnecessary for some PGOAnalysisMap features."), cl::Hidden, cl::init(false))
static void emitGlobalConstantFP(const ConstantFP *CFP, AsmPrinter &AP)
static bool isGOTEquivalentCandidate(const GlobalVariable *GV, unsigned &NumGOTEquivUsers)
Only consider global GOT equivalents if at least one user is a cstexpr inside an initializer of anoth...
static void emitFakeUse(const MachineInstr *MI, AsmPrinter &AP)
static unsigned getNumGlobalVariableUses(const Constant *C)
Compute the number of Global Variables that uses a Constant.
static void tagGlobalDefinition(Module &M, GlobalVariable *G)
static void emitBasicBlockLoopComments(const MachineBasicBlock &MBB, const MachineLoopInfo *LI, const AsmPrinter &AP)
emitBasicBlockLoopComments - Pretty-print comments for basic blocks.
static void handleIndirectSymViaGOTPCRel(AsmPrinter &AP, const MCExpr **ME, const Constant *BaseCst, uint64_t Offset)
Transform a not absolute MCExpr containing a reference to a GOT equivalent global,...
static int isRepeatedByteSequence(const ConstantDataSequential *V)
isRepeatedByteSequence - Determine whether the given value is composed of a repeated sequence of iden...
static void emitGlobalAliasInline(AsmPrinter &AP, uint64_t Offset, AsmPrinter::AliasMapTy *AliasList)
static bool needFuncLabels(const MachineFunction &MF, const AsmPrinter &Asm)
Returns true if function begin and end labels should be emitted.
static cl::bits< PGOMapFeaturesEnum > PgoAnalysisMapFeatures("pgo-analysis-map", cl::Hidden, cl::CommaSeparated, cl::values(clEnumValN(PGOMapFeaturesEnum::None, "none", "Disable all options"), clEnumValN(PGOMapFeaturesEnum::FuncEntryCount, "func-entry-count", "Function Entry Count"), clEnumValN(PGOMapFeaturesEnum::BBFreq, "bb-freq", "Basic Block Frequency"), clEnumValN(PGOMapFeaturesEnum::BrProb, "br-prob", "Branch Probability"), clEnumValN(PGOMapFeaturesEnum::All, "all", "Enable all options")), cl::desc("Enable extended information within the SHT_LLVM_BB_ADDR_MAP that is " "extracted from PGO related analysis."))
static void PrintChildLoopComment(raw_ostream &OS, const MachineLoop *Loop, unsigned FunctionNumber)
PrintChildLoopComment - Print comments about child loops within the loop for this basic block,...
static StringRef getMIMnemonic(const MachineInstr &MI, MCStreamer &Streamer)
PGOMapFeaturesEnum
Definition: AsmPrinter.cpp:143
static void emitComments(const MachineInstr &MI, const MCSubtargetInfo *STI, raw_ostream &CommentOS)
emitComments - Pretty-print comments for instructions.
static void PrintParentLoopComment(raw_ostream &OS, const MachineLoop *Loop, unsigned FunctionNumber)
PrintParentLoopComment - Print comments about parent loops of this one.
static void emitGlobalConstantStruct(const DataLayout &DL, const ConstantStruct *CS, AsmPrinter &AP, const Constant *BaseCV, uint64_t Offset, AsmPrinter::AliasMapTy *AliasList)
static void emitGlobalConstantDataSequential(const DataLayout &DL, const ConstantDataSequential *CDS, AsmPrinter &AP, AsmPrinter::AliasMapTy *AliasList)
static void emitKill(const MachineInstr *MI, AsmPrinter &AP)
static void emitGlobalConstantImpl(const DataLayout &DL, const Constant *C, AsmPrinter &AP, const Constant *BaseCV=nullptr, uint64_t Offset=0, AsmPrinter::AliasMapTy *AliasList=nullptr)
static cl::opt< bool > PrintLatency("asm-print-latency", cl::desc("Print instruction latencies as verbose asm comments"), cl::Hidden, cl::init(false))
static bool emitDebugLabelComment(const MachineInstr *MI, AsmPrinter &AP)
This method handles the target-independent form of DBG_LABEL, returning true if it was able to do so.
static bool canBeHidden(const GlobalValue *GV, const MCAsmInfo &MAI)
Definition: AsmPrinter.cpp:645
static void emitGlobalConstantVector(const DataLayout &DL, const Constant *CV, AsmPrinter &AP, AsmPrinter::AliasMapTy *AliasList)
static cl::opt< bool > EmitJumpTableSizesSection("emit-jump-table-sizes-section", cl::desc("Emit a section containing jump table addresses and sizes"), cl::Hidden, cl::init(false))
static void emitGlobalConstantArray(const DataLayout &DL, const ConstantArray *CA, AsmPrinter &AP, const Constant *BaseCV, uint64_t Offset, AsmPrinter::AliasMapTy *AliasList)
static void emitGlobalConstantLargeInt(const ConstantInt *CI, AsmPrinter &AP)
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
Definition: CommandLine.h:686
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Looks at all the uses of the given value Returns the Liveness deduced from the uses of this value Adds all uses that cause the result to be MaybeLive to MaybeLiveRetUses If the result is MaybeLiveUses might be modified but its content should be ignored(since it might not be complete). DeadArgumentEliminationPass
This file defines the DenseMap class.
This file contains constants used for implementing Dwarf debug support.
std::string Name
uint64_t Size
Symbol * Sym
Definition: ELF_riscv.cpp:479
#define DEBUG_TYPE
This file contains the declaration of the GlobalIFunc class, which represents a single indirect funct...
const HexagonInstrInfo * TII
IRTranslator LLVM IR MI
Module.h This file contains the declarations for the Module class.
===- LazyMachineBlockFrequencyInfo.h - Lazy Block Frequency -*- C++ -*–===//
const FeatureInfo AllFeatures[]
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
#define G(x, y, z)
Definition: MD5.cpp:56
This file declares the MachineConstantPool class which is an abstract constant pool to keep track of ...
===- MachineOptimizationRemarkEmitter.h - Opt Diagnostics -*- C++ -*-—===//
static cl::opt< std::string > OutputFilename("o", cl::desc("Output filename"), cl::value_desc("filename"), cl::init("-"))
This file provides utility analysis objects describing memory locations.
This file contains the declarations for metadata subclasses.
if(PassOpts->AAPipeline)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file contains some templates that are useful if you are working with the STL at all.
raw_pwrite_stream & OS
#define OP(OPC)
Definition: Instruction.h:45
This file defines the SmallPtrSet class.
This file defines the SmallString class.
This file defines the SmallVector class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
Definition: Statistic.h:166
This file contains some functions that are useful when dealing with strings.
This file describes how to lower LLVM code to machine code.
Value * RHS
Value * LHS
opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
Definition: APFloat.cpp:5463
double convertToDouble() const
Converts this APFloat to host double value.
Definition: APFloat.cpp:5525
void toString(SmallVectorImpl< char > &Str, unsigned FormatPrecision=0, unsigned FormatMaxPadding=3, bool TruncateZero=true) const
Definition: APFloat.h:1475
APInt bitcastToAPInt() const
Definition: APFloat.h:1351
Class for arbitrary precision integers.
Definition: APInt.h:78
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1468
unsigned getNumWords() const
Get the number of words.
Definition: APInt.h:1475
const uint64_t * getRawData() const
This function returns a pointer to the internal storage of the APInt.
Definition: APInt.h:569
int64_t getSExtValue() const
Get sign extended value.
Definition: APInt.h:1542
void lshrInPlace(unsigned ShiftAmt)
Logical right-shift this APInt by ShiftAmt in place.
Definition: APInt.h:858
AddrLabelMap(MCContext &context)
Definition: AsmPrinter.cpp:229
void UpdateForRAUWBlock(BasicBlock *Old, BasicBlock *New)
Definition: AsmPrinter.cpp:330
void takeDeletedSymbolsForFunction(Function *F, std::vector< MCSymbol * > &Result)
If we have any deleted symbols for F, return them.
Definition: AsmPrinter.cpp:269
void UpdateForDeletedBlock(BasicBlock *BB)
Definition: AsmPrinter.cpp:303
ArrayRef< MCSymbol * > getAddrLabelSymbolToEmit(BasicBlock *BB)
Definition: AsmPrinter.cpp:245
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
void setPreservesAll()
Set by analyses that do not transform their input at all.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:163
virtual ~AsmPrinterHandler()
Pin vtables to this file.
virtual void markFunctionEnd()
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:87
virtual void emitInstruction(const MachineInstr *)
Targets should implement this to emit instructions.
Definition: AsmPrinter.h:562
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
Definition: AsmPrinter.cpp:408
MCSymbol * getSymbolWithGlobalValueBase(const GlobalValue *GV, StringRef Suffix) const
Return the MCSymbol for a private symbol with global value name as its base, with the specified suffi...
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition: AsmPrinter.cpp:697
void emitULEB128(uint64_t Value, const char *Desc=nullptr, unsigned PadTo=0) const
Emit the specified unsigned leb128 value.
SmallVector< XRayFunctionEntry, 4 > Sleds
Definition: AsmPrinter.h:363
MapVector< MBBSectionID, MBBSectionRange > MBBSectionRanges
Definition: AsmPrinter.h:141
bool isDwarf64() const
void emitNops(unsigned N)
Emit N NOP instructions.
MCSymbol * CurrentFnBegin
Definition: AsmPrinter.h:186
MachineLoopInfo * MLI
This is a pointer to the current MachineLoopInfo.
Definition: AsmPrinter.h:114
virtual void emitDebugValue(const MCExpr *Value, unsigned Size) const
Emit the directive and value for debug thread local expression.
Definition: AsmPrinter.cpp:916
void EmitToStreamer(MCStreamer &S, const MCInst &Inst)
Definition: AsmPrinter.cpp:428
virtual void emitConstantPool()
Print to the current output stream assembly representations of the constants in the constant pool MCP...
virtual void emitGlobalVariable(const GlobalVariable *GV)
Emit the specified global variable to the .s file.
Definition: AsmPrinter.cpp:719
virtual const MCExpr * lowerConstantPtrAuth(const ConstantPtrAuth &CPA)
Definition: AsmPrinter.h:583
unsigned int getUnitLengthFieldByteSize() const
Returns 4 for DWARF32 and 12 for DWARF64.
void emitLabelPlusOffset(const MCSymbol *Label, uint64_t Offset, unsigned Size, bool IsSectionRelative=false) const
Emit something like ".long Label+Offset" where the size in bytes of the directive is specified by Siz...
~AsmPrinter() override
Definition: AsmPrinter.cpp:394
TargetMachine & TM
Target machine description.
Definition: AsmPrinter.h:90
void emitXRayTable()
Emit a table with all XRay instrumentation points.
virtual void emitGlobalAlias(const Module &M, const GlobalAlias &GA)
virtual void emitBasicBlockEnd(const MachineBasicBlock &MBB)
Targets can override this to emit stuff at the end of a basic block.
MCSymbol * CurrentFnDescSym
The symbol for the current function descriptor on AIX.
Definition: AsmPrinter.h:128
MCSymbol * CurrentFnBeginLocal
For dso_local functions, the current $local alias for the function.
Definition: AsmPrinter.h:189
MapVector< const MCSymbol *, GOTEquivUsePair > GlobalGOTEquivs
Definition: AsmPrinter.h:146
virtual MCSymbol * GetCPISymbol(unsigned CPID) const
Return the symbol for the specified constant pool entry.
void emitGlobalGOTEquivs()
Constant expressions using GOT equivalent globals may not be eligible for PC relative GOT entry conve...
MCSymbol * getFunctionBegin() const
Definition: AsmPrinter.h:269
void emitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo, unsigned Size) const
Emit something like ".long Hi-Lo" where the size in bytes of the directive is specified by Size and H...
void emitKCFITrapEntry(const MachineFunction &MF, const MCSymbol *Symbol)
virtual void emitMachOIFuncStubHelperBody(Module &M, const GlobalIFunc &GI, MCSymbol *LazyPointer)
Definition: AsmPrinter.h:614
MCSymbol * getMBBExceptionSym(const MachineBasicBlock &MBB)
MCSymbol * getAddrLabelSymbol(const BasicBlock *BB)
Return the symbol to be used for the specified basic block when its address is taken.
Definition: AsmPrinter.h:279
const MCAsmInfo * MAI
Target Asm Printer information.
Definition: AsmPrinter.h:93
SmallVector< std::unique_ptr< AsmPrinterHandler >, 2 > Handlers
Definition: AsmPrinter.h:199
bool emitSpecialLLVMGlobal(const GlobalVariable *GV)
Check to see if the specified global is a special global used by LLVM.
MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:105
virtual void emitJumpTableInfo()
Print assembly representations of the jump tables used by the current function to the current output ...
void computeGlobalGOTEquivs(Module &M)
Unnamed constant global variables solely contaning a pointer to another globals variable act like a g...
static Align getGVAlignment(const GlobalObject *GV, const DataLayout &DL, Align InAlign=Align(1))
Return the alignment for the specified GV.
Definition: AsmPrinter.cpp:361
void emitInt8(int Value) const
Emit a byte directive and value.
CFISection getFunctionCFISectionType(const Function &F) const
Get the CFISection type for a function.
virtual void SetupMachineFunction(MachineFunction &MF)
This should be called when a new MachineFunction is being processed from runOnMachineFunction.
void emitFunctionBody()
This method emits the body and trailer for a function.
virtual bool isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const
Return true if the basic block has exactly one predecessor and the control transfer mechanism between...
void emitBBAddrMapSection(const MachineFunction &MF)
void emitPCSections(const MachineFunction &MF)
Emits the PC sections collected from instructions.
MachineDominatorTree * MDT
This is a pointer to the current MachineDominatorTree.
Definition: AsmPrinter.h:111
virtual void emitStartOfAsmFile(Module &)
This virtual method can be overridden by targets that want to emit something at the start of their fi...
Definition: AsmPrinter.h:538
MCSymbol * GetJTISymbol(unsigned JTID, bool isLinkerPrivate=false) const
Return the symbol for the specified jump table entry.
virtual void emitMachineConstantPoolValue(MachineConstantPoolValue *MCPV)
void emitStackMaps()
Emit the stack maps.
bool hasDebugInfo() const
Returns true if valid debug info is present.
Definition: AsmPrinter.h:440
virtual void emitFunctionBodyStart()
Targets can override this to emit stuff before the first basic block in the function.
Definition: AsmPrinter.h:546
std::pair< const GlobalVariable *, unsigned > GOTEquivUsePair
Map global GOT equivalent MCSymbols to GlobalVariables and keep track of its number of uses by other ...
Definition: AsmPrinter.h:145
void emitPatchableFunctionEntries()
void recordSled(MCSymbol *Sled, const MachineInstr &MI, SledKind Kind, uint8_t Version=0)
virtual void emitEndOfAsmFile(Module &)
This virtual method can be overridden by targets that want to emit something at the end of their file...
Definition: AsmPrinter.h:542
bool doInitialization(Module &M) override
Set up the AsmPrinter when we are working on a new module.
Definition: AsmPrinter.cpp:459
MCSymbol * GetJTSetSymbol(unsigned UID, unsigned MBBID) const
Return the symbol for the specified jump table .set FIXME: privatize to AsmPrinter.
virtual void emitMachOIFuncStubBody(Module &M, const GlobalIFunc &GI, MCSymbol *LazyPointer)
Definition: AsmPrinter.h:608
virtual void emitImplicitDef(const MachineInstr *MI) const
Targets can override this to customize the output of IMPLICIT_DEF instructions in verbose mode.
virtual void emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const
This emits linkage information about GVSym based on GV, if this is supported by the target.
Definition: AsmPrinter.cpp:652
void getAnalysisUsage(AnalysisUsage &AU) const override
Record analysis usage.
Definition: AsmPrinter.cpp:450
unsigned getFunctionNumber() const
Return a unique ID for the current function.
Definition: AsmPrinter.cpp:404
MachineOptimizationRemarkEmitter * ORE
Optimization remark emitter.
Definition: AsmPrinter.h:117
virtual bool shouldEmitWeakSwiftAsyncExtendedFramePointerFlags() const
Definition: AsmPrinter.h:920
void printOffset(int64_t Offset, raw_ostream &OS) const
This is just convenient handler for printing offsets.
void emitGlobalConstant(const DataLayout &DL, const Constant *CV, AliasMapTy *AliasList=nullptr)
EmitGlobalConstant - Print a general LLVM constant to the .s file.
void emitFrameAlloc(const MachineInstr &MI)
void emitStackSizeSection(const MachineFunction &MF)
MCSymbol * getSymbolPreferLocal(const GlobalValue &GV) const
Similar to getSymbol() but preferred for references.
Definition: AsmPrinter.cpp:701
MCSymbol * CurrentFnSym
The symbol for the current function.
Definition: AsmPrinter.h:124
MachineModuleInfo * MMI
This is a pointer to the current MachineModuleInfo.
Definition: AsmPrinter.h:108
void emitSLEB128(int64_t Value, const char *Desc=nullptr) const
Emit the specified signed leb128 value.
void emitAlignment(Align Alignment, const GlobalObject *GV=nullptr, unsigned MaxBytesToEmit=0) const
Emit an alignment directive to the specified power of two boundary.
MCContext & OutContext
This is the context for the output file that we are streaming.
Definition: AsmPrinter.h:97
void emitCFIInstruction(const MachineInstr &MI)
MCSymbol * createTempSymbol(const Twine &Name) const
bool doFinalization(Module &M) override
Shut down the asmprinter.
MCSymbol * GetExternalSymbolSymbol(Twine Sym) const
Return the MCSymbol for the specified ExternalSymbol.
virtual const MCSubtargetInfo * getIFuncMCSubtargetInfo() const
getSubtargetInfo() cannot be used where this is needed because we don't have a MachineFunction when w...
Definition: AsmPrinter.h:604
void emitStackUsage(const MachineFunction &MF)
virtual void emitKCFITypeId(const MachineFunction &MF)
bool isPositionIndependent() const
Definition: AsmPrinter.cpp:399
virtual void emitXXStructorList(const DataLayout &DL, const Constant *List, bool IsCtor)
This method emits llvm.global_ctors or llvm.global_dtors list.
void emitPCSectionsLabel(const MachineFunction &MF, const MDNode &MD)
Emits a label as reference for PC sections.
MCSymbol * CurrentPatchableFunctionEntrySym
The symbol for the entry in __patchable_function_entires.
Definition: AsmPrinter.h:120
virtual void emitBasicBlockStart(const MachineBasicBlock &MBB)
Targets can override this to emit stuff at the start of a basic block.
void takeDeletedSymbolsForFunction(const Function *F, std::vector< MCSymbol * > &Result)
If the specified function has had any references to address-taken blocks generated,...
Definition: AsmPrinter.cpp:294
void emitVisibility(MCSymbol *Sym, unsigned Visibility, bool IsDefinition=true) const
This emits visibility information about symbol, if this is supported by the target.
void emitInt32(int Value) const
Emit a long directive and value.
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
Definition: AsmPrinter.h:102
virtual const MCExpr * lowerConstant(const Constant *CV)
Lower the specified LLVM Constant to an MCExpr.
virtual void emitFunctionDescriptor()
Definition: AsmPrinter.h:571
const MCSection * getCurrentSection() const
Return the current section we are emitting to.
Definition: AsmPrinter.cpp:446
unsigned int getDwarfOffsetByteSize() const
Returns 4 for DWARF32 and 8 for DWARF64.
size_t NumUserHandlers
Definition: AsmPrinter.h:200
MCSymbol * CurrentFnSymForSize
The symbol used to represent the start of the current function for the purpose of calculating its siz...
Definition: AsmPrinter.h:133
bool isVerbose() const
Return true if assembly output should contain comments.
Definition: AsmPrinter.h:260
MCSymbol * getFunctionEnd() const
Definition: AsmPrinter.h:270
virtual void emitXXStructor(const DataLayout &DL, const Constant *CV)
Targets can override this to change how global constants that are part of a C++ static/global constru...
Definition: AsmPrinter.h:579
void preprocessXXStructorList(const DataLayout &DL, const Constant *List, SmallVector< Structor, 8 > &Structors)
This method gathers an array of Structors and then sorts them out by Priority.
void emitInt16(int Value) const
Emit a short directive and value.
void setDwarfVersion(uint16_t Version)
void getNameWithPrefix(SmallVectorImpl< char > &Name, const GlobalValue *GV) const
Definition: AsmPrinter.cpp:692
SmallVector< std::unique_ptr< AsmPrinterHandler >, 1 > EHHandlers
A handle to the EH info emitter (if present).
Definition: AsmPrinter.h:194
void emitPseudoProbe(const MachineInstr &MI)
unsigned getPointerSize() const
Return the pointer size from the TargetMachine.
Definition: AsmPrinter.cpp:419
void emitRemarksSection(remarks::RemarkStreamer &RS)
StackMaps SM
Definition: AsmPrinter.h:202
MCSymbol * GetBlockAddressSymbol(const BlockAddress *BA) const
Return the MCSymbol used to satisfy BlockAddress uses of the specified basic block.
ArrayRef< MCSymbol * > getAddrLabelSymbolToEmit(const BasicBlock *BB)
Return the symbol to be used for the specified basic block when its address is taken.
Definition: AsmPrinter.cpp:286
virtual void emitFunctionBodyEnd()
Targets can override this to emit stuff after the last basic block in the function.
Definition: AsmPrinter.h:550
const DataLayout & getDataLayout() const
Return information about data layout.
Definition: AsmPrinter.cpp:412
virtual void emitFunctionEntryLabel()
EmitFunctionEntryLabel - Emit the label that is the entrypoint for the function.
void emitInitialRawDwarfLocDirective(const MachineFunction &MF)
Emits inital debug location directive.
Definition: AsmPrinter.cpp:432
void emitInt64(uint64_t Value) const
Emit a long long directive and value.
uint16_t getDwarfVersion() const
dwarf::FormParams getDwarfFormParams() const
Returns information about the byte size of DW_FORM values.
const MCSubtargetInfo & getSubtargetInfo() const
Return information about subtarget.
Definition: AsmPrinter.cpp:423
bool usesCFIWithoutEH() const
Since emitting CFI unwind information is entangled with supporting the exceptions,...
bool doesDwarfUseRelocationsAcrossSections() const
Definition: AsmPrinter.h:325
@ None
Do not emit either .eh_frame or .debug_frame.
@ Debug
Emit .debug_frame.
void addAsmPrinterHandler(std::unique_ptr< AsmPrinterHandler > Handler)
virtual std::tuple< const MCSymbol *, uint64_t, const MCSymbol *, codeview::JumpTableEntrySize > getCodeViewJumpTableInfo(int JTI, const MachineInstr *BranchInstr, const MCSymbol *BranchLabel) const
Gets information required to create a CodeView debug symbol for a jump table.
void emitLabelDifferenceAsULEB128(const MCSymbol *Hi, const MCSymbol *Lo) const
Emit something like ".uleb128 Hi-Lo".
AsmPrinter(TargetMachine &TM, std::unique_ptr< MCStreamer > Streamer)
Definition: AsmPrinter.cpp:385
virtual const MCExpr * lowerBlockAddressConstant(const BlockAddress &BA)
Lower the specified BlockAddress to an MCExpr.
LLVM Basic Block Representation.
Definition: BasicBlock.h:61
unsigned getNumber() const
Definition: BasicBlock.h:104
bool hasAddressTaken() const
Returns true if there are any uses of this basic block other than direct branches,...
Definition: BasicBlock.h:661
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:220
The address of a basic block.
Definition: Constants.h:893
BasicBlock * getBasicBlock() const
Definition: Constants.h:924
uint64_t getFrequency() const
Returns the frequency as a fixpoint number scaled by the entry frequency.
uint32_t getNumerator() const
Value handle with callbacks on RAUW and destruction.
Definition: ValueHandle.h:383
virtual void allUsesReplacedWith(Value *)
Callback for Value RAUW.
Definition: ValueHandle.h:423
virtual void deleted()
Callback for Value destruction.
Definition: ValueHandle.h:414
ConstMIBundleOperands - Iterate over all operands in a const bundle of machine instructions.
ConstantArray - Constant Array Declarations.
Definition: Constants.h:427
ArrayType * getType() const
Specialize the getType() method to always return an ArrayType, which reduces the amount of casting ne...
Definition: Constants.h:446
static Constant * get(LLVMContext &Context, ArrayRef< ElementTy > Elts)
get() constructor - Return a constant with array type with an element count and element type matching...
Definition: Constants.h:709
ConstantDataSequential - A vector or array constant whose element type is a simple 1/2/4/8-byte integ...
Definition: Constants.h:587
StringRef getAsString() const
If this array is isString(), then this method returns the array as a StringRef.
Definition: Constants.h:662
uint64_t getElementByteSize() const
Return the size (in bytes) of each element in the array/vector.
Definition: Constants.cpp:2865
bool isString(unsigned CharSize=8) const
This method returns true if this is an array of CharSize integers.
Definition: Constants.cpp:3208
uint64_t getElementAsInteger(unsigned i) const
If this is a sequential container of integers (of any size), return the specified element in the low ...
Definition: Constants.cpp:3115
unsigned getNumElements() const
Return the number of elements in the array or vector.
Definition: Constants.cpp:2858
Type * getElementType() const
Return the element type of the array/vector.
Definition: Constants.cpp:2832
APFloat getElementAsAPFloat(unsigned i) const
If this is a sequential container of floating point type, return the specified element as an APFloat.
Definition: Constants.cpp:3163
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:1108
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2321
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:271
const APFloat & getValueAPF() const
Definition: Constants.h:314
This is the shared class of boolean and integer constants.
Definition: Constants.h:83
uint64_t getLimitedValue(uint64_t Limit=~0ULL) const
getLimitedValue - If the value is smaller than the specified limit, return it, otherwise return the l...
Definition: Constants.h:258
unsigned getBitWidth() const
getBitWidth - Return the scalar bitwidth of this constant.
Definition: Constants.h:151
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:148
A signed pointer, in the ptrauth sense.
Definition: Constants.h:1021
StructType * getType() const
Specialization - reduce amount of casting.
Definition: Constants.h:498
static Constant * getAnon(ArrayRef< Constant * > V, bool Packed=false)
Return an anonymous struct that has the specified elements.
Definition: Constants.h:480
This is an important base class in LLVM.
Definition: Constant.h:42
const Constant * stripPointerCasts() const
Definition: Constant.h:218
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
Definition: Constants.cpp:435
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
Definition: Constants.cpp:90
DWARF expression.
iterator_range< expr_op_iterator > expr_ops() const
unsigned getNumElements() const
static std::optional< const DIExpression * > convertToNonVariadicExpression(const DIExpression *Expr)
If Expr is a valid single-location expression, i.e.
Debug location.
Subprogram description.
Wrapper for a function that represents a value that functionally represents the original function.
Definition: Constants.h:941
This class represents an Operation in the Expression.
bool print(raw_ostream &OS, DIDumpOptions DumpOpts, const DWARFExpression *Expr, DWARFUnit *U) const
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:63
bool isBigEndian() const
Definition: DataLayout.h:198
TypeSize getTypeStoreSize(Type *Ty) const
Returns the maximum number of bytes that may be overwritten by storing the specified type.
Definition: DataLayout.h:421
A debug info location.
Definition: DebugLoc.h:33
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:156
bool erase(const KeyT &Val)
Definition: DenseMap.h:321
bool empty() const
Definition: DenseMap.h:98
iterator end()
Definition: DenseMap.h:84
Collects and handles dwarf debug information.
Definition: DwarfDebug.h:351
const MachineInstr * emitInitialLocDirective(const MachineFunction &MF, unsigned CUID)
Emits inital debug location directive.
Emits exception handling directives.
Definition: EHStreamer.h:30
DISubprogram * getSubprogram() const
Get the attached subprogram.
Definition: Metadata.cpp:1874
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:905
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1048
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
Definition: Function.cpp:369
std::optional< ProfileCount > getEntryCount(bool AllowSynthetic=false) const
Get the entry count for this function.
Definition: Function.cpp:1133
bool needsUnwindTableEntry() const
True if this function needs an unwind table.
Definition: Function.h:682
GCMetadataPrinter - Emits GC metadata as assembly code.
An analysis pass which caches information about the entire Module.
Definition: GCMetadata.h:203
GCStrategy describes a garbage collector algorithm's code generation requirements,...
Definition: GCStrategy.h:63
bool usesMetadata() const
If set, appropriate metadata tables must be emitted by the back-end (assembler, JIT,...
Definition: GCStrategy.h:118
const std::string & getName() const
Return the name of the GC strategy.
Definition: GCStrategy.h:88
const GlobalObject * getAliaseeObject() const
Definition: Globals.cpp:595
const Constant * getAliasee() const
Definition: GlobalAlias.h:86
const Function * getResolverFunction() const
Definition: Globals.cpp:624
const Constant * getResolver() const
Definition: GlobalIFunc.h:72
StringRef getSection() const
Get the custom section of this global if it has one.
Definition: GlobalObject.h:117
MaybeAlign getAlign() const
Returns the alignment of the given variable or function.
Definition: GlobalObject.h:79
bool hasMetadata() const
Return true if this value has any metadata attached to it.
Definition: Value.h:589
bool hasSection() const
Check if this global has a custom object file section.
Definition: GlobalObject.h:109
bool hasLinkOnceLinkage() const
Definition: GlobalValue.h:516
bool hasExternalLinkage() const
Definition: GlobalValue.h:512
bool isDSOLocal() const
Definition: GlobalValue.h:306
bool isThreadLocal() const
If the value is "Thread Local", its value isn't shared by the threads.
Definition: GlobalValue.h:264
VisibilityTypes getVisibility() const
Definition: GlobalValue.h:249
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:296
LinkageTypes getLinkage() const
Definition: GlobalValue.h:547
bool hasLocalLinkage() const
Definition: GlobalValue.h:529
static StringRef dropLLVMManglingEscape(StringRef Name)
If the given string begins with the GlobalValue name mangling escape character '\1',...
Definition: GlobalValue.h:568
bool hasPrivateLinkage() const
Definition: GlobalValue.h:528
bool isTagged() const
Definition: GlobalValue.h:366
bool isDeclarationForLinker() const
Definition: GlobalValue.h:619
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:657
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:295
VisibilityTypes
An enumeration for the kinds of visibility of global values.
Definition: GlobalValue.h:66
@ DefaultVisibility
The GV is visible.
Definition: GlobalValue.h:67
@ HiddenVisibility
The GV is hidden.
Definition: GlobalValue.h:68
@ ProtectedVisibility
The GV is protected.
Definition: GlobalValue.h:69
const DataLayout & getDataLayout() const
Get the data layout of the module this global belongs to.
Definition: Globals.cpp:130
bool canBenefitFromLocalAlias() const
Definition: Globals.cpp:112
bool hasComdat() const
Definition: GlobalValue.h:242
bool hasWeakLinkage() const
Definition: GlobalValue.h:523
bool hasCommonLinkage() const
Definition: GlobalValue.h:533
bool hasGlobalUnnamedAddr() const
Definition: GlobalValue.h:216
bool hasAppendingLinkage() const
Definition: GlobalValue.h:526
static bool isDiscardableIfUnused(LinkageTypes Linkage)
Whether the definition of this global may be discarded if it is not used in its compilation unit.
Definition: GlobalValue.h:450
bool canBeOmittedFromSymbolTable() const
True if GV can be left out of the object symbol table.
Definition: Globals.cpp:425
bool hasAvailableExternallyLinkage() const
Definition: GlobalValue.h:513
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:51
@ PrivateLinkage
Like Internal, but omit from symbol table.
Definition: GlobalValue.h:60
@ CommonLinkage
Tentative definitions.
Definition: GlobalValue.h:62
@ InternalLinkage
Rename collisions when linking (static functions).
Definition: GlobalValue.h:59
@ LinkOnceAnyLinkage
Keep one copy of function when linking (inline)
Definition: GlobalValue.h:54
@ WeakODRLinkage
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:57
@ ExternalLinkage
Externally visible function.
Definition: GlobalValue.h:52
@ WeakAnyLinkage
Keep one copy of named function when linking (weak)
Definition: GlobalValue.h:56
@ AppendingLinkage
Special purpose, only applies to global arrays.
Definition: GlobalValue.h:58
@ AvailableExternallyLinkage
Available for inspection, not emission.
Definition: GlobalValue.h:53
@ ExternalWeakLinkage
ExternalWeak linkage description.
Definition: GlobalValue.h:61
@ LinkOnceODRLinkage
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:55
Type * getValueType() const
Definition: GlobalValue.h:297
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
bool hasInitializer() const
Definitions have initializers, declarations don't.
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
bool isTailCall(const MachineInstr &MI) const override
Itinerary data supplied by a subtarget to be used by a target.
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:311
void emitError(const Instruction *I, const Twine &ErrorStr)
emitError - Emit an error message to the currently installed error handler with optional location inf...
This is an alternative analysis pass to MachineBlockFrequencyInfo.
bool isInnermost() const
Return true if the loop does not contain any (natural) loops.
BlockT * getHeader() const
unsigned getLoopDepth() const
Return the nesting level of this loop.
LoopT * getParentLoop() const
Return the parent loop if it exists or nullptr for top level loops.
LoopT * getLoopFor(const BlockT *BB) const
Return the inner most loop that BB lives in.
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:39
This class is intended to be used as a base class for asm properties and features specific to the tar...
Definition: MCAsmInfo.h:56
bool hasDotTypeDotSizeDirective() const
Definition: MCAsmInfo.h:613
bool useIntegratedAssembler() const
Return true if assembly (inline or otherwise) should be parsed.
Definition: MCAsmInfo.h:698
MCSymbolAttr getProtectedVisibilityAttr() const
Definition: MCAsmInfo.h:634
unsigned getAssemblerDialect() const
Definition: MCAsmInfo.h:567
bool useAssignmentForEHBegin() const
Definition: MCAsmInfo.h:547
bool usesCFIWithoutEH() const
Definition: MCAsmInfo.h:649
bool avoidWeakIfComdat() const
Definition: MCAsmInfo.h:624
bool isAIX() const
Definition: MCAsmInfo.h:524
MCSymbolAttr getHiddenDeclarationVisibilityAttr() const
Definition: MCAsmInfo.h:630
bool hasWeakDefCanBeHiddenDirective() const
Definition: MCAsmInfo.h:620
LCOMM::LCOMMType getLCOMMDirectiveAlignmentType() const
Definition: MCAsmInfo.h:608
bool needsDwarfSectionOffsetDirective() const
Definition: MCAsmInfo.h:518
bool doesSupportDebugInformation() const
Definition: MCAsmInfo.h:640
bool doesSetDirectiveSuppressReloc() const
Definition: MCAsmInfo.h:600
WinEH::EncodingType getWinEHEncodingType() const
Definition: MCAsmInfo.h:643
bool doesDwarfUseRelocationsAcrossSections() const
Definition: MCAsmInfo.h:667
MCSymbolAttr getMemtagAttr() const
Definition: MCAsmInfo.h:638
bool hasSubsectionsViaSymbols() const
Definition: MCAsmInfo.h:463
bool isMachO() const
Definition: MCAsmInfo.h:526
bool usesWindowsCFI() const
Definition: MCAsmInfo.h:661
bool binutilsIsAtLeast(int Major, int Minor) const
Definition: MCAsmInfo.h:705
MCSymbolAttr getHiddenVisibilityAttr() const
Definition: MCAsmInfo.h:626
bool hasSingleParameterDotFile() const
Definition: MCAsmInfo.h:614
const char * getWeakRefDirective() const
Definition: MCAsmInfo.h:618
bool hasNoDeadStrip() const
Definition: MCAsmInfo.h:616
virtual MCSection * getNonexecutableStackSection(MCContext &Ctx) const
Targets can implement this method to specify a section to switch to if the translation unit doesn't h...
Definition: MCAsmInfo.h:482
ExceptionHandling getExceptionHandlingType() const
Definition: MCAsmInfo.h:642
bool needsLocalForSize() const
Definition: MCAsmInfo.h:548
bool hasFunctionAlignment() const
Definition: MCAsmInfo.h:612
bool hasIdentDirective() const
Definition: MCAsmInfo.h:615
unsigned getCodePointerSize() const
Get the code pointer size in bytes.
Definition: MCAsmInfo.h:449
static const MCBinaryExpr * createAdd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:537
static const MCBinaryExpr * createSub(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:622
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)
Definition: MCExpr.cpp:222
Context object for machine code objects.
Definition: MCContext.h:83
const MCObjectFileInfo * getObjectFileInfo() const
Definition: MCContext.h:416
MCSectionMachO * getMachOSection(StringRef Segment, StringRef Section, unsigned TypeAndAttributes, unsigned Reserved2, SectionKind K, const char *BeginSymName=nullptr)
Return the MCSection for the specified mach-o section.
Definition: MCContext.cpp:488
MCSymbol * createTempSymbol()
Create a temporary symbol with a unique name.
Definition: MCContext.cpp:345
MCSymbol * createLinkerPrivateTempSymbol()
Create a new linker temporary symbol with the specified prefix (Name) or "tmp".
Definition: MCContext.cpp:335
MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)
Definition: MCContext.h:551
MCSectionCOFF * getCOFFSection(StringRef Section, unsigned Characteristics, StringRef COMDATSymName, int Selection, unsigned UniqueID=GenericSectionID)
Definition: MCContext.cpp:692
void reportWarning(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:1079
void reportError(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:1072
MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition: MCContext.cpp:212
MCSymbol * createLinkerPrivateSymbol(const Twine &Name)
Definition: MCContext.cpp:339
MCSymbol * createNamedTempSymbol()
Create a temporary symbol with a unique name whose name cannot be omitted in the symbol table.
Definition: MCContext.cpp:347
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:34
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:185
unsigned getOpcode() const
Definition: MCInst.h:199
void setOpcode(unsigned Op)
Definition: MCInst.h:198
Interface to description of machine instruction set.
Definition: MCInstrInfo.h:26
MCSection * getTLSBSSSection() const
MCSection * getStackSizesSection(const MCSection &TextSec) const
MCSection * getBBAddrMapSection(const MCSection &TextSec) const
MCSection * getRemarksSection() const
MCSection * getTLSExtraDataSection() const
MCSection * getKCFITrapSection(const MCSection &TextSec) const
MCSection * getPCSection(StringRef Name, const MCSection *TextSec) const
MCSection * getTextSection() const
MCSection * getDataSection() const
This represents a section on Windows.
Definition: MCSectionCOFF.h:27
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:36
static constexpr unsigned NonUniqueID
Definition: MCSection.h:40
bool isVirtualSection() const
Check whether this section is "virtual", that is has no actual object file contents.
Definition: MCSection.h:197
Streaming machine code generation interface.
Definition: MCStreamer.h:213
virtual void emitBinaryData(StringRef Data)
Functionally identical to EmitBytes.
virtual void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI)
Emit the given Instruction into the current section.
virtual StringRef getMnemonic(const MCInst &MI) const
Returns the mnemonic for MI, if the streamer has access to a instruction printer and returns an empty...
Definition: MCStreamer.h:446
void emitZeros(uint64_t NumBytes)
Emit NumBytes worth of zeros.
Definition: MCStreamer.cpp:229
Generic base class for all target subtargets.
const Triple & getTargetTriple() const
const MCSchedModel & getSchedModel() const
Get the machine model for this subtarget's CPU.
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:192
const MCSymbol & getSymbol() const
Definition: MCExpr.h:411
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:398
StringRef getSymbolTableName() const
Definition: MCSymbolXCOFF.h:68
bool hasRename() const
Definition: MCSymbolXCOFF.h:61
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
bool isDefined() const
isDefined - Check if this symbol is defined (i.e., it has an address).
Definition: MCSymbol.h:250
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:205
bool isVariable() const
isVariable - Check if this is a variable symbol.
Definition: MCSymbol.h:300
void redefineIfPossible()
Prepare this symbol to be redefined.
Definition: MCSymbol.h:232
This represents an "assembler immediate".
Definition: MCValue.h:36
int64_t getConstant() const
Definition: MCValue.h:43
const MCSymbolRefExpr * getSymB() const
Definition: MCValue.h:45
const MCSymbolRefExpr * getSymA() const
Definition: MCValue.h:44
bool isAbsolute() const
Is this an absolute (as opposed to relocatable) value.
Definition: MCValue.h:49
Metadata node.
Definition: Metadata.h:1073
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1434
ArrayRef< MDOperand > operands() const
Definition: Metadata.h:1432
Tracking metadata reference owned by Metadata.
Definition: Metadata.h:895
A single uniqued string.
Definition: Metadata.h:724
StringRef getString() const
Definition: Metadata.cpp:616
unsigned pred_size() const
bool isEHPad() const
Returns true if the block is a landing pad.
MCSymbol * getSymbol() const
Return the MCSymbol for this basic block.
MCSymbol * getEHCatchretSymbol() const
Return the EHCatchret Symbol for this basic block.
bool hasLabelMustBeEmitted() const
Test whether this block must have its label emitted.
int getNumber() const
MachineBasicBlocks are uniquely numbered at the function level, unless they're not in a MachineFuncti...
std::optional< UniqueBBID > getBBID() const
const BasicBlock * getBasicBlock() const
Return the LLVM basic block that this instance corresponded to originally.
unsigned getMaxBytesForAlignment() const
Return the maximum amount of padding allowed for aligning the basic block.
bool isIRBlockAddressTaken() const
Test whether this block is the target of an IR BlockAddress.
MCSymbol * getEndSymbol() const
Returns the MCSymbol marking the end of this basic block.
bool isEHFuncletEntry() const
Returns true if this is the entry block of an EH funclet.
bool sameSection(const MachineBasicBlock *MBB) const
Returns true if this and MBB belong to the same section.
unsigned succ_size() const
bool isReturnBlock() const
Convenience function that returns true if the block ends in a return instruction.
MBBSectionID getSectionID() const
Returns the section ID of this basic block.
bool isEntryBlock() const
Returns true if this is the entry block of the function.
BasicBlock * getAddressTakenIRBlock() const
Retrieves the BasicBlock which corresponds to this MachineBasicBlock.
bool isEHCatchretTarget() const
Returns true if this is a target block of a catchret.
bool isLayoutSuccessor(const MachineBasicBlock *MBB) const
Return true if the specified MBB will be emitted immediately after this block, such that if this bloc...
instr_iterator instr_end()
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
bool isBeginSection() const
Returns true if this block begins any section.
iterator_range< iterator > terminators()
iterator_range< succ_iterator > successors()
reverse_iterator rbegin()
bool isMachineBlockAddressTaken() const
Test whether this block is used as something other than the target of a terminator,...
bool isEndSection() const
Returns true if this block ends any section.
Align getAlignment() const
Return alignment of the basic block.
StringRef getName() const
Return the name of the corresponding LLVM basic block, or an empty string.
MachineBlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate machine basic b...
BlockFrequency getBlockFreq(const MachineBasicBlock *MBB) const
getblockFreq - Return block frequency.
BranchProbability getEdgeProbability(const MachineBasicBlock *Src, const MachineBasicBlock *Dst) const
This class is a data container for one entry in a MachineConstantPool.
bool isMachineConstantPoolEntry() const
isMachineConstantPoolEntry - Return true if the MachineConstantPoolEntry is indeed a target specific ...
union llvm::MachineConstantPoolEntry::@204 Val
The constant itself.
MachineConstantPoolValue * MachineCPVal
Align Alignment
The required alignment for this entry.
unsigned getSizeInBytes(const DataLayout &DL) const
SectionKind getSectionKind(const DataLayout *DL) const
Abstract base class for all machine specific constantpool value subclasses.
The MachineConstantPool class keeps track of constants referenced by a function which must be spilled...
const std::vector< MachineConstantPoolEntry > & getConstants() const
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
bool needsSplitStackProlog() const
Return true if this function requires a split stack prolog, even if it uses no stack space.
bool hasVarSizedObjects() const
This method may be called any time after instruction selection is complete to determine if the stack ...
uint64_t getStackSize() const
Return the number of bytes that must be allocated to hold all of the fixed size frame objects.
uint64_t getUnsafeStackSize() const
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
unsigned getFunctionNumber() const
getFunctionNumber - Return a unique ID for the current function.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
const std::vector< MCCFIInstruction > & getFrameInstructions() const
Returns a reference to a list of cfi instructions in the function's prologue.
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
void setSection(MCSection *S)
Indicates the Section this function belongs to.
MCSymbol * getJTISymbol(unsigned JTI, MCContext &Ctx, bool isLinkerPrivate=false) const
getJTISymbol - Return the MCSymbol for the specified non-empty jump table.
void push_back(MachineBasicBlock *MBB)
reverse_iterator rbegin()
bool hasBBSections() const
Returns true if this function has basic block sections enabled.
MCContext & getContext() const
unsigned size() const
const DataLayout & getDataLayout() const
Return the DataLayout attached to the Module associated to this MF.
Align getAlignment() const
getAlignment - Return the alignment of the function.
Function & getFunction()
Return the LLVM function that this machine code represents.
const std::vector< LandingPadInfo > & getLandingPads() const
Return a reference to the landing pad info for the current function.
MCSection * getSection() const
Returns the Section this function belongs to.
const MachineBasicBlock & back() const
bool shouldSplitStack() const
Should we be emitting segmented stack stuff for the function.
MachineConstantPool * getConstantPool()
getConstantPool - Return the constant pool object for the current function.
const MachineBasicBlock & front() const
const MachineJumpTableInfo * getJumpTableInfo() const
getJumpTableInfo - Return the jump table info object for the current function.
const TargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
Representation of each machine instruction.
Definition: MachineInstr.h:71
unsigned getEntrySize(const DataLayout &TD) const
getEntrySize - Return the size of each entry in the jump table.
@ EK_GPRel32BlockAddress
EK_GPRel32BlockAddress - Each entry is an address of block, encoded with a relocation as gp-relative,...
@ EK_Inline
EK_Inline - Jump table entries are emitted inline at their point of use.
@ EK_LabelDifference32
EK_LabelDifference32 - Each entry is the address of the block minus the address of the jump table.
@ EK_Custom32
EK_Custom32 - Each entry is a 32-bit value that is custom lowered by the TargetLowering::LowerCustomJ...
@ EK_LabelDifference64
EK_LabelDifference64 - Each entry is the address of the block minus the address of the jump table.
@ EK_BlockAddress
EK_BlockAddress - Each entry is a plain address of block, e.g.: .word LBB123.
@ EK_GPRel64BlockAddress
EK_GPRel64BlockAddress - Each entry is an address of block, encoded with a relocation as gp-relative,...
unsigned getEntryAlignment(const DataLayout &TD) const
getEntryAlignment - Return the alignment of each entry in the jump table.
JTEntryKind getEntryKind() const
const std::vector< MachineJumpTableEntry > & getJumpTables() const
MachineModuleInfoCOFF - This is a MachineModuleInfoImpl implementation for COFF targets.
SymbolListTy GetGVStubList()
Accessor methods to return the set of stubs in sorted order.
MachineModuleInfoELF - This is a MachineModuleInfoImpl implementation for ELF targets.
SymbolListTy GetGVStubList()
Accessor methods to return the set of stubs in sorted order.
std::vector< std::pair< MCSymbol *, StubValueTy > > SymbolListTy
const MCContext & getContext() const
const Module * getModule() const
Ty & getObjFileInfo()
Keep track of various per-module pieces of information for backends that would like to do so.
MachineOperand class - Representation of each machine instruction operand.
@ MO_Immediate
Immediate operand.
@ MO_CImmediate
Immediate >64bit operand.
@ MO_FrameIndex
Abstract Stack Frame Index.
@ MO_Register
Register operand.
@ MO_TargetIndex
Target-dependent index+offset operand.
@ MO_FPImmediate
Floating-point immediate operand.
Diagnostic information for optimization analysis remarks.
void emit(DiagnosticInfoOptimizationBase &OptDiag)
Emit an optimization remark.
bool allowExtraAnalysis(StringRef PassName) const
Whether we allow for extra compile-time budget to perform more analysis to be more informative.
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:121
This class implements a map that also provides access to all stored values in a deterministic order.
Definition: MapVector.h:36
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
StringRef getName() const
Get a short "name" for the module.
Definition: Module.h:285
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.h:294
Metadata * getModuleFlag(StringRef Key) const
Return the corresponding value if Key appears in module flags, otherwise return null.
Definition: Module.cpp:354
A tuple of MDNodes.
Definition: Metadata.h:1737
unsigned getNumOperands() const
Definition: Metadata.cpp:1421
iterator_range< op_iterator > operands()
Definition: Metadata.h:1833
Wrapper for a value that won't be replaced with a CFI jump table pointer in LowerTypeTestsModule.
Definition: Constants.h:980
static PointerType * getUnqual(Type *ElementType)
This constructs a pointer to an object of the specified type in the default address space (address sp...
Definition: DerivedTypes.h:686
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
static iterator_range< iterator > entries()
Definition: Registry.h:113
SimpleRegistryEntry< T > entry
Definition: Registry.h:47
Represents a location in source code.
Definition: SMLoc.h:23
SectionKind - This is a simple POD value that classifies the properties of a section.
Definition: SectionKind.h:22
bool isCommon() const
Definition: SectionKind.h:173
bool isBSS() const
Definition: SectionKind.h:169
static SectionKind getReadOnlyWithRel()
Definition: SectionKind.h:214
bool isBSSLocal() const
Definition: SectionKind.h:170
bool isThreadBSS() const
Definition: SectionKind.h:161
bool isThreadLocal() const
Definition: SectionKind.h:157
bool isThreadData() const
Definition: SectionKind.h:162
static SectionKind getReadOnly()
Definition: SectionKind.h:192
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:384
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:519
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
bool empty() const
Definition: SmallVector.h:81
size_t size() const
Definition: SmallVector.h:78
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:573
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:937
void push_back(const T &Elt)
Definition: SmallVector.h:413
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1196
void serializeToStackMapSection()
If there is any stack map data, create a stack map section and serialize the map info into it.
Definition: StackMaps.cpp:715
int64_t getFixed() const
Returns the fixed component of the stack.
Definition: TypeSize.h:49
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:51
constexpr StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:571
bool contains(StringRef Other) const
Return true if the given string is a substring of *this, and false otherwise.
Definition: StringRef.h:424
size_t find(char C, size_t From=0) const
Search for the first character C in the string.
Definition: StringRef.h:297
Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...
Definition: DataLayout.h:567
TypeSize getSizeInBytes() const
Definition: DataLayout.h:574
TypeSize getElementOffset(unsigned Idx) const
Definition: DataLayout.h:596
Class to represent struct types.
Definition: DerivedTypes.h:218
unsigned getNumElements() const
Random access to the elements.
Definition: DerivedTypes.h:365
Information about stack frame layout on the target.
virtual StackOffset getFrameIndexReference(const MachineFunction &MF, int FI, Register &FrameReg) const
getFrameIndexReference - This method should return the base register and offset used to reference a f...
TargetInstrInfo - Interface to description of machine instruction set.
virtual MCInst getNop() const
Return the noop instruction to use for a noop.
Align getMinFunctionAlignment() const
Return the minimum function alignment.
virtual MCSection * getSectionForCommandLines() const
If supported, return the section to use for the llvm.commandline metadata.
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.
virtual void emitModuleMetadata(MCStreamer &Streamer, Module &M) const
Emit the module-level metadata that the platform cares about.
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
bool supportGOTPCRelWithOffset() const
Target GOT "PC"-relative relocation supports encoding an additional binary expression with an offset?
bool supportIndirectSymViaGOTPCRel() const
Target supports replacing a data "PC"-relative access to a symbol through another symbol,...
virtual MCSymbol * getFunctionEntryPointSymbol(const GlobalValue *Func, const TargetMachine &TM) const
If supported, return the function entry point symbol.
virtual const MCExpr * lowerRelativeReference(const GlobalValue *LHS, const GlobalValue *RHS, 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...
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
virtual const MCExpr * getPICJumpTableRelocBaseExpr(const MachineFunction *MF, unsigned JTI, MCContext &Ctx) const
This returns the relocation base for the given PIC jumptable, the same as getPICJumpTableRelocBase,...
virtual const MCExpr * LowerCustomJumpTableEntry(const MachineJumpTableInfo *, const MachineBasicBlock *, unsigned, MCContext &) const
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:77
bool isPositionIndependent() const
virtual bool isNoopAddrSpaceCast(unsigned SrcAS, unsigned DestAS) const
Returns true if a cast between SrcAS and DestAS is a noop.
const Triple & getTargetTriple() const
const MCSubtargetInfo * getMCSubtargetInfo() const
bool useEmulatedTLS() const
Returns true if this target uses emulated TLS.
unsigned getPointerSize(unsigned AS) const
Get the pointer size for this target.
virtual TargetLoweringObjectFile * getObjFileLowering() const
Reloc::Model getRelocationModel() const
Returns the code generation relocation model.
virtual const TargetSubtargetInfo * getSubtargetImpl(const Function &) const
Virtual method implemented by subclasses that returns a reference to that target's TargetSubtargetInf...
TargetOptions Options
MCSymbol * getSymbol(const GlobalValue *GV) const
unsigned getProgramPointerSize() const
CodeModel::Model getCodeModel() const
Returns the code model.
void getNameWithPrefix(SmallVectorImpl< char > &Name, const GlobalValue *GV, Mangler &Mang, bool MayAlwaysUsePrivate=false) const
const MCAsmInfo * getMCAsmInfo() const
Return target specific asm information.
unsigned EmitStackSizeSection
Emit section containing metadata on function stack sizes.
unsigned EmitAddrsig
Emit address-significance table.
unsigned UseInitArray
UseInitArray - Use .init_array instead of .ctors for static constructors.
MCTargetOptions MCOptions
Machine level options.
unsigned ForceDwarfFrameSection
Emit DWARF debug frame section.
std::string StackUsageOutput
Name of the stack usage file (i.e., .su file) if user passes -fstack-usage.
unsigned XRayFunctionIndex
Emit XRay Function Index section.
TargetSubtargetInfo - Generic base class for all target subtargets.
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
virtual const TargetFrameLowering * getFrameLowering() const
virtual const TargetInstrInfo * getInstrInfo() const
virtual const TargetLowering * getTargetLowering() const
Target - Wrapper for Target specific information.
TinyPtrVector - This class is specialized for cases where there are normally 0 or 1 element in a vect...
Definition: TinyPtrVector.h:29
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
bool isOSBinFormatMachO() const
Tests whether the environment is MachO.
Definition: Triple.h:763
bool isOSBinFormatCOFF() const
Tests whether the OS uses the COFF binary format.
Definition: Triple.h:755
bool isOSWindows() const
Tests whether the OS is Windows.
Definition: Triple.h:655
bool isOSBinFormatXCOFF() const
Tests whether the OS uses the XCOFF binary format.
Definition: Triple.h:773
bool isOSAIX() const
Tests whether the OS is AIX.
Definition: Triple.h:741
bool isOSBinFormatELF() const
Tests whether the OS uses the ELF binary format.
Definition: Triple.h:750
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
bool isFloatTy() const
Return true if this is 'float', a 32-bit IEEE fp type.
Definition: Type.h:153
bool isBFloatTy() const
Return true if this is 'bfloat', a 16-bit bfloat type.
Definition: Type.h:145
void print(raw_ostream &O, bool IsForDebug=false, bool NoDetails=false) const
Print the current type.
bool isPPC_FP128Ty() const
Return true if this is powerpc long double.
Definition: Type.h:165
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
Definition: Type.h:310
bool isHalfTy() const
Return true if this is 'half', a 16-bit IEEE fp type.
Definition: Type.h:142
bool isDoubleTy() const
Return true if this is 'double', a 64-bit IEEE fp type.
Definition: Type.h:156
bool isFunctionTy() const
True if this is an instance of FunctionType.
Definition: Type.h:255
Value * getOperand(unsigned i) const
Definition: User.h:228
unsigned getNumOperands() const
Definition: User.h:250
Value * operator=(Value *RHS)
Definition: ValueHandle.h:69
LLVM Value Representation.
Definition: Value.h:74
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
bool hasOneUse() const
Return true if there is exactly one use of this value.
Definition: Value.h:434
iterator_range< user_iterator > users()
Definition: Value.h:421
User * user_back()
Definition: Value.h:407
void printAsOperand(raw_ostream &O, bool PrintType=true, const Module *M=nullptr) const
Print the name of this Value out to the specified raw_ostream.
Definition: AsmWriter.cpp:5144
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
Definition: Value.cpp:694
bool use_empty() const
Definition: Value.h:344
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:1075
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:309
reverse_self_iterator getReverseIterator()
Definition: ilist_node.h:135
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
raw_ostream & indent(unsigned NumSpaces)
indent - Insert 'NumSpaces' spaces.
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:661
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:691
std::optional< StringRef > getFilename() const
Return the filename that the remark diagnostics are emitted to.
bool needsSection() const
Check if the remarks also need to have associated metadata in a section.
remarks::RemarkSerializer & getSerializer()
Return the serializer used for this stream.
StringRef OperationEncodingString(unsigned Encoding)
Definition: Dwarf.cpp:138
This file contains the declaration of the Comdat class, which represents a single COMDAT in LLVM.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ IMAGE_SCN_MEM_READ
Definition: COFF.h:335
@ IMAGE_SCN_MEM_DISCARDABLE
Definition: COFF.h:330
@ IMAGE_SCN_LNK_INFO
Definition: COFF.h:306
@ IMAGE_SCN_CNT_INITIALIZED_DATA
Definition: COFF.h:303
@ IMAGE_SCN_LNK_COMDAT
Definition: COFF.h:308
@ IMAGE_SYM_CLASS_EXTERNAL
External symbol.
Definition: COFF.h:223
@ IMAGE_SYM_CLASS_STATIC
Static.
Definition: COFF.h:224
@ IMAGE_COMDAT_SELECT_ASSOCIATIVE
Definition: COFF.h:458
@ IMAGE_COMDAT_SELECT_ANY
Definition: COFF.h:455
@ IMAGE_SYM_DTYPE_FUNCTION
A function that returns a base type.
Definition: COFF.h:275
@ SCT_COMPLEX_TYPE_SHIFT
Type is formed as (base + (derived << SCT_COMPLEX_TYPE_SHIFT))
Definition: COFF.h:279
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
@ SHT_LLVM_JT_SIZES
Definition: ELF.h:1141
@ SHT_PROGBITS
Definition: ELF.h:1098
@ SHT_LLVM_SYMPART
Definition: ELF.h:1131
@ SHF_ALLOC
Definition: ELF.h:1198
@ SHF_LINK_ORDER
Definition: ELF.h:1213
@ SHF_GROUP
Definition: ELF.h:1220
@ SHF_WRITE
Definition: ELF.h:1195
@ STT_FUNC
Definition: ELF.h:1365
@ S_ATTR_LIVE_SUPPORT
S_ATTR_LIVE_SUPPORT - Blocks are live if they reference live blocks.
Definition: MachO.h:202
@ Itanium
Windows CE ARM, PowerPC, SH3, SH4.
@ X86
Windows x64, Windows Itanium (IA-64)
ValuesClass values(OptsTy... Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
Definition: CommandLine.h:711
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:443
@ CommaSeparated
Definition: CommandLine.h:163
uint8_t getUnitLengthFieldByteSize(DwarfFormat Format)
Get the byte size of the unit length field depending on the DWARF format.
Definition: Dwarf.h:1110
@ DWARF64
Definition: Dwarf.h:91
uint8_t getDwarfOffsetByteSize(DwarfFormat Format)
The size of a reference determined by the DWARF 32/64-bit format.
Definition: Dwarf.h:1071
DiagnosticInfoOptimizationBase::Argument NV
void make_absolute(const Twine &current_directory, SmallVectorImpl< char > &path)
Make path an absolute path.
Definition: Path.cpp:906
@ OF_Text
The file should be opened in text mode on platforms like z/OS that make this distinction.
Definition: FileSystem.h:754
StringRef filename(StringRef path LLVM_LIFETIME_BOUND, Style style=Style::native)
Get filename.
Definition: Path.cpp:577
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:480
void stable_sort(R &&Range)
Definition: STLExtras.h:2037
int popcount(T Value) noexcept
Count the number of set bits in a value.
Definition: bit.h:385
ExceptionHandling
@ SjLj
setjmp/longjmp based exceptions
@ ZOS
z/OS MVS Exception Handling.
@ None
No exception support.
@ AIX
AIX Exception Handling.
@ DwarfCFI
DWARF-like instruction based exceptions.
@ WinEH
Windows Exception Handling.
@ Wasm
WebAssembly Exception Handling.
bool IsConstantOffsetFromGlobal(Constant *C, GlobalValue *&GV, APInt &Offset, const DataLayout &DL, DSOLocalEquivalent **DSOEquiv=nullptr)
If this constant is a constant offset from a global, return the global and the constant.
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
Definition: STLExtras.h:2115
@ MCDR_DataRegionEnd
.end_data_region
Definition: MCDirectives.h:66
@ MCDR_DataRegionJT32
.data_region jt32
Definition: MCDirectives.h:65
bool isNoOpWithoutInvoke(EHPersonality Pers)
Return true if this personality may be safely removed if there are no invoke instructions remaining i...
Constant * ConstantFoldConstant(const Constant *C, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldConstant - Fold the constant using the specified DataLayout.
auto reverse(ContainerTy &&C)
Definition: STLExtras.h:420
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1664
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:167
EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:125
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
@ Global
Append to llvm.global_dtors.
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:155
constexpr unsigned BitWidth
Definition: BitmaskEnum.h:217
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1873
Constant * ConstantFoldIntegerCast(Constant *C, Type *DestTy, bool IsSigned, const DataLayout &DL)
Constant fold a zext, sext or trunc, depending on IsSigned and whether the DestTy is wider or narrowe...
Printable printReg(Register Reg, const TargetRegisterInfo *TRI=nullptr, unsigned SubIdx=0, const MachineRegisterInfo *MRI=nullptr)
Prints virtual and physical registers with or without a TRI instance.
MCSymbolAttr
Definition: MCDirectives.h:18
@ MCSA_Local
.local (ELF)
Definition: MCDirectives.h:38
@ MCSA_WeakDefAutoPrivate
.weak_def_can_be_hidden (MachO)
Definition: MCDirectives.h:48
@ MCSA_WeakReference
.weak_reference (MachO)
Definition: MCDirectives.h:47
@ MCSA_AltEntry
.alt_entry (MachO)
Definition: MCDirectives.h:41
@ MCSA_ELF_TypeIndFunction
.type _foo, STT_GNU_IFUNC
Definition: MCDirectives.h:24
@ MCSA_Weak
.weak
Definition: MCDirectives.h:45
@ MCSA_WeakDefinition
.weak_definition (MachO)
Definition: MCDirectives.h:46
@ MCSA_Global
.type _foo, @gnu_unique_object
Definition: MCDirectives.h:30
@ MCSA_Cold
.cold (MachO)
Definition: MCDirectives.h:22
@ MCSA_ELF_TypeObject
.type _foo, STT_OBJECT # aka @object
Definition: MCDirectives.h:25
@ MCSA_ELF_TypeFunction
.type _foo, STT_FUNC # aka @function
Definition: MCDirectives.h:23
@ MCSA_Invalid
Not a valid directive.
Definition: MCDirectives.h:19
@ MCSA_NoDeadStrip
.no_dead_strip (MachO)
Definition: MCDirectives.h:39
constexpr const char * PseudoProbeDescMetadataName
Definition: PseudoProbe.h:25
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:860
#define N
#define NC
Definition: regutils.h:42
static constexpr roundingMode rmNearestTiesToEven
Definition: APFloat.h:302
static const fltSemantics & IEEEdouble() LLVM_READNONE
Definition: APFloat.cpp:258
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
Map a basic block section ID to the begin and end symbols of that section which determine the section...
Definition: AsmPrinter.h:137
llvm.global_ctors and llvm.global_dtors are arrays of Structor structs.
Definition: AsmPrinter.h:472
void emit(int, MCStreamer *) const
Description of the encoding of one expression Op.
Machine model for scheduling, bundling, and heuristics.
Definition: MCSchedule.h:256
static int computeInstrLatency(const MCSubtargetInfo &STI, const MCSchedClassDesc &SCDesc)
Returns the latency value for the scheduling class.
Definition: MCSchedule.cpp:42
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:117
A helper struct providing information about the byte size of DW_FORM values that vary in size dependi...
Definition: Dwarf.h:1084
This is the base class for a remark serializer.
virtual std::unique_ptr< MetaSerializer > metaSerializer(raw_ostream &OS, std::optional< StringRef > ExternalFilename=std::nullopt)=0
Return the corresponding metadata serializer.