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