LLVM 19.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/MCSection.h"
99#include "llvm/MC/MCStreamer.h"
101#include "llvm/MC/MCSymbol.h"
102#include "llvm/MC/MCSymbolELF.h"
104#include "llvm/MC/MCValue.h"
105#include "llvm/MC/SectionKind.h"
106#include "llvm/Object/ELFTypes.h"
107#include "llvm/Pass.h"
109#include "llvm/Support/Casting.h"
113#include "llvm/Support/Format.h"
115#include "llvm/Support/Path.h"
116#include "llvm/Support/Timer.h"
122#include <algorithm>
123#include <cassert>
124#include <cinttypes>
125#include <cstdint>
126#include <iterator>
127#include <memory>
128#include <optional>
129#include <string>
130#include <utility>
131#include <vector>
132
133using namespace llvm;
134
135#define DEBUG_TYPE "asm-printer"
136
137// This is a replication of fields of object::PGOAnalysisMap::Features. It
138// should match the order of the fields so that
139// `object::PGOAnalysisMap::Features::decode(PgoAnalysisMapFeatures.getBits())`
140// succeeds.
143 BBFreq,
144 BrProb,
145};
147 "pgo-analysis-map", cl::Hidden, cl::CommaSeparated,
149 "func-entry-count", "Function Entry Count"),
151 "Basic Block Frequency"),
153 "Branch Probability")),
154 cl::desc(
155 "Enable extended information within the SHT_LLVM_BB_ADDR_MAP that is "
156 "extracted from PGO related analysis."));
157
158const char DWARFGroupName[] = "dwarf";
159const char DWARFGroupDescription[] = "DWARF Emission";
160const char DbgTimerName[] = "emit";
161const char DbgTimerDescription[] = "Debug Info Emission";
162const char EHTimerName[] = "write_exception";
163const char EHTimerDescription[] = "DWARF Exception Writer";
164const char CFGuardName[] = "Control Flow Guard";
165const char CFGuardDescription[] = "Control Flow Guard";
166const char CodeViewLineTablesGroupName[] = "linetables";
167const char CodeViewLineTablesGroupDescription[] = "CodeView Line Tables";
168const char PPTimerName[] = "emit";
169const char PPTimerDescription[] = "Pseudo Probe Emission";
170const char PPGroupName[] = "pseudo probe";
171const char PPGroupDescription[] = "Pseudo Probe Emission";
172
173STATISTIC(EmittedInsts, "Number of machine instrs printed");
174
175char AsmPrinter::ID = 0;
176
177namespace {
178class AddrLabelMapCallbackPtr final : CallbackVH {
179 AddrLabelMap *Map = nullptr;
180
181public:
182 AddrLabelMapCallbackPtr() = default;
183 AddrLabelMapCallbackPtr(Value *V) : CallbackVH(V) {}
184
185 void setPtr(BasicBlock *BB) {
187 }
188
189 void setMap(AddrLabelMap *map) { Map = map; }
190
191 void deleted() override;
192 void allUsesReplacedWith(Value *V2) override;
193};
194} // namespace
195
197 MCContext &Context;
198 struct AddrLabelSymEntry {
199 /// The symbols for the label.
201
202 Function *Fn; // The containing function of the BasicBlock.
203 unsigned Index; // The index in BBCallbacks for the BasicBlock.
204 };
205
206 DenseMap<AssertingVH<BasicBlock>, AddrLabelSymEntry> AddrLabelSymbols;
207
208 /// Callbacks for the BasicBlock's that we have entries for. We use this so
209 /// we get notified if a block is deleted or RAUWd.
210 std::vector<AddrLabelMapCallbackPtr> BBCallbacks;
211
212 /// This is a per-function list of symbols whose corresponding BasicBlock got
213 /// deleted. These symbols need to be emitted at some point in the file, so
214 /// AsmPrinter emits them after the function body.
215 DenseMap<AssertingVH<Function>, std::vector<MCSymbol *>>
216 DeletedAddrLabelsNeedingEmission;
217
218public:
219 AddrLabelMap(MCContext &context) : Context(context) {}
220
222 assert(DeletedAddrLabelsNeedingEmission.empty() &&
223 "Some labels for deleted blocks never got emitted");
224 }
225
227
229 std::vector<MCSymbol *> &Result);
230
233};
234
236 assert(BB->hasAddressTaken() &&
237 "Shouldn't get label for block without address taken");
238 AddrLabelSymEntry &Entry = AddrLabelSymbols[BB];
239
240 // If we already had an entry for this block, just return it.
241 if (!Entry.Symbols.empty()) {
242 assert(BB->getParent() == Entry.Fn && "Parent changed");
243 return Entry.Symbols;
244 }
245
246 // Otherwise, this is a new entry, create a new symbol for it and add an
247 // entry to BBCallbacks so we can be notified if the BB is deleted or RAUWd.
248 BBCallbacks.emplace_back(BB);
249 BBCallbacks.back().setMap(this);
250 Entry.Index = BBCallbacks.size() - 1;
251 Entry.Fn = BB->getParent();
253 : Context.createTempSymbol();
254 Entry.Symbols.push_back(Sym);
255 return Entry.Symbols;
256}
257
258/// If we have any deleted symbols for F, return them.
260 Function *F, std::vector<MCSymbol *> &Result) {
261 DenseMap<AssertingVH<Function>, std::vector<MCSymbol *>>::iterator I =
262 DeletedAddrLabelsNeedingEmission.find(F);
263
264 // If there are no entries for the function, just return.
265 if (I == DeletedAddrLabelsNeedingEmission.end())
266 return;
267
268 // Otherwise, take the list.
269 std::swap(Result, I->second);
270 DeletedAddrLabelsNeedingEmission.erase(I);
271}
272
273//===- Address of Block Management ----------------------------------------===//
274
277 // Lazily create AddrLabelSymbols.
278 if (!AddrLabelSymbols)
279 AddrLabelSymbols = std::make_unique<AddrLabelMap>(OutContext);
280 return AddrLabelSymbols->getAddrLabelSymbolToEmit(
281 const_cast<BasicBlock *>(BB));
282}
283
285 const Function *F, std::vector<MCSymbol *> &Result) {
286 // If no blocks have had their addresses taken, we're done.
287 if (!AddrLabelSymbols)
288 return;
289 return AddrLabelSymbols->takeDeletedSymbolsForFunction(
290 const_cast<Function *>(F), Result);
291}
292
294 // If the block got deleted, there is no need for the symbol. If the symbol
295 // was already emitted, we can just forget about it, otherwise we need to
296 // queue it up for later emission when the function is output.
297 AddrLabelSymEntry Entry = std::move(AddrLabelSymbols[BB]);
298 AddrLabelSymbols.erase(BB);
299 assert(!Entry.Symbols.empty() && "Didn't have a symbol, why a callback?");
300 BBCallbacks[Entry.Index] = nullptr; // Clear the callback.
301
302#if !LLVM_MEMORY_SANITIZER_BUILD
303 // BasicBlock is destroyed already, so this access is UB detectable by msan.
304 assert((BB->getParent() == nullptr || BB->getParent() == Entry.Fn) &&
305 "Block/parent mismatch");
306#endif
307
308 for (MCSymbol *Sym : Entry.Symbols) {
309 if (Sym->isDefined())
310 return;
311
312 // If the block is not yet defined, we need to emit it at the end of the
313 // function. Add the symbol to the DeletedAddrLabelsNeedingEmission list
314 // for the containing Function. Since the block is being deleted, its
315 // parent may already be removed, we have to get the function from 'Entry'.
316 DeletedAddrLabelsNeedingEmission[Entry.Fn].push_back(Sym);
317 }
318}
319
321 // Get the entry for the RAUW'd block and remove it from our map.
322 AddrLabelSymEntry OldEntry = std::move(AddrLabelSymbols[Old]);
323 AddrLabelSymbols.erase(Old);
324 assert(!OldEntry.Symbols.empty() && "Didn't have a symbol, why a callback?");
325
326 AddrLabelSymEntry &NewEntry = AddrLabelSymbols[New];
327
328 // If New is not address taken, just move our symbol over to it.
329 if (NewEntry.Symbols.empty()) {
330 BBCallbacks[OldEntry.Index].setPtr(New); // Update the callback.
331 NewEntry = std::move(OldEntry); // Set New's entry.
332 return;
333 }
334
335 BBCallbacks[OldEntry.Index] = nullptr; // Update the callback.
336
337 // Otherwise, we need to add the old symbols to the new block's set.
338 llvm::append_range(NewEntry.Symbols, OldEntry.Symbols);
339}
340
341void AddrLabelMapCallbackPtr::deleted() {
342 Map->UpdateForDeletedBlock(cast<BasicBlock>(getValPtr()));
343}
344
345void AddrLabelMapCallbackPtr::allUsesReplacedWith(Value *V2) {
346 Map->UpdateForRAUWBlock(cast<BasicBlock>(getValPtr()), cast<BasicBlock>(V2));
347}
348
349/// getGVAlignment - Return the alignment to use for the specified global
350/// value. This rounds up to the preferred alignment if possible and legal.
352 Align InAlign) {
353 Align Alignment;
354 if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV))
355 Alignment = DL.getPreferredAlign(GVar);
356
357 // If InAlign is specified, round it to it.
358 if (InAlign > Alignment)
359 Alignment = InAlign;
360
361 // If the GV has a specified alignment, take it into account.
362 const MaybeAlign GVAlign(GV->getAlign());
363 if (!GVAlign)
364 return Alignment;
365
366 assert(GVAlign && "GVAlign must be set");
367
368 // If the GVAlign is larger than NumBits, or if we are required to obey
369 // NumBits because the GV has an assigned section, obey it.
370 if (*GVAlign > Alignment || GV->hasSection())
371 Alignment = *GVAlign;
372 return Alignment;
373}
374
375AsmPrinter::AsmPrinter(TargetMachine &tm, std::unique_ptr<MCStreamer> Streamer)
376 : MachineFunctionPass(ID), TM(tm), MAI(tm.getMCAsmInfo()),
377 OutContext(Streamer->getContext()), OutStreamer(std::move(Streamer)),
378 SM(*this) {
379 VerboseAsm = OutStreamer->isVerboseAsm();
380 DwarfUsesRelocationsAcrossSections =
382}
383
385 assert(!DD && Handlers.size() == NumUserHandlers &&
386 "Debug/EH info didn't get finalized");
387}
388
390 return TM.isPositionIndependent();
391}
392
393/// getFunctionNumber - Return a unique ID for the current function.
395 return MF->getFunctionNumber();
396}
397
399 return *TM.getObjFileLowering();
400}
401
403 assert(MMI && "MMI could not be nullptr!");
404 return MMI->getModule()->getDataLayout();
405}
406
407// Do not use the cached DataLayout because some client use it without a Module
408// (dsymutil, llvm-dwarfdump).
410 return TM.getPointerSize(0); // FIXME: Default address space
411}
412
414 assert(MF && "getSubtargetInfo requires a valid MachineFunction!");
416}
417
420}
421
423 if (DD) {
424 assert(OutStreamer->hasRawTextSupport() &&
425 "Expected assembly output mode.");
426 // This is NVPTX specific and it's unclear why.
427 // PR51079: If we have code without debug information we need to give up.
429 if (!MFSP)
430 return;
431 (void)DD->emitInitialLocDirective(MF, /*CUID=*/0);
432 }
433}
434
435/// getCurrentSection() - Return the current section we are emitting to.
437 return OutStreamer->getCurrentSectionOnly();
438}
439
441 AU.setPreservesAll();
447}
448
450 auto *MMIWP = getAnalysisIfAvailable<MachineModuleInfoWrapperPass>();
451 MMI = MMIWP ? &MMIWP->getMMI() : nullptr;
452 HasSplitStack = false;
453 HasNoSplitStack = false;
454
455 AddrLabelSymbols = nullptr;
456
457 // Initialize TargetLoweringObjectFile.
459 .Initialize(OutContext, TM);
460
462 .getModuleMetadata(M);
463
464 // On AIX, we delay emitting any section information until
465 // after emitting the .file pseudo-op. This allows additional
466 // information (such as the embedded command line) to be associated
467 // with all sections in the object file rather than a single section.
469 OutStreamer->initSections(false, *TM.getMCSubtargetInfo());
470
471 // Emit the version-min deployment target directive if needed.
472 //
473 // FIXME: If we end up with a collection of these sorts of Darwin-specific
474 // or ELF-specific things, it may make sense to have a platform helper class
475 // that will work with the target helper class. For now keep it here, as the
476 // alternative is duplicated code in each of the target asm printers that
477 // use the directive, where it would need the same conditionalization
478 // anyway.
479 const Triple &Target = TM.getTargetTriple();
480 Triple TVT(M.getDarwinTargetVariantTriple());
481 OutStreamer->emitVersionForTarget(
482 Target, M.getSDKVersion(),
483 M.getDarwinTargetVariantTriple().empty() ? nullptr : &TVT,
484 M.getDarwinTargetVariantSDKVersion());
485
486 // Allow the target to emit any magic that it wants at the start of the file.
488
489 // Very minimal debug info. It is ignored if we emit actual debug info. If we
490 // don't, this at least helps the user find where a global came from.
492 // .file "foo.c"
493
494 SmallString<128> FileName;
496 FileName = llvm::sys::path::filename(M.getSourceFileName());
497 else
498 FileName = M.getSourceFileName();
499 if (MAI->hasFourStringsDotFile()) {
500#ifdef PACKAGE_VENDOR
501 const char VerStr[] =
502 PACKAGE_VENDOR " " PACKAGE_NAME " version " PACKAGE_VERSION;
503#else
504 const char VerStr[] = PACKAGE_NAME " version " PACKAGE_VERSION;
505#endif
506 // TODO: Add timestamp and description.
507 OutStreamer->emitFileDirective(FileName, VerStr, "", "");
508 } else {
509 OutStreamer->emitFileDirective(FileName);
510 }
511 }
512
513 // On AIX, emit bytes for llvm.commandline metadata after .file so that the
514 // C_INFO symbol is preserved if any csect is kept by the linker.
516 emitModuleCommandLines(M);
517 // Now we can generate section information.
518 OutStreamer->initSections(false, *TM.getMCSubtargetInfo());
519
520 // To work around an AIX assembler and/or linker bug, generate
521 // a rename for the default text-section symbol name. This call has
522 // no effect when generating object code directly.
523 MCSection *TextSection =
524 OutStreamer->getContext().getObjectFileInfo()->getTextSection();
525 MCSymbolXCOFF *XSym =
526 static_cast<MCSectionXCOFF *>(TextSection)->getQualNameSymbol();
527 if (XSym->hasRename())
528 OutStreamer->emitXCOFFRenameDirective(XSym, XSym->getSymbolTableName());
529 }
530
531 GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>();
532 assert(MI && "AsmPrinter didn't require GCModuleInfo?");
533 for (const auto &I : *MI)
534 if (GCMetadataPrinter *MP = getOrCreateGCPrinter(*I))
535 MP->beginAssembly(M, *MI, *this);
536
537 // Emit module-level inline asm if it exists.
538 if (!M.getModuleInlineAsm().empty()) {
539 OutStreamer->AddComment("Start of file scope inline assembly");
540 OutStreamer->addBlankLine();
541 emitInlineAsm(
542 M.getModuleInlineAsm() + "\n", *TM.getMCSubtargetInfo(),
543 TM.Options.MCOptions, nullptr,
545 OutStreamer->AddComment("End of file scope inline assembly");
546 OutStreamer->addBlankLine();
547 }
548
550 bool EmitCodeView = M.getCodeViewFlag();
551 if (EmitCodeView && TM.getTargetTriple().isOSWindows()) {
552 Handlers.emplace_back(std::make_unique<CodeViewDebug>(this),
556 }
557 if (!EmitCodeView || M.getDwarfVersion()) {
558 assert(MMI && "MMI could not be nullptr here!");
559 if (MMI->hasDebugInfo()) {
560 DD = new DwarfDebug(this);
561 Handlers.emplace_back(std::unique_ptr<DwarfDebug>(DD), DbgTimerName,
564 }
565 }
566 }
567
568 if (M.getNamedMetadata(PseudoProbeDescMetadataName)) {
569 PP = new PseudoProbeHandler(this);
570 Handlers.emplace_back(std::unique_ptr<PseudoProbeHandler>(PP), PPTimerName,
572 }
573
574 switch (MAI->getExceptionHandlingType()) {
576 // We may want to emit CFI for debug.
577 [[fallthrough]];
581 for (auto &F : M.getFunctionList()) {
583 ModuleCFISection = getFunctionCFISectionType(F);
584 // If any function needsUnwindTableEntry(), it needs .eh_frame and hence
585 // the module needs .eh_frame. If we have found that case, we are done.
586 if (ModuleCFISection == CFISection::EH)
587 break;
588 }
590 usesCFIWithoutEH() || ModuleCFISection != CFISection::EH);
591 break;
592 default:
593 break;
594 }
595
596 EHStreamer *ES = nullptr;
597 switch (MAI->getExceptionHandlingType()) {
599 if (!usesCFIWithoutEH())
600 break;
601 [[fallthrough]];
605 ES = new DwarfCFIException(this);
606 break;
608 ES = new ARMException(this);
609 break;
611 switch (MAI->getWinEHEncodingType()) {
612 default: llvm_unreachable("unsupported unwinding information encoding");
614 break;
617 ES = new WinException(this);
618 break;
619 }
620 break;
622 ES = new WasmException(this);
623 break;
625 ES = new AIXException(this);
626 break;
627 }
628 if (ES)
629 Handlers.emplace_back(std::unique_ptr<EHStreamer>(ES), EHTimerName,
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 Handlers.emplace_back(std::make_unique<WinCFGuard>(this), CFGuardName,
638
639 for (const HandlerInfo &HI : Handlers) {
640 NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName,
641 HI.TimerGroupDescription, TimePassesIsEnabled);
642 HI.Handler->beginModule(&M);
643 }
644
645 return false;
646}
647
648static bool canBeHidden(const GlobalValue *GV, const MCAsmInfo &MAI) {
650 return false;
651
652 return GV->canBeOmittedFromSymbolTable();
653}
654
655void AsmPrinter::emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const {
657 switch (Linkage) {
663 if (MAI->hasWeakDefDirective()) {
664 // .globl _foo
665 OutStreamer->emitSymbolAttribute(GVSym, MCSA_Global);
666
667 if (!canBeHidden(GV, *MAI))
668 // .weak_definition _foo
669 OutStreamer->emitSymbolAttribute(GVSym, MCSA_WeakDefinition);
670 else
671 OutStreamer->emitSymbolAttribute(GVSym, MCSA_WeakDefAutoPrivate);
672 } else if (MAI->avoidWeakIfComdat() && GV->hasComdat()) {
673 // .globl _foo
674 OutStreamer->emitSymbolAttribute(GVSym, MCSA_Global);
675 //NOTE: linkonce is handled by the section the symbol was assigned to.
676 } else {
677 // .weak _foo
678 OutStreamer->emitSymbolAttribute(GVSym, MCSA_Weak);
679 }
680 return;
682 OutStreamer->emitSymbolAttribute(GVSym, MCSA_Global);
683 return;
686 return;
690 llvm_unreachable("Should never emit this");
691 }
692 llvm_unreachable("Unknown linkage type!");
693}
694
696 const GlobalValue *GV) const {
697 TM.getNameWithPrefix(Name, GV, getObjFileLowering().getMangler());
698}
699
701 return TM.getSymbol(GV);
702}
703
705 // On ELF, use .Lfoo$local if GV is a non-interposable GlobalObject with an
706 // exact definion (intersection of GlobalValue::hasExactDefinition() and
707 // !isInterposable()). These linkages include: external, appending, internal,
708 // private. It may be profitable to use a local alias for external. The
709 // assembler would otherwise be conservative and assume a global default
710 // visibility symbol can be interposable, even if the code generator already
711 // assumed it.
713 const Module &M = *GV.getParent();
715 M.getPIELevel() == PIELevel::Default && GV.isDSOLocal())
716 return getSymbolWithGlobalValueBase(&GV, "$local");
717 }
718 return TM.getSymbol(&GV);
719}
720
721/// EmitGlobalVariable - Emit the specified global variable to the .s file.
723 bool IsEmuTLSVar = TM.useEmulatedTLS() && GV->isThreadLocal();
724 assert(!(IsEmuTLSVar && GV->hasCommonLinkage()) &&
725 "No emulated TLS variables in the common section");
726
727 // Never emit TLS variable xyz in emulated TLS model.
728 // The initialization value is in __emutls_t.xyz instead of xyz.
729 if (IsEmuTLSVar)
730 return;
731
732 if (GV->hasInitializer()) {
733 // Check to see if this is a special global used by LLVM, if so, emit it.
734 if (emitSpecialLLVMGlobal(GV))
735 return;
736
737 // Skip the emission of global equivalents. The symbol can be emitted later
738 // on by emitGlobalGOTEquivs in case it turns out to be needed.
739 if (GlobalGOTEquivs.count(getSymbol(GV)))
740 return;
741
742 if (isVerbose()) {
743 // When printing the control variable __emutls_v.*,
744 // we don't need to print the original TLS variable name.
745 GV->printAsOperand(OutStreamer->getCommentOS(),
746 /*PrintType=*/false, GV->getParent());
747 OutStreamer->getCommentOS() << '\n';
748 }
749 }
750
751 MCSymbol *GVSym = getSymbol(GV);
752 MCSymbol *EmittedSym = GVSym;
753
754 // getOrCreateEmuTLSControlSym only creates the symbol with name and default
755 // attributes.
756 // GV's or GVSym's attributes will be used for the EmittedSym.
757 emitVisibility(EmittedSym, GV->getVisibility(), !GV->isDeclaration());
758
759 if (GV->isTagged()) {
761
762 if (T.getArch() != Triple::aarch64 || !T.isAndroid())
764 "tagged symbols (-fsanitize=memtag-globals) are "
765 "only supported on AArch64 Android");
766 OutStreamer->emitSymbolAttribute(EmittedSym, MAI->getMemtagAttr());
767 }
768
769 if (!GV->hasInitializer()) // External globals require no extra code.
770 return;
771
772 GVSym->redefineIfPossible();
773 if (GVSym->isDefined() || GVSym->isVariable())
774 OutContext.reportError(SMLoc(), "symbol '" + Twine(GVSym->getName()) +
775 "' is already defined");
776
778 OutStreamer->emitSymbolAttribute(EmittedSym, MCSA_ELF_TypeObject);
779
781
782 const DataLayout &DL = GV->getParent()->getDataLayout();
783 uint64_t Size = DL.getTypeAllocSize(GV->getValueType());
784
785 // If the alignment is specified, we *must* obey it. Overaligning a global
786 // with a specified alignment is a prompt way to break globals emitted to
787 // sections and expected to be contiguous (e.g. ObjC metadata).
788 const Align Alignment = getGVAlignment(GV, DL);
789
790 for (const HandlerInfo &HI : Handlers) {
791 NamedRegionTimer T(HI.TimerName, HI.TimerDescription,
792 HI.TimerGroupName, HI.TimerGroupDescription,
794 HI.Handler->setSymbolSize(GVSym, Size);
795 }
796
797 // Handle common symbols
798 if (GVKind.isCommon()) {
799 if (Size == 0) Size = 1; // .comm Foo, 0 is undefined, avoid it.
800 // .comm _foo, 42, 4
801 OutStreamer->emitCommonSymbol(GVSym, Size, Alignment);
802 return;
803 }
804
805 // Determine to which section this global should be emitted.
806 MCSection *TheSection = getObjFileLowering().SectionForGlobal(GV, GVKind, TM);
807
808 // If we have a bss global going to a section that supports the
809 // zerofill directive, do so here.
810 if (GVKind.isBSS() && MAI->hasMachoZeroFillDirective() &&
811 TheSection->isVirtualSection()) {
812 if (Size == 0)
813 Size = 1; // zerofill of 0 bytes is undefined.
814 emitLinkage(GV, GVSym);
815 // .zerofill __DATA, __bss, _foo, 400, 5
816 OutStreamer->emitZerofill(TheSection, GVSym, Size, Alignment);
817 return;
818 }
819
820 // If this is a BSS local symbol and we are emitting in the BSS
821 // section use .lcomm/.comm directive.
822 if (GVKind.isBSSLocal() &&
823 getObjFileLowering().getBSSSection() == TheSection) {
824 if (Size == 0)
825 Size = 1; // .comm Foo, 0 is undefined, avoid it.
826
827 // Use .lcomm only if it supports user-specified alignment.
828 // Otherwise, while it would still be correct to use .lcomm in some
829 // cases (e.g. when Align == 1), the external assembler might enfore
830 // some -unknown- default alignment behavior, which could cause
831 // spurious differences between external and integrated assembler.
832 // Prefer to simply fall back to .local / .comm in this case.
834 // .lcomm _foo, 42
835 OutStreamer->emitLocalCommonSymbol(GVSym, Size, Alignment);
836 return;
837 }
838
839 // .local _foo
840 OutStreamer->emitSymbolAttribute(GVSym, MCSA_Local);
841 // .comm _foo, 42, 4
842 OutStreamer->emitCommonSymbol(GVSym, Size, Alignment);
843 return;
844 }
845
846 // Handle thread local data for mach-o which requires us to output an
847 // additional structure of data and mangle the original symbol so that we
848 // can reference it later.
849 //
850 // TODO: This should become an "emit thread local global" method on TLOF.
851 // All of this macho specific stuff should be sunk down into TLOFMachO and
852 // stuff like "TLSExtraDataSection" should no longer be part of the parent
853 // TLOF class. This will also make it more obvious that stuff like
854 // MCStreamer::EmitTBSSSymbol is macho specific and only called from macho
855 // specific code.
856 if (GVKind.isThreadLocal() && MAI->hasMachoTBSSDirective()) {
857 // Emit the .tbss symbol
858 MCSymbol *MangSym =
859 OutContext.getOrCreateSymbol(GVSym->getName() + Twine("$tlv$init"));
860
861 if (GVKind.isThreadBSS()) {
862 TheSection = getObjFileLowering().getTLSBSSSection();
863 OutStreamer->emitTBSSSymbol(TheSection, MangSym, Size, Alignment);
864 } else if (GVKind.isThreadData()) {
865 OutStreamer->switchSection(TheSection);
866
867 emitAlignment(Alignment, GV);
868 OutStreamer->emitLabel(MangSym);
869
871 GV->getInitializer());
872 }
873
874 OutStreamer->addBlankLine();
875
876 // Emit the variable struct for the runtime.
878
879 OutStreamer->switchSection(TLVSect);
880 // Emit the linkage here.
881 emitLinkage(GV, GVSym);
882 OutStreamer->emitLabel(GVSym);
883
884 // Three pointers in size:
885 // - __tlv_bootstrap - used to make sure support exists
886 // - spare pointer, used when mapped by the runtime
887 // - pointer to mangled symbol above with initializer
888 unsigned PtrSize = DL.getPointerTypeSize(GV->getType());
889 OutStreamer->emitSymbolValue(GetExternalSymbolSymbol("_tlv_bootstrap"),
890 PtrSize);
891 OutStreamer->emitIntValue(0, PtrSize);
892 OutStreamer->emitSymbolValue(MangSym, PtrSize);
893
894 OutStreamer->addBlankLine();
895 return;
896 }
897
898 MCSymbol *EmittedInitSym = GVSym;
899
900 OutStreamer->switchSection(TheSection);
901
902 emitLinkage(GV, EmittedInitSym);
903 emitAlignment(Alignment, GV);
904
905 OutStreamer->emitLabel(EmittedInitSym);
906 MCSymbol *LocalAlias = getSymbolPreferLocal(*GV);
907 if (LocalAlias != EmittedInitSym)
908 OutStreamer->emitLabel(LocalAlias);
909
911
913 // .size foo, 42
914 OutStreamer->emitELFSize(EmittedInitSym,
916
917 OutStreamer->addBlankLine();
918}
919
920/// Emit the directive and value for debug thread local expression
921///
922/// \p Value - The value to emit.
923/// \p Size - The size of the integer (in bytes) to emit.
924void AsmPrinter::emitDebugValue(const MCExpr *Value, unsigned Size) const {
925 OutStreamer->emitValue(Value, Size);
926}
927
928void AsmPrinter::emitFunctionHeaderComment() {}
929
930/// EmitFunctionHeader - This method emits the header for the current
931/// function.
932void AsmPrinter::emitFunctionHeader() {
933 const Function &F = MF->getFunction();
934
935 if (isVerbose())
936 OutStreamer->getCommentOS()
937 << "-- Begin function "
938 << GlobalValue::dropLLVMManglingEscape(F.getName()) << '\n';
939
940 // Print out constants referenced by the function
942
943 // Print the 'header' of function.
944 // If basic block sections are desired, explicitly request a unique section
945 // for this function's entry block.
946 if (MF->front().isBeginSection())
947 MF->setSection(getObjFileLowering().getUniqueSectionForFunction(F, TM));
948 else
949 MF->setSection(getObjFileLowering().SectionForGlobal(&F, TM));
950 OutStreamer->switchSection(MF->getSection());
951
953 emitVisibility(CurrentFnSym, F.getVisibility());
954
957
961
963 OutStreamer->emitSymbolAttribute(CurrentFnSym, MCSA_ELF_TypeFunction);
964
965 if (F.hasFnAttribute(Attribute::Cold))
966 OutStreamer->emitSymbolAttribute(CurrentFnSym, MCSA_Cold);
967
968 // Emit the prefix data.
969 if (F.hasPrefixData()) {
971 // Preserving prefix data on platforms which use subsections-via-symbols
972 // is a bit tricky. Here we introduce a symbol for the prefix data
973 // and use the .alt_entry attribute to mark the function's real entry point
974 // as an alternative entry point to the prefix-data symbol.
976 OutStreamer->emitLabel(PrefixSym);
977
978 emitGlobalConstant(F.getParent()->getDataLayout(), F.getPrefixData());
979
980 // Emit an .alt_entry directive for the actual function symbol.
981 OutStreamer->emitSymbolAttribute(CurrentFnSym, MCSA_AltEntry);
982 } else {
983 emitGlobalConstant(F.getParent()->getDataLayout(), F.getPrefixData());
984 }
985 }
986
987 // Emit KCFI type information before patchable-function-prefix nops.
989
990 // Emit M NOPs for -fpatchable-function-entry=N,M where M>0. We arbitrarily
991 // place prefix data before NOPs.
992 unsigned PatchableFunctionPrefix = 0;
993 unsigned PatchableFunctionEntry = 0;
994 (void)F.getFnAttribute("patchable-function-prefix")
995 .getValueAsString()
996 .getAsInteger(10, PatchableFunctionPrefix);
997 (void)F.getFnAttribute("patchable-function-entry")
998 .getValueAsString()
999 .getAsInteger(10, PatchableFunctionEntry);
1000 if (PatchableFunctionPrefix) {
1004 emitNops(PatchableFunctionPrefix);
1005 } else if (PatchableFunctionEntry) {
1006 // May be reassigned when emitting the body, to reference the label after
1007 // the initial BTI (AArch64) or endbr32/endbr64 (x86).
1009 }
1010
1011 // Emit the function prologue data for the indirect call sanitizer.
1012 if (const MDNode *MD = F.getMetadata(LLVMContext::MD_func_sanitize)) {
1013 assert(MD->getNumOperands() == 2);
1014
1015 auto *PrologueSig = mdconst::extract<Constant>(MD->getOperand(0));
1016 auto *TypeHash = mdconst::extract<Constant>(MD->getOperand(1));
1017 emitGlobalConstant(F.getParent()->getDataLayout(), PrologueSig);
1018 emitGlobalConstant(F.getParent()->getDataLayout(), TypeHash);
1019 }
1020
1021 if (isVerbose()) {
1022 F.printAsOperand(OutStreamer->getCommentOS(),
1023 /*PrintType=*/false, F.getParent());
1024 emitFunctionHeaderComment();
1025 OutStreamer->getCommentOS() << '\n';
1026 }
1027
1028 // Emit the function descriptor. This is a virtual function to allow targets
1029 // to emit their specific function descriptor. Right now it is only used by
1030 // the AIX target. The PowerPC 64-bit V1 ELF target also uses function
1031 // descriptors and should be converted to use this hook as well.
1034
1035 // Emit the CurrentFnSym. This is a virtual function to allow targets to do
1036 // their wild and crazy things as required.
1038
1039 // If the function had address-taken blocks that got deleted, then we have
1040 // references to the dangling symbols. Emit them at the start of the function
1041 // so that we don't get references to undefined symbols.
1042 std::vector<MCSymbol*> DeadBlockSyms;
1043 takeDeletedSymbolsForFunction(&F, DeadBlockSyms);
1044 for (MCSymbol *DeadBlockSym : DeadBlockSyms) {
1045 OutStreamer->AddComment("Address taken block that was later removed");
1046 OutStreamer->emitLabel(DeadBlockSym);
1047 }
1048
1049 if (CurrentFnBegin) {
1052 OutStreamer->emitLabel(CurPos);
1053 OutStreamer->emitAssignment(CurrentFnBegin,
1055 } else {
1056 OutStreamer->emitLabel(CurrentFnBegin);
1057 }
1058 }
1059
1060 // Emit pre-function debug and/or EH information.
1061 for (const HandlerInfo &HI : Handlers) {
1062 NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName,
1063 HI.TimerGroupDescription, TimePassesIsEnabled);
1064 HI.Handler->beginFunction(MF);
1065 }
1066 for (const HandlerInfo &HI : Handlers) {
1067 NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName,
1068 HI.TimerGroupDescription, TimePassesIsEnabled);
1069 HI.Handler->beginBasicBlockSection(MF->front());
1070 }
1071
1072 // Emit the prologue data.
1073 if (F.hasPrologueData())
1074 emitGlobalConstant(F.getParent()->getDataLayout(), F.getPrologueData());
1075}
1076
1077/// EmitFunctionEntryLabel - Emit the label that is the entrypoint for the
1078/// function. This can be overridden by targets as required to do custom stuff.
1081
1082 // The function label could have already been emitted if two symbols end up
1083 // conflicting due to asm renaming. Detect this and emit an error.
1084 if (CurrentFnSym->isVariable())
1086 "' is a protected alias");
1087
1088 OutStreamer->emitLabel(CurrentFnSym);
1089
1092 if (Sym != CurrentFnSym) {
1093 cast<MCSymbolELF>(Sym)->setType(ELF::STT_FUNC);
1095 OutStreamer->emitLabel(Sym);
1097 OutStreamer->emitSymbolAttribute(Sym, MCSA_ELF_TypeFunction);
1098 }
1099 }
1100}
1101
1102/// emitComments - Pretty-print comments for instructions.
1103static void emitComments(const MachineInstr &MI, raw_ostream &CommentOS) {
1104 const MachineFunction *MF = MI.getMF();
1106
1107 // Check for spills and reloads
1108
1109 // We assume a single instruction only has a spill or reload, not
1110 // both.
1111 std::optional<LocationSize> Size;
1112 if ((Size = MI.getRestoreSize(TII))) {
1113 CommentOS << Size->getValue() << "-byte Reload\n";
1114 } else if ((Size = MI.getFoldedRestoreSize(TII))) {
1115 if (!Size->hasValue())
1116 CommentOS << "Unknown-size Folded Reload\n";
1117 else if (Size->getValue())
1118 CommentOS << Size->getValue() << "-byte Folded Reload\n";
1119 } else if ((Size = MI.getSpillSize(TII))) {
1120 CommentOS << Size->getValue() << "-byte Spill\n";
1121 } else if ((Size = MI.getFoldedSpillSize(TII))) {
1122 if (!Size->hasValue())
1123 CommentOS << "Unknown-size Folded Spill\n";
1124 else if (Size->getValue())
1125 CommentOS << Size->getValue() << "-byte Folded Spill\n";
1126 }
1127
1128 // Check for spill-induced copies
1129 if (MI.getAsmPrinterFlag(MachineInstr::ReloadReuse))
1130 CommentOS << " Reload Reuse\n";
1131}
1132
1133/// emitImplicitDef - This method emits the specified machine instruction
1134/// that is an implicit def.
1136 Register RegNo = MI->getOperand(0).getReg();
1137
1138 SmallString<128> Str;
1140 OS << "implicit-def: "
1141 << printReg(RegNo, MF->getSubtarget().getRegisterInfo());
1142
1143 OutStreamer->AddComment(OS.str());
1144 OutStreamer->addBlankLine();
1145}
1146
1147static void emitKill(const MachineInstr *MI, AsmPrinter &AP) {
1148 std::string Str;
1150 OS << "kill:";
1151 for (const MachineOperand &Op : MI->operands()) {
1152 assert(Op.isReg() && "KILL instruction must have only register operands");
1153 OS << ' ' << (Op.isDef() ? "def " : "killed ")
1154 << printReg(Op.getReg(), AP.MF->getSubtarget().getRegisterInfo());
1155 }
1156 AP.OutStreamer->AddComment(OS.str());
1157 AP.OutStreamer->addBlankLine();
1158}
1159
1160/// emitDebugValueComment - This method handles the target-independent form
1161/// of DBG_VALUE, returning true if it was able to do so. A false return
1162/// means the target will need to handle MI in EmitInstruction.
1164 // This code handles only the 4-operand target-independent form.
1165 if (MI->isNonListDebugValue() && MI->getNumOperands() != 4)
1166 return false;
1167
1168 SmallString<128> Str;
1170 OS << "DEBUG_VALUE: ";
1171
1172 const DILocalVariable *V = MI->getDebugVariable();
1173 if (auto *SP = dyn_cast<DISubprogram>(V->getScope())) {
1174 StringRef Name = SP->getName();
1175 if (!Name.empty())
1176 OS << Name << ":";
1177 }
1178 OS << V->getName();
1179 OS << " <- ";
1180
1181 const DIExpression *Expr = MI->getDebugExpression();
1182 // First convert this to a non-variadic expression if possible, to simplify
1183 // the output.
1184 if (auto NonVariadicExpr = DIExpression::convertToNonVariadicExpression(Expr))
1185 Expr = *NonVariadicExpr;
1186 // Then, output the possibly-simplified expression.
1187 if (Expr->getNumElements()) {
1188 OS << '[';
1189 ListSeparator LS;
1190 for (auto &Op : Expr->expr_ops()) {
1191 OS << LS << dwarf::OperationEncodingString(Op.getOp());
1192 for (unsigned I = 0; I < Op.getNumArgs(); ++I)
1193 OS << ' ' << Op.getArg(I);
1194 }
1195 OS << "] ";
1196 }
1197
1198 // Register or immediate value. Register 0 means undef.
1199 for (const MachineOperand &Op : MI->debug_operands()) {
1200 if (&Op != MI->debug_operands().begin())
1201 OS << ", ";
1202 switch (Op.getType()) {
1204 APFloat APF = APFloat(Op.getFPImm()->getValueAPF());
1205 Type *ImmTy = Op.getFPImm()->getType();
1206 if (ImmTy->isBFloatTy() || ImmTy->isHalfTy() || ImmTy->isFloatTy() ||
1207 ImmTy->isDoubleTy()) {
1208 OS << APF.convertToDouble();
1209 } else {
1210 // There is no good way to print long double. Convert a copy to
1211 // double. Ah well, it's only a comment.
1212 bool ignored;
1214 &ignored);
1215 OS << "(long double) " << APF.convertToDouble();
1216 }
1217 break;
1218 }
1220 OS << Op.getImm();
1221 break;
1222 }
1224 Op.getCImm()->getValue().print(OS, false /*isSigned*/);
1225 break;
1226 }
1228 OS << "!target-index(" << Op.getIndex() << "," << Op.getOffset() << ")";
1229 break;
1230 }
1233 Register Reg;
1234 std::optional<StackOffset> Offset;
1235 if (Op.isReg()) {
1236 Reg = Op.getReg();
1237 } else {
1238 const TargetFrameLowering *TFI =
1240 Offset = TFI->getFrameIndexReference(*AP.MF, Op.getIndex(), Reg);
1241 }
1242 if (!Reg) {
1243 // Suppress offset, it is not meaningful here.
1244 OS << "undef";
1245 break;
1246 }
1247 // The second operand is only an offset if it's an immediate.
1248 if (MI->isIndirectDebugValue())
1249 Offset = StackOffset::getFixed(MI->getDebugOffset().getImm());
1250 if (Offset)
1251 OS << '[';
1252 OS << printReg(Reg, AP.MF->getSubtarget().getRegisterInfo());
1253 if (Offset)
1254 OS << '+' << Offset->getFixed() << ']';
1255 break;
1256 }
1257 default:
1258 llvm_unreachable("Unknown operand type");
1259 }
1260 }
1261
1262 // NOTE: Want this comment at start of line, don't emit with AddComment.
1263 AP.OutStreamer->emitRawComment(OS.str());
1264 return true;
1265}
1266
1267/// This method handles the target-independent form of DBG_LABEL, returning
1268/// true if it was able to do so. A false return means the target will need
1269/// to handle MI in EmitInstruction.
1271 if (MI->getNumOperands() != 1)
1272 return false;
1273
1274 SmallString<128> Str;
1276 OS << "DEBUG_LABEL: ";
1277
1278 const DILabel *V = MI->getDebugLabel();
1279 if (auto *SP = dyn_cast<DISubprogram>(
1280 V->getScope()->getNonLexicalBlockFileScope())) {
1281 StringRef Name = SP->getName();
1282 if (!Name.empty())
1283 OS << Name << ":";
1284 }
1285 OS << V->getName();
1286
1287 // NOTE: Want this comment at start of line, don't emit with AddComment.
1288 AP.OutStreamer->emitRawComment(OS.str());
1289 return true;
1290}
1291
1294 // Ignore functions that won't get emitted.
1295 if (F.isDeclarationForLinker())
1296 return CFISection::None;
1297
1299 F.needsUnwindTableEntry())
1300 return CFISection::EH;
1301
1302 if (MAI->usesCFIWithoutEH() && F.hasUWTable())
1303 return CFISection::EH;
1304
1305 assert(MMI != nullptr && "Invalid machine module info");
1307 return CFISection::Debug;
1308
1309 return CFISection::None;
1310}
1311
1315}
1316
1319}
1320
1322 return MAI->usesCFIWithoutEH() && ModuleCFISection != CFISection::None;
1323}
1324
1326 ExceptionHandling ExceptionHandlingType = MAI->getExceptionHandlingType();
1327 if (!usesCFIWithoutEH() &&
1328 ExceptionHandlingType != ExceptionHandling::DwarfCFI &&
1329 ExceptionHandlingType != ExceptionHandling::ARM)
1330 return;
1331
1333 return;
1334
1335 // If there is no "real" instruction following this CFI instruction, skip
1336 // emitting it; it would be beyond the end of the function's FDE range.
1337 auto *MBB = MI.getParent();
1338 auto I = std::next(MI.getIterator());
1339 while (I != MBB->end() && I->isTransient())
1340 ++I;
1341 if (I == MBB->instr_end() &&
1343 return;
1344
1345 const std::vector<MCCFIInstruction> &Instrs = MF->getFrameInstructions();
1346 unsigned CFIIndex = MI.getOperand(0).getCFIIndex();
1347 const MCCFIInstruction &CFI = Instrs[CFIIndex];
1348 emitCFIInstruction(CFI);
1349}
1350
1352 // The operands are the MCSymbol and the frame offset of the allocation.
1353 MCSymbol *FrameAllocSym = MI.getOperand(0).getMCSymbol();
1354 int FrameOffset = MI.getOperand(1).getImm();
1355
1356 // Emit a symbol assignment.
1357 OutStreamer->emitAssignment(FrameAllocSym,
1358 MCConstantExpr::create(FrameOffset, OutContext));
1359}
1360
1361/// Returns the BB metadata to be emitted in the SHT_LLVM_BB_ADDR_MAP section
1362/// for a given basic block. This can be used to capture more precise profile
1363/// information.
1368 MBB.isEHPad(), const_cast<MachineBasicBlock &>(MBB).canFallThrough(),
1369 !MBB.empty() && MBB.rbegin()->isIndirectBranch()}
1370 .encode();
1371}
1372
1374getBBAddrMapFeature(const MachineFunction &MF, int NumMBBSectionRanges) {
1375 return {PgoAnalysisMapFeatures.isSet(PGOMapFeaturesEnum::FuncEntryCount),
1376 PgoAnalysisMapFeatures.isSet(PGOMapFeaturesEnum::BBFreq),
1377 PgoAnalysisMapFeatures.isSet(PGOMapFeaturesEnum::BrProb),
1378 MF.hasBBSections() && NumMBBSectionRanges > 1};
1379}
1380
1382 MCSection *BBAddrMapSection =
1384 assert(BBAddrMapSection && ".llvm_bb_addr_map section is not initialized.");
1385
1386 const MCSymbol *FunctionSymbol = getFunctionBegin();
1387
1388 OutStreamer->pushSection();
1389 OutStreamer->switchSection(BBAddrMapSection);
1390 OutStreamer->AddComment("version");
1391 uint8_t BBAddrMapVersion = OutStreamer->getContext().getBBAddrMapVersion();
1392 OutStreamer->emitInt8(BBAddrMapVersion);
1393 OutStreamer->AddComment("feature");
1394 auto Features = getBBAddrMapFeature(MF, MBBSectionRanges.size());
1395 OutStreamer->emitInt8(Features.encode());
1396 // Emit BB Information for each basic block in the function.
1397 if (Features.MultiBBRange) {
1398 OutStreamer->AddComment("number of basic block ranges");
1399 OutStreamer->emitULEB128IntValue(MBBSectionRanges.size());
1400 }
1401 // Number of blocks in each MBB section.
1402 MapVector<unsigned, unsigned> MBBSectionNumBlocks;
1403 const MCSymbol *PrevMBBEndSymbol = nullptr;
1404 if (!Features.MultiBBRange) {
1405 OutStreamer->AddComment("function address");
1406 OutStreamer->emitSymbolValue(FunctionSymbol, getPointerSize());
1407 OutStreamer->AddComment("number of basic blocks");
1408 OutStreamer->emitULEB128IntValue(MF.size());
1409 PrevMBBEndSymbol = FunctionSymbol;
1410 } else {
1411 unsigned BBCount = 0;
1412 for (const MachineBasicBlock &MBB : MF) {
1413 BBCount++;
1414 if (MBB.isEndSection()) {
1415 // Store each section's basic block count when it ends.
1416 MBBSectionNumBlocks[MBB.getSectionIDNum()] = BBCount;
1417 // Reset the count for the next section.
1418 BBCount = 0;
1419 }
1420 }
1421 }
1422 // Emit the BB entry for each basic block in the function.
1423 for (const MachineBasicBlock &MBB : MF) {
1424 const MCSymbol *MBBSymbol =
1425 MBB.isEntryBlock() ? FunctionSymbol : MBB.getSymbol();
1426 bool IsBeginSection =
1427 Features.MultiBBRange && (MBB.isBeginSection() || MBB.isEntryBlock());
1428 if (IsBeginSection) {
1429 OutStreamer->AddComment("base address");
1430 OutStreamer->emitSymbolValue(MBBSymbol, getPointerSize());
1431 OutStreamer->AddComment("number of basic blocks");
1432 OutStreamer->emitULEB128IntValue(
1433 MBBSectionNumBlocks[MBB.getSectionIDNum()]);
1434 PrevMBBEndSymbol = MBBSymbol;
1435 }
1436 // TODO: Remove this check when version 1 is deprecated.
1437 if (BBAddrMapVersion > 1) {
1438 OutStreamer->AddComment("BB id");
1439 // Emit the BB ID for this basic block.
1440 // We only emit BaseID since CloneID is unset for
1441 // basic-block-sections=labels.
1442 // TODO: Emit the full BBID when labels and sections can be mixed
1443 // together.
1444 OutStreamer->emitULEB128IntValue(MBB.getBBID()->BaseID);
1445 }
1446 // Emit the basic block offset relative to the end of the previous block.
1447 // This is zero unless the block is padded due to alignment.
1448 emitLabelDifferenceAsULEB128(MBBSymbol, PrevMBBEndSymbol);
1449 // Emit the basic block size. When BBs have alignments, their size cannot
1450 // always be computed from their offsets.
1452 // Emit the Metadata.
1453 OutStreamer->emitULEB128IntValue(getBBAddrMapMetadata(MBB));
1454 PrevMBBEndSymbol = MBB.getEndSymbol();
1455 }
1456
1457 if (Features.hasPGOAnalysis()) {
1458 assert(BBAddrMapVersion >= 2 &&
1459 "PGOAnalysisMap only supports version 2 or later");
1460
1461 if (Features.FuncEntryCount) {
1462 OutStreamer->AddComment("function entry count");
1463 auto MaybeEntryCount = MF.getFunction().getEntryCount();
1464 OutStreamer->emitULEB128IntValue(
1465 MaybeEntryCount ? MaybeEntryCount->getCount() : 0);
1466 }
1467 const MachineBlockFrequencyInfo *MBFI =
1468 Features.BBFreq
1469 ? &getAnalysis<LazyMachineBlockFrequencyInfoPass>().getBFI()
1470 : nullptr;
1471 const MachineBranchProbabilityInfo *MBPI =
1472 Features.BrProb ? &getAnalysis<MachineBranchProbabilityInfo>()
1473 : nullptr;
1474
1475 if (Features.BBFreq || Features.BrProb) {
1476 for (const MachineBasicBlock &MBB : MF) {
1477 if (Features.BBFreq) {
1478 OutStreamer->AddComment("basic block frequency");
1479 OutStreamer->emitULEB128IntValue(
1480 MBFI->getBlockFreq(&MBB).getFrequency());
1481 }
1482 if (Features.BrProb) {
1483 unsigned SuccCount = MBB.succ_size();
1484 OutStreamer->AddComment("basic block successor count");
1485 OutStreamer->emitULEB128IntValue(SuccCount);
1486 for (const MachineBasicBlock *SuccMBB : MBB.successors()) {
1487 OutStreamer->AddComment("successor BB ID");
1488 OutStreamer->emitULEB128IntValue(SuccMBB->getBBID()->BaseID);
1489 OutStreamer->AddComment("successor branch probability");
1490 OutStreamer->emitULEB128IntValue(
1491 MBPI->getEdgeProbability(&MBB, SuccMBB).getNumerator());
1492 }
1493 }
1494 }
1495 }
1496 }
1497
1498 OutStreamer->popSection();
1499}
1500
1502 const MCSymbol *Symbol) {
1503 MCSection *Section =
1505 if (!Section)
1506 return;
1507
1508 OutStreamer->pushSection();
1509 OutStreamer->switchSection(Section);
1510
1512 OutStreamer->emitLabel(Loc);
1513 OutStreamer->emitAbsoluteSymbolDiff(Symbol, Loc, 4);
1514
1515 OutStreamer->popSection();
1516}
1517
1519 const Function &F = MF.getFunction();
1520 if (const MDNode *MD = F.getMetadata(LLVMContext::MD_kcfi_type))
1521 emitGlobalConstant(F.getParent()->getDataLayout(),
1522 mdconst::extract<ConstantInt>(MD->getOperand(0)));
1523}
1524
1526 if (PP) {
1527 auto GUID = MI.getOperand(0).getImm();
1528 auto Index = MI.getOperand(1).getImm();
1529 auto Type = MI.getOperand(2).getImm();
1530 auto Attr = MI.getOperand(3).getImm();
1531 DILocation *DebugLoc = MI.getDebugLoc();
1532 PP->emitPseudoProbe(GUID, Index, Type, Attr, DebugLoc);
1533 }
1534}
1535
1538 return;
1539
1540 MCSection *StackSizeSection =
1542 if (!StackSizeSection)
1543 return;
1544
1545 const MachineFrameInfo &FrameInfo = MF.getFrameInfo();
1546 // Don't emit functions with dynamic stack allocations.
1547 if (FrameInfo.hasVarSizedObjects())
1548 return;
1549
1550 OutStreamer->pushSection();
1551 OutStreamer->switchSection(StackSizeSection);
1552
1553 const MCSymbol *FunctionSymbol = getFunctionBegin();
1554 uint64_t StackSize =
1555 FrameInfo.getStackSize() + FrameInfo.getUnsafeStackSize();
1556 OutStreamer->emitSymbolValue(FunctionSymbol, TM.getProgramPointerSize());
1557 OutStreamer->emitULEB128IntValue(StackSize);
1558
1559 OutStreamer->popSection();
1560}
1561
1563 const std::string &OutputFilename = MF.getTarget().Options.StackUsageOutput;
1564
1565 // OutputFilename empty implies -fstack-usage is not passed.
1566 if (OutputFilename.empty())
1567 return;
1568
1569 const MachineFrameInfo &FrameInfo = MF.getFrameInfo();
1570 uint64_t StackSize =
1571 FrameInfo.getStackSize() + FrameInfo.getUnsafeStackSize();
1572
1573 if (StackUsageStream == nullptr) {
1574 std::error_code EC;
1575 StackUsageStream =
1576 std::make_unique<raw_fd_ostream>(OutputFilename, EC, sys::fs::OF_Text);
1577 if (EC) {
1578 errs() << "Could not open file: " << EC.message();
1579 return;
1580 }
1581 }
1582
1583 if (const DISubprogram *DSP = MF.getFunction().getSubprogram())
1584 *StackUsageStream << DSP->getFilename() << ':' << DSP->getLine();
1585 else
1586 *StackUsageStream << MF.getFunction().getParent()->getName();
1587
1588 *StackUsageStream << ':' << MF.getName() << '\t' << StackSize << '\t';
1589 if (FrameInfo.hasVarSizedObjects())
1590 *StackUsageStream << "dynamic\n";
1591 else
1592 *StackUsageStream << "static\n";
1593}
1594
1596 const MDNode &MD) {
1597 MCSymbol *S = MF.getContext().createTempSymbol("pcsection");
1598 OutStreamer->emitLabel(S);
1599 PCSectionsSymbols[&MD].emplace_back(S);
1600}
1601
1603 const Function &F = MF.getFunction();
1604 if (PCSectionsSymbols.empty() && !F.hasMetadata(LLVMContext::MD_pcsections))
1605 return;
1606
1608 const unsigned RelativeRelocSize =
1610 : 4;
1611
1612 // Switch to PCSection, short-circuiting the common case where the current
1613 // section is still valid (assume most MD_pcsections contain just 1 section).
1614 auto SwitchSection = [&, Prev = StringRef()](const StringRef &Sec) mutable {
1615 if (Sec == Prev)
1616 return;
1618 assert(S && "PC section is not initialized");
1619 OutStreamer->switchSection(S);
1620 Prev = Sec;
1621 };
1622 // Emit symbols into sections and data as specified in the pcsections MDNode.
1623 auto EmitForMD = [&](const MDNode &MD, ArrayRef<const MCSymbol *> Syms,
1624 bool Deltas) {
1625 // Expect the first operand to be a section name. After that, a tuple of
1626 // constants may appear, which will simply be emitted into the current
1627 // section (the user of MD_pcsections decides the format of encoded data).
1628 assert(isa<MDString>(MD.getOperand(0)) && "first operand not a string");
1629 bool ConstULEB128 = false;
1630 for (const MDOperand &MDO : MD.operands()) {
1631 if (auto *S = dyn_cast<MDString>(MDO)) {
1632 // Found string, start of new section!
1633 // Find options for this section "<section>!<opts>" - supported options:
1634 // C = Compress constant integers of size 2-8 bytes as ULEB128.
1635 const StringRef SecWithOpt = S->getString();
1636 const size_t OptStart = SecWithOpt.find('!'); // likely npos
1637 const StringRef Sec = SecWithOpt.substr(0, OptStart);
1638 const StringRef Opts = SecWithOpt.substr(OptStart); // likely empty
1639 ConstULEB128 = Opts.contains('C');
1640#ifndef NDEBUG
1641 for (char O : Opts)
1642 assert((O == '!' || O == 'C') && "Invalid !pcsections options");
1643#endif
1644 SwitchSection(Sec);
1645 const MCSymbol *Prev = Syms.front();
1646 for (const MCSymbol *Sym : Syms) {
1647 if (Sym == Prev || !Deltas) {
1648 // Use the entry itself as the base of the relative offset.
1649 MCSymbol *Base = MF.getContext().createTempSymbol("pcsection_base");
1650 OutStreamer->emitLabel(Base);
1651 // Emit relative relocation `addr - base`, which avoids a dynamic
1652 // relocation in the final binary. User will get the address with
1653 // `base + addr`.
1654 emitLabelDifference(Sym, Base, RelativeRelocSize);
1655 } else {
1656 // Emit delta between symbol and previous symbol.
1657 if (ConstULEB128)
1659 else
1660 emitLabelDifference(Sym, Prev, 4);
1661 }
1662 Prev = Sym;
1663 }
1664 } else {
1665 // Emit auxiliary data after PC.
1666 assert(isa<MDNode>(MDO) && "expecting either string or tuple");
1667 const auto *AuxMDs = cast<MDNode>(MDO);
1668 for (const MDOperand &AuxMDO : AuxMDs->operands()) {
1669 assert(isa<ConstantAsMetadata>(AuxMDO) && "expecting a constant");
1670 const Constant *C = cast<ConstantAsMetadata>(AuxMDO)->getValue();
1671 const DataLayout &DL = F.getParent()->getDataLayout();
1672 const uint64_t Size = DL.getTypeStoreSize(C->getType());
1673
1674 if (auto *CI = dyn_cast<ConstantInt>(C);
1675 CI && ConstULEB128 && Size > 1 && Size <= 8) {
1676 emitULEB128(CI->getZExtValue());
1677 } else {
1679 }
1680 }
1681 }
1682 }
1683 };
1684
1685 OutStreamer->pushSection();
1686 // Emit PCs for function start and function size.
1687 if (const MDNode *MD = F.getMetadata(LLVMContext::MD_pcsections))
1688 EmitForMD(*MD, {getFunctionBegin(), getFunctionEnd()}, true);
1689 // Emit PCs for instructions collected.
1690 for (const auto &MS : PCSectionsSymbols)
1691 EmitForMD(*MS.first, MS.second, false);
1692 OutStreamer->popSection();
1693 PCSectionsSymbols.clear();
1694}
1695
1696/// Returns true if function begin and end labels should be emitted.
1697static bool needFuncLabels(const MachineFunction &MF) {
1698 MachineModuleInfo &MMI = MF.getMMI();
1699 if (!MF.getLandingPads().empty() || MF.hasEHFunclets() ||
1700 MMI.hasDebugInfo() ||
1701 MF.getFunction().hasMetadata(LLVMContext::MD_pcsections))
1702 return true;
1703
1704 // We might emit an EH table that uses function begin and end labels even if
1705 // we don't have any landingpads.
1706 if (!MF.getFunction().hasPersonalityFn())
1707 return false;
1708 return !isNoOpWithoutInvoke(
1710}
1711
1712/// EmitFunctionBody - This method emits the body and trailer for a
1713/// function.
1715 emitFunctionHeader();
1716
1717 // Emit target-specific gunk before the function body.
1719
1720 if (isVerbose()) {
1721 // Get MachineDominatorTree or compute it on the fly if it's unavailable
1722 MDT = getAnalysisIfAvailable<MachineDominatorTree>();
1723 if (!MDT) {
1724 OwnedMDT = std::make_unique<MachineDominatorTree>();
1725 OwnedMDT->getBase().recalculate(*MF);
1726 MDT = OwnedMDT.get();
1727 }
1728
1729 // Get MachineLoopInfo or compute it on the fly if it's unavailable
1730 MLI = getAnalysisIfAvailable<MachineLoopInfo>();
1731 if (!MLI) {
1732 OwnedMLI = std::make_unique<MachineLoopInfo>();
1733 OwnedMLI->getBase().analyze(MDT->getBase());
1734 MLI = OwnedMLI.get();
1735 }
1736 }
1737
1738 // Print out code for the function.
1739 bool HasAnyRealCode = false;
1740 int NumInstsInFunction = 0;
1741 bool IsEHa = MMI->getModule()->getModuleFlag("eh-asynch");
1742
1743 bool CanDoExtraAnalysis = ORE->allowExtraAnalysis(DEBUG_TYPE);
1744 for (auto &MBB : *MF) {
1745 // Print a label for the basic block.
1747 DenseMap<StringRef, unsigned> MnemonicCounts;
1748 for (auto &MI : MBB) {
1749 // Print the assembly for the instruction.
1750 if (!MI.isPosition() && !MI.isImplicitDef() && !MI.isKill() &&
1751 !MI.isDebugInstr()) {
1752 HasAnyRealCode = true;
1753 ++NumInstsInFunction;
1754 }
1755
1756 // If there is a pre-instruction symbol, emit a label for it here.
1757 if (MCSymbol *S = MI.getPreInstrSymbol())
1758 OutStreamer->emitLabel(S);
1759
1760 if (MDNode *MD = MI.getPCSections())
1761 emitPCSectionsLabel(*MF, *MD);
1762
1763 for (const HandlerInfo &HI : Handlers) {
1764 NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName,
1765 HI.TimerGroupDescription, TimePassesIsEnabled);
1766 HI.Handler->beginInstruction(&MI);
1767 }
1768
1769 if (isVerbose())
1770 emitComments(MI, OutStreamer->getCommentOS());
1771
1772 switch (MI.getOpcode()) {
1773 case TargetOpcode::CFI_INSTRUCTION:
1775 break;
1776 case TargetOpcode::LOCAL_ESCAPE:
1778 break;
1779 case TargetOpcode::ANNOTATION_LABEL:
1780 case TargetOpcode::GC_LABEL:
1781 OutStreamer->emitLabel(MI.getOperand(0).getMCSymbol());
1782 break;
1783 case TargetOpcode::EH_LABEL:
1784 OutStreamer->emitLabel(MI.getOperand(0).getMCSymbol());
1785 // For AsynchEH, insert a Nop if followed by a trap inst
1786 // Or the exception won't be caught.
1787 // (see MCConstantExpr::create(1,..) in WinException.cpp)
1788 // Ignore SDiv/UDiv because a DIV with Const-0 divisor
1789 // must have being turned into an UndefValue.
1790 // Div with variable opnds won't be the first instruction in
1791 // an EH region as it must be led by at least a Load
1792 {
1793 auto MI2 = std::next(MI.getIterator());
1794 if (IsEHa && MI2 != MBB.end() &&
1795 (MI2->mayLoadOrStore() || MI2->mayRaiseFPException()))
1796 emitNops(1);
1797 }
1798 break;
1799 case TargetOpcode::INLINEASM:
1800 case TargetOpcode::INLINEASM_BR:
1801 emitInlineAsm(&MI);
1802 break;
1803 case TargetOpcode::DBG_VALUE:
1804 case TargetOpcode::DBG_VALUE_LIST:
1805 if (isVerbose()) {
1806 if (!emitDebugValueComment(&MI, *this))
1808 }
1809 break;
1810 case TargetOpcode::DBG_INSTR_REF:
1811 // This instruction reference will have been resolved to a machine
1812 // location, and a nearby DBG_VALUE created. We can safely ignore
1813 // the instruction reference.
1814 break;
1815 case TargetOpcode::DBG_PHI:
1816 // This instruction is only used to label a program point, it's purely
1817 // meta information.
1818 break;
1819 case TargetOpcode::DBG_LABEL:
1820 if (isVerbose()) {
1821 if (!emitDebugLabelComment(&MI, *this))
1823 }
1824 break;
1825 case TargetOpcode::IMPLICIT_DEF:
1826 if (isVerbose()) emitImplicitDef(&MI);
1827 break;
1828 case TargetOpcode::KILL:
1829 if (isVerbose()) emitKill(&MI, *this);
1830 break;
1831 case TargetOpcode::PSEUDO_PROBE:
1833 break;
1834 case TargetOpcode::ARITH_FENCE:
1835 if (isVerbose())
1836 OutStreamer->emitRawComment("ARITH_FENCE");
1837 break;
1838 case TargetOpcode::MEMBARRIER:
1839 OutStreamer->emitRawComment("MEMBARRIER");
1840 break;
1841 case TargetOpcode::JUMP_TABLE_DEBUG_INFO:
1842 // This instruction is only used to note jump table debug info, it's
1843 // purely meta information.
1844 break;
1845 default:
1847 if (CanDoExtraAnalysis) {
1848 MCInst MCI;
1849 MCI.setOpcode(MI.getOpcode());
1850 auto Name = OutStreamer->getMnemonic(MCI);
1851 auto I = MnemonicCounts.insert({Name, 0u});
1852 I.first->second++;
1853 }
1854 break;
1855 }
1856
1857 // If there is a post-instruction symbol, emit a label for it here.
1858 if (MCSymbol *S = MI.getPostInstrSymbol())
1859 OutStreamer->emitLabel(S);
1860
1861 for (const HandlerInfo &HI : Handlers) {
1862 NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName,
1863 HI.TimerGroupDescription, TimePassesIsEnabled);
1864 HI.Handler->endInstruction();
1865 }
1866 }
1867
1868 // We must emit temporary symbol for the end of this basic block, if either
1869 // we have BBLabels enabled or if this basic blocks marks the end of a
1870 // section.
1871 if (MF->hasBBLabels() || MF->getTarget().Options.BBAddrMap ||
1873 OutStreamer->emitLabel(MBB.getEndSymbol());
1874
1875 if (MBB.isEndSection()) {
1876 // The size directive for the section containing the entry block is
1877 // handled separately by the function section.
1878 if (!MBB.sameSection(&MF->front())) {
1880 // Emit the size directive for the basic block section.
1881 const MCExpr *SizeExp = MCBinaryExpr::createSub(
1883 MCSymbolRefExpr::create(CurrentSectionBeginSym, OutContext),
1884 OutContext);
1885 OutStreamer->emitELFSize(CurrentSectionBeginSym, SizeExp);
1886 }
1888 MBBSectionRange{CurrentSectionBeginSym, MBB.getEndSymbol()};
1889 }
1890 }
1892
1893 if (CanDoExtraAnalysis) {
1894 // Skip empty blocks.
1895 if (MBB.empty())
1896 continue;
1897
1899 MBB.begin()->getDebugLoc(), &MBB);
1900
1901 // Generate instruction mix remark. First, sort counts in descending order
1902 // by count and name.
1904 for (auto &KV : MnemonicCounts)
1905 MnemonicVec.emplace_back(KV.first, KV.second);
1906
1907 sort(MnemonicVec, [](const std::pair<StringRef, unsigned> &A,
1908 const std::pair<StringRef, unsigned> &B) {
1909 if (A.second > B.second)
1910 return true;
1911 if (A.second == B.second)
1912 return StringRef(A.first) < StringRef(B.first);
1913 return false;
1914 });
1915 R << "BasicBlock: " << ore::NV("BasicBlock", MBB.getName()) << "\n";
1916 for (auto &KV : MnemonicVec) {
1917 auto Name = (Twine("INST_") + getToken(KV.first.trim()).first).str();
1918 R << KV.first << ": " << ore::NV(Name, KV.second) << "\n";
1919 }
1920 ORE->emit(R);
1921 }
1922 }
1923
1924 EmittedInsts += NumInstsInFunction;
1925 MachineOptimizationRemarkAnalysis R(DEBUG_TYPE, "InstructionCount",
1927 &MF->front());
1928 R << ore::NV("NumInstructions", NumInstsInFunction)
1929 << " instructions in function";
1930 ORE->emit(R);
1931
1932 // If the function is empty and the object file uses .subsections_via_symbols,
1933 // then we need to emit *something* to the function body to prevent the
1934 // labels from collapsing together. Just emit a noop.
1935 // Similarly, don't emit empty functions on Windows either. It can lead to
1936 // duplicate entries (two functions with the same RVA) in the Guard CF Table
1937 // after linking, causing the kernel not to load the binary:
1938 // https://developercommunity.visualstudio.com/content/problem/45366/vc-linker-creates-invalid-dll-with-clang-cl.html
1939 // FIXME: Hide this behind some API in e.g. MCAsmInfo or MCTargetStreamer.
1940 const Triple &TT = TM.getTargetTriple();
1941 if (!HasAnyRealCode && (MAI->hasSubsectionsViaSymbols() ||
1942 (TT.isOSWindows() && TT.isOSBinFormatCOFF()))) {
1943 MCInst Noop = MF->getSubtarget().getInstrInfo()->getNop();
1944
1945 // Targets can opt-out of emitting the noop here by leaving the opcode
1946 // unspecified.
1947 if (Noop.getOpcode()) {
1948 OutStreamer->AddComment("avoids zero-length function");
1949 emitNops(1);
1950 }
1951 }
1952
1953 // Switch to the original section in case basic block sections was used.
1954 OutStreamer->switchSection(MF->getSection());
1955
1956 const Function &F = MF->getFunction();
1957 for (const auto &BB : F) {
1958 if (!BB.hasAddressTaken())
1959 continue;
1961 if (Sym->isDefined())
1962 continue;
1963 OutStreamer->AddComment("Address of block that was removed by CodeGen");
1964 OutStreamer->emitLabel(Sym);
1965 }
1966
1967 // Emit target-specific gunk after the function body.
1969
1970 // Even though wasm supports .type and .size in general, function symbols
1971 // are automatically sized.
1972 bool EmitFunctionSize = MAI->hasDotTypeDotSizeDirective() && !TT.isWasm();
1973
1974 if (needFuncLabels(*MF) || EmitFunctionSize) {
1975 // Create a symbol for the end of function.
1976 CurrentFnEnd = createTempSymbol("func_end");
1977 OutStreamer->emitLabel(CurrentFnEnd);
1978 }
1979
1980 // If the target wants a .size directive for the size of the function, emit
1981 // it.
1982 if (EmitFunctionSize) {
1983 // We can get the size as difference between the function label and the
1984 // temp label.
1985 const MCExpr *SizeExp = MCBinaryExpr::createSub(
1986 MCSymbolRefExpr::create(CurrentFnEnd, OutContext),
1988 OutStreamer->emitELFSize(CurrentFnSym, SizeExp);
1990 OutStreamer->emitELFSize(CurrentFnBeginLocal, SizeExp);
1991 }
1992
1993 // Call endBasicBlockSection on the last block now, if it wasn't already
1994 // called.
1995 if (!MF->back().isEndSection()) {
1996 for (const HandlerInfo &HI : Handlers) {
1997 NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName,
1998 HI.TimerGroupDescription, TimePassesIsEnabled);
1999 HI.Handler->endBasicBlockSection(MF->back());
2000 }
2001 }
2002 for (const HandlerInfo &HI : Handlers) {
2003 NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName,
2004 HI.TimerGroupDescription, TimePassesIsEnabled);
2005 HI.Handler->markFunctionEnd();
2006 }
2007
2009 MBBSectionRange{CurrentFnBegin, CurrentFnEnd};
2010
2011 // Print out jump tables referenced by the function.
2013
2014 // Emit post-function debug and/or EH information.
2015 for (const HandlerInfo &HI : Handlers) {
2016 NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName,
2017 HI.TimerGroupDescription, TimePassesIsEnabled);
2018 HI.Handler->endFunction(MF);
2019 }
2020
2021 // Emit section containing BB address offsets and their metadata, when
2022 // BB labels are requested for this function. Skip empty functions.
2023 if (HasAnyRealCode) {
2026 else if (PgoAnalysisMapFeatures.getBits() != 0)
2028 SMLoc(), "pgo-analysis-map is enabled for function " + MF->getName() +
2029 " but it does not have labels");
2030 }
2031
2032 // Emit sections containing instruction and function PCs.
2034
2035 // Emit section containing stack size metadata.
2037
2038 // Emit .su file containing function stack size information.
2040
2042
2043 if (isVerbose())
2044 OutStreamer->getCommentOS() << "-- End function\n";
2045
2046 OutStreamer->addBlankLine();
2047}
2048
2049/// Compute the number of Global Variables that uses a Constant.
2050static unsigned getNumGlobalVariableUses(const Constant *C) {
2051 if (!C)
2052 return 0;
2053
2054 if (isa<GlobalVariable>(C))
2055 return 1;
2056
2057 unsigned NumUses = 0;
2058 for (const auto *CU : C->users())
2059 NumUses += getNumGlobalVariableUses(dyn_cast<Constant>(CU));
2060
2061 return NumUses;
2062}
2063
2064/// Only consider global GOT equivalents if at least one user is a
2065/// cstexpr inside an initializer of another global variables. Also, don't
2066/// handle cstexpr inside instructions. During global variable emission,
2067/// candidates are skipped and are emitted later in case at least one cstexpr
2068/// isn't replaced by a PC relative GOT entry access.
2070 unsigned &NumGOTEquivUsers) {
2071 // Global GOT equivalents are unnamed private globals with a constant
2072 // pointer initializer to another global symbol. They must point to a
2073 // GlobalVariable or Function, i.e., as GlobalValue.
2074 if (!GV->hasGlobalUnnamedAddr() || !GV->hasInitializer() ||
2075 !GV->isConstant() || !GV->isDiscardableIfUnused() ||
2076 !isa<GlobalValue>(GV->getOperand(0)))
2077 return false;
2078
2079 // To be a got equivalent, at least one of its users need to be a constant
2080 // expression used by another global variable.
2081 for (const auto *U : GV->users())
2082 NumGOTEquivUsers += getNumGlobalVariableUses(dyn_cast<Constant>(U));
2083
2084 return NumGOTEquivUsers > 0;
2085}
2086
2087/// Unnamed constant global variables solely contaning a pointer to
2088/// another globals variable is equivalent to a GOT table entry; it contains the
2089/// the address of another symbol. Optimize it and replace accesses to these
2090/// "GOT equivalents" by using the GOT entry for the final global instead.
2091/// Compute GOT equivalent candidates among all global variables to avoid
2092/// emitting them if possible later on, after it use is replaced by a GOT entry
2093/// access.
2095 if (!getObjFileLowering().supportIndirectSymViaGOTPCRel())
2096 return;
2097
2098 for (const auto &G : M.globals()) {
2099 unsigned NumGOTEquivUsers = 0;
2100 if (!isGOTEquivalentCandidate(&G, NumGOTEquivUsers))
2101 continue;
2102
2103 const MCSymbol *GOTEquivSym = getSymbol(&G);
2104 GlobalGOTEquivs[GOTEquivSym] = std::make_pair(&G, NumGOTEquivUsers);
2105 }
2106}
2107
2108/// Constant expressions using GOT equivalent globals may not be eligible
2109/// for PC relative GOT entry conversion, in such cases we need to emit such
2110/// globals we previously omitted in EmitGlobalVariable.
2112 if (!getObjFileLowering().supportIndirectSymViaGOTPCRel())
2113 return;
2114
2116 for (auto &I : GlobalGOTEquivs) {
2117 const GlobalVariable *GV = I.second.first;
2118 unsigned Cnt = I.second.second;
2119 if (Cnt)
2120 FailedCandidates.push_back(GV);
2121 }
2122 GlobalGOTEquivs.clear();
2123
2124 for (const auto *GV : FailedCandidates)
2126}
2127
2128void AsmPrinter::emitGlobalAlias(const Module &M, const GlobalAlias &GA) {
2129 MCSymbol *Name = getSymbol(&GA);
2130 bool IsFunction = GA.getValueType()->isFunctionTy();
2131 // Treat bitcasts of functions as functions also. This is important at least
2132 // on WebAssembly where object and function addresses can't alias each other.
2133 if (!IsFunction)
2134 IsFunction = isa<Function>(GA.getAliasee()->stripPointerCasts());
2135
2136 // AIX's assembly directive `.set` is not usable for aliasing purpose,
2137 // so AIX has to use the extra-label-at-definition strategy. At this
2138 // point, all the extra label is emitted, we just have to emit linkage for
2139 // those labels.
2142 "Visibility should be handled with emitLinkage() on AIX.");
2143
2144 // Linkage for alias of global variable has been emitted.
2145 if (isa<GlobalVariable>(GA.getAliaseeObject()))
2146 return;
2147
2148 emitLinkage(&GA, Name);
2149 // If it's a function, also emit linkage for aliases of function entry
2150 // point.
2151 if (IsFunction)
2152 emitLinkage(&GA,
2153 getObjFileLowering().getFunctionEntryPointSymbol(&GA, TM));
2154 return;
2155 }
2156
2158 OutStreamer->emitSymbolAttribute(Name, MCSA_Global);
2159 else if (GA.hasWeakLinkage() || GA.hasLinkOnceLinkage())
2160 OutStreamer->emitSymbolAttribute(Name, MCSA_WeakReference);
2161 else
2162 assert(GA.hasLocalLinkage() && "Invalid alias linkage");
2163
2164 // Set the symbol type to function if the alias has a function type.
2165 // This affects codegen when the aliasee is not a function.
2166 if (IsFunction) {
2167 OutStreamer->emitSymbolAttribute(Name, MCSA_ELF_TypeFunction);
2169 OutStreamer->beginCOFFSymbolDef(Name);
2170 OutStreamer->emitCOFFSymbolStorageClass(
2175 OutStreamer->endCOFFSymbolDef();
2176 }
2177 }
2178
2180
2181 const MCExpr *Expr = lowerConstant(GA.getAliasee());
2182
2183 if (MAI->hasAltEntry() && isa<MCBinaryExpr>(Expr))
2184 OutStreamer->emitSymbolAttribute(Name, MCSA_AltEntry);
2185
2186 // Emit the directives as assignments aka .set:
2187 OutStreamer->emitAssignment(Name, Expr);
2188 MCSymbol *LocalAlias = getSymbolPreferLocal(GA);
2189 if (LocalAlias != Name)
2190 OutStreamer->emitAssignment(LocalAlias, Expr);
2191
2192 // If the aliasee does not correspond to a symbol in the output, i.e. the
2193 // alias is not of an object or the aliased object is private, then set the
2194 // size of the alias symbol from the type of the alias. We don't do this in
2195 // other situations as the alias and aliasee having differing types but same
2196 // size may be intentional.
2197 const GlobalObject *BaseObject = GA.getAliaseeObject();
2199 (!BaseObject || BaseObject->hasPrivateLinkage())) {
2200 const DataLayout &DL = M.getDataLayout();
2201 uint64_t Size = DL.getTypeAllocSize(GA.getValueType());
2203 }
2204}
2205
2206void AsmPrinter::emitGlobalIFunc(Module &M, const GlobalIFunc &GI) {
2208 "IFunc is not supported on AIX.");
2209
2210 auto EmitLinkage = [&](MCSymbol *Sym) {
2212 OutStreamer->emitSymbolAttribute(Sym, MCSA_Global);
2213 else if (GI.hasWeakLinkage() || GI.hasLinkOnceLinkage())
2214 OutStreamer->emitSymbolAttribute(Sym, MCSA_WeakReference);
2215 else
2216 assert(GI.hasLocalLinkage() && "Invalid ifunc linkage");
2217 };
2218
2220 MCSymbol *Name = getSymbol(&GI);
2221 EmitLinkage(Name);
2222 OutStreamer->emitSymbolAttribute(Name, MCSA_ELF_TypeIndFunction);
2224
2225 // Emit the directives as assignments aka .set:
2226 const MCExpr *Expr = lowerConstant(GI.getResolver());
2227 OutStreamer->emitAssignment(Name, Expr);
2228 MCSymbol *LocalAlias = getSymbolPreferLocal(GI);
2229 if (LocalAlias != Name)
2230 OutStreamer->emitAssignment(LocalAlias, Expr);
2231
2232 return;
2233 }
2234
2236 llvm::report_fatal_error("IFuncs are not supported on this platform");
2237
2238 // On Darwin platforms, emit a manually-constructed .symbol_resolver that
2239 // implements the symbol resolution duties of the IFunc.
2240 //
2241 // Normally, this would be handled by linker magic, but unfortunately there
2242 // are a few limitations in ld64 and ld-prime's implementation of
2243 // .symbol_resolver that mean we can't always use them:
2244 //
2245 // * resolvers cannot be the target of an alias
2246 // * resolvers cannot have private linkage
2247 // * resolvers cannot have linkonce linkage
2248 // * resolvers cannot appear in executables
2249 // * resolvers cannot appear in bundles
2250 //
2251 // This works around that by emitting a close approximation of what the
2252 // linker would have done.
2253
2254 MCSymbol *LazyPointer =
2255 GetExternalSymbolSymbol(GI.getName() + ".lazy_pointer");
2256 MCSymbol *StubHelper = GetExternalSymbolSymbol(GI.getName() + ".stub_helper");
2257
2259
2260 const DataLayout &DL = M.getDataLayout();
2261 emitAlignment(Align(DL.getPointerSize()));
2262 OutStreamer->emitLabel(LazyPointer);
2263 emitVisibility(LazyPointer, GI.getVisibility());
2264 OutStreamer->emitValue(MCSymbolRefExpr::create(StubHelper, OutContext), 8);
2265
2267
2268 const TargetSubtargetInfo *STI =
2270 const TargetLowering *TLI = STI->getTargetLowering();
2271 Align TextAlign(TLI->getMinFunctionAlignment());
2272
2273 MCSymbol *Stub = getSymbol(&GI);
2274 EmitLinkage(Stub);
2275 OutStreamer->emitCodeAlignment(TextAlign, getIFuncMCSubtargetInfo());
2276 OutStreamer->emitLabel(Stub);
2277 emitVisibility(Stub, GI.getVisibility());
2278 emitMachOIFuncStubBody(M, GI, LazyPointer);
2279
2280 OutStreamer->emitCodeAlignment(TextAlign, getIFuncMCSubtargetInfo());
2281 OutStreamer->emitLabel(StubHelper);
2282 emitVisibility(StubHelper, GI.getVisibility());
2283 emitMachOIFuncStubHelperBody(M, GI, LazyPointer);
2284}
2285
2287 if (!RS.needsSection())
2288 return;
2289
2290 remarks::RemarkSerializer &RemarkSerializer = RS.getSerializer();
2291
2292 std::optional<SmallString<128>> Filename;
2293 if (std::optional<StringRef> FilenameRef = RS.getFilename()) {
2294 Filename = *FilenameRef;
2295 sys::fs::make_absolute(*Filename);
2296 assert(!Filename->empty() && "The filename can't be empty.");
2297 }
2298
2299 std::string Buf;
2301 std::unique_ptr<remarks::MetaSerializer> MetaSerializer =
2302 Filename ? RemarkSerializer.metaSerializer(OS, Filename->str())
2303 : RemarkSerializer.metaSerializer(OS);
2304 MetaSerializer->emit();
2305
2306 // Switch to the remarks section.
2307 MCSection *RemarksSection =
2309 OutStreamer->switchSection(RemarksSection);
2310
2311 OutStreamer->emitBinaryData(OS.str());
2312}
2313
2315 // Set the MachineFunction to nullptr so that we can catch attempted
2316 // accesses to MF specific features at the module level and so that
2317 // we can conditionalize accesses based on whether or not it is nullptr.
2318 MF = nullptr;
2319
2320 // Gather all GOT equivalent globals in the module. We really need two
2321 // passes over the globals: one to compute and another to avoid its emission
2322 // in EmitGlobalVariable, otherwise we would not be able to handle cases
2323 // where the got equivalent shows up before its use.
2325
2326 // Emit global variables.
2327 for (const auto &G : M.globals())
2329
2330 // Emit remaining GOT equivalent globals.
2332
2334
2335 // Emit linkage(XCOFF) and visibility info for declarations
2336 for (const Function &F : M) {
2337 if (!F.isDeclarationForLinker())
2338 continue;
2339
2340 MCSymbol *Name = getSymbol(&F);
2341 // Function getSymbol gives us the function descriptor symbol for XCOFF.
2342
2344 GlobalValue::VisibilityTypes V = F.getVisibility();
2346 continue;
2347
2348 emitVisibility(Name, V, false);
2349 continue;
2350 }
2351
2352 if (F.isIntrinsic())
2353 continue;
2354
2355 // Handle the XCOFF case.
2356 // Variable `Name` is the function descriptor symbol (see above). Get the
2357 // function entry point symbol.
2358 MCSymbol *FnEntryPointSym = TLOF.getFunctionEntryPointSymbol(&F, TM);
2359 // Emit linkage for the function entry point.
2360 emitLinkage(&F, FnEntryPointSym);
2361
2362 // Emit linkage for the function descriptor.
2363 emitLinkage(&F, Name);
2364 }
2365
2366 // Emit the remarks section contents.
2367 // FIXME: Figure out when is the safest time to emit this section. It should
2368 // not come after debug info.
2369 if (remarks::RemarkStreamer *RS = M.getContext().getMainRemarkStreamer())
2370 emitRemarksSection(*RS);
2371
2373
2376
2377 // Output stubs for external and common global variables.
2379 if (!Stubs.empty()) {
2380 OutStreamer->switchSection(TLOF.getDataSection());
2381 const DataLayout &DL = M.getDataLayout();
2382
2383 emitAlignment(Align(DL.getPointerSize()));
2384 for (const auto &Stub : Stubs) {
2385 OutStreamer->emitLabel(Stub.first);
2386 OutStreamer->emitSymbolValue(Stub.second.getPointer(),
2387 DL.getPointerSize());
2388 }
2389 }
2390 }
2391
2393 MachineModuleInfoCOFF &MMICOFF =
2395
2396 // Output stubs for external and common global variables.
2398 if (!Stubs.empty()) {
2399 const DataLayout &DL = M.getDataLayout();
2400
2401 for (const auto &Stub : Stubs) {
2403 SectionName += Stub.first->getName();
2404 OutStreamer->switchSection(OutContext.getCOFFSection(
2408 SectionKind::getReadOnly(), Stub.first->getName(),
2410 emitAlignment(Align(DL.getPointerSize()));
2411 OutStreamer->emitSymbolAttribute(Stub.first, MCSA_Global);
2412 OutStreamer->emitLabel(Stub.first);
2413 OutStreamer->emitSymbolValue(Stub.second.getPointer(),
2414 DL.getPointerSize());
2415 }
2416 }
2417 }
2418
2419 // This needs to happen before emitting debug information since that can end
2420 // arbitrary sections.
2421 if (auto *TS = OutStreamer->getTargetStreamer())
2422 TS->emitConstantPools();
2423
2424 // Emit Stack maps before any debug info. Mach-O requires that no data or
2425 // text sections come after debug info has been emitted. This matters for
2426 // stack maps as they are arbitrary data, and may even have a custom format
2427 // through user plugins.
2428 emitStackMaps();
2429
2430 // Print aliases in topological order, that is, for each alias a = b,
2431 // b must be printed before a.
2432 // This is because on some targets (e.g. PowerPC) linker expects aliases in
2433 // such an order to generate correct TOC information.
2436 for (const auto &Alias : M.aliases()) {
2437 if (Alias.hasAvailableExternallyLinkage())
2438 continue;
2439 for (const GlobalAlias *Cur = &Alias; Cur;
2440 Cur = dyn_cast<GlobalAlias>(Cur->getAliasee())) {
2441 if (!AliasVisited.insert(Cur).second)
2442 break;
2443 AliasStack.push_back(Cur);
2444 }
2445 for (const GlobalAlias *AncestorAlias : llvm::reverse(AliasStack))
2446 emitGlobalAlias(M, *AncestorAlias);
2447 AliasStack.clear();
2448 }
2449
2450 // IFuncs must come before deubginfo in case the backend decides to emit them
2451 // as actual functions, since on Mach-O targets, we cannot create regular
2452 // sections after DWARF.
2453 for (const auto &IFunc : M.ifuncs())
2454 emitGlobalIFunc(M, IFunc);
2455
2456 // Finalize debug and EH information.
2457 for (const HandlerInfo &HI : Handlers) {
2458 NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName,
2459 HI.TimerGroupDescription, TimePassesIsEnabled);
2460 HI.Handler->endModule();
2461 }
2462
2463 // This deletes all the ephemeral handlers that AsmPrinter added, while
2464 // keeping all the user-added handlers alive until the AsmPrinter is
2465 // destroyed.
2466 Handlers.erase(Handlers.begin() + NumUserHandlers, Handlers.end());
2467 DD = nullptr;
2468
2469 // If the target wants to know about weak references, print them all.
2470 if (MAI->getWeakRefDirective()) {
2471 // FIXME: This is not lazy, it would be nice to only print weak references
2472 // to stuff that is actually used. Note that doing so would require targets
2473 // to notice uses in operands (due to constant exprs etc). This should
2474 // happen with the MC stuff eventually.
2475
2476 // Print out module-level global objects here.
2477 for (const auto &GO : M.global_objects()) {
2478 if (!GO.hasExternalWeakLinkage())
2479 continue;
2480 OutStreamer->emitSymbolAttribute(getSymbol(&GO), MCSA_WeakReference);
2481 }
2483 auto SymbolName = "swift_async_extendedFramePointerFlags";
2484 auto Global = M.getGlobalVariable(SymbolName);
2485 if (!Global) {
2486 auto Int8PtrTy = PointerType::getUnqual(M.getContext());
2487 Global = new GlobalVariable(M, Int8PtrTy, false,
2489 SymbolName);
2490 OutStreamer->emitSymbolAttribute(getSymbol(Global), MCSA_WeakReference);
2491 }
2492 }
2493 }
2494
2495 GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>();
2496 assert(MI && "AsmPrinter didn't require GCModuleInfo?");
2497 for (GCModuleInfo::iterator I = MI->end(), E = MI->begin(); I != E; )
2498 if (GCMetadataPrinter *MP = getOrCreateGCPrinter(**--I))
2499 MP->finishAssembly(M, *MI, *this);
2500
2501 // Emit llvm.ident metadata in an '.ident' directive.
2502 emitModuleIdents(M);
2503
2504 // Emit bytes for llvm.commandline metadata.
2505 // The command line metadata is emitted earlier on XCOFF.
2507 emitModuleCommandLines(M);
2508
2509 // Emit .note.GNU-split-stack and .note.GNU-no-split-stack sections if
2510 // split-stack is used.
2511 if (TM.getTargetTriple().isOSBinFormatELF() && HasSplitStack) {
2512 OutStreamer->switchSection(OutContext.getELFSection(".note.GNU-split-stack",
2513 ELF::SHT_PROGBITS, 0));
2514 if (HasNoSplitStack)
2515 OutStreamer->switchSection(OutContext.getELFSection(
2516 ".note.GNU-no-split-stack", ELF::SHT_PROGBITS, 0));
2517 }
2518
2519 // If we don't have any trampolines, then we don't require stack memory
2520 // to be executable. Some targets have a directive to declare this.
2521 Function *InitTrampolineIntrinsic = M.getFunction("llvm.init.trampoline");
2522 if (!InitTrampolineIntrinsic || InitTrampolineIntrinsic->use_empty())
2524 OutStreamer->switchSection(S);
2525
2526 if (TM.Options.EmitAddrsig) {
2527 // Emit address-significance attributes for all globals.
2528 OutStreamer->emitAddrsig();
2529 for (const GlobalValue &GV : M.global_values()) {
2530 if (!GV.use_empty() && !GV.isThreadLocal() &&
2531 !GV.hasDLLImportStorageClass() &&
2532 !GV.getName().starts_with("llvm.") &&
2533 !GV.hasAtLeastLocalUnnamedAddr())
2534 OutStreamer->emitAddrsigSym(getSymbol(&GV));
2535 }
2536 }
2537
2538 // Emit symbol partition specifications (ELF only).
2540 unsigned UniqueID = 0;
2541 for (const GlobalValue &GV : M.global_values()) {
2542 if (!GV.hasPartition() || GV.isDeclarationForLinker() ||
2543 GV.getVisibility() != GlobalValue::DefaultVisibility)
2544 continue;
2545
2546 OutStreamer->switchSection(
2547 OutContext.getELFSection(".llvm_sympart", ELF::SHT_LLVM_SYMPART, 0, 0,
2548 "", false, ++UniqueID, nullptr));
2549 OutStreamer->emitBytes(GV.getPartition());
2550 OutStreamer->emitZeros(1);
2551 OutStreamer->emitValue(
2554 }
2555 }
2556
2557 // Allow the target to emit any magic that it wants at the end of the file,
2558 // after everything else has gone out.
2560
2561 MMI = nullptr;
2562 AddrLabelSymbols = nullptr;
2563
2564 OutStreamer->finish();
2565 OutStreamer->reset();
2566 OwnedMLI.reset();
2567 OwnedMDT.reset();
2568
2569 return false;
2570}
2571
2573 auto Res = MBBSectionExceptionSyms.try_emplace(MBB.getSectionIDNum());
2574 if (Res.second)
2575 Res.first->second = createTempSymbol("exception");
2576 return Res.first->second;
2577}
2578
2580 this->MF = &MF;
2581 const Function &F = MF.getFunction();
2582
2583 // Record that there are split-stack functions, so we will emit a special
2584 // section to tell the linker.
2585 if (MF.shouldSplitStack()) {
2586 HasSplitStack = true;
2587
2589 HasNoSplitStack = true;
2590 } else
2591 HasNoSplitStack = true;
2592
2593 // Get the function symbol.
2594 if (!MAI->needsFunctionDescriptors()) {
2596 } else {
2598 "Only AIX uses the function descriptor hooks.");
2599 // AIX is unique here in that the name of the symbol emitted for the
2600 // function body does not have the same name as the source function's
2601 // C-linkage name.
2602 assert(CurrentFnDescSym && "The function descriptor symbol needs to be"
2603 " initalized first.");
2604
2605 // Get the function entry point symbol.
2607 }
2608
2610 CurrentFnBegin = nullptr;
2611 CurrentFnBeginLocal = nullptr;
2612 CurrentSectionBeginSym = nullptr;
2613 MBBSectionRanges.clear();
2614 MBBSectionExceptionSyms.clear();
2615 bool NeedsLocalForSize = MAI->needsLocalForSize();
2616 if (F.hasFnAttribute("patchable-function-entry") ||
2617 F.hasFnAttribute("function-instrument") ||
2618 F.hasFnAttribute("xray-instruction-threshold") || needFuncLabels(MF) ||
2619 NeedsLocalForSize || MF.getTarget().Options.EmitStackSizeSection ||
2621 CurrentFnBegin = createTempSymbol("func_begin");
2622 if (NeedsLocalForSize)
2624 }
2625
2626 ORE = &getAnalysis<MachineOptimizationRemarkEmitterPass>().getORE();
2627}
2628
2629namespace {
2630
2631// Keep track the alignment, constpool entries per Section.
2632 struct SectionCPs {
2633 MCSection *S;
2634 Align Alignment;
2636
2637 SectionCPs(MCSection *s, Align a) : S(s), Alignment(a) {}
2638 };
2639
2640} // end anonymous namespace
2641
2642/// EmitConstantPool - Print to the current output stream assembly
2643/// representations of the constants in the constant pool MCP. This is
2644/// used to print out constants which have been "spilled to memory" by
2645/// the code generator.
2647 const MachineConstantPool *MCP = MF->getConstantPool();
2648 const std::vector<MachineConstantPoolEntry> &CP = MCP->getConstants();
2649 if (CP.empty()) return;
2650
2651 // Calculate sections for constant pool entries. We collect entries to go into
2652 // the same section together to reduce amount of section switch statements.
2653 SmallVector<SectionCPs, 4> CPSections;
2654 for (unsigned i = 0, e = CP.size(); i != e; ++i) {
2655 const MachineConstantPoolEntry &CPE = CP[i];
2656 Align Alignment = CPE.getAlign();
2657
2659
2660 const Constant *C = nullptr;
2661 if (!CPE.isMachineConstantPoolEntry())
2662 C = CPE.Val.ConstVal;
2663
2665 getDataLayout(), Kind, C, Alignment);
2666
2667 // The number of sections are small, just do a linear search from the
2668 // last section to the first.
2669 bool Found = false;
2670 unsigned SecIdx = CPSections.size();
2671 while (SecIdx != 0) {
2672 if (CPSections[--SecIdx].S == S) {
2673 Found = true;
2674 break;
2675 }
2676 }
2677 if (!Found) {
2678 SecIdx = CPSections.size();
2679 CPSections.push_back(SectionCPs(S, Alignment));
2680 }
2681
2682 if (Alignment > CPSections[SecIdx].Alignment)
2683 CPSections[SecIdx].Alignment = Alignment;
2684 CPSections[SecIdx].CPEs.push_back(i);
2685 }
2686
2687 // Now print stuff into the calculated sections.
2688 const MCSection *CurSection = nullptr;
2689 unsigned Offset = 0;
2690 for (unsigned i = 0, e = CPSections.size(); i != e; ++i) {
2691 for (unsigned j = 0, ee = CPSections[i].CPEs.size(); j != ee; ++j) {
2692 unsigned CPI = CPSections[i].CPEs[j];
2693 MCSymbol *Sym = GetCPISymbol(CPI);
2694 if (!Sym->isUndefined())
2695 continue;
2696
2697 if (CurSection != CPSections[i].S) {
2698 OutStreamer->switchSection(CPSections[i].S);
2699 emitAlignment(Align(CPSections[i].Alignment));
2700 CurSection = CPSections[i].S;
2701 Offset = 0;
2702 }
2703
2704 MachineConstantPoolEntry CPE = CP[CPI];
2705
2706 // Emit inter-object padding for alignment.
2707 unsigned NewOffset = alignTo(Offset, CPE.getAlign());
2708 OutStreamer->emitZeros(NewOffset - Offset);
2709
2710 Offset = NewOffset + CPE.getSizeInBytes(getDataLayout());
2711
2712 OutStreamer->emitLabel(Sym);
2715 else
2717 }
2718 }
2719}
2720
2721// Print assembly representations of the jump tables used by the current
2722// function.
2724 const DataLayout &DL = MF->getDataLayout();
2725 const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo();
2726 if (!MJTI) return;
2727 if (MJTI->getEntryKind() == MachineJumpTableInfo::EK_Inline) return;
2728 const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
2729 if (JT.empty()) return;
2730
2731 // Pick the directive to use to print the jump table entries, and switch to
2732 // the appropriate section.
2733 const Function &F = MF->getFunction();
2735 bool JTInDiffSection = !TLOF.shouldPutJumpTableInFunctionSection(
2738 F);
2739 if (JTInDiffSection) {
2740 // Drop it in the readonly section.
2741 MCSection *ReadOnlySection = TLOF.getSectionForJumpTable(F, TM);
2742 OutStreamer->switchSection(ReadOnlySection);
2743 }
2744
2746
2747 // Jump tables in code sections are marked with a data_region directive
2748 // where that's supported.
2749 if (!JTInDiffSection)
2750 OutStreamer->emitDataRegion(MCDR_DataRegionJT32);
2751
2752 for (unsigned JTI = 0, e = JT.size(); JTI != e; ++JTI) {
2753 const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs;
2754
2755 // If this jump table was deleted, ignore it.
2756 if (JTBBs.empty()) continue;
2757
2758 // For the EK_LabelDifference32 entry, if using .set avoids a relocation,
2759 /// emit a .set directive for each unique entry.
2765 for (const MachineBasicBlock *MBB : JTBBs) {
2766 if (!EmittedSets.insert(MBB).second)
2767 continue;
2768
2769 // .set LJTSet, LBB32-base
2770 const MCExpr *LHS =
2772 OutStreamer->emitAssignment(GetJTSetSymbol(JTI, MBB->getNumber()),
2774 OutContext));
2775 }
2776 }
2777
2778 // On some targets (e.g. Darwin) we want to emit two consecutive labels
2779 // before each jump table. The first label is never referenced, but tells
2780 // the assembler and linker the extents of the jump table object. The
2781 // second label is actually referenced by the code.
2782 if (JTInDiffSection && DL.hasLinkerPrivateGlobalPrefix())
2783 // FIXME: This doesn't have to have any specific name, just any randomly
2784 // named and numbered local label started with 'l' would work. Simplify
2785 // GetJTISymbol.
2786 OutStreamer->emitLabel(GetJTISymbol(JTI, true));
2787
2788 MCSymbol* JTISymbol = GetJTISymbol(JTI);
2789 OutStreamer->emitLabel(JTISymbol);
2790
2791 for (const MachineBasicBlock *MBB : JTBBs)
2792 emitJumpTableEntry(MJTI, MBB, JTI);
2793 }
2794 if (!JTInDiffSection)
2795 OutStreamer->emitDataRegion(MCDR_DataRegionEnd);
2796}
2797
2798/// EmitJumpTableEntry - Emit a jump table entry for the specified MBB to the
2799/// current stream.
2800void AsmPrinter::emitJumpTableEntry(const MachineJumpTableInfo *MJTI,
2801 const MachineBasicBlock *MBB,
2802 unsigned UID) const {
2803 assert(MBB && MBB->getNumber() >= 0 && "Invalid basic block");
2804 const MCExpr *Value = nullptr;
2805 switch (MJTI->getEntryKind()) {
2807 llvm_unreachable("Cannot emit EK_Inline jump table entry");
2810 MJTI, MBB, UID, OutContext);
2811 break;
2813 // EK_BlockAddress - Each entry is a plain address of block, e.g.:
2814 // .word LBB123
2816 break;
2818 // EK_GPRel32BlockAddress - Each entry is an address of block, encoded
2819 // with a relocation as gp-relative, e.g.:
2820 // .gprel32 LBB123
2821 MCSymbol *MBBSym = MBB->getSymbol();
2822 OutStreamer->emitGPRel32Value(MCSymbolRefExpr::create(MBBSym, OutContext));
2823 return;
2824 }
2825
2827 // EK_GPRel64BlockAddress - Each entry is an address of block, encoded
2828 // with a relocation as gp-relative, e.g.:
2829 // .gpdword LBB123
2830 MCSymbol *MBBSym = MBB->getSymbol();
2831 OutStreamer->emitGPRel64Value(MCSymbolRefExpr::create(MBBSym, OutContext));
2832 return;
2833 }
2834
2837 // Each entry is the address of the block minus the address of the jump
2838 // table. This is used for PIC jump tables where gprel32 is not supported.
2839 // e.g.:
2840 // .word LBB123 - LJTI1_2
2841 // If the .set directive avoids relocations, this is emitted as:
2842 // .set L4_5_set_123, LBB123 - LJTI1_2
2843 // .word L4_5_set_123
2847 OutContext);
2848 break;
2849 }
2854 break;
2855 }
2856 }
2857
2858 assert(Value && "Unknown entry kind!");
2859
2860 unsigned EntrySize = MJTI->getEntrySize(getDataLayout());
2861 OutStreamer->emitValue(Value, EntrySize);
2862}
2863
2864/// EmitSpecialLLVMGlobal - Check to see if the specified global is a
2865/// special global used by LLVM. If so, emit it and return true, otherwise
2866/// do nothing and return false.
2868 if (GV->getName() == "llvm.used") {
2869 if (MAI->hasNoDeadStrip()) // No need to emit this at all.
2870 emitLLVMUsedList(cast<ConstantArray>(GV->getInitializer()));
2871 return true;
2872 }
2873
2874 // Ignore debug and non-emitted data. This handles llvm.compiler.used.
2875 if (GV->getSection() == "llvm.metadata" ||
2877 return true;
2878
2879 if (GV->getName() == "llvm.arm64ec.symbolmap") {
2880 // For ARM64EC, print the table that maps between symbols and the
2881 // corresponding thunks to translate between x64 and AArch64 code.
2882 // This table is generated by AArch64Arm64ECCallLowering.
2883 OutStreamer->switchSection(OutContext.getCOFFSection(
2885 auto *Arr = cast<ConstantArray>(GV->getInitializer());
2886 for (auto &U : Arr->operands()) {
2887 auto *C = cast<Constant>(U);
2888 auto *Src = cast<Function>(C->getOperand(0)->stripPointerCasts());
2889 auto *Dst = cast<Function>(C->getOperand(1)->stripPointerCasts());
2890 int Kind = cast<ConstantInt>(C->getOperand(2))->getZExtValue();
2891
2892 if (Src->hasDLLImportStorageClass()) {
2893 // For now, we assume dllimport functions aren't directly called.
2894 // (We might change this later to match MSVC.)
2895 OutStreamer->emitCOFFSymbolIndex(
2896 OutContext.getOrCreateSymbol("__imp_" + Src->getName()));
2897 OutStreamer->emitCOFFSymbolIndex(getSymbol(Dst));
2898 OutStreamer->emitInt32(Kind);
2899 } else {
2900 // FIXME: For non-dllimport functions, MSVC emits the same entry
2901 // twice, for reasons I don't understand. I have to assume the linker
2902 // ignores the redundant entry; there aren't any reasonable semantics
2903 // to attach to it.
2904 OutStreamer->emitCOFFSymbolIndex(getSymbol(Src));
2905 OutStreamer->emitCOFFSymbolIndex(getSymbol(Dst));
2906 OutStreamer->emitInt32(Kind);
2907 }
2908 }
2909 return true;
2910 }
2911
2912 if (!GV->hasAppendingLinkage()) return false;
2913
2914 assert(GV->hasInitializer() && "Not a special LLVM global!");
2915
2916 if (GV->getName() == "llvm.global_ctors") {
2918 /* isCtor */ true);
2919
2920 return true;
2921 }
2922
2923 if (GV->getName() == "llvm.global_dtors") {
2925 /* isCtor */ false);
2926
2927 return true;
2928 }
2929
2930 report_fatal_error("unknown special variable");
2931}
2932
2933/// EmitLLVMUsedList - For targets that define a MAI::UsedDirective, mark each
2934/// global in the specified llvm.used list.
2935void AsmPrinter::emitLLVMUsedList(const ConstantArray *InitList) {
2936 // Should be an array of 'i8*'.
2937 for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) {
2938 const GlobalValue *GV =
2939 dyn_cast<GlobalValue>(InitList->getOperand(i)->stripPointerCasts());
2940 if (GV)
2941 OutStreamer->emitSymbolAttribute(getSymbol(GV), MCSA_NoDeadStrip);
2942 }
2943}
2944
2946 const Constant *List,
2947 SmallVector<Structor, 8> &Structors) {
2948 // Should be an array of '{ i32, void ()*, i8* }' structs. The first value is
2949 // the init priority.
2950 if (!isa<ConstantArray>(List))
2951 return;
2952
2953 // Gather the structors in a form that's convenient for sorting by priority.
2954 for (Value *O : cast<ConstantArray>(List)->operands()) {
2955 auto *CS = cast<ConstantStruct>(O);
2956 if (CS->getOperand(1)->isNullValue())
2957 break; // Found a null terminator, skip the rest.
2958 ConstantInt *Priority = dyn_cast<ConstantInt>(CS->getOperand(0));
2959 if (!Priority)
2960 continue; // Malformed.
2961 Structors.push_back(Structor());
2962 Structor &S = Structors.back();
2963 S.Priority = Priority->getLimitedValue(65535);
2964 S.Func = CS->getOperand(1);
2965 if (!CS->getOperand(2)->isNullValue()) {
2966 if (TM.getTargetTriple().isOSAIX())
2968 "associated data of XXStructor list is not yet supported on AIX");
2969 S.ComdatKey =
2970 dyn_cast<GlobalValue>(CS->getOperand(2)->stripPointerCasts());
2971 }
2972 }
2973
2974 // Emit the function pointers in the target-specific order
2975 llvm::stable_sort(Structors, [](const Structor &L, const Structor &R) {
2976 return L.Priority < R.Priority;
2977 });
2978}
2979
2980/// EmitXXStructorList - Emit the ctor or dtor list taking into account the init
2981/// priority.
2983 bool IsCtor) {
2984 SmallVector<Structor, 8> Structors;
2985 preprocessXXStructorList(DL, List, Structors);
2986 if (Structors.empty())
2987 return;
2988
2989 // Emit the structors in reverse order if we are using the .ctor/.dtor
2990 // initialization scheme.
2991 if (!TM.Options.UseInitArray)
2992 std::reverse(Structors.begin(), Structors.end());
2993
2994 const Align Align = DL.getPointerPrefAlignment();
2995 for (Structor &S : Structors) {
2997 const MCSymbol *KeySym = nullptr;
2998 if (GlobalValue *GV = S.ComdatKey) {
2999 if (GV->isDeclarationForLinker())
3000 // If the associated variable is not defined in this module
3001 // (it might be available_externally, or have been an
3002 // available_externally definition that was dropped by the
3003 // EliminateAvailableExternally pass), some other TU
3004 // will provide its dynamic initializer.
3005 continue;
3006
3007 KeySym = getSymbol(GV);
3008 }
3009
3010 MCSection *OutputSection =
3011 (IsCtor ? Obj.getStaticCtorSection(S.Priority, KeySym)
3012 : Obj.getStaticDtorSection(S.Priority, KeySym));
3013 OutStreamer->switchSection(OutputSection);
3014 if (OutStreamer->getCurrentSection() != OutStreamer->getPreviousSection())
3016 emitXXStructor(DL, S.Func);
3017 }
3018}
3019
3020void AsmPrinter::emitModuleIdents(Module &M) {
3021 if (!MAI->hasIdentDirective())
3022 return;
3023
3024 if (const NamedMDNode *NMD = M.getNamedMetadata("llvm.ident")) {
3025 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
3026 const MDNode *N = NMD->getOperand(i);
3027 assert(N->getNumOperands() == 1 &&
3028 "llvm.ident metadata entry can have only one operand");
3029 const MDString *S = cast<MDString>(N->getOperand(0));
3030 OutStreamer->emitIdent(S->getString());
3031 }
3032 }
3033}
3034
3035void AsmPrinter::emitModuleCommandLines(Module &M) {
3037 if (!CommandLine)
3038 return;
3039
3040 const NamedMDNode *NMD = M.getNamedMetadata("llvm.commandline");
3041 if (!NMD || !NMD->getNumOperands())
3042 return;
3043
3044 OutStreamer->pushSection();
3045 OutStreamer->switchSection(CommandLine);
3046 OutStreamer->emitZeros(1);
3047 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
3048 const MDNode *N = NMD->getOperand(i);
3049 assert(N->getNumOperands() == 1 &&
3050 "llvm.commandline metadata entry can have only one operand");
3051 const MDString *S = cast<MDString>(N->getOperand(0));
3052 OutStreamer->emitBytes(S->getString());
3053 OutStreamer->emitZeros(1);
3054 }
3055 OutStreamer->popSection();
3056}
3057
3058//===--------------------------------------------------------------------===//
3059// Emission and print routines
3060//
3061
3062/// Emit a byte directive and value.
3063///
3064void AsmPrinter::emitInt8(int Value) const { OutStreamer->emitInt8(Value); }
3065
3066/// Emit a short directive and value.
3067void AsmPrinter::emitInt16(int Value) const { OutStreamer->emitInt16(Value); }
3068
3069/// Emit a long directive and value.
3070void AsmPrinter::emitInt32(int Value) const { OutStreamer->emitInt32(Value); }
3071
3072/// EmitSLEB128 - emit the specified signed leb128 value.
3073void AsmPrinter::emitSLEB128(int64_t Value, const char *Desc) const {
3074 if (isVerbose() && Desc)
3075 OutStreamer->AddComment(Desc);
3076
3077 OutStreamer->emitSLEB128IntValue(Value);
3078}
3079
3081 unsigned PadTo) const {
3082 if (isVerbose() && Desc)
3083 OutStreamer->AddComment(Desc);
3084
3085 OutStreamer->emitULEB128IntValue(Value, PadTo);
3086}
3087
3088/// Emit a long long directive and value.
3090 OutStreamer->emitInt64(Value);
3091}
3092
3093/// Emit something like ".long Hi-Lo" where the size in bytes of the directive
3094/// is specified by Size and Hi/Lo specify the labels. This implicitly uses
3095/// .set if it avoids relocations.
3097 unsigned Size) const {
3098 OutStreamer->emitAbsoluteSymbolDiff(Hi, Lo, Size);
3099}
3100
3101/// Emit something like ".uleb128 Hi-Lo".
3103 const MCSymbol *Lo) const {
3104 OutStreamer->emitAbsoluteSymbolDiffAsULEB128(Hi, Lo);
3105}
3106
3107/// EmitLabelPlusOffset - Emit something like ".long Label+Offset"
3108/// where the size in bytes of the directive is specified by Size and Label
3109/// specifies the label. This implicitly uses .set if it is available.
3111 unsigned Size,
3112 bool IsSectionRelative) const {
3113 if (MAI->needsDwarfSectionOffsetDirective() && IsSectionRelative) {
3114 OutStreamer->emitCOFFSecRel32(Label, Offset);
3115 if (Size > 4)
3116 OutStreamer->emitZeros(Size - 4);
3117 return;
3118 }
3119
3120 // Emit Label+Offset (or just Label if Offset is zero)
3121 const MCExpr *Expr = MCSymbolRefExpr::create(Label, OutContext);
3122 if (Offset)
3125
3126 OutStreamer->emitValue(Expr, Size);
3127}
3128
3129//===----------------------------------------------------------------------===//
3130
3131// EmitAlignment - Emit an alignment directive to the specified power of
3132// two boundary. If a global value is specified, and if that global has
3133// an explicit alignment requested, it will override the alignment request
3134// if required for correctness.
3136 unsigned MaxBytesToEmit) const {
3137 if (GV)
3138 Alignment = getGVAlignment(GV, GV->getParent()->getDataLayout(), Alignment);
3139
3140 if (Alignment == Align(1))
3141 return; // 1-byte aligned: no need to emit alignment.
3142
3143 if (getCurrentSection()->getKind().isText()) {
3144 const MCSubtargetInfo *STI = nullptr;
3145 if (this->MF)
3146 STI = &getSubtargetInfo();
3147 else
3148 STI = TM.getMCSubtargetInfo();
3149 OutStreamer->emitCodeAlignment(Alignment, STI, MaxBytesToEmit);
3150 } else
3151 OutStreamer->emitValueToAlignment(Alignment, 0, 1, MaxBytesToEmit);
3152}
3153
3154//===----------------------------------------------------------------------===//
3155// Constant emission.
3156//===----------------------------------------------------------------------===//
3157
3159 MCContext &Ctx = OutContext;
3160
3161 if (CV->isNullValue() || isa<UndefValue>(CV))
3162 return MCConstantExpr::create(0, Ctx);
3163
3164 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV))
3165 return MCConstantExpr::create(CI->getZExtValue(), Ctx);
3166
3167 if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV))
3168 return MCSymbolRefExpr::create(getSymbol(GV), Ctx);
3169
3170 if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV))
3172
3173 if (const auto *Equiv = dyn_cast<DSOLocalEquivalent>(CV))
3175
3176 if (const NoCFIValue *NC = dyn_cast<NoCFIValue>(CV))
3177 return MCSymbolRefExpr::create(getSymbol(NC->getGlobalValue()), Ctx);
3178
3179 const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV);
3180 if (!CE) {
3181 llvm_unreachable("Unknown constant value to lower!");
3182 }
3183
3184 // The constant expression opcodes are limited to those that are necessary
3185 // to represent relocations on supported targets. Expressions involving only
3186 // constant addresses are constant folded instead.
3187 switch (CE->getOpcode()) {
3188 default:
3189 break; // Error
3190 case Instruction::AddrSpaceCast: {
3191 const Constant *Op = CE->getOperand(0);
3192 unsigned DstAS = CE->getType()->getPointerAddressSpace();
3193 unsigned SrcAS = Op->getType()->getPointerAddressSpace();
3194 if (TM.isNoopAddrSpaceCast(SrcAS, DstAS))
3195 return lowerConstant(Op);
3196
3197 break; // Error
3198 }
3199 case Instruction::GetElementPtr: {
3200 // Generate a symbolic expression for the byte address
3201 APInt OffsetAI(getDataLayout().getPointerTypeSizeInBits(CE->getType()), 0);
3202 cast<GEPOperator>(CE)->accumulateConstantOffset(getDataLayout(), OffsetAI);
3203
3204 const MCExpr *Base = lowerConstant(CE->getOperand(0));
3205 if (!OffsetAI)
3206 return Base;
3207
3208 int64_t Offset = OffsetAI.getSExtValue();
3210 Ctx);
3211 }
3212
3213 case Instruction::Trunc:
3214 // We emit the value and depend on the assembler to truncate the generated
3215 // expression properly. This is important for differences between
3216 // blockaddress labels. Since the two labels are in the same function, it
3217 // is reasonable to treat their delta as a 32-bit value.
3218 [[fallthrough]];
3219 case Instruction::BitCast:
3220 return lowerConstant(CE->getOperand(0));
3221
3222 case Instruction::IntToPtr: {
3223 const DataLayout &DL = getDataLayout();
3224
3225 // Handle casts to pointers by changing them into casts to the appropriate
3226 // integer type. This promotes constant folding and simplifies this code.
3227 Constant *Op = CE->getOperand(0);
3228 Op = ConstantFoldIntegerCast(Op, DL.getIntPtrType(CV->getType()),
3229 /*IsSigned*/ false, DL);
3230 if (Op)
3231 return lowerConstant(Op);
3232
3233 break; // Error
3234 }
3235
3236 case Instruction::PtrToInt: {
3237 const DataLayout &DL = getDataLayout();
3238
3239 // Support only foldable casts to/from pointers that can be eliminated by
3240 // changing the pointer to the appropriately sized integer type.
3241 Constant *Op = CE->getOperand(0);
3242 Type *Ty = CE->getType();
3243
3244 const MCExpr *OpExpr = lowerConstant(Op);
3245
3246 // We can emit the pointer value into this slot if the slot is an
3247 // integer slot equal to the size of the pointer.
3248 //
3249 // If the pointer is larger than the resultant integer, then
3250 // as with Trunc just depend on the assembler to truncate it.
3251 if (DL.getTypeAllocSize(Ty).getFixedValue() <=
3252 DL.getTypeAllocSize(Op->getType()).getFixedValue())
3253 return OpExpr;
3254
3255 break; // Error
3256 }
3257
3258 case Instruction::Sub: {
3259 GlobalValue *LHSGV;
3260 APInt LHSOffset;
3261 DSOLocalEquivalent *DSOEquiv;
3262 if (IsConstantOffsetFromGlobal(CE->getOperand(0), LHSGV, LHSOffset,
3263 getDataLayout(), &DSOEquiv)) {
3264 GlobalValue *RHSGV;
3265 APInt RHSOffset;
3266 if (IsConstantOffsetFromGlobal(CE->getOperand(1), RHSGV, RHSOffset,
3267 getDataLayout())) {
3268 const MCExpr *RelocExpr =
3270 if (!RelocExpr) {
3271 const MCExpr *LHSExpr =
3273 if (DSOEquiv &&
3274 getObjFileLowering().supportDSOLocalEquivalentLowering())
3275 LHSExpr =
3277 RelocExpr = MCBinaryExpr::createSub(
3278 LHSExpr, MCSymbolRefExpr::create(getSymbol(RHSGV), Ctx), Ctx);
3279 }
3280 int64_t Addend = (LHSOffset - RHSOffset).getSExtValue();
3281 if (Addend != 0)
3282 RelocExpr = MCBinaryExpr::createAdd(
3283 RelocExpr, MCConstantExpr::create(Addend, Ctx), Ctx);
3284 return RelocExpr;
3285 }
3286 }
3287
3288 const MCExpr *LHS = lowerConstant(CE->getOperand(0));
3289 const MCExpr *RHS = lowerConstant(CE->getOperand(1));
3290 return MCBinaryExpr::createSub(LHS, RHS, Ctx);
3291 break;
3292 }
3293
3294 case Instruction::Add: {
3295 const MCExpr *LHS = lowerConstant(CE->getOperand(0));
3296 const MCExpr *RHS = lowerConstant(CE->getOperand(1));
3297 return MCBinaryExpr::createAdd(LHS, RHS, Ctx);
3298 }
3299 }
3300
3301 // If the code isn't optimized, there may be outstanding folding
3302 // opportunities. Attempt to fold the expression using DataLayout as a
3303 // last resort before giving up.
3305 if (C != CE)
3306 return lowerConstant(C);
3307
3308 // Otherwise report the problem to the user.
3309 std::string S;
3311 OS << "Unsupported expression in static initializer: ";
3312 CE->printAsOperand(OS, /*PrintType=*/false,
3313 !MF ? nullptr : MF->getFunction().getParent());
3314 report_fatal_error(Twine(OS.str()));
3315}
3316
3317static void emitGlobalConstantImpl(const DataLayout &DL, const Constant *C,
3318 AsmPrinter &AP,
3319 const Constant *BaseCV = nullptr,
3320 uint64_t Offset = 0,
3321 AsmPrinter::AliasMapTy *AliasList = nullptr);
3322
3323static void emitGlobalConstantFP(const ConstantFP *CFP, AsmPrinter &AP);
3324static void emitGlobalConstantFP(APFloat APF, Type *ET, AsmPrinter &AP);
3325
3326/// isRepeatedByteSequence - Determine whether the given value is
3327/// composed of a repeated sequence of identical bytes and return the
3328/// byte value. If it is not a repeated sequence, return -1.
3330 StringRef Data = V->getRawDataValues();
3331 assert(!Data.empty() && "Empty aggregates should be CAZ node");
3332 char C = Data[0];
3333 for (unsigned i = 1, e = Data.size(); i != e; ++i)
3334 if (Data[i] != C) return -1;
3335 return static_cast<uint8_t>(C); // Ensure 255 is not returned as -1.
3336}
3337
3338/// isRepeatedByteSequence - Determine whether the given value is
3339/// composed of a repeated sequence of identical bytes and return the
3340/// byte value. If it is not a repeated sequence, return -1.
3341static int isRepeatedByteSequence(const Value *V, const DataLayout &DL) {
3342 if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
3343 uint64_t Size = DL.getTypeAllocSizeInBits(V->getType());
3344 assert(Size % 8 == 0);
3345
3346 // Extend the element to take zero padding into account.
3347 APInt Value = CI->getValue().zext(Size);
3348 if (!Value.isSplat(8))
3349 return -1;
3350
3351 return Value.zextOrTrunc(8).getZExtValue();
3352 }
3353 if (const ConstantArray *CA = dyn_cast<ConstantArray>(V)) {
3354 // Make sure all array elements are sequences of the same repeated
3355 // byte.
3356 assert(CA->getNumOperands() != 0 && "Should be a CAZ");
3357 Constant *Op0 = CA->getOperand(0);
3358 int Byte = isRepeatedByteSequence(Op0, DL);
3359 if (Byte == -1)
3360 return -1;
3361
3362 // All array elements must be equal.
3363 for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i)
3364 if (CA->getOperand(i) != Op0)
3365 return -1;
3366 return Byte;
3367 }
3368
3369 if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(V))
3370 return isRepeatedByteSequence(CDS);
3371
3372 return -1;
3373}
3374
3376 AsmPrinter::AliasMapTy *AliasList) {
3377 if (AliasList) {
3378 auto AliasIt = AliasList->find(Offset);
3379 if (AliasIt != AliasList->end()) {
3380 for (const GlobalAlias *GA : AliasIt->second)
3381 AP.OutStreamer->emitLabel(AP.getSymbol(GA));
3382 AliasList->erase(Offset);
3383 }
3384 }
3385}
3386
3388 const DataLayout &DL, const ConstantDataSequential *CDS, AsmPrinter &AP,
3389 AsmPrinter::AliasMapTy *AliasList) {
3390 // See if we can aggregate this into a .fill, if so, emit it as such.
3391 int Value = isRepeatedByteSequence(CDS, DL);
3392 if (Value != -1) {
3393 uint64_t Bytes = DL.getTypeAllocSize(CDS->getType());
3394 // Don't emit a 1-byte object as a .fill.
3395 if (Bytes > 1)
3396 return AP.OutStreamer->emitFill(Bytes, Value);
3397 }
3398
3399 // If this can be emitted with .ascii/.asciz, emit it as such.
3400 if (CDS->isString())
3401 return AP.OutStreamer->emitBytes(CDS->getAsString());
3402
3403 // Otherwise, emit the values in successive locations.
3404 unsigned ElementByteSize = CDS->getElementByteSize();
3405 if (isa<IntegerType>(CDS->getElementType())) {
3406 for (unsigned I = 0, E = CDS->getNumElements(); I != E; ++I) {
3407 emitGlobalAliasInline(AP, ElementByteSize * I, AliasList);
3408 if (AP.isVerbose())
3409 AP.OutStreamer->getCommentOS()
3410 << format("0x%" PRIx64 "\n", CDS->getElementAsInteger(I));
3411 AP.OutStreamer->emitIntValue(CDS->getElementAsInteger(I),
3412 ElementByteSize);
3413 }
3414 } else {
3415 Type *ET = CDS->getElementType();
3416 for (unsigned I = 0, E = CDS->getNumElements(); I != E; ++I) {
3417 emitGlobalAliasInline(AP, ElementByteSize * I, AliasList);
3419 }
3420 }
3421
3422 unsigned Size = DL.getTypeAllocSize(CDS->getType());
3423 unsigned EmittedSize =
3424 DL.getTypeAllocSize(CDS->getElementType()) * CDS->getNumElements();
3425 assert(EmittedSize <= Size && "Size cannot be less than EmittedSize!");
3426 if (unsigned Padding = Size - EmittedSize)
3427 AP.OutStreamer->emitZeros(Padding);
3428}
3429
3431 const ConstantArray *CA, AsmPrinter &AP,
3432 const Constant *BaseCV, uint64_t Offset,
3433 AsmPrinter::AliasMapTy *AliasList) {
3434 // See if we can aggregate some values. Make sure it can be
3435 // represented as a series of bytes of the constant value.
3436 int Value = isRepeatedByteSequence(CA, DL);
3437
3438 if (Value != -1) {
3439 uint64_t Bytes = DL.getTypeAllocSize(CA->getType());
3440 AP.OutStreamer->emitFill(Bytes, Value);
3441 } else {
3442 for (unsigned I = 0, E = CA->getNumOperands(); I != E; ++I) {
3443 emitGlobalConstantImpl(DL, CA->getOperand(I), AP, BaseCV, Offset,
3444 AliasList);
3445 Offset += DL.getTypeAllocSize(CA->getOperand(I)->getType());
3446 }
3447 }
3448}
3449
3450static void emitGlobalConstantLargeInt(const ConstantInt *CI, AsmPrinter &AP);
3451
3453 const ConstantVector *CV, AsmPrinter &AP,
3454 AsmPrinter::AliasMapTy *AliasList) {
3455 Type *ElementType = CV->getType()->getElementType();
3456 uint64_t ElementSizeInBits = DL.getTypeSizeInBits(ElementType);
3457 uint64_t ElementAllocSizeInBits = DL.getTypeAllocSizeInBits(ElementType);
3458 uint64_t EmittedSize;
3459 if (ElementSizeInBits != ElementAllocSizeInBits) {
3460 // If the allocation size of an element is different from the size in bits,
3461 // printing each element separately will insert incorrect padding.
3462 //
3463 // The general algorithm here is complicated; instead of writing it out
3464 // here, just use the existing code in ConstantFolding.
3465 Type *IntT =
3466 IntegerType::get(CV->getContext(), DL.getTypeSizeInBits(CV->getType()));
3467 ConstantInt *CI = dyn_cast_or_null<ConstantInt>(ConstantFoldConstant(
3468 ConstantExpr::getBitCast(const_cast<ConstantVector *>(CV), IntT), DL));
3469 if (!CI) {
3471 "Cannot lower vector global with unusual element type");
3472 }
3473 emitGlobalAliasInline(AP, 0, AliasList);
3475 EmittedSize = DL.getTypeStoreSize(CV->getType());
3476 } else {
3477 for (unsigned I = 0, E = CV->getType()->getNumElements(); I != E; ++I) {
3478 emitGlobalAliasInline(AP, DL.getTypeAllocSize(CV->getType()) * I, AliasList);
3480 }
3481 EmittedSize =
3482 DL.getTypeAllocSize(ElementType) * CV->getType()->getNumElements();
3483 }
3484
3485 unsigned Size = DL.getTypeAllocSize(CV->getType());
3486 if (unsigned Padding = Size - EmittedSize)
3487 AP.OutStreamer->emitZeros(Padding);
3488}
3489
3491 const ConstantStruct *CS, AsmPrinter &AP,
3492 const Constant *BaseCV, uint64_t Offset,
3493 AsmPrinter::AliasMapTy *AliasList) {
3494 // Print the fields in successive locations. Pad to align if needed!
3495 unsigned Size = DL.getTypeAllocSize(CS->getType());
3496 const StructLayout *Layout = DL.getStructLayout(CS->getType());
3497 uint64_t SizeSoFar = 0;
3498 for (unsigned I = 0, E = CS->getNumOperands(); I != E; ++I) {
3499 const Constant *Field = CS->getOperand(I);
3500
3501 // Print the actual field value.
3502 emitGlobalConstantImpl(DL, Field, AP, BaseCV, Offset + SizeSoFar,
3503 AliasList);
3504
3505 // Check if padding is needed and insert one or more 0s.
3506 uint64_t FieldSize = DL.getTypeAllocSize(Field->getType());
3507 uint64_t PadSize = ((I == E - 1 ? Size : Layout->getElementOffset(I + 1)) -
3508 Layout->getElementOffset(I)) -
3509 FieldSize;
3510 SizeSoFar += FieldSize + PadSize;
3511
3512 // Insert padding - this may include padding to increase the size of the
3513 // current field up to the ABI size (if the struct is not packed) as well
3514 // as padding to ensure that the next field starts at the right offset.
3515 AP.OutStreamer->emitZeros(PadSize);
3516 }
3517 assert(SizeSoFar == Layout->getSizeInBytes() &&
3518 "Layout of constant struct may be incorrect!");
3519}
3520
3521static void emitGlobalConstantFP(APFloat APF, Type *ET, AsmPrinter &AP) {
3522 assert(ET && "Unknown float type");
3523 APInt API = APF.bitcastToAPInt();
3524
3525 // First print a comment with what we think the original floating-point value
3526 // should have been.
3527 if (AP.isVerbose()) {
3528 SmallString<8> StrVal;
3529 APF.toString(StrVal);
3530 ET->print(AP.OutStreamer->getCommentOS());
3531 AP.OutStreamer->getCommentOS() << ' ' << StrVal << '\n';
3532 }
3533
3534 // Now iterate through the APInt chunks, emitting them in endian-correct
3535 // order, possibly with a smaller chunk at beginning/end (e.g. for x87 80-bit
3536 // floats).
3537 unsigned NumBytes = API.getBitWidth() / 8;
3538 unsigned TrailingBytes = NumBytes % sizeof(uint64_t);
3539 const uint64_t *p = API.getRawData();
3540
3541 // PPC's long double has odd notions of endianness compared to how LLVM
3542 // handles it: p[0] goes first for *big* endian on PPC.
3543 if (AP.getDataLayout().isBigEndian() && !ET->isPPC_FP128Ty()) {
3544 int Chunk = API.getNumWords() - 1;
3545
3546 if (TrailingBytes)
3547 AP.OutStreamer->emitIntValueInHexWithPadding(p[Chunk--], TrailingBytes);
3548
3549 for (; Chunk >= 0; --Chunk)
3550 AP.OutStreamer->emitIntValueInHexWithPadding(p[Chunk], sizeof(uint64_t));
3551 } else {
3552 unsigned Chunk;
3553 for (Chunk = 0; Chunk < NumBytes / sizeof(uint64_t); ++Chunk)
3554 AP.OutStreamer->emitIntValueInHexWithPadding(p[Chunk], sizeof(uint64_t));
3555
3556 if (TrailingBytes)
3557 AP.OutStreamer->emitIntValueInHexWithPadding(p[Chunk], TrailingBytes);
3558 }
3559
3560 // Emit the tail padding for the long double.
3561 const DataLayout &DL = AP.getDataLayout();
3562 AP.OutStreamer->emitZeros(DL.getTypeAllocSize(ET) - DL.getTypeStoreSize(ET));
3563}
3564
3565static void emitGlobalConstantFP(const ConstantFP *CFP, AsmPrinter &AP) {
3566 emitGlobalConstantFP(CFP->getValueAPF(), CFP->getType(), AP);
3567}
3568
3570 const DataLayout &DL = AP.getDataLayout();
3571 unsigned BitWidth = CI->getBitWidth();
3572
3573 // Copy the value as we may massage the layout for constants whose bit width
3574 // is not a multiple of 64-bits.
3575 APInt Realigned(CI->getValue());
3576 uint64_t ExtraBits = 0;
3577 unsigned ExtraBitsSize = BitWidth & 63;
3578
3579 if (ExtraBitsSize) {
3580 // The bit width of the data is not a multiple of 64-bits.
3581 // The extra bits are expected to be at the end of the chunk of the memory.
3582 // Little endian:
3583 // * Nothing to be done, just record the extra bits to emit.
3584 // Big endian:
3585 // * Record the extra bits to emit.
3586 // * Realign the raw data to emit the chunks of 64-bits.
3587 if (DL.isBigEndian()) {
3588 // Basically the structure of the raw data is a chunk of 64-bits cells:
3589 // 0 1 BitWidth / 64
3590 // [chunk1][chunk2] ... [chunkN].
3591 // The most significant chunk is chunkN and it should be emitted first.
3592 // However, due to the alignment issue chunkN contains useless bits.
3593 // Realign the chunks so that they contain only useful information:
3594 // ExtraBits 0 1 (BitWidth / 64) - 1
3595 // chu[nk1 chu][nk2 chu] ... [nkN-1 chunkN]
3596 ExtraBitsSize = alignTo(ExtraBitsSize, 8);
3597 ExtraBits = Realigned.getRawData()[0] &
3598 (((uint64_t)-1) >> (64 - ExtraBitsSize));
3599 if (BitWidth >= 64)
3600 Realigned.lshrInPlace(ExtraBitsSize);
3601 } else
3602 ExtraBits = Realigned.getRawData()[BitWidth / 64];
3603 }
3604
3605 // We don't expect assemblers to support integer data directives
3606 // for more than 64 bits, so we emit the data in at most 64-bit
3607 // quantities at a time.
3608 const uint64_t *RawData = Realigned.getRawData();
3609 for (unsigned i = 0, e = BitWidth / 64; i != e; ++i) {
3610 uint64_t Val = DL.isBigEndian() ? RawData[e - i - 1] : RawData[i];
3611 AP.OutStreamer->emitIntValue(Val, 8);
3612 }
3613
3614 if (ExtraBitsSize) {
3615 // Emit the extra bits after the 64-bits chunks.
3616
3617 // Emit a directive that fills the expected size.
3619 Size -= (BitWidth / 64) * 8;
3620 assert(Size && Size * 8 >= ExtraBitsSize &&
3621 (ExtraBits & (((uint64_t)-1) >> (64 - ExtraBitsSize)))
3622 == ExtraBits && "Directive too small for extra bits.");
3623 AP.OutStreamer->emitIntValue(ExtraBits, Size);
3624 }
3625}
3626
3627/// Transform a not absolute MCExpr containing a reference to a GOT
3628/// equivalent global, by a target specific GOT pc relative access to the
3629/// final symbol.
3631 const Constant *BaseCst,
3632 uint64_t Offset) {
3633 // The global @foo below illustrates a global that uses a got equivalent.
3634 //
3635 // @bar = global i32 42
3636 // @gotequiv = private unnamed_addr constant i32* @bar
3637 // @foo = i32 trunc (i64 sub (i64 ptrtoint (i32** @gotequiv to i64),
3638 // i64 ptrtoint (i32* @foo to i64))
3639 // to i32)
3640 //
3641 // The cstexpr in @foo is converted into the MCExpr `ME`, where we actually
3642 // check whether @foo is suitable to use a GOTPCREL. `ME` is usually in the
3643 // form:
3644 //
3645 // foo = cstexpr, where
3646 // cstexpr := <gotequiv> - "." + <cst>
3647 // cstexpr := <gotequiv> - (<foo> - <offset from @foo base>) + <cst>
3648 //
3649 // After canonicalization by evaluateAsRelocatable `ME` turns into:
3650 //
3651 // cstexpr := <gotequiv> - <foo> + gotpcrelcst, where
3652 // gotpcrelcst := <offset from @foo base> + <cst>
3653 MCValue MV;
3654 if (!(*ME)->evaluateAsRelocatable(MV, nullptr, nullptr) || MV.isAbsolute())
3655 return;
3656 const MCSymbolRefExpr *SymA = MV.getSymA();
3657 if (!SymA)
3658 return;
3659
3660 // Check that GOT equivalent symbol is cached.
3661 const MCSymbol *GOTEquivSym = &SymA->getSymbol();
3662 if (!AP.GlobalGOTEquivs.count(GOTEquivSym))
3663 return;
3664
3665 const GlobalValue *BaseGV = dyn_cast_or_null<GlobalValue>(BaseCst);
3666 if (!BaseGV)
3667 return;
3668
3669 // Check for a valid base symbol
3670 const MCSymbol *BaseSym = AP.getSymbol(BaseGV);
3671 const MCSymbolRefExpr *SymB = MV.getSymB();
3672
3673 if (!SymB || BaseSym != &SymB->getSymbol())
3674 return;
3675
3676 // Make sure to match:
3677 //
3678 // gotpcrelcst := <offset from @foo base> + <cst>
3679 //
3680 int64_t GOTPCRelCst = Offset + MV.getConstant();
3681 if (!AP.getObjFileLowering().supportGOTPCRelWithOffset() && GOTPCRelCst != 0)
3682 return;
3683
3684 // Emit the GOT PC relative to replace the got equivalent global, i.e.:
3685 //
3686 // bar:
3687 // .long 42
3688 // gotequiv:
3689 // .quad bar
3690 // foo:
3691 // .long gotequiv - "." + <cst>
3692 //
3693 // is replaced by the target specific equivalent to:
3694 //
3695 // bar:
3696 // .long 42
3697 // foo:
3698 // .long bar@GOTPCREL+<gotpcrelcst>
3699 AsmPrinter::GOTEquivUsePair Result = AP.GlobalGOTEquivs[GOTEquivSym];
3700 const GlobalVariable *GV = Result.first;
3701 int NumUses = (int)Result.second;
3702 const GlobalValue *FinalGV = dyn_cast<GlobalValue>(GV->getOperand(0));
3703 const MCSymbol *FinalSym = AP.getSymbol(FinalGV);
3705 FinalGV, FinalSym, MV, Offset, AP.MMI, *AP.OutStreamer);
3706
3707 // Update GOT equivalent usage information
3708 --NumUses;
3709 if (NumUses >= 0)
3710 AP.GlobalGOTEquivs[GOTEquivSym] = std::make_pair(GV, NumUses);
3711}
3712
3713static void emitGlobalConstantImpl(const DataLayout &DL, const Constant *CV,
3714 AsmPrinter &AP, const Constant *BaseCV,
3716 AsmPrinter::AliasMapTy *AliasList) {
3717 emitGlobalAliasInline(AP, Offset, AliasList);
3718 uint64_t Size = DL.getTypeAllocSize(CV->getType());
3719
3720 // Globals with sub-elements such as combinations of arrays and structs
3721 // are handled recursively by emitGlobalConstantImpl. Keep track of the
3722 // constant symbol base and the current position with BaseCV and Offset.
3723 if (!BaseCV && CV->hasOneUse())
3724 BaseCV = dyn_cast<Constant>(CV->user_back());
3725
3726 if (isa<ConstantAggregateZero>(CV) || isa<UndefValue>(CV))
3727 return AP.OutStreamer->emitZeros(Size);
3728
3729 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
3730 const uint64_t StoreSize = DL.getTypeStoreSize(CV->getType());
3731
3732 if (StoreSize <= 8) {
3733 if (AP.isVerbose())
3734 AP.OutStreamer->getCommentOS()
3735 << format("0x%" PRIx64 "\n", CI->getZExtValue());
3736 AP.OutStreamer->emitIntValue(CI->getZExtValue(), StoreSize);
3737 } else {
3739 }
3740
3741 // Emit tail padding if needed
3742 if (Size != StoreSize)
3743 AP.OutStreamer->emitZeros(Size - StoreSize);
3744
3745 return;
3746 }
3747
3748 if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV))
3749 return emitGlobalConstantFP(CFP, AP);
3750
3751 if (isa<ConstantPointerNull>(CV)) {
3752 AP.OutStreamer->emitIntValue(0, Size);
3753 return;
3754 }
3755
3756 if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(CV))
3757 return emitGlobalConstantDataSequential(DL, CDS, AP, AliasList);
3758
3759 if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV))
3760 return emitGlobalConstantArray(DL, CVA, AP, BaseCV, Offset, AliasList);
3761
3762 if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV))
3763 return emitGlobalConstantStruct(DL, CVS, AP, BaseCV, Offset, AliasList);
3764
3765 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
3766 // Look through bitcasts, which might not be able to be MCExpr'ized (e.g. of
3767 // vectors).
3768 if (CE->getOpcode() == Instruction::BitCast)
3769 return emitGlobalConstantImpl(DL, CE->getOperand(0), AP);
3770
3771 if (Size > 8) {
3772 // If the constant expression's size is greater than 64-bits, then we have
3773 // to emit the value in chunks. Try to constant fold the value and emit it
3774 // that way.
3775 Constant *New = ConstantFoldConstant(CE, DL);
3776 if (New != CE)
3777 return emitGlobalConstantImpl(DL, New, AP);
3778 }
3779 }
3780
3781 if (const ConstantVector *V = dyn_cast<ConstantVector>(CV))
3782 return emitGlobalConstantVector(DL, V, AP, AliasList);
3783
3784 // Otherwise, it must be a ConstantExpr. Lower it to an MCExpr, then emit it
3785 // thread the streamer with EmitValue.
3786 const MCExpr *ME = AP.lowerConstant(CV);
3787
3788 // Since lowerConstant already folded and got rid of all IR pointer and
3789 // integer casts, detect GOT equivalent accesses by looking into the MCExpr
3790 // directly.
3792 handleIndirectSymViaGOTPCRel(AP, &ME, BaseCV, Offset);
3793
3794 AP.OutStreamer->emitValue(ME, Size);
3795}
3796
3797/// EmitGlobalConstant - Print a general LLVM constant to the .s file.
3799 AliasMapTy *AliasList) {
3800 uint64_t Size = DL.getTypeAllocSize(CV->getType());
3801 if (Size)
3802 emitGlobalConstantImpl(DL, CV, *this, nullptr, 0, AliasList);
3803 else if (MAI->hasSubsectionsViaSymbols()) {
3804 // If the global has zero size, emit a single byte so that two labels don't
3805 // look like they are at the same location.
3806 OutStreamer->emitIntValue(0, 1);
3807 }
3808 if (!AliasList)
3809 return;
3810 // TODO: These remaining aliases are not emitted in the correct location. Need
3811 // to handle the case where the alias offset doesn't refer to any sub-element.
3812 for (auto &AliasPair : *AliasList) {
3813 for (const GlobalAlias *GA : AliasPair.second)
3814 OutStreamer->emitLabel(getSymbol(GA));
3815 }
3816}
3817
3819 // Target doesn't support this yet!
3820 llvm_unreachable("Target does not support EmitMachineConstantPoolValue");
3821}
3822
3824 if (Offset > 0)
3825 OS << '+' << Offset;
3826 else if (Offset < 0)
3827 OS << Offset;
3828}
3829
3830void AsmPrinter::emitNops(unsigned N) {
3832 for (; N; --N)
3834}
3835
3836//===----------------------------------------------------------------------===//
3837// Symbol Lowering Routines.
3838//===----------------------------------------------------------------------===//
3839
3841 return OutContext.createTempSymbol(Name, true);
3842}
3843
3845 return const_cast<AsmPrinter *>(this)->getAddrLabelSymbol(
3846 BA->getBasicBlock());
3847}
3848
3850 return const_cast<AsmPrinter *>(this)->getAddrLabelSymbol(BB);
3851}
3852
3853/// GetCPISymbol - Return the symbol for the specified constant pool entry.
3854MCSymbol *AsmPrinter::GetCPISymbol(unsigned CPID) const {
3855 if (getSubtargetInfo().getTargetTriple().isWindowsMSVCEnvironment()) {
3856 const MachineConstantPoolEntry &CPE =
3857 MF->getConstantPool()->getConstants()[CPID];
3858 if (!CPE.isMachineConstantPoolEntry()) {
3859 const DataLayout &DL = MF->getDataLayout();
3860 SectionKind Kind = CPE.getSectionKind(&DL);
3861 const Constant *C = CPE.Val.ConstVal;
3862 Align Alignment = CPE.Alignment;
3863 if (const MCSectionCOFF *S = dyn_cast<MCSectionCOFF>(
3864 getObjFileLowering().getSectionForConstant(DL, Kind, C,
3865 Alignment))) {
3866 if (MCSymbol *Sym = S->getCOMDATSymbol()) {
3867 if (Sym->isUndefined())
3868 OutStreamer->emitSymbolAttribute(Sym, MCSA_Global);
3869 return Sym;
3870 }
3871 }
3872 }
3873 }
3874
3875 const DataLayout &DL = getDataLayout();
3876 return OutContext.getOrCreateSymbol(Twine(DL.getPrivateGlobalPrefix()) +
3877 "CPI" + Twine(getFunctionNumber()) + "_" +
3878 Twine(CPID));
3879}
3880
3881/// GetJTISymbol - Return the symbol for the specified jump table entry.
3882MCSymbol *AsmPrinter::GetJTISymbol(unsigned JTID, bool isLinkerPrivate) const {
3883 return MF->getJTISymbol(JTID, OutContext, isLinkerPrivate);
3884}
3885
3886/// GetJTSetSymbol - Return the symbol for the specified jump table .set
3887/// FIXME: privatize to AsmPrinter.
3888MCSymbol *AsmPrinter::GetJTSetSymbol(unsigned UID, unsigned MBBID) const {
3889 const DataLayout &DL = getDataLayout();
3890 return OutContext.getOrCreateSymbol(Twine(DL.getPrivateGlobalPrefix()) +
3891 Twine(getFunctionNumber()) + "_" +
3892 Twine(UID) + "_set_" + Twine(MBBID));
3893}
3894
3896 StringRef Suffix) const {
3898}
3899
3900/// Return the MCSymbol for the specified ExternalSymbol.
3902 SmallString<60> NameStr;
3904 return OutContext.getOrCreateSymbol(NameStr);
3905}
3906
3907/// PrintParentLoopComment - Print comments about parent loops of this one.
3909 unsigned FunctionNumber) {
3910 if (!Loop) return;
3911 PrintParentLoopComment(OS, Loop->getParentLoop(), FunctionNumber);
3913 << "Parent Loop BB" << FunctionNumber << "_"
3914 << Loop->getHeader()->getNumber()
3915 << " Depth=" << Loop->getLoopDepth() << '\n';
3916}
3917
3918/// PrintChildLoopComment - Print comments about child loops within
3919/// the loop for this basic block, with nesting.
3921 unsigned FunctionNumber) {
3922 // Add child loop information
3923 for (const MachineLoop *CL : *Loop) {
3924 OS.indent(CL->getLoopDepth()*2)
3925 << "Child Loop BB" << FunctionNumber << "_"
3926 << CL->getHeader()->getNumber() << " Depth " << CL->getLoopDepth()
3927 << '\n';
3928 PrintChildLoopComment(OS, CL, FunctionNumber);
3929 }
3930}
3931
3932/// emitBasicBlockLoopComments - Pretty-print comments for basic blocks.
3934 const MachineLoopInfo *LI,
3935 const AsmPrinter &AP) {
3936 // Add loop depth information
3937 const MachineLoop *Loop = LI->getLoopFor(&MBB);
3938 if (!Loop) return;
3939
3940 MachineBasicBlock *Header = Loop->getHeader();
3941 assert(Header && "No header for loop");
3942
3943 // If this block is not a loop header, just print out what is the loop header
3944 // and return.
3945 if (Header != &MBB) {
3946 AP.OutStreamer->AddComment(" in Loop: Header=BB" +
3947 Twine(AP.getFunctionNumber())+"_" +
3948 Twine(Loop->getHeader()->getNumber())+
3949 " Depth="+Twine(Loop->getLoopDepth()));
3950 return;
3951 }
3952
3953 // Otherwise, it is a loop header. Print out information about child and
3954 // parent loops.
3955 raw_ostream &OS = AP.OutStreamer->getCommentOS();
3956
3958
3959 OS << "=>";
3960 OS.indent(Loop->getLoopDepth()*2-2);
3961
3962 OS << "This ";
3963 if (Loop->isInnermost())
3964 OS << "Inner ";
3965 OS << "Loop Header: Depth=" + Twine(Loop->getLoopDepth()) << '\n';
3966
3968}
3969
3970/// emitBasicBlockStart - This method prints the label for the specified
3971/// MachineBasicBlock, an alignment (if present) and a comment describing
3972/// it if appropriate.
3974 // End the previous funclet and start a new one.
3975 if (MBB.isEHFuncletEntry()) {
3976 for (const HandlerInfo &HI : Handlers) {
3977 HI.Handler->endFunclet();
3978 HI.Handler->beginFunclet(MBB);
3979 }
3980 }
3981
3982 // Switch to a new section if this basic block must begin a section. The
3983 // entry block is always placed in the function section and is handled
3984 // separately.
3985 if (MBB.isBeginSection() && !MBB.isEntryBlock()) {
3986 OutStreamer->switchSection(
3987 getObjFileLowering().getSectionForMachineBasicBlock(MF->getFunction(),
3988 MBB, TM));
3989 CurrentSectionBeginSym = MBB.getSymbol();
3990 }
3991
3992 // Emit an alignment directive for this block, if needed.
3993 const Align Alignment = MBB.getAlignment();
3994 if (Alignment != Align(1))
3995 emitAlignment(Alignment, nullptr, MBB.getMaxBytesForAlignment());
3996
3997 // If the block has its address taken, emit any labels that were used to
3998 // reference the block. It is possible that there is more than one label
3999 // here, because multiple LLVM BB's may have been RAUW'd to this block after
4000 // the references were generated.
4001 if (MBB.isIRBlockAddressTaken()) {
4002 if (isVerbose())
4003 OutStreamer->AddComment("Block address taken");
4004
4006 assert(BB && BB->hasAddressTaken() && "Missing BB");
4008 OutStreamer->emitLabel(Sym);
4009 } else if (isVerbose() && MBB.isMachineBlockAddressTaken()) {
4010 OutStreamer->AddComment("Block address taken");
4011 }
4012
4013 // Print some verbose block comments.
4014 if (isVerbose()) {
4015 if (const BasicBlock *BB = MBB.getBasicBlock()) {
4016 if (BB->hasName()) {
4017 BB->printAsOperand(OutStreamer->getCommentOS(),
4018 /*PrintType=*/false, BB->getModule());
4019 OutStreamer->getCommentOS() << '\n';
4020 }
4021 }
4022
4023 assert(MLI != nullptr && "MachineLoopInfo should has been computed");
4025 }
4026
4027 // Print the main label for the block.
4028 if (shouldEmitLabelForBasicBlock(MBB)) {
4030 OutStreamer->AddComment("Label of block must be emitted");
4031 OutStreamer->emitLabel(MBB.getSymbol());
4032 } else {
4033 if (isVerbose()) {
4034 // NOTE: Want this comment at start of line, don't emit with AddComment.
4035 OutStreamer->emitRawComment(" %bb." + Twine(MBB.getNumber()) + ":",
4036 false);
4037 }
4038 }
4039
4040 if (MBB.isEHCatchretTarget() &&
4042 OutStreamer->emitLabel(MBB.getEHCatchretSymbol());
4043 }
4044
4045 // With BB sections, each basic block must handle CFI information on its own
4046 // if it begins a section (Entry block call is handled separately, next to
4047 // beginFunction).
4048 if (MBB.isBeginSection() && !MBB.isEntryBlock())
4049 for (const HandlerInfo &HI : Handlers)
4050 HI.Handler->beginBasicBlockSection(MBB);
4051}
4052
4054 // Check if CFI information needs to be updated for this MBB with basic block
4055 // sections.
4056 if (MBB.isEndSection())
4057 for (const HandlerInfo &HI : Handlers)
4058 HI.Handler->endBasicBlockSection(MBB);
4059}
4060
4061void AsmPrinter::emitVisibility(MCSymbol *Sym, unsigned Visibility,
4062 bool IsDefinition) const {
4064
4065 switch (Visibility) {
4066 default: break;
4068 if (IsDefinition)
4069 Attr = MAI->getHiddenVisibilityAttr();
4070 else
4072 break;
4075 break;
4076 }
4077
4078 if (Attr != MCSA_Invalid)
4079 OutStreamer->emitSymbolAttribute(Sym, Attr);
4080}
4081
4082bool AsmPrinter::shouldEmitLabelForBasicBlock(
4083 const MachineBasicBlock &MBB) const {
4084 // With `-fbasic-block-sections=`, a label is needed for every non-entry block
4085 // in the labels mode (option `=labels`) and every section beginning in the
4086 // sections mode (`=all` and `=list=`).
4087 if ((MF->hasBBLabels() || MF->getTarget().Options.BBAddrMap ||
4088 MBB.isBeginSection()) &&
4089 !MBB.isEntryBlock())
4090 return true;
4091 // A label is needed for any block with at least one predecessor (when that
4092 // predecessor is not the fallthrough predecessor, or if it is an EH funclet
4093 // entry, or if a label is forced).
4094 return !MBB.pred_empty() &&
4097}
4098
4099/// isBlockOnlyReachableByFallthough - Return true if the basic block has
4100/// exactly one predecessor and the control transfer mechanism between
4101/// the predecessor and this block is a fall-through.
4104 // If this is a landing pad, it isn't a fall through. If it has no preds,
4105 // then nothing falls through to it.
4106 if (MBB->isEHPad() || MBB->pred_empty())
4107 return false;
4108
4109 // If there isn't exactly one predecessor, it can't be a fall through.
4110 if (MBB->pred_size() > 1)
4111 return false;
4112
4113 // The predecessor has to be immediately before this block.
4114 MachineBasicBlock *Pred = *MBB->pred_begin();
4115 if (!Pred->isLayoutSuccessor(MBB))
4116 return false;
4117
4118 // If the block is completely empty, then it definitely does fall through.
4119 if (Pred->empty())
4120 return true;
4121
4122 // Check the terminators in the previous blocks
4123 for (const auto &MI : Pred->terminators()) {
4124 // If it is not a simple branch, we are in a table somewhere.
4125 if (!MI.isBranch() || MI.isIndirectBranch())
4126 return false;
4127
4128 // If we are the operands of one of the branches, this is not a fall
4129 // through. Note that targets with delay slots will usually bundle
4130 // terminators with the delay slot instruction.
4131 for (ConstMIBundleOperands OP(MI); OP.isValid(); ++OP) {
4132 if (OP->isJTI())
4133 return false;
4134 if (OP->isMBB() && OP->getMBB() == MBB)
4135 return false;
4136 }
4137 }
4138
4139 return true;
4140}
4141
4142GCMetadataPrinter *AsmPrinter::getOrCreateGCPrinter(GCStrategy &S) {
4143 if (!S.usesMetadata())
4144 return nullptr;
4145
4146 auto [GCPI, Inserted] = GCMetadataPrinters.insert({&S, nullptr});
4147 if (!Inserted)
4148 return GCPI->second.get();
4149
4150 auto Name = S.getName();
4151
4152 for (const GCMetadataPrinterRegistry::entry &GCMetaPrinter :
4154 if (Name == GCMetaPrinter.getName()) {
4155 std::unique_ptr<GCMetadataPrinter> GMP = GCMetaPrinter.instantiate();
4156 GMP->S = &S;
4157 GCPI->second = std::move(GMP);
4158 return GCPI->second.get();
4159 }
4160
4161 report_fatal_error("no GCMetadataPrinter registered for GC: " + Twine(Name));
4162}
4163
4165 GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>();
4166 assert(MI && "AsmPrinter didn't require GCModuleInfo?");
4167 bool NeedsDefault = false;
4168 if (MI->begin() == MI->end())
4169 // No GC strategy, use the default format.
4170 NeedsDefault = true;
4171 else
4172 for (const auto &I : *MI) {
4173 if (GCMetadataPrinter *MP = getOrCreateGCPrinter(*I))
4174 if (MP->emitStackMaps(SM, *this))
4175 continue;
4176 // The strategy doesn't have printer or doesn't emit custom stack maps.
4177 // Use the default format.
4178 NeedsDefault = true;
4179 }
4180
4181 if (NeedsDefault)
4183}
4184
4185/// Pin vtable to this file.
4187
4189
4190// In the binary's "xray_instr_map" section, an array of these function entries
4191// describes each instrumentation point. When XRay patches your code, the index
4192// into this table will be given to your handler as a patch point identifier.
4194 auto Kind8 = static_cast<uint8_t>(Kind);
4195 Out->emitBinaryData(StringRef(reinterpret_cast<const char *>(&Kind8), 1));
4196 Out->emitBinaryData(
4197 StringRef(reinterpret_cast<const char *>(&AlwaysInstrument), 1));
4198 Out->emitBinaryData(StringRef(reinterpret_cast<const char *>(&Version), 1));
4199 auto Padding = (4 * Bytes) - ((2 * Bytes) + 3);
4200 assert(Padding >= 0 && "Instrumentation map entry > 4 * Word Size");
4201 Out->emitZeros(Padding);
4202}
4203
4205 if (Sleds.empty())
4206 return;
4207
4208 auto PrevSection = OutStreamer->getCurrentSectionOnly();
4209 const Function &F = MF->getFunction();
4210 MCSection *InstMap = nullptr;
4211 MCSection *FnSledIndex = nullptr;
4212 const Triple &TT = TM.getTargetTriple();
4213 // Use PC-relative addresses on all targets.
4214 if (TT.isOSBinFormatELF()) {
4215 auto LinkedToSym = cast<MCSymbolELF>(CurrentFnSym);
4216 auto Flags = ELF::SHF_ALLOC | ELF::SHF_LINK_ORDER;
4217 StringRef GroupName;
4218 if (F.hasComdat()) {
4219 Flags |= ELF::SHF_GROUP;
4220 GroupName = F.getComdat()->getName();
4221 }
4222 InstMap = OutContext.getELFSection("xray_instr_map", ELF::SHT_PROGBITS,
4223 Flags, 0, GroupName, F.hasComdat(),
4224 MCSection::NonUniqueID, LinkedToSym);
4225
4227 FnSledIndex = OutContext.getELFSection(
4228 "xray_fn_idx", ELF::SHT_PROGBITS, Flags, 0, GroupName, F.hasComdat(),
4229 MCSection::NonUniqueID, LinkedToSym);
4231 InstMap = OutContext.getMachOSection("__DATA", "xray_instr_map",
4235 FnSledIndex = OutContext.getMachOSection("__DATA", "xray_fn_idx",
4238 } else {
4239 llvm_unreachable("Unsupported target");
4240 }
4241
4242 auto WordSizeBytes = MAI->getCodePointerSize();
4243
4244 // Now we switch to the instrumentation map section. Because this is done
4245 // per-function, we are able to create an index entry that will represent the
4246 // range of sleds associated with a function.
4247 auto &Ctx = OutContext;
4248 MCSymbol *SledsStart =
4249 OutContext.createLinkerPrivateSymbol("xray_sleds_start");
4250 OutStreamer->switchSection(InstMap);
4251 OutStreamer->emitLabel(SledsStart);
4252 for (const auto &Sled : Sleds) {
4253 MCSymbol *Dot = Ctx.createTempSymbol();
4254 OutStreamer->emitLabel(Dot);
4255 OutStreamer->emitValueImpl(
4257 MCSymbolRefExpr::create(Dot, Ctx), Ctx),
4258 WordSizeBytes);
4259 OutStreamer->emitValueImpl(
4263 MCConstantExpr::create(WordSizeBytes, Ctx),
4264 Ctx),
4265 Ctx),
4266 WordSizeBytes);
4267 Sled.emit(WordSizeBytes, OutStreamer.get());
4268 }
4269 MCSymbol *SledsEnd = OutContext.createTempSymbol("xray_sleds_end", true);
4270 OutStreamer->emitLabel(SledsEnd);
4271
4272 // We then emit a single entry in the index per function. We use the symbols
4273 // that bound the instrumentation map as the range for a specific function.
4274 // Each entry here will be 2 * word size aligned, as we're writing down two
4275 // pointers. This should work for both 32-bit and 64-bit platforms.
4276 if (FnSledIndex) {
4277 OutStreamer->switchSection(FnSledIndex);
4278 OutStreamer->emitCodeAlignment(Align(2 * WordSizeBytes),
4279 &getSubtargetInfo());
4280 // For Mach-O, use an "l" symbol as the atom of this subsection. The label
4281 // difference uses a SUBTRACTOR external relocation which references the
4282 // symbol.
4283 MCSymbol *Dot = Ctx.createLinkerPrivateSymbol("xray_fn_idx");
4284 OutStreamer->emitLabel(Dot);
4285 OutStreamer->emitValueImpl(
4287 MCSymbolRefExpr::create(Dot, Ctx), Ctx),
4288 WordSizeBytes);
4289 OutStreamer->emitValueImpl(MCConstantExpr::create(Sleds.size(), Ctx),
4290 WordSizeBytes);
4291 OutStreamer->switchSection(PrevSection);
4292 }
4293 Sleds.clear();
4294}
4295
4297 SledKind Kind, uint8_t Version) {
4298 const Function &F = MI.getMF()->getFunction();
4299 auto Attr = F.getFnAttribute("function-instrument");
4300 bool LogArgs = F.hasFnAttribute("xray-log-args");
4301 bool AlwaysInstrument =
4302 Attr.isStringAttribute() && Attr.getValueAsString() == "xray-always";
4303 if (Kind == SledKind::FUNCTION_ENTER && LogArgs)
4305 Sleds.emplace_back(XRayFunctionEntry{Sled, CurrentFnSym, Kind,
4306 AlwaysInstrument, &F, Version});
4307}
4308
4310 const Function &F = MF->getFunction();
4311 unsigned PatchableFunctionPrefix = 0, PatchableFunctionEntry = 0;
4312 (void)F.getFnAttribute("patchable-function-prefix")
4313 .getValueAsString()
4314 .getAsInteger(10, PatchableFunctionPrefix);
4315 (void)F.getFnAttribute("patchable-function-entry")
4316 .getValueAsString()
4317 .getAsInteger(10, PatchableFunctionEntry);
4318 if (!PatchableFunctionPrefix && !PatchableFunctionEntry)
4319 return;
4320 const unsigned PointerSize = getPointerSize();
4322 auto Flags = ELF::SHF_WRITE | ELF::SHF_ALLOC;
4323 const MCSymbolELF *LinkedToSym = nullptr;
4324 StringRef GroupName;
4325
4326 // GNU as < 2.35 did not support section flag 'o'. GNU ld < 2.36 did not
4327 // support mixed SHF_LINK_ORDER and non-SHF_LINK_ORDER sections.
4328 if (MAI->useIntegratedAssembler() || MAI->binutilsIsAtLeast(2, 36)) {
4329 Flags |= ELF::SHF_LINK_ORDER;
4330 if (F.hasComdat()) {
4331 Flags |= ELF::SHF_GROUP;
4332 GroupName = F.getComdat()->getName();
4333 }
4334 LinkedToSym = cast<MCSymbolELF>(CurrentFnSym);
4335 }
4336 OutStreamer->switchSection(OutContext.getELFSection(
4337 "__patchable_function_entries", ELF::SHT_PROGBITS, Flags, 0, GroupName,
4338 F.hasComdat(), MCSection::NonUniqueID, LinkedToSym));
4339 emitAlignment(Align(PointerSize));
4340 OutStreamer->emitSymbolValue(CurrentPatchableFunctionEntrySym, PointerSize);
4341 }
4342}
4343
4345 return OutStreamer->getContext().getDwarfVersion();
4346}
4347
4349 OutStreamer->getContext().setDwarfVersion(Version);
4350}
4351
4353 return OutStreamer->getContext().getDwarfFormat() == dwarf::DWARF64;
4354}
4355
4358 OutStreamer->getContext().getDwarfFormat());
4359}
4360
4362 return {getDwarfVersion(), uint8_t(MAI->getCodePointerSize()),
4363 OutStreamer->getContext().getDwarfFormat(),
4365}
4366
4369 OutStreamer->getContext().getDwarfFormat());
4370}
4371
4372std::tuple<const MCSymbol *, uint64_t, const MCSymbol *,
4375 const MCSymbol *BranchLabel) const {
4376 const auto TLI = MF->getSubtarget().getTargetLowering();
4377 const auto BaseExpr =
4379 const auto Base = &cast<MCSymbolRefExpr>(BaseExpr)->getSymbol();
4380
4381 // By default, for the architectures that support CodeView,
4382 // EK_LabelDifference32 is implemented as an Int32 from the base address.
4383 return std::make_tuple(Base, 0, BranchLabel,
4385}
MachineBasicBlock & MBB
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
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...
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)
const char CFGuardDescription[]
Definition: AsmPrinter.cpp:165
const char CFGuardName[]
Definition: AsmPrinter.cpp:164
static void emitGlobalConstantVector(const DataLayout &DL, const ConstantVector *CV, AsmPrinter &AP, AsmPrinter::AliasMapTy *AliasList)
static cl::bits< PGOMapFeaturesEnum > PgoAnalysisMapFeatures("pgo-analysis-map", cl::Hidden, cl::CommaSeparated, cl::values(clEnumValN(PGOMapFeaturesEnum::FuncEntryCount, "func-entry-count", "Function Entry Count"), clEnumValN(PGOMapFeaturesEnum::BBFreq, "bb-freq", "Basic Block Frequency"), clEnumValN(PGOMapFeaturesEnum::BrProb, "br-prob", "Branch Probability")), cl::desc("Enable extended information within the SHT_LLVM_BB_ADDR_MAP that is " "extracted from PGO related analysis."))
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 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 unsigned getNumGlobalVariableUses(const Constant *C)
Compute the number of Global Variables that uses a Constant.
const char EHTimerDescription[]
Definition: AsmPrinter.cpp:163
const char PPTimerName[]
Definition: AsmPrinter.cpp:168
const char CodeViewLineTablesGroupDescription[]
Definition: AsmPrinter.cpp:167
static void emitBasicBlockLoopComments(const MachineBasicBlock &MBB, const MachineLoopInfo *LI, const AsmPrinter &AP)
emitBasicBlockLoopComments - Pretty-print comments for basic blocks.
static bool needFuncLabels(const MachineFunction &MF)
Returns true if function begin and end labels should be emitted.
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)
const char PPGroupDescription[]
Definition: AsmPrinter.cpp:171
const char PPTimerDescription[]
Definition: AsmPrinter.cpp:169
const char EHTimerName[]
Definition: AsmPrinter.cpp:162
const char PPGroupName[]
Definition: AsmPrinter.cpp:170
const char DWARFGroupDescription[]
Definition: AsmPrinter.cpp:159
static void PrintChildLoopComment(raw_ostream &OS, const MachineLoop *Loop, unsigned FunctionNumber)
PrintChildLoopComment - Print comments about child loops within the loop for this basic block,...
PGOMapFeaturesEnum
Definition: AsmPrinter.cpp:141
const char CodeViewLineTablesGroupName[]
Definition: AsmPrinter.cpp:166
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)
const char DbgTimerName[]
Definition: AsmPrinter.cpp:160
const char DbgTimerDescription[]
Definition: AsmPrinter.cpp:161
static void emitGlobalConstantImpl(const DataLayout &DL, const Constant *C, AsmPrinter &AP, const Constant *BaseCV=nullptr, uint64_t Offset=0, AsmPrinter::AliasMapTy *AliasList=nullptr)
const char DWARFGroupName[]
Definition: AsmPrinter.cpp:158
static void emitComments(const MachineInstr &MI, raw_ostream &CommentOS)
emitComments - Pretty-print comments for instructions.
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:648
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")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
Definition: CommandLine.h:693
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
===- LazyMachineBlockFrequencyInfo.h - Lazy Block Frequency -*- C++ -*–===//
#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.
Module.h This file contains the declarations for the Module class.
LLVMContext & Context
if(VerifyEach)
const char LLVMTargetMachineRef TM
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
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:167
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:5196
double convertToDouble() const
Converts this APFloat to host double value.
Definition: APFloat.cpp:5255
void toString(SmallVectorImpl< char > &Str, unsigned FormatPrecision=0, unsigned FormatMaxPadding=3, bool TruncateZero=true) const
Definition: APFloat.h:1325
APInt bitcastToAPInt() const
Definition: APFloat.h:1210
Class for arbitrary precision integers.
Definition: APInt.h:76
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1439
unsigned getNumWords() const
Get the number of words.
Definition: APInt.h:1446
const uint64_t * getRawData() const
This function returns a pointer to the internal storage of the APInt.
Definition: APInt.h:547
int64_t getSExtValue() const
Get sign extended value.
Definition: APInt.h:1513
void lshrInPlace(unsigned ShiftAmt)
Logical right-shift this APInt by ShiftAmt in place.
Definition: APInt.h:836
AddrLabelMap(MCContext &context)
Definition: AsmPrinter.cpp:219
void UpdateForRAUWBlock(BasicBlock *Old, BasicBlock *New)
Definition: AsmPrinter.cpp:320
void takeDeletedSymbolsForFunction(Function *F, std::vector< MCSymbol * > &Result)
If we have any deleted symbols for F, return them.
Definition: AsmPrinter.cpp:259
void UpdateForDeletedBlock(BasicBlock *BB)
Definition: AsmPrinter.cpp:293
ArrayRef< MCSymbol * > getAddrLabelSymbolToEmit(BasicBlock *BB)
Definition: AsmPrinter.cpp:235
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
virtual ~AsmPrinterHandler()
Pin vtable to this file.
virtual void markFunctionEnd()
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:84
virtual void emitInstruction(const MachineInstr *)
Targets should implement this to emit instructions.
Definition: AsmPrinter.h:567
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
Definition: AsmPrinter.cpp:398
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:700
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:368
bool isDwarf64() const
void emitNops(unsigned N)
Emit N NOP instructions.
MCSymbol * CurrentFnBegin
Definition: AsmPrinter.h:200
MachineLoopInfo * MLI
This is a pointer to the current MachineLoopInfo.
Definition: AsmPrinter.h:111
virtual void emitDebugValue(const MCExpr *Value, unsigned Size) const
Emit the directive and value for debug thread local expression.
Definition: AsmPrinter.cpp:924
void EmitToStreamer(MCStreamer &S, const MCInst &Inst)
Definition: AsmPrinter.cpp:418
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:722
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:384
TargetMachine & TM
Target machine description.
Definition: AsmPrinter.h:87
void emitXRayTable()
Emit a table with all XRay instrumentation points.
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:125
MCSymbol * CurrentFnBeginLocal
For dso_local functions, the current $local alias for the function.
Definition: AsmPrinter.h:203
MapVector< const MCSymbol *, GOTEquivUsePair > GlobalGOTEquivs
Definition: AsmPrinter.h:143
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:274
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:612
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:284
const MCAsmInfo * MAI
Target Asm Printer information.
Definition: AsmPrinter.h:90
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:102
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:351
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.
MapVector< unsigned, MBBSectionRange > MBBSectionRanges
Definition: AsmPrinter.h:138
MachineDominatorTree * MDT
This is a pointer to the current MachineDominatorTree.
Definition: AsmPrinter.h:108
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:543
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.
virtual void emitFunctionBodyStart()
Targets can override this to emit stuff before the first basic block in the function.
Definition: AsmPrinter.h:551
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:142
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:547
bool doInitialization(Module &M) override
Set up the AsmPrinter when we are working on a new module.
Definition: AsmPrinter.cpp:449
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:606
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:655
void getAnalysisUsage(AnalysisUsage &AU) const override
Record analysis usage.
Definition: AsmPrinter.cpp:440
unsigned getFunctionNumber() const
Return a unique ID for the current function.
Definition: AsmPrinter.cpp:394
MachineOptimizationRemarkEmitter * ORE
Optimization remark emitter.
Definition: AsmPrinter.h:114
virtual bool shouldEmitWeakSwiftAsyncExtendedFramePointerFlags() const
Definition: AsmPrinter.h:908
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:704
MCSymbol * CurrentFnSym
The symbol for the current function.
Definition: AsmPrinter.h:121
MachineModuleInfo * MMI
This is a pointer to the current MachineModuleInfo.
Definition: AsmPrinter.h:105
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:94
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:602
void emitStackUsage(const MachineFunction &MF)
virtual void emitKCFITypeId(const MachineFunction &MF)
bool isPositionIndependent() const
Definition: AsmPrinter.cpp:389
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:117
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:284
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:99
virtual const MCExpr * lowerConstant(const Constant *CV)
Lower the specified LLVM Constant to an MCExpr.
virtual void emitFunctionDescriptor()
Definition: AsmPrinter.h:576
const MCSection * getCurrentSection() const
Return the current section we are emitting to.
Definition: AsmPrinter.cpp:436
unsigned int getDwarfOffsetByteSize() const
Returns 4 for DWARF32 and 8 for DWARF64.
size_t NumUserHandlers
Definition: AsmPrinter.h:208
MCSymbol * CurrentFnSymForSize
The symbol used to represent the start of the current function for the purpose of calculating its siz...
Definition: AsmPrinter.h:130
bool isVerbose() const
Return true if assembly output should contain comments.
Definition: AsmPrinter.h:265
MCSymbol * getFunctionEnd() const
Definition: AsmPrinter.h:275
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:584
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:695
void emitPseudoProbe(const MachineInstr &MI)
unsigned getPointerSize() const
Return the pointer size from the TargetMachine.
Definition: AsmPrinter.cpp:409
void emitRemarksSection(remarks::RemarkStreamer &RS)
StackMaps SM
Definition: AsmPrinter.h:210
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:276
virtual void emitFunctionBodyEnd()
Targets can override this to emit stuff after the last basic block in the function.
Definition: AsmPrinter.h:555
const DataLayout & getDataLayout() const
Return information about data layout.
Definition: AsmPrinter.cpp:402
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:422
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:413
bool usesCFIWithoutEH() const
Since emitting CFI unwind information is entangled with supporting the exceptions,...
bool doesDwarfUseRelocationsAcrossSections() const
Definition: AsmPrinter.h:330
@ None
Do not emit either .eh_frame or .debug_frame.
@ Debug
Emit .debug_frame.
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:375
std::vector< HandlerInfo > Handlers
A vector of all debug/EH info emitters we should use.
Definition: AsmPrinter.h:207
LLVM Basic Block Representation.
Definition: BasicBlock.h:60
bool hasAddressTaken() const
Returns true if there are any uses of this basic block other than direct branches,...
Definition: BasicBlock.h:639
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:205
The address of a basic block.
Definition: Constants.h:888
BasicBlock * getBasicBlock() const
Definition: Constants.h:917
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:422
ArrayType * getType() const
Specialize the getType() method to always return an ArrayType, which reduces the amount of casting ne...
Definition: Constants.h:441
ConstantDataSequential - A vector or array constant whose element type is a simple 1/2/4/8-byte integ...
Definition: Constants.h:582
StringRef getAsString() const
If this array is isString(), then this method returns the array as a StringRef.
Definition: Constants.h:657
uint64_t getElementByteSize() const
Return the size (in bytes) of each element in the array/vector.
Definition: Constants.cpp:2751
bool isString(unsigned CharSize=8) const
This method returns true if this is an array of CharSize integers.
Definition: Constants.cpp:3094
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:3001
unsigned getNumElements() const
Return the number of elements in the array or vector.
Definition: Constants.cpp:2744
Type * getElementType() const
Return the element type of the array/vector.
Definition: Constants.cpp:2718
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:3049
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:1016
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2140
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:267
const APFloat & getValueAPF() const
Definition: Constants.h:310
This is the shared class of boolean and integer constants.
Definition: Constants.h:79
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:254
unsigned getBitWidth() const
getBitWidth - Return the scalar bitwidth of this constant.
Definition: Constants.h:147
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:144
StructType * getType() const
Specialization - reduce amount of casting.
Definition: Constants.h:493
Constant Vector Declarations.
Definition: Constants.h:506
FixedVectorType * getType() const
Specialize the getType() method to always return a FixedVectorType, which reduces the amount of casti...
Definition: Constants.h:529
This is an important base class in LLVM.
Definition: Constant.h:41
const Constant * stripPointerCasts() const
Definition: Constant.h:213
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:934
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:110
bool isBigEndian() const
Definition: DataLayout.h:239
TypeSize getTypeStoreSize(Type *Ty) const
Returns the maximum number of bytes that may be overwritten by storing the specified type.
Definition: DataLayout.h:472
A debug info location.
Definition: DebugLoc.h:33
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:155
bool erase(const KeyT &Val)
Definition: DenseMap.h:329
bool empty() const
Definition: DenseMap.h:98
iterator end()
Definition: DenseMap.h:84
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:220
Collects and handles dwarf debug information.
Definition: DwarfDebug.h:351
DebugLoc emitInitialLocDirective(const MachineFunction &MF, unsigned CUID)
Emits inital debug location directive.
Emits exception handling directives.
Definition: EHStreamer.h:30
unsigned getNumElements() const
Definition: DerivedTypes.h:582
DISubprogram * getSubprogram() const
Get the attached subprogram.
Definition: Metadata.cpp:1828
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:850
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1874
std::optional< ProfileCount > getEntryCount(bool AllowSynthetic=false) const
Get the entry count for this function.
Definition: Function.cpp:1959
bool needsUnwindTableEntry() const
True if this function needs an unwind table.
Definition: Function.h:655
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:556
const Constant * getAliasee() const
Definition: GlobalAlias.h:84
const Function * getResolverFunction() const
Definition: Globals.cpp:585
const Constant * getResolver() const
Definition: GlobalIFunc.h:70
StringRef getSection() const
Get the custom section of this global if it has one.
Definition: GlobalObject.h:118
MaybeAlign getAlign() const
Returns the alignment of the given variable or function.
Definition: GlobalObject.h:80
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:110
bool hasLinkOnceLinkage() const
Definition: GlobalValue.h:514
bool hasExternalLinkage() const
Definition: GlobalValue.h:510
bool isDSOLocal() const
Definition: GlobalValue.h:305
bool isThreadLocal() const
If the value is "Thread Local", its value isn't shared by the threads.
Definition: GlobalValue.h:263
VisibilityTypes getVisibility() const
Definition: GlobalValue.h:248
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:274
LinkageTypes getLinkage() const
Definition: GlobalValue.h:545
bool hasLocalLinkage() const
Definition: GlobalValue.h:527
static StringRef dropLLVMManglingEscape(StringRef Name)
If the given string begins with the GlobalValue name mangling escape character '\1',...
Definition: GlobalValue.h:566
bool hasPrivateLinkage() const
Definition: GlobalValue.h:526
bool isTagged() const
Definition: GlobalValue.h:364
bool isDeclarationForLinker() const
Definition: GlobalValue.h:617
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:655
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:294
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
bool canBenefitFromLocalAlias() const
Definition: Globals.cpp:107
bool hasComdat() const
Definition: GlobalValue.h:241
bool hasWeakLinkage() const
Definition: GlobalValue.h:521
bool hasCommonLinkage() const
Definition: GlobalValue.h:531
bool hasGlobalUnnamedAddr() const
Definition: GlobalValue.h:215
bool hasAppendingLinkage() const
Definition: GlobalValue.h:524
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:448
bool canBeOmittedFromSymbolTable() const
True if GV can be left out of the object symbol table.
Definition: Globals.cpp:393
bool hasAvailableExternallyLinkage() const
Definition: GlobalValue.h:511
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:296
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
static IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition: Type.cpp:278
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.
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:44
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 needsFunctionDescriptors() const
Definition: MCAsmInfo.h:875
bool hasDotTypeDotSizeDirective() const
Definition: MCAsmInfo.h:748
bool useIntegratedAssembler() const
Return true if assembly (inline or otherwise) should be parsed.
Definition: MCAsmInfo.h:842
bool hasBasenameOnlyForFileDirective() const
Definition: MCAsmInfo.h:741
MCSymbolAttr getProtectedVisibilityAttr() const
Definition: MCAsmInfo.h:772
bool hasFourStringsDotFile() const
Definition: MCAsmInfo.h:750
unsigned getAssemblerDialect() const
Definition: MCAsmInfo.h:682
bool useAssignmentForEHBegin() const
Definition: MCAsmInfo.h:662
bool usesCFIWithoutEH() const
Definition: MCAsmInfo.h:787
bool hasAltEntry() const
Definition: MCAsmInfo.h:753
bool avoidWeakIfComdat() const
Definition: MCAsmInfo.h:762
bool hasVisibilityOnlyWithLinkage() const
Definition: MCAsmInfo.h:631
bool hasMachoZeroFillDirective() const
Definition: MCAsmInfo.h:627
MCSymbolAttr getHiddenDeclarationVisibilityAttr() const
Definition: MCAsmInfo.h:768
bool hasWeakDefDirective() const
Definition: MCAsmInfo.h:756
bool hasWeakDefCanBeHiddenDirective() const
Definition: MCAsmInfo.h:758
LCOMM::LCOMMType getLCOMMDirectiveAlignmentType() const
Definition: MCAsmInfo.h:737
bool needsDwarfSectionOffsetDirective() const
Definition: MCAsmInfo.h:621
bool doesSupportDebugInformation() const
Definition: MCAsmInfo.h:778
bool doesSetDirectiveSuppressReloc() const
Definition: MCAsmInfo.h:727
WinEH::EncodingType getWinEHEncodingType() const
Definition: MCAsmInfo.h:781
bool doesDwarfUseRelocationsAcrossSections() const
Definition: MCAsmInfo.h:805
MCSymbolAttr getMemtagAttr() const
Definition: MCAsmInfo.h:776
bool hasSubsectionsViaSymbols() const
Definition: MCAsmInfo.h:560
bool hasMachoTBSSDirective() const
Definition: MCAsmInfo.h:628
bool usesWindowsCFI() const
Definition: MCAsmInfo.h:799
bool binutilsIsAtLeast(int Major, int Minor) const
Definition: MCAsmInfo.h:849
MCSymbolAttr getHiddenVisibilityAttr() const
Definition: MCAsmInfo.h:764
bool hasSingleParameterDotFile() const
Definition: MCAsmInfo.h:749
const char * getWeakRefDirective() const
Definition: MCAsmInfo.h:755
bool hasNoDeadStrip() const
Definition: MCAsmInfo.h:752
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:579
ExceptionHandling getExceptionHandlingType() const
Definition: MCAsmInfo.h:780
bool needsLocalForSize() const
Definition: MCAsmInfo.h:663
bool hasFunctionAlignment() const
Definition: MCAsmInfo.h:747
bool hasIdentDirective() const
Definition: MCAsmInfo.h:751
unsigned getCodePointerSize() const
Get the code pointer size in bytes.
Definition: MCAsmInfo.h:546
static const MCBinaryExpr * createAdd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:536
static const MCBinaryExpr * createSub(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:621
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)
Definition: MCExpr.cpp:194
Context object for machine code objects.
Definition: MCContext.h:76
const MCObjectFileInfo * getObjectFileInfo() const
Definition: MCContext.h:450
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:437
MCSymbol * createTempSymbol()
Create a temporary symbol with a unique name.
Definition: MCContext.cpp:321
MCSymbol * createLinkerPrivateTempSymbol()
Create a new linker temporary symbol with the specified prefix (Name) or "tmp".
Definition: MCContext.cpp:311
MCSectionELF * getELFSection(const Twine &Section, unsigned Type, unsigned Flags)
Definition: MCContext.h:567
void reportWarning(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:1071
void reportError(SMLoc L, const Twine &Msg)
Definition: MCContext.cpp:1064
MCSectionCOFF * getCOFFSection(StringRef Section, unsigned Characteristics, SectionKind Kind, StringRef COMDATSymName, int Selection, unsigned UniqueID=GenericSectionID, const char *BeginSymName=nullptr)
Definition: MCContext.cpp:667
MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition: MCContext.cpp:200
MCSymbol * createLinkerPrivateSymbol(const Twine &Name)
Definition: MCContext.cpp:315
MCSymbol * createNamedTempSymbol()
Create a temporary symbol with a unique name whose name cannot be omitted in the symbol table.
Definition: MCContext.cpp:323
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
unsigned getOpcode() const
Definition: MCInst.h:198
void setOpcode(unsigned Op)
Definition: MCInst.h:197
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:26
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition: MCSection.h:39
static constexpr unsigned NonUniqueID
Definition: MCSection.h:41
virtual bool isVirtualSection() const =0
Check whether this section is "virtual", that is has no actual object file contents.
Streaming machine code generation interface.
Definition: MCStreamer.h:212
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.
void emitZeros(uint64_t NumBytes)
Emit NumBytes worth of zeros.
Definition: MCStreamer.cpp:230
Generic base class for all target subtargets.
const Triple & getTargetTriple() const
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:192
const MCSymbol & getSymbol() const
Definition: MCExpr.h:410
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:397
StringRef getSymbolTableName() const
Definition: MCSymbolXCOFF.h:67
bool hasRename() const
Definition: MCSymbolXCOFF.h:60
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:40
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:1067
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1428
ArrayRef< MDOperand > operands() const
Definition: Metadata.h:1426
Tracking metadata reference owned by Metadata.
Definition: Metadata.h:889
A single uniqued string.
Definition: Metadata.h:720
StringRef getString() const
Definition: Metadata.cpp:607
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.
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.
unsigned getSectionIDNum() const
Returns the unique section ID number of this basic block.
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 ...
MachineConstantPoolValue * MachineCPVal
Align Alignment
The required alignment for this entry.
unsigned getSizeInBytes(const DataLayout &DL) const
SectionKind getSectionKind(const DataLayout *DL) const
union llvm::MachineConstantPoolEntry::@195 Val
The constant itself.
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
MachineDomTree & getBase()
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.
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 LLVMTargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
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
MachineModuleInfo & getMMI() 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
bool hasBBLabels() const
Returns true if basic block labels are to be generated for this function.
const MachineJumpTableInfo * getJumpTableInfo() const
getJumpTableInfo - Return the jump table info object for the current function.
Representation of each machine instruction.
Definition: MachineInstr.h:69
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
MachineLoop * getLoopFor(const MachineBasicBlock *BB) const
Return the innermost loop that BB lives in.
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
This class contains meta information specific to a module.
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.
bool hasDebugInfo() const
Returns true if valid debug info is present.
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:119
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:278
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.h:287
Metadata * getModuleFlag(StringRef Key) const
Return the corresponding value if Key appears in module flags, otherwise return null.
Definition: Module.cpp:331
A tuple of MDNodes.
Definition: Metadata.h:1729
MDNode * getOperand(unsigned i) const
Definition: Metadata.cpp:1379
unsigned getNumOperands() const
Definition: Metadata.cpp:1375
Wrapper for a value that won't be replaced with a CFI jump table pointer in LowerTypeTestsModule.
Definition: Constants.h:971
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:662
void emitPseudoProbe(uint64_t Guid, uint64_t Index, uint64_t Type, uint64_t Attr, const DILocation *DebugLoc)
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
static iterator_range< iterator > entries()
Definition: Registry.h:101
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 getMetadata()
Definition: SectionKind.h:188
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:342
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:427
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:94
size_t size() const
Definition: SmallVector.h:91
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:950
void push_back(const T &Elt)
Definition: SmallVector.h:426
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
void serializeToStackMapSection()
If there is any stack map data, create a stack map section and serialize the map info into it.
Definition: StackMaps.cpp:722
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:50
constexpr StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:567
bool contains(StringRef Other) const
Return true if the given string is a substring of *this, and false otherwise.
Definition: StringRef.h:420
size_t find(char C, size_t From=0) const
Search for the first character C in the string.
Definition: StringRef.h:293
Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...
Definition: DataLayout.h:622
TypeSize getSizeInBytes() const
Definition: DataLayout.h:629
TypeSize getElementOffset(unsigned Idx) const
Definition: DataLayout.h:651
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:76
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:716
bool isOSBinFormatCOFF() const
Tests whether the OS uses the COFF binary format.
Definition: Triple.h:708
bool isOSWindows() const
Tests whether the OS is Windows.
Definition: Triple.h:608
bool isOSBinFormatXCOFF() const
Tests whether the OS uses the XCOFF binary format.
Definition: Triple.h:726
bool isOSAIX() const
Tests whether the OS is AIX.
Definition: Triple.h:694
bool isOSBinFormatELF() const
Tests whether the OS uses the ELF binary format.
Definition: Triple.h:703
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:154
bool isBFloatTy() const
Return true if this is 'bfloat', a 16-bit bfloat type.
Definition: Type.h:146
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:166
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
Definition: Type.h:302
bool isHalfTy() const
Return true if this is 'half', a 16-bit IEEE fp type.
Definition: Type.h:143
bool isDoubleTy() const
Return true if this is 'double', a 64-bit IEEE fp type.
Definition: Type.h:157
bool isFunctionTy() const
True if this is an instance of FunctionType.
Definition: Type.h:246
Value * getOperand(unsigned i) const
Definition: User.h:169
unsigned getNumOperands() const
Definition: User.h:191
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:5043
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
Definition: Value.cpp:693
bool use_empty() const
Definition: Value.h:344
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:1074
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:309
Type * getElementType() const
Definition: DerivedTypes.h:436
reverse_self_iterator getReverseIterator()
Definition: ilist_node.h:112
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:660
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:690
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_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_ANY
Definition: COFF.h:422
@ 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
@ SHF_ALLOC
Definition: ELF.h:1155
@ SHF_LINK_ORDER
Definition: ELF.h:1170
@ SHF_GROUP
Definition: ELF.h:1177
@ SHF_WRITE
Definition: ELF.h:1152
@ SHT_PROGBITS
Definition: ELF.h:1063
@ SHT_LLVM_SYMPART
Definition: ELF.h:1093
@ STT_FUNC
Definition: ELF.h:1322
@ 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:718
@ CommaSeparated
Definition: CommandLine.h:164
uint8_t getUnitLengthFieldByteSize(DwarfFormat Format)
Get the byte size of the unit length field depending on the DWARF format.
Definition: Dwarf.h:788
@ 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:749
DiagnosticInfoOptimizationBase::Argument NV
void make_absolute(const Twine &current_directory, SmallVectorImpl< char > &path)
Make path an absolute path.
Definition: Path.cpp:907
@ OF_Text
The file should be opened in text mode on platforms like z/OS that make this distinction.
Definition: FileSystem.h:759
StringRef filename(StringRef path, Style style=Style::native)
Get filename.
Definition: Path.cpp:578
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
void stable_sort(R &&Range)
Definition: STLExtras.h:2004
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:2082
bool TimePassesIsEnabled
If the user specifies the -time-passes argument on an LLVM tool command line then the value of this b...
@ 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:428
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1656
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:156
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:191
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:1858
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 OP(n)
Definition: regex2.h:73
#define NC
Definition: regutils.h:42
static constexpr roundingMode rmNearestTiesToEven
Definition: APFloat.h:230
static const fltSemantics & IEEEdouble() LLVM_READNONE
Definition: APFloat.cpp:250
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
struct HandlerInfo and Handlers permit users or target extended AsmPrinter to add their own handlers.
Definition: AsmPrinter.h:147
Map a basic block section ID to the begin and end symbols of that section which determine the section...
Definition: AsmPrinter.h:134
llvm.global_ctors and llvm.global_dtors are arrays of Structor structs.
Definition: AsmPrinter.h:474
void emit(int, MCStreamer *) const
Description of the encoding of one expression Op.
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:117
This class is basically a combination of TimeRegion and Timer.
Definition: Timer.h:163
A helper struct providing information about the byte size of DW_FORM values that vary in size dependi...
Definition: Dwarf.h:762
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.