Thanks to visit codestin.com
Credit goes to llvm.org

LLVM 22.0.0git
AsmWriter.cpp
Go to the documentation of this file.
1//===- AsmWriter.cpp - Printing LLVM as an assembly file ------------------===//
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 library implements `print` family of functions in classes like
10// Module, Function, Value, etc. In-memory representation of those classes is
11// converted to IR strings.
12//
13// Note that these routines must be extremely tolerant of various errors in the
14// LLVM code, because it can be used for debugging transformations.
15//
16//===----------------------------------------------------------------------===//
17
18#include "llvm/ADT/APFloat.h"
19#include "llvm/ADT/APInt.h"
20#include "llvm/ADT/ArrayRef.h"
21#include "llvm/ADT/DenseMap.h"
22#include "llvm/ADT/STLExtras.h"
23#include "llvm/ADT/SetVector.h"
28#include "llvm/ADT/StringRef.h"
31#include "llvm/Config/llvm-config.h"
32#include "llvm/IR/Argument.h"
34#include "llvm/IR/Attributes.h"
35#include "llvm/IR/BasicBlock.h"
36#include "llvm/IR/CFG.h"
37#include "llvm/IR/CallingConv.h"
38#include "llvm/IR/Comdat.h"
39#include "llvm/IR/Constant.h"
40#include "llvm/IR/Constants.h"
44#include "llvm/IR/Function.h"
45#include "llvm/IR/GlobalAlias.h"
46#include "llvm/IR/GlobalIFunc.h"
48#include "llvm/IR/GlobalValue.h"
51#include "llvm/IR/InlineAsm.h"
52#include "llvm/IR/InstrTypes.h"
53#include "llvm/IR/Instruction.h"
56#include "llvm/IR/LLVMContext.h"
57#include "llvm/IR/Metadata.h"
58#include "llvm/IR/Module.h"
61#include "llvm/IR/Operator.h"
62#include "llvm/IR/Type.h"
63#include "llvm/IR/TypeFinder.h"
65#include "llvm/IR/Use.h"
66#include "llvm/IR/User.h"
67#include "llvm/IR/Value.h"
71#include "llvm/Support/Debug.h"
73#include "llvm/Support/Format.h"
77#include <cassert>
78#include <cctype>
79#include <cstddef>
80#include <cstdint>
81#include <iterator>
82#include <memory>
83#include <optional>
84#include <string>
85#include <tuple>
86#include <utility>
87#include <vector>
88
89using namespace llvm;
90
91// See https://llvm.org/docs/DebuggingLLVM.html for why these flags are useful.
92
93static cl::opt<bool>
94 PrintInstAddrs("print-inst-addrs", cl::Hidden,
95 cl::desc("Print addresses of instructions when dumping"));
96
98 "print-inst-debug-locs", cl::Hidden,
99 cl::desc("Pretty print debug locations of instructions when dumping"));
100
102 "print-prof-data", cl::Hidden,
103 cl::desc("Pretty print perf data (branch weights, etc) when dumping"));
104
105// Make virtual table appear in this compilation unit.
107
108//===----------------------------------------------------------------------===//
109// Helper Functions
110//===----------------------------------------------------------------------===//
111
113
116
117/// Look for a value that might be wrapped as metadata, e.g. a value in a
118/// metadata operand. Returns the input value as-is if it is not wrapped.
119static const Value *skipMetadataWrapper(const Value *V) {
120 if (const auto *MAV = dyn_cast<MetadataAsValue>(V))
121 if (const auto *VAM = dyn_cast<ValueAsMetadata>(MAV->getMetadata()))
122 return VAM->getValue();
123 return V;
124}
125
126static void orderValue(const Value *V, OrderMap &OM) {
127 if (OM.lookup(V))
128 return;
129
130 if (const auto *C = dyn_cast<Constant>(V)) {
131 if (isa<ConstantData>(C))
132 return;
133
134 if (C->getNumOperands() && !isa<GlobalValue>(C))
135 for (const Value *Op : C->operands())
137 orderValue(Op, OM);
138 }
139
140 // Note: we cannot cache this lookup above, since inserting into the map
141 // changes the map's size, and thus affects the other IDs.
142 unsigned ID = OM.size() + 1;
143 OM[V] = ID;
144}
145
146static OrderMap orderModule(const Module *M) {
147 OrderMap OM;
148
149 auto OrderConstantValue = [&OM](const Value *V) {
150 if (isa<Constant>(V) || isa<InlineAsm>(V))
151 orderValue(V, OM);
152 };
153
154 auto OrderConstantFromMetadata = [&](Metadata *MD) {
155 if (const auto *VAM = dyn_cast<ValueAsMetadata>(MD)) {
156 OrderConstantValue(VAM->getValue());
157 } else if (const auto *AL = dyn_cast<DIArgList>(MD)) {
158 for (const auto *VAM : AL->getArgs())
159 OrderConstantValue(VAM->getValue());
160 }
161 };
162
163 for (const GlobalVariable &G : M->globals()) {
164 if (G.hasInitializer())
165 if (!isa<GlobalValue>(G.getInitializer()))
166 orderValue(G.getInitializer(), OM);
167 orderValue(&G, OM);
168 }
169 for (const GlobalAlias &A : M->aliases()) {
170 if (!isa<GlobalValue>(A.getAliasee()))
171 orderValue(A.getAliasee(), OM);
172 orderValue(&A, OM);
173 }
174 for (const GlobalIFunc &I : M->ifuncs()) {
175 if (!isa<GlobalValue>(I.getResolver()))
176 orderValue(I.getResolver(), OM);
177 orderValue(&I, OM);
178 }
179 for (const Function &F : *M) {
180 for (const Use &U : F.operands())
181 if (!isa<GlobalValue>(U.get()))
182 orderValue(U.get(), OM);
183
184 orderValue(&F, OM);
185
186 if (F.isDeclaration())
187 continue;
188
189 for (const Argument &A : F.args())
190 orderValue(&A, OM);
191 for (const BasicBlock &BB : F) {
192 orderValue(&BB, OM);
193 for (const Instruction &I : BB) {
194 // Debug records can contain Value references, that can then contain
195 // Values disconnected from the rest of the Value hierachy, if wrapped
196 // in some kind of constant-expression. Find and order any Values that
197 // are wrapped in debug-info.
198 for (DbgVariableRecord &DVR : filterDbgVars(I.getDbgRecordRange())) {
199 OrderConstantFromMetadata(DVR.getRawLocation());
200 if (DVR.isDbgAssign())
201 OrderConstantFromMetadata(DVR.getRawAddress());
202 }
203
204 for (const Value *Op : I.operands()) {
206 if ((isa<Constant>(*Op) && !isa<GlobalValue>(*Op)) ||
208 orderValue(Op, OM);
209 }
210 orderValue(&I, OM);
211 }
212 }
213 }
214 return OM;
215}
216
217static std::vector<unsigned>
218predictValueUseListOrder(const Value *V, unsigned ID, const OrderMap &OM) {
219 // Predict use-list order for this one.
220 using Entry = std::pair<const Use *, unsigned>;
222 for (const Use &U : V->uses())
223 // Check if this user will be serialized.
224 if (OM.lookup(U.getUser()))
225 List.push_back(std::make_pair(&U, List.size()));
226
227 if (List.size() < 2)
228 // We may have lost some users.
229 return {};
230
231 // When referencing a value before its declaration, a temporary value is
232 // created, which will later be RAUWed with the actual value. This reverses
233 // the use list. This happens for all values apart from basic blocks.
234 bool GetsReversed = !isa<BasicBlock>(V);
235 if (auto *BA = dyn_cast<BlockAddress>(V))
236 ID = OM.lookup(BA->getBasicBlock());
237 llvm::sort(List, [&](const Entry &L, const Entry &R) {
238 const Use *LU = L.first;
239 const Use *RU = R.first;
240 if (LU == RU)
241 return false;
242
243 auto LID = OM.lookup(LU->getUser());
244 auto RID = OM.lookup(RU->getUser());
245
246 // If ID is 4, then expect: 7 6 5 1 2 3.
247 if (LID < RID) {
248 if (GetsReversed)
249 if (RID <= ID)
250 return true;
251 return false;
252 }
253 if (RID < LID) {
254 if (GetsReversed)
255 if (LID <= ID)
256 return false;
257 return true;
258 }
259
260 // LID and RID are equal, so we have different operands of the same user.
261 // Assume operands are added in order for all instructions.
262 if (GetsReversed)
263 if (LID <= ID)
264 return LU->getOperandNo() < RU->getOperandNo();
265 return LU->getOperandNo() > RU->getOperandNo();
266 });
267
269 // Order is already correct.
270 return {};
271
272 // Store the shuffle.
273 std::vector<unsigned> Shuffle(List.size());
274 for (size_t I = 0, E = List.size(); I != E; ++I)
275 Shuffle[I] = List[I].second;
276 return Shuffle;
277}
278
280 OrderMap OM = orderModule(M);
281 UseListOrderMap ULOM;
282 for (const auto &Pair : OM) {
283 const Value *V = Pair.first;
284 if (V->use_empty() || std::next(V->use_begin()) == V->use_end())
285 continue;
286
287 std::vector<unsigned> Shuffle =
288 predictValueUseListOrder(V, Pair.second, OM);
289 if (Shuffle.empty())
290 continue;
291
292 const Function *F = nullptr;
293 if (auto *I = dyn_cast<Instruction>(V))
294 F = I->getFunction();
295 if (auto *A = dyn_cast<Argument>(V))
296 F = A->getParent();
297 if (auto *BB = dyn_cast<BasicBlock>(V))
298 F = BB->getParent();
299 ULOM[F][V] = std::move(Shuffle);
300 }
301 return ULOM;
302}
303
304static const Module *getModuleFromVal(const Value *V) {
305 if (const auto *MA = dyn_cast<Argument>(V))
306 return MA->getParent() ? MA->getParent()->getParent() : nullptr;
307
308 if (const auto *BB = dyn_cast<BasicBlock>(V))
309 return BB->getParent() ? BB->getParent()->getParent() : nullptr;
310
311 if (const auto *I = dyn_cast<Instruction>(V)) {
312 const Function *M = I->getParent() ? I->getParent()->getParent() : nullptr;
313 return M ? M->getParent() : nullptr;
314 }
315
316 if (const auto *GV = dyn_cast<GlobalValue>(V))
317 return GV->getParent();
318
319 if (const auto *MAV = dyn_cast<MetadataAsValue>(V)) {
320 for (const User *U : MAV->users())
321 if (isa<Instruction>(U))
322 if (const Module *M = getModuleFromVal(U))
323 return M;
324 return nullptr;
325 }
326
327 return nullptr;
328}
329
330static const Module *getModuleFromDPI(const DbgMarker *Marker) {
331 const Function *M =
332 Marker->getParent() ? Marker->getParent()->getParent() : nullptr;
333 return M ? M->getParent() : nullptr;
334}
335
336static const Module *getModuleFromDPI(const DbgRecord *DR) {
337 return DR->getMarker() ? getModuleFromDPI(DR->getMarker()) : nullptr;
338}
339
340static void printCallingConv(unsigned cc, raw_ostream &Out) {
341 switch (cc) {
342 default: Out << "cc" << cc; break;
343 case CallingConv::Fast: Out << "fastcc"; break;
344 case CallingConv::Cold: Out << "coldcc"; break;
345 case CallingConv::AnyReg: Out << "anyregcc"; break;
346 case CallingConv::PreserveMost: Out << "preserve_mostcc"; break;
347 case CallingConv::PreserveAll: Out << "preserve_allcc"; break;
348 case CallingConv::PreserveNone: Out << "preserve_nonecc"; break;
349 case CallingConv::CXX_FAST_TLS: Out << "cxx_fast_tlscc"; break;
350 case CallingConv::GHC: Out << "ghccc"; break;
351 case CallingConv::Tail: Out << "tailcc"; break;
352 case CallingConv::GRAAL: Out << "graalcc"; break;
353 case CallingConv::CFGuard_Check: Out << "cfguard_checkcc"; break;
354 case CallingConv::X86_StdCall: Out << "x86_stdcallcc"; break;
355 case CallingConv::X86_FastCall: Out << "x86_fastcallcc"; break;
356 case CallingConv::X86_ThisCall: Out << "x86_thiscallcc"; break;
357 case CallingConv::X86_RegCall: Out << "x86_regcallcc"; break;
358 case CallingConv::X86_VectorCall:Out << "x86_vectorcallcc"; break;
359 case CallingConv::Intel_OCL_BI: Out << "intel_ocl_bicc"; break;
360 case CallingConv::ARM_APCS: Out << "arm_apcscc"; break;
361 case CallingConv::ARM_AAPCS: Out << "arm_aapcscc"; break;
362 case CallingConv::ARM_AAPCS_VFP: Out << "arm_aapcs_vfpcc"; break;
363 case CallingConv::AArch64_VectorCall: Out << "aarch64_vector_pcs"; break;
365 Out << "aarch64_sve_vector_pcs";
366 break;
368 Out << "aarch64_sme_preservemost_from_x0";
369 break;
371 Out << "aarch64_sme_preservemost_from_x1";
372 break;
374 Out << "aarch64_sme_preservemost_from_x2";
375 break;
376 case CallingConv::MSP430_INTR: Out << "msp430_intrcc"; break;
377 case CallingConv::AVR_INTR: Out << "avr_intrcc "; break;
378 case CallingConv::AVR_SIGNAL: Out << "avr_signalcc "; break;
379 case CallingConv::PTX_Kernel: Out << "ptx_kernel"; break;
380 case CallingConv::PTX_Device: Out << "ptx_device"; break;
381 case CallingConv::X86_64_SysV: Out << "x86_64_sysvcc"; break;
382 case CallingConv::Win64: Out << "win64cc"; break;
383 case CallingConv::SPIR_FUNC: Out << "spir_func"; break;
384 case CallingConv::SPIR_KERNEL: Out << "spir_kernel"; break;
385 case CallingConv::Swift: Out << "swiftcc"; break;
386 case CallingConv::SwiftTail: Out << "swifttailcc"; break;
387 case CallingConv::X86_INTR: Out << "x86_intrcc"; break;
389 Out << "hhvmcc";
390 break;
392 Out << "hhvm_ccc";
393 break;
394 case CallingConv::AMDGPU_VS: Out << "amdgpu_vs"; break;
395 case CallingConv::AMDGPU_LS: Out << "amdgpu_ls"; break;
396 case CallingConv::AMDGPU_HS: Out << "amdgpu_hs"; break;
397 case CallingConv::AMDGPU_ES: Out << "amdgpu_es"; break;
398 case CallingConv::AMDGPU_GS: Out << "amdgpu_gs"; break;
399 case CallingConv::AMDGPU_PS: Out << "amdgpu_ps"; break;
400 case CallingConv::AMDGPU_CS: Out << "amdgpu_cs"; break;
402 Out << "amdgpu_cs_chain";
403 break;
405 Out << "amdgpu_cs_chain_preserve";
406 break;
407 case CallingConv::AMDGPU_KERNEL: Out << "amdgpu_kernel"; break;
408 case CallingConv::AMDGPU_Gfx: Out << "amdgpu_gfx"; break;
410 Out << "amdgpu_gfx_whole_wave";
411 break;
412 case CallingConv::M68k_RTD: Out << "m68k_rtdcc"; break;
414 Out << "riscv_vector_cc";
415 break;
416#define CC_VLS_CASE(ABI_VLEN) \
417 case CallingConv::RISCV_VLSCall_##ABI_VLEN: \
418 Out << "riscv_vls_cc(" #ABI_VLEN ")"; \
419 break;
420 CC_VLS_CASE(32)
421 CC_VLS_CASE(64)
422 CC_VLS_CASE(128)
423 CC_VLS_CASE(256)
424 CC_VLS_CASE(512)
425 CC_VLS_CASE(1024)
426 CC_VLS_CASE(2048)
427 CC_VLS_CASE(4096)
428 CC_VLS_CASE(8192)
429 CC_VLS_CASE(16384)
430 CC_VLS_CASE(32768)
431 CC_VLS_CASE(65536)
432#undef CC_VLS_CASE
434 Out << "cheriot_compartmentcallcc";
435 break;
437 Out << "cheriot_compartmentcalleecc";
438 break;
440 Out << "cheriot_librarycallcc";
441 break;
442 }
443}
444
452
454 assert(!Name.empty() && "Cannot get empty name!");
455
456 // Scan the name to see if it needs quotes first.
457 bool NeedsQuotes = isdigit(static_cast<unsigned char>(Name[0]));
458 if (!NeedsQuotes) {
459 for (unsigned char C : Name) {
460 // By making this unsigned, the value passed in to isalnum will always be
461 // in the range 0-255. This is important when building with MSVC because
462 // its implementation will assert. This situation can arise when dealing
463 // with UTF-8 multibyte characters.
464 if (!isalnum(C) && C != '-' && C != '.' && C != '_') {
465 NeedsQuotes = true;
466 break;
467 }
468 }
469 }
470
471 // If we didn't need any quotes, just write out the name in one blast.
472 if (!NeedsQuotes) {
473 OS << Name;
474 return;
475 }
476
477 // Okay, we need quotes. Output the quotes and escape any scary characters as
478 // needed.
479 OS << '"';
480 printEscapedString(Name, OS);
481 OS << '"';
482}
483
484/// Turn the specified name into an 'LLVM name', which is either prefixed with %
485/// (if the string only contains simple characters) or is surrounded with ""'s
486/// (if it has special chars in it). Print it out.
487static void printLLVMName(raw_ostream &OS, StringRef Name, PrefixType Prefix) {
488 switch (Prefix) {
489 case NoPrefix:
490 break;
491 case GlobalPrefix:
492 OS << '@';
493 break;
494 case ComdatPrefix:
495 OS << '$';
496 break;
497 case LabelPrefix:
498 break;
499 case LocalPrefix:
500 OS << '%';
501 break;
502 }
504}
505
506/// Turn the specified name into an 'LLVM name', which is either prefixed with %
507/// (if the string only contains simple characters) or is surrounded with ""'s
508/// (if it has special chars in it). Print it out.
509static void printLLVMName(raw_ostream &OS, const Value *V) {
510 printLLVMName(OS, V->getName(),
512}
513
514static void printShuffleMask(raw_ostream &Out, Type *Ty, ArrayRef<int> Mask) {
515 Out << ", <";
517 Out << "vscale x ";
518 Out << Mask.size() << " x i32> ";
519 if (all_of(Mask, [](int Elt) { return Elt == 0; })) {
520 Out << "zeroinitializer";
521 } else if (all_of(Mask, [](int Elt) { return Elt == PoisonMaskElem; })) {
522 Out << "poison";
523 } else {
524 Out << "<";
525 ListSeparator LS;
526 for (int Elt : Mask) {
527 Out << LS << "i32 ";
528 if (Elt == PoisonMaskElem)
529 Out << "poison";
530 else
531 Out << Elt;
532 }
533 Out << ">";
534 }
535}
536
537namespace {
538
539class TypePrinting {
540public:
541 TypePrinting(const Module *M = nullptr) : DeferredM(M) {}
542
543 TypePrinting(const TypePrinting &) = delete;
544 TypePrinting &operator=(const TypePrinting &) = delete;
545
546 /// The named types that are used by the current module.
547 TypeFinder &getNamedTypes();
548
549 /// The numbered types, number to type mapping.
550 std::vector<StructType *> &getNumberedTypes();
551
552 bool empty();
553
554 void print(Type *Ty, raw_ostream &OS);
555
556 void printStructBody(StructType *Ty, raw_ostream &OS);
557
558private:
559 void incorporateTypes();
560
561 /// A module to process lazily when needed. Set to nullptr as soon as used.
562 const Module *DeferredM;
563
564 TypeFinder NamedTypes;
565
566 // The numbered types, along with their value.
567 DenseMap<StructType *, unsigned> Type2Number;
568
569 std::vector<StructType *> NumberedTypes;
570};
571
572} // end anonymous namespace
573
574TypeFinder &TypePrinting::getNamedTypes() {
575 incorporateTypes();
576 return NamedTypes;
577}
578
579std::vector<StructType *> &TypePrinting::getNumberedTypes() {
580 incorporateTypes();
581
582 // We know all the numbers that each type is used and we know that it is a
583 // dense assignment. Convert the map to an index table, if it's not done
584 // already (judging from the sizes):
585 if (NumberedTypes.size() == Type2Number.size())
586 return NumberedTypes;
587
588 NumberedTypes.resize(Type2Number.size());
589 for (const auto &P : Type2Number) {
590 assert(P.second < NumberedTypes.size() && "Didn't get a dense numbering?");
591 assert(!NumberedTypes[P.second] && "Didn't get a unique numbering?");
592 NumberedTypes[P.second] = P.first;
593 }
594 return NumberedTypes;
595}
596
597bool TypePrinting::empty() {
598 incorporateTypes();
599 return NamedTypes.empty() && Type2Number.empty();
600}
601
602void TypePrinting::incorporateTypes() {
603 if (!DeferredM)
604 return;
605
606 NamedTypes.run(*DeferredM, false);
607 DeferredM = nullptr;
608
609 // The list of struct types we got back includes all the struct types, split
610 // the unnamed ones out to a numbering and remove the anonymous structs.
611 unsigned NextNumber = 0;
612
613 std::vector<StructType *>::iterator NextToUse = NamedTypes.begin();
614 for (StructType *STy : NamedTypes) {
615 // Ignore anonymous types.
616 if (STy->isLiteral())
617 continue;
618
619 if (STy->getName().empty())
620 Type2Number[STy] = NextNumber++;
621 else
622 *NextToUse++ = STy;
623 }
624
625 NamedTypes.erase(NextToUse, NamedTypes.end());
626}
627
628/// Write the specified type to the specified raw_ostream, making use of type
629/// names or up references to shorten the type name where possible.
630void TypePrinting::print(Type *Ty, raw_ostream &OS) {
631 switch (Ty->getTypeID()) {
632 case Type::VoidTyID: OS << "void"; return;
633 case Type::HalfTyID: OS << "half"; return;
634 case Type::BFloatTyID: OS << "bfloat"; return;
635 case Type::FloatTyID: OS << "float"; return;
636 case Type::DoubleTyID: OS << "double"; return;
637 case Type::X86_FP80TyID: OS << "x86_fp80"; return;
638 case Type::FP128TyID: OS << "fp128"; return;
639 case Type::PPC_FP128TyID: OS << "ppc_fp128"; return;
640 case Type::LabelTyID: OS << "label"; return;
641 case Type::MetadataTyID:
642 OS << "metadata";
643 return;
644 case Type::X86_AMXTyID: OS << "x86_amx"; return;
645 case Type::TokenTyID: OS << "token"; return;
646 case Type::IntegerTyID:
647 OS << 'i' << cast<IntegerType>(Ty)->getBitWidth();
648 return;
649
650 case Type::FunctionTyID: {
651 FunctionType *FTy = cast<FunctionType>(Ty);
652 print(FTy->getReturnType(), OS);
653 OS << " (";
654 ListSeparator LS;
655 for (Type *Ty : FTy->params()) {
656 OS << LS;
657 print(Ty, OS);
658 }
659 if (FTy->isVarArg())
660 OS << LS << "...";
661 OS << ')';
662 return;
663 }
664 case Type::StructTyID: {
665 StructType *STy = cast<StructType>(Ty);
666
667 if (STy->isLiteral())
668 return printStructBody(STy, OS);
669
670 if (!STy->getName().empty())
671 return printLLVMName(OS, STy->getName(), LocalPrefix);
672
673 incorporateTypes();
674 const auto I = Type2Number.find(STy);
675 if (I != Type2Number.end())
676 OS << '%' << I->second;
677 else // Not enumerated, print the hex address.
678 OS << "%\"type " << STy << '\"';
679 return;
680 }
681 case Type::PointerTyID: {
683 OS << "ptr";
684 if (unsigned AddressSpace = PTy->getAddressSpace())
685 OS << " addrspace(" << AddressSpace << ')';
686 return;
687 }
688 case Type::ArrayTyID: {
689 ArrayType *ATy = cast<ArrayType>(Ty);
690 OS << '[' << ATy->getNumElements() << " x ";
691 print(ATy->getElementType(), OS);
692 OS << ']';
693 return;
694 }
695 case Type::FixedVectorTyID:
696 case Type::ScalableVectorTyID: {
697 VectorType *PTy = cast<VectorType>(Ty);
698 ElementCount EC = PTy->getElementCount();
699 OS << "<";
700 if (EC.isScalable())
701 OS << "vscale x ";
702 OS << EC.getKnownMinValue() << " x ";
703 print(PTy->getElementType(), OS);
704 OS << '>';
705 return;
706 }
707 case Type::TypedPointerTyID: {
708 TypedPointerType *TPTy = cast<TypedPointerType>(Ty);
709 OS << "typedptr(" << *TPTy->getElementType() << ", "
710 << TPTy->getAddressSpace() << ")";
711 return;
712 }
713 case Type::TargetExtTyID:
714 TargetExtType *TETy = cast<TargetExtType>(Ty);
715 OS << "target(\"";
717 OS << "\"";
718 for (Type *Inner : TETy->type_params()) {
719 OS << ", ";
720 Inner->print(OS, /*IsForDebug=*/false, /*NoDetails=*/true);
721 }
722 for (unsigned IntParam : TETy->int_params())
723 OS << ", " << IntParam;
724 OS << ")";
725 return;
726 }
727 llvm_unreachable("Invalid TypeID");
728}
729
730void TypePrinting::printStructBody(StructType *STy, raw_ostream &OS) {
731 if (STy->isOpaque()) {
732 OS << "opaque";
733 return;
734 }
735
736 if (STy->isPacked())
737 OS << '<';
738
739 if (STy->getNumElements() == 0) {
740 OS << "{}";
741 } else {
742 OS << "{ ";
743 ListSeparator LS;
744 for (Type *Ty : STy->elements()) {
745 OS << LS;
746 print(Ty, OS);
747 }
748
749 OS << " }";
750 }
751 if (STy->isPacked())
752 OS << '>';
753}
754
756
757namespace llvm {
758
759//===----------------------------------------------------------------------===//
760// SlotTracker Class: Enumerate slot numbers for unnamed values
761//===----------------------------------------------------------------------===//
762/// This class provides computation of slot numbers for LLVM Assembly writing.
763///
765public:
766 /// ValueMap - A mapping of Values to slot numbers.
768
769private:
770 /// TheModule - The module for which we are holding slot numbers.
771 const Module* TheModule;
772
773 /// TheFunction - The function for which we are holding slot numbers.
774 const Function* TheFunction = nullptr;
775 bool FunctionProcessed = false;
776 bool ShouldInitializeAllMetadata;
777
778 std::function<void(AbstractSlotTrackerStorage *, const Module *, bool)>
779 ProcessModuleHookFn;
780 std::function<void(AbstractSlotTrackerStorage *, const Function *, bool)>
781 ProcessFunctionHookFn;
782
783 /// The summary index for which we are holding slot numbers.
784 const ModuleSummaryIndex *TheIndex = nullptr;
785
786 /// mMap - The slot map for the module level data.
787 ValueMap mMap;
788 unsigned mNext = 0;
789
790 /// fMap - The slot map for the function level data.
791 ValueMap fMap;
792 unsigned fNext = 0;
793
794 /// mdnMap - Map for MDNodes.
796 unsigned mdnNext = 0;
797
798 /// asMap - The slot map for attribute sets.
800 unsigned asNext = 0;
801
802 /// ModulePathMap - The slot map for Module paths used in the summary index.
803 StringMap<unsigned> ModulePathMap;
804 unsigned ModulePathNext = 0;
805
806 /// GUIDMap - The slot map for GUIDs used in the summary index.
808 unsigned GUIDNext = 0;
809
810 /// TypeIdMap - The slot map for type ids used in the summary index.
811 StringMap<unsigned> TypeIdMap;
812 unsigned TypeIdNext = 0;
813
814 /// TypeIdCompatibleVtableMap - The slot map for type compatible vtable ids
815 /// used in the summary index.
816 StringMap<unsigned> TypeIdCompatibleVtableMap;
817 unsigned TypeIdCompatibleVtableNext = 0;
818
819public:
820 /// Construct from a module.
821 ///
822 /// If \c ShouldInitializeAllMetadata, initializes all metadata in all
823 /// functions, giving correct numbering for metadata referenced only from
824 /// within a function (even if no functions have been initialized).
825 explicit SlotTracker(const Module *M,
826 bool ShouldInitializeAllMetadata = false);
827
828 /// Construct from a function, starting out in incorp state.
829 ///
830 /// If \c ShouldInitializeAllMetadata, initializes all metadata in all
831 /// functions, giving correct numbering for metadata referenced only from
832 /// within a function (even if no functions have been initialized).
833 explicit SlotTracker(const Function *F,
834 bool ShouldInitializeAllMetadata = false);
835
836 /// Construct from a module summary index.
837 explicit SlotTracker(const ModuleSummaryIndex *Index);
838
839 SlotTracker(const SlotTracker &) = delete;
841
842 ~SlotTracker() = default;
843
844 void setProcessHook(
845 std::function<void(AbstractSlotTrackerStorage *, const Module *, bool)>);
846 void setProcessHook(std::function<void(AbstractSlotTrackerStorage *,
847 const Function *, bool)>);
848
849 unsigned getNextMetadataSlot() override { return mdnNext; }
850
851 void createMetadataSlot(const MDNode *N) override;
852
853 /// Return the slot number of the specified value in it's type
854 /// plane. If something is not in the SlotTracker, return -1.
855 int getLocalSlot(const Value *V);
856 int getGlobalSlot(const GlobalValue *V);
857 int getMetadataSlot(const MDNode *N) override;
858 int getAttributeGroupSlot(AttributeSet AS);
859 int getModulePathSlot(StringRef Path);
860 int getGUIDSlot(GlobalValue::GUID GUID);
861 int getTypeIdSlot(StringRef Id);
862 int getTypeIdCompatibleVtableSlot(StringRef Id);
863
864 /// If you'd like to deal with a function instead of just a module, use
865 /// this method to get its data into the SlotTracker.
867 TheFunction = F;
868 FunctionProcessed = false;
869 }
870
871 const Function *getFunction() const { return TheFunction; }
872
873 /// After calling incorporateFunction, use this method to remove the
874 /// most recently incorporated function from the SlotTracker. This
875 /// will reset the state of the machine back to just the module contents.
876 void purgeFunction();
877
878 /// MDNode map iterators.
880
881 mdn_iterator mdn_begin() { return mdnMap.begin(); }
882 mdn_iterator mdn_end() { return mdnMap.end(); }
883 unsigned mdn_size() const { return mdnMap.size(); }
884 bool mdn_empty() const { return mdnMap.empty(); }
885
886 /// AttributeSet map iterators.
888
889 as_iterator as_begin() { return asMap.begin(); }
890 as_iterator as_end() { return asMap.end(); }
891 unsigned as_size() const { return asMap.size(); }
892 bool as_empty() const { return asMap.empty(); }
893
894 /// GUID map iterators.
896
897 /// These functions do the actual initialization.
898 inline void initializeIfNeeded();
900
901 // Implementation Details
902private:
903 /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
904 void CreateModuleSlot(const GlobalValue *V);
905
906 /// CreateMetadataSlot - Insert the specified MDNode* into the slot table.
907 void CreateMetadataSlot(const MDNode *N);
908
909 /// CreateFunctionSlot - Insert the specified Value* into the slot table.
910 void CreateFunctionSlot(const Value *V);
911
912 /// Insert the specified AttributeSet into the slot table.
913 void CreateAttributeSetSlot(AttributeSet AS);
914
915 inline void CreateModulePathSlot(StringRef Path);
916 void CreateGUIDSlot(GlobalValue::GUID GUID);
917 void CreateTypeIdSlot(StringRef Id);
918 void CreateTypeIdCompatibleVtableSlot(StringRef Id);
919
920 /// Add all of the module level global variables (and their initializers)
921 /// and function declarations, but not the contents of those functions.
922 void processModule();
923 // Returns number of allocated slots
924 int processIndex();
925
926 /// Add all of the functions arguments, basic blocks, and instructions.
927 void processFunction();
928
929 /// Add the metadata directly attached to a GlobalObject.
930 void processGlobalObjectMetadata(const GlobalObject &GO);
931
932 /// Add all of the metadata from a function.
933 void processFunctionMetadata(const Function &F);
934
935 /// Add all of the metadata from an instruction.
936 void processInstructionMetadata(const Instruction &I);
937
938 /// Add all of the metadata from a DbgRecord.
939 void processDbgRecordMetadata(const DbgRecord &DVR);
940};
941
942} // end namespace llvm
943
945 const Function *F)
946 : M(M), F(F), Machine(&Machine) {}
947
949 bool ShouldInitializeAllMetadata)
950 : ShouldCreateStorage(M),
951 ShouldInitializeAllMetadata(ShouldInitializeAllMetadata), M(M) {}
952
954
956 if (!ShouldCreateStorage)
957 return Machine;
958
959 ShouldCreateStorage = false;
960 MachineStorage =
961 std::make_unique<SlotTracker>(M, ShouldInitializeAllMetadata);
962 Machine = MachineStorage.get();
963 if (ProcessModuleHookFn)
964 Machine->setProcessHook(ProcessModuleHookFn);
965 if (ProcessFunctionHookFn)
966 Machine->setProcessHook(ProcessFunctionHookFn);
967 return Machine;
968}
969
971 // Using getMachine() may lazily create the slot tracker.
972 if (!getMachine())
973 return;
974
975 // Nothing to do if this is the right function already.
976 if (this->F == &F)
977 return;
978 if (this->F)
979 Machine->purgeFunction();
980 Machine->incorporateFunction(&F);
981 this->F = &F;
982}
983
985 assert(F && "No function incorporated");
986 return Machine->getLocalSlot(V);
987}
988
990 std::function<void(AbstractSlotTrackerStorage *, const Module *, bool)>
991 Fn) {
992 ProcessModuleHookFn = Fn;
993}
994
996 std::function<void(AbstractSlotTrackerStorage *, const Function *, bool)>
997 Fn) {
998 ProcessFunctionHookFn = Fn;
999}
1000
1002 if (const auto *FA = dyn_cast<Argument>(V))
1003 return new SlotTracker(FA->getParent());
1004
1005 if (const auto *I = dyn_cast<Instruction>(V))
1006 if (I->getParent())
1007 return new SlotTracker(I->getParent()->getParent());
1008
1009 if (const auto *BB = dyn_cast<BasicBlock>(V))
1010 return new SlotTracker(BB->getParent());
1011
1012 if (const auto *GV = dyn_cast<GlobalVariable>(V))
1013 return new SlotTracker(GV->getParent());
1014
1015 if (const auto *GA = dyn_cast<GlobalAlias>(V))
1016 return new SlotTracker(GA->getParent());
1017
1018 if (const auto *GIF = dyn_cast<GlobalIFunc>(V))
1019 return new SlotTracker(GIF->getParent());
1020
1021 if (const auto *Func = dyn_cast<Function>(V))
1022 return new SlotTracker(Func);
1023
1024 return nullptr;
1025}
1026
1027#if 0
1028#define ST_DEBUG(X) dbgs() << X
1029#else
1030#define ST_DEBUG(X)
1031#endif
1032
1033// Module level constructor. Causes the contents of the Module (sans functions)
1034// to be added to the slot table.
1035SlotTracker::SlotTracker(const Module *M, bool ShouldInitializeAllMetadata)
1036 : TheModule(M), ShouldInitializeAllMetadata(ShouldInitializeAllMetadata) {}
1037
1038// Function level constructor. Causes the contents of the Module and the one
1039// function provided to be added to the slot table.
1040SlotTracker::SlotTracker(const Function *F, bool ShouldInitializeAllMetadata)
1041 : TheModule(F ? F->getParent() : nullptr), TheFunction(F),
1042 ShouldInitializeAllMetadata(ShouldInitializeAllMetadata) {}
1043
1045 : TheModule(nullptr), ShouldInitializeAllMetadata(false), TheIndex(Index) {}
1046
1048 if (TheModule) {
1049 processModule();
1050 TheModule = nullptr; ///< Prevent re-processing next time we're called.
1051 }
1052
1053 if (TheFunction && !FunctionProcessed)
1054 processFunction();
1055}
1056
1058 if (!TheIndex)
1059 return 0;
1060 int NumSlots = processIndex();
1061 TheIndex = nullptr; ///< Prevent re-processing next time we're called.
1062 return NumSlots;
1063}
1064
1065// Iterate through all the global variables, functions, and global
1066// variable initializers and create slots for them.
1067void SlotTracker::processModule() {
1068 ST_DEBUG("begin processModule!\n");
1069
1070 // Add all of the unnamed global variables to the value table.
1071 for (const GlobalVariable &Var : TheModule->globals()) {
1072 if (!Var.hasName())
1073 CreateModuleSlot(&Var);
1074 processGlobalObjectMetadata(Var);
1075 auto Attrs = Var.getAttributes();
1076 if (Attrs.hasAttributes())
1077 CreateAttributeSetSlot(Attrs);
1078 }
1079
1080 for (const GlobalAlias &A : TheModule->aliases()) {
1081 if (!A.hasName())
1082 CreateModuleSlot(&A);
1083 }
1084
1085 for (const GlobalIFunc &I : TheModule->ifuncs()) {
1086 if (!I.hasName())
1087 CreateModuleSlot(&I);
1088 processGlobalObjectMetadata(I);
1089 }
1090
1091 // Add metadata used by named metadata.
1092 for (const NamedMDNode &NMD : TheModule->named_metadata()) {
1093 for (const MDNode *N : NMD.operands())
1094 CreateMetadataSlot(N);
1095 }
1096
1097 for (const Function &F : *TheModule) {
1098 if (!F.hasName())
1099 // Add all the unnamed functions to the table.
1100 CreateModuleSlot(&F);
1101
1102 if (ShouldInitializeAllMetadata)
1103 processFunctionMetadata(F);
1104
1105 // Add all the function attributes to the table.
1106 // FIXME: Add attributes of other objects?
1107 AttributeSet FnAttrs = F.getAttributes().getFnAttrs();
1108 if (FnAttrs.hasAttributes())
1109 CreateAttributeSetSlot(FnAttrs);
1110 }
1111
1112 if (ProcessModuleHookFn)
1113 ProcessModuleHookFn(this, TheModule, ShouldInitializeAllMetadata);
1114
1115 ST_DEBUG("end processModule!\n");
1116}
1117
1118// Process the arguments, basic blocks, and instructions of a function.
1119void SlotTracker::processFunction() {
1120 ST_DEBUG("begin processFunction!\n");
1121 fNext = 0;
1122
1123 // Process function metadata if it wasn't hit at the module-level.
1124 if (!ShouldInitializeAllMetadata)
1125 processFunctionMetadata(*TheFunction);
1126
1127 // Add all the function arguments with no names.
1128 for(Function::const_arg_iterator AI = TheFunction->arg_begin(),
1129 AE = TheFunction->arg_end(); AI != AE; ++AI)
1130 if (!AI->hasName())
1131 CreateFunctionSlot(&*AI);
1132
1133 ST_DEBUG("Inserting Instructions:\n");
1134
1135 // Add all of the basic blocks and instructions with no names.
1136 for (auto &BB : *TheFunction) {
1137 if (!BB.hasName())
1138 CreateFunctionSlot(&BB);
1139
1140 for (auto &I : BB) {
1141 if (!I.getType()->isVoidTy() && !I.hasName())
1142 CreateFunctionSlot(&I);
1143
1144 // We allow direct calls to any llvm.foo function here, because the
1145 // target may not be linked into the optimizer.
1146 if (const auto *Call = dyn_cast<CallBase>(&I)) {
1147 // Add all the call attributes to the table.
1148 AttributeSet Attrs = Call->getAttributes().getFnAttrs();
1149 if (Attrs.hasAttributes())
1150 CreateAttributeSetSlot(Attrs);
1151 }
1152 }
1153 }
1154
1155 if (ProcessFunctionHookFn)
1156 ProcessFunctionHookFn(this, TheFunction, ShouldInitializeAllMetadata);
1157
1158 FunctionProcessed = true;
1159
1160 ST_DEBUG("end processFunction!\n");
1161}
1162
1163// Iterate through all the GUID in the index and create slots for them.
1164int SlotTracker::processIndex() {
1165 ST_DEBUG("begin processIndex!\n");
1166 assert(TheIndex);
1167
1168 // The first block of slots are just the module ids, which start at 0 and are
1169 // assigned consecutively. Since the StringMap iteration order isn't
1170 // guaranteed, order by path string before assigning slots.
1171 std::vector<StringRef> ModulePaths;
1172 for (auto &[ModPath, _] : TheIndex->modulePaths())
1173 ModulePaths.push_back(ModPath);
1174 llvm::sort(ModulePaths);
1175 for (auto &ModPath : ModulePaths)
1176 CreateModulePathSlot(ModPath);
1177
1178 // Start numbering the GUIDs after the module ids.
1179 GUIDNext = ModulePathNext;
1180
1181 for (auto &GlobalList : *TheIndex)
1182 CreateGUIDSlot(GlobalList.first);
1183
1184 // Start numbering the TypeIdCompatibleVtables after the GUIDs.
1185 TypeIdCompatibleVtableNext = GUIDNext;
1186 for (auto &TId : TheIndex->typeIdCompatibleVtableMap())
1187 CreateTypeIdCompatibleVtableSlot(TId.first);
1188
1189 // Start numbering the TypeIds after the TypeIdCompatibleVtables.
1190 TypeIdNext = TypeIdCompatibleVtableNext;
1191 for (const auto &TID : TheIndex->typeIds())
1192 CreateTypeIdSlot(TID.second.first);
1193
1194 ST_DEBUG("end processIndex!\n");
1195 return TypeIdNext;
1196}
1197
1198void SlotTracker::processGlobalObjectMetadata(const GlobalObject &GO) {
1200 GO.getAllMetadata(MDs);
1201 for (auto &MD : MDs)
1202 CreateMetadataSlot(MD.second);
1203}
1204
1205void SlotTracker::processFunctionMetadata(const Function &F) {
1206 processGlobalObjectMetadata(F);
1207 for (auto &BB : F) {
1208 for (auto &I : BB) {
1209 for (const DbgRecord &DR : I.getDbgRecordRange())
1210 processDbgRecordMetadata(DR);
1211 processInstructionMetadata(I);
1212 }
1213 }
1214}
1215
1216void SlotTracker::processDbgRecordMetadata(const DbgRecord &DR) {
1217 // Tolerate null metadata pointers: it's a completely illegal debug record,
1218 // but we can have faulty metadata from debug-intrinsic days being
1219 // autoupgraded into debug records. This gets caught by the verifier, which
1220 // then will print the faulty IR, hitting this code path.
1221 if (const auto *DVR = dyn_cast<const DbgVariableRecord>(&DR)) {
1222 // Process metadata used by DbgRecords; we only specifically care about the
1223 // DILocalVariable, DILocation, and DIAssignID fields, as the Value and
1224 // Expression fields should only be printed inline and so do not use a slot.
1225 // Note: The above doesn't apply for empty-metadata operands.
1226 if (auto *Empty = dyn_cast_if_present<MDNode>(DVR->getRawLocation()))
1227 CreateMetadataSlot(Empty);
1228 if (DVR->getRawVariable())
1229 CreateMetadataSlot(DVR->getRawVariable());
1230 if (DVR->isDbgAssign()) {
1231 if (auto *AssignID = DVR->getRawAssignID())
1232 CreateMetadataSlot(cast<MDNode>(AssignID));
1233 if (auto *Empty = dyn_cast_if_present<MDNode>(DVR->getRawAddress()))
1234 CreateMetadataSlot(Empty);
1235 }
1236 } else if (const auto *DLR = dyn_cast<const DbgLabelRecord>(&DR)) {
1237 CreateMetadataSlot(DLR->getRawLabel());
1238 } else {
1239 llvm_unreachable("unsupported DbgRecord kind");
1240 }
1241 if (DR.getDebugLoc())
1242 CreateMetadataSlot(DR.getDebugLoc().getAsMDNode());
1243}
1244
1245void SlotTracker::processInstructionMetadata(const Instruction &I) {
1246 // Process metadata used directly by intrinsics.
1247 if (const auto *CI = dyn_cast<CallInst>(&I))
1248 if (Function *F = CI->getCalledFunction())
1249 if (F->isIntrinsic())
1250 for (auto &Op : I.operands())
1252 if (auto *N = dyn_cast<MDNode>(V->getMetadata()))
1253 CreateMetadataSlot(N);
1254
1255 // Process metadata attached to this instruction.
1257 I.getAllMetadata(MDs);
1258 for (auto &MD : MDs)
1259 CreateMetadataSlot(MD.second);
1260}
1261
1262/// Clean up after incorporating a function. This is the only way to get out of
1263/// the function incorporation state that affects get*Slot/Create*Slot. Function
1264/// incorporation state is indicated by TheFunction != 0.
1266 ST_DEBUG("begin purgeFunction!\n");
1267 fMap.clear(); // Simply discard the function level map
1268 TheFunction = nullptr;
1269 FunctionProcessed = false;
1270 ST_DEBUG("end purgeFunction!\n");
1271}
1272
1273/// getGlobalSlot - Get the slot number of a global value.
1275 // Check for uninitialized state and do lazy initialization.
1277
1278 // Find the value in the module map
1279 ValueMap::iterator MI = mMap.find(V);
1280 return MI == mMap.end() ? -1 : (int)MI->second;
1281}
1282
1284 std::function<void(AbstractSlotTrackerStorage *, const Module *, bool)>
1285 Fn) {
1286 ProcessModuleHookFn = Fn;
1287}
1288
1290 std::function<void(AbstractSlotTrackerStorage *, const Function *, bool)>
1291 Fn) {
1292 ProcessFunctionHookFn = Fn;
1293}
1294
1295/// getMetadataSlot - Get the slot number of a MDNode.
1296void SlotTracker::createMetadataSlot(const MDNode *N) { CreateMetadataSlot(N); }
1297
1298/// getMetadataSlot - Get the slot number of a MDNode.
1300 // Check for uninitialized state and do lazy initialization.
1302
1303 // Find the MDNode in the module map
1304 mdn_iterator MI = mdnMap.find(N);
1305 return MI == mdnMap.end() ? -1 : (int)MI->second;
1306}
1307
1308/// getLocalSlot - Get the slot number for a value that is local to a function.
1310 assert(!isa<Constant>(V) && "Can't get a constant or global slot with this!");
1311
1312 // Check for uninitialized state and do lazy initialization.
1314
1315 ValueMap::iterator FI = fMap.find(V);
1316 return FI == fMap.end() ? -1 : (int)FI->second;
1317}
1318
1320 // Check for uninitialized state and do lazy initialization.
1322
1323 // Find the AttributeSet in the module map.
1324 as_iterator AI = asMap.find(AS);
1325 return AI == asMap.end() ? -1 : (int)AI->second;
1326}
1327
1329 // Check for uninitialized state and do lazy initialization.
1331
1332 // Find the Module path in the map
1333 auto I = ModulePathMap.find(Path);
1334 return I == ModulePathMap.end() ? -1 : (int)I->second;
1335}
1336
1338 // Check for uninitialized state and do lazy initialization.
1340
1341 // Find the GUID in the map
1342 guid_iterator I = GUIDMap.find(GUID);
1343 return I == GUIDMap.end() ? -1 : (int)I->second;
1344}
1345
1347 // Check for uninitialized state and do lazy initialization.
1349
1350 // Find the TypeId string in the map
1351 auto I = TypeIdMap.find(Id);
1352 return I == TypeIdMap.end() ? -1 : (int)I->second;
1353}
1354
1356 // Check for uninitialized state and do lazy initialization.
1358
1359 // Find the TypeIdCompatibleVtable string in the map
1360 auto I = TypeIdCompatibleVtableMap.find(Id);
1361 return I == TypeIdCompatibleVtableMap.end() ? -1 : (int)I->second;
1362}
1363
1364/// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
1365void SlotTracker::CreateModuleSlot(const GlobalValue *V) {
1366 assert(V && "Can't insert a null Value into SlotTracker!");
1367 assert(!V->getType()->isVoidTy() && "Doesn't need a slot!");
1368 assert(!V->hasName() && "Doesn't need a slot!");
1369
1370 unsigned DestSlot = mNext++;
1371 mMap[V] = DestSlot;
1372
1373 ST_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" <<
1374 DestSlot << " [");
1375 // G = Global, F = Function, A = Alias, I = IFunc, o = other
1376 ST_DEBUG((isa<GlobalVariable>(V) ? 'G' :
1377 (isa<Function>(V) ? 'F' :
1378 (isa<GlobalAlias>(V) ? 'A' :
1379 (isa<GlobalIFunc>(V) ? 'I' : 'o')))) << "]\n");
1380}
1381
1382/// CreateSlot - Create a new slot for the specified value if it has no name.
1383void SlotTracker::CreateFunctionSlot(const Value *V) {
1384 assert(!V->getType()->isVoidTy() && !V->hasName() && "Doesn't need a slot!");
1385
1386 unsigned DestSlot = fNext++;
1387 fMap[V] = DestSlot;
1388
1389 // G = Global, F = Function, o = other
1390 ST_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" <<
1391 DestSlot << " [o]\n");
1392}
1393
1394/// CreateModuleSlot - Insert the specified MDNode* into the slot table.
1395void SlotTracker::CreateMetadataSlot(const MDNode *N) {
1396 assert(N && "Can't insert a null Value into SlotTracker!");
1397
1398 // Don't make slots for DIExpressions. We just print them inline everywhere.
1399 if (isa<DIExpression>(N))
1400 return;
1401
1402 unsigned DestSlot = mdnNext;
1403 if (!mdnMap.insert(std::make_pair(N, DestSlot)).second)
1404 return;
1405 ++mdnNext;
1406
1407 // Recursively add any MDNodes referenced by operands.
1408 for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
1409 if (const auto *Op = dyn_cast_or_null<MDNode>(N->getOperand(i)))
1410 CreateMetadataSlot(Op);
1411}
1412
1413void SlotTracker::CreateAttributeSetSlot(AttributeSet AS) {
1414 assert(AS.hasAttributes() && "Doesn't need a slot!");
1415
1416 if (asMap.try_emplace(AS, asNext).second)
1417 ++asNext;
1418}
1419
1420/// Create a new slot for the specified Module
1421void SlotTracker::CreateModulePathSlot(StringRef Path) {
1422 ModulePathMap[Path] = ModulePathNext++;
1423}
1424
1425/// Create a new slot for the specified GUID
1426void SlotTracker::CreateGUIDSlot(GlobalValue::GUID GUID) {
1427 GUIDMap[GUID] = GUIDNext++;
1428}
1429
1430/// Create a new slot for the specified Id
1431void SlotTracker::CreateTypeIdSlot(StringRef Id) {
1432 TypeIdMap[Id] = TypeIdNext++;
1433}
1434
1435/// Create a new slot for the specified Id
1436void SlotTracker::CreateTypeIdCompatibleVtableSlot(StringRef Id) {
1437 TypeIdCompatibleVtableMap[Id] = TypeIdCompatibleVtableNext++;
1438}
1439
1440namespace {
1441/// Common instances used by most of the printer functions.
1442struct AsmWriterContext {
1443 TypePrinting *TypePrinter = nullptr;
1444 SlotTracker *Machine = nullptr;
1445 const Module *Context = nullptr;
1446
1447 AsmWriterContext(TypePrinting *TP, SlotTracker *ST, const Module *M = nullptr)
1448 : TypePrinter(TP), Machine(ST), Context(M) {}
1449
1450 static AsmWriterContext &getEmpty() {
1451 static AsmWriterContext EmptyCtx(nullptr, nullptr);
1452 return EmptyCtx;
1453 }
1454
1455 /// A callback that will be triggered when the underlying printer
1456 /// prints a Metadata as operand.
1457 virtual void onWriteMetadataAsOperand(const Metadata *) {}
1458
1459 virtual ~AsmWriterContext() = default;
1460};
1461} // end anonymous namespace
1462
1463//===----------------------------------------------------------------------===//
1464// AsmWriter Implementation
1465//===----------------------------------------------------------------------===//
1466
1467static void writeAsOperandInternal(raw_ostream &Out, const Value *V,
1468 AsmWriterContext &WriterCtx,
1469 bool PrintType = false);
1470
1471static void writeAsOperandInternal(raw_ostream &Out, const Metadata *MD,
1472 AsmWriterContext &WriterCtx,
1473 bool FromValue = false);
1474
1475static void writeOptimizationInfo(raw_ostream &Out, const User *U) {
1476 if (const auto *FPO = dyn_cast<const FPMathOperator>(U))
1477 Out << FPO->getFastMathFlags();
1478
1479 if (const auto *OBO = dyn_cast<OverflowingBinaryOperator>(U)) {
1480 if (OBO->hasNoUnsignedWrap())
1481 Out << " nuw";
1482 if (OBO->hasNoSignedWrap())
1483 Out << " nsw";
1484 } else if (const auto *Div = dyn_cast<PossiblyExactOperator>(U)) {
1485 if (Div->isExact())
1486 Out << " exact";
1487 } else if (const auto *PDI = dyn_cast<PossiblyDisjointInst>(U)) {
1488 if (PDI->isDisjoint())
1489 Out << " disjoint";
1490 } else if (const auto *GEP = dyn_cast<GEPOperator>(U)) {
1491 if (GEP->isInBounds())
1492 Out << " inbounds";
1493 else if (GEP->hasNoUnsignedSignedWrap())
1494 Out << " nusw";
1495 if (GEP->hasNoUnsignedWrap())
1496 Out << " nuw";
1497 if (auto InRange = GEP->getInRange()) {
1498 Out << " inrange(" << InRange->getLower() << ", " << InRange->getUpper()
1499 << ")";
1500 }
1501 } else if (const auto *NNI = dyn_cast<PossiblyNonNegInst>(U)) {
1502 if (NNI->hasNonNeg())
1503 Out << " nneg";
1504 } else if (const auto *TI = dyn_cast<TruncInst>(U)) {
1505 if (TI->hasNoUnsignedWrap())
1506 Out << " nuw";
1507 if (TI->hasNoSignedWrap())
1508 Out << " nsw";
1509 } else if (const auto *ICmp = dyn_cast<ICmpInst>(U)) {
1510 if (ICmp->hasSameSign())
1511 Out << " samesign";
1512 }
1513}
1514
1515static void writeAPFloatInternal(raw_ostream &Out, const APFloat &APF) {
1516 if (&APF.getSemantics() == &APFloat::IEEEsingle() ||
1517 &APF.getSemantics() == &APFloat::IEEEdouble()) {
1518 // We would like to output the FP constant value in exponential notation,
1519 // but we cannot do this if doing so will lose precision. Check here to
1520 // make sure that we only output it in exponential format if we can parse
1521 // the value back and get the same value.
1522 //
1523 bool ignored;
1524 bool isDouble = &APF.getSemantics() == &APFloat::IEEEdouble();
1525 bool isInf = APF.isInfinity();
1526 bool isNaN = APF.isNaN();
1527
1528 if (!isInf && !isNaN) {
1529 double Val = APF.convertToDouble();
1530 SmallString<128> StrVal;
1531 APF.toString(StrVal, 6, 0, false);
1532 // Check to make sure that the stringized number is not some string like
1533 // "Inf" or NaN, that atof will accept, but the lexer will not. Check
1534 // that the string matches the "[-+]?[0-9]" regex.
1535 //
1536 assert((isDigit(StrVal[0]) ||
1537 ((StrVal[0] == '-' || StrVal[0] == '+') && isDigit(StrVal[1]))) &&
1538 "[-+]?[0-9] regex does not match!");
1539 // Reparse stringized version!
1540 if (APFloat(APFloat::IEEEdouble(), StrVal).convertToDouble() == Val) {
1541 Out << StrVal;
1542 return;
1543 }
1544 }
1545
1546 // Otherwise we could not reparse it to exactly the same value, so we must
1547 // output the string in hexadecimal format! Note that loading and storing
1548 // floating point types changes the bits of NaNs on some hosts, notably
1549 // x86, so we must not use these types.
1550 static_assert(sizeof(double) == sizeof(uint64_t),
1551 "assuming that double is 64 bits!");
1552 APFloat apf = APF;
1553
1554 // Floats are represented in ASCII IR as double, convert.
1555 // FIXME: We should allow 32-bit hex float and remove this.
1556 if (!isDouble) {
1557 // A signaling NaN is quieted on conversion, so we need to recreate the
1558 // expected value after convert (quiet bit of the payload is clear).
1559 bool IsSNAN = apf.isSignaling();
1561 &ignored);
1562 if (IsSNAN) {
1563 APInt Payload = apf.bitcastToAPInt();
1564 apf =
1566 }
1567 }
1568
1569 Out << format_hex(apf.bitcastToAPInt().getZExtValue(), 0, /*Upper=*/true);
1570 return;
1571 }
1572
1573 // Either half, bfloat or some form of long double.
1574 // These appear as a magic letter identifying the type, then a
1575 // fixed number of hex digits.
1576 Out << "0x";
1577 APInt API = APF.bitcastToAPInt();
1578 if (&APF.getSemantics() == &APFloat::x87DoubleExtended()) {
1579 Out << 'K';
1580 Out << format_hex_no_prefix(API.getHiBits(16).getZExtValue(), 4,
1581 /*Upper=*/true);
1582 Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
1583 /*Upper=*/true);
1584 } else if (&APF.getSemantics() == &APFloat::IEEEquad()) {
1585 Out << 'L';
1586 Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
1587 /*Upper=*/true);
1588 Out << format_hex_no_prefix(API.getHiBits(64).getZExtValue(), 16,
1589 /*Upper=*/true);
1590 } else if (&APF.getSemantics() == &APFloat::PPCDoubleDouble()) {
1591 Out << 'M';
1592 Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
1593 /*Upper=*/true);
1594 Out << format_hex_no_prefix(API.getHiBits(64).getZExtValue(), 16,
1595 /*Upper=*/true);
1596 } else if (&APF.getSemantics() == &APFloat::IEEEhalf()) {
1597 Out << 'H';
1598 Out << format_hex_no_prefix(API.getZExtValue(), 4,
1599 /*Upper=*/true);
1600 } else if (&APF.getSemantics() == &APFloat::BFloat()) {
1601 Out << 'R';
1602 Out << format_hex_no_prefix(API.getZExtValue(), 4,
1603 /*Upper=*/true);
1604 } else
1605 llvm_unreachable("Unsupported floating point type");
1606}
1607
1608static void writeConstantInternal(raw_ostream &Out, const Constant *CV,
1609 AsmWriterContext &WriterCtx) {
1610 if (const auto *CI = dyn_cast<ConstantInt>(CV)) {
1611 Type *Ty = CI->getType();
1612
1613 if (Ty->isVectorTy()) {
1614 Out << "splat (";
1615 WriterCtx.TypePrinter->print(Ty->getScalarType(), Out);
1616 Out << " ";
1617 }
1618
1619 if (Ty->getScalarType()->isIntegerTy(1))
1620 Out << (CI->getZExtValue() ? "true" : "false");
1621 else
1622 Out << CI->getValue();
1623
1624 if (Ty->isVectorTy())
1625 Out << ")";
1626
1627 return;
1628 }
1629
1630 if (const auto *CFP = dyn_cast<ConstantFP>(CV)) {
1631 Type *Ty = CFP->getType();
1632
1633 if (Ty->isVectorTy()) {
1634 Out << "splat (";
1635 WriterCtx.TypePrinter->print(Ty->getScalarType(), Out);
1636 Out << " ";
1637 }
1638
1639 writeAPFloatInternal(Out, CFP->getValueAPF());
1640
1641 if (Ty->isVectorTy())
1642 Out << ")";
1643
1644 return;
1645 }
1646
1648 Out << "zeroinitializer";
1649 return;
1650 }
1651
1652 if (const auto *BA = dyn_cast<BlockAddress>(CV)) {
1653 Out << "blockaddress(";
1654 writeAsOperandInternal(Out, BA->getFunction(), WriterCtx);
1655 Out << ", ";
1656 writeAsOperandInternal(Out, BA->getBasicBlock(), WriterCtx);
1657 Out << ")";
1658 return;
1659 }
1660
1661 if (const auto *Equiv = dyn_cast<DSOLocalEquivalent>(CV)) {
1662 Out << "dso_local_equivalent ";
1663 writeAsOperandInternal(Out, Equiv->getGlobalValue(), WriterCtx);
1664 return;
1665 }
1666
1667 if (const auto *NC = dyn_cast<NoCFIValue>(CV)) {
1668 Out << "no_cfi ";
1669 writeAsOperandInternal(Out, NC->getGlobalValue(), WriterCtx);
1670 return;
1671 }
1672
1673 if (const auto *CPA = dyn_cast<ConstantPtrAuth>(CV)) {
1674 Out << "ptrauth (";
1675
1676 // ptrauth (ptr CST, i32 KEY[, i64 DISC[, ptr ADDRDISC]?]?)
1677 unsigned NumOpsToWrite = 2;
1678 if (!CPA->getOperand(2)->isNullValue())
1679 NumOpsToWrite = 3;
1680 if (!CPA->getOperand(3)->isNullValue())
1681 NumOpsToWrite = 4;
1682
1683 ListSeparator LS;
1684 for (unsigned i = 0, e = NumOpsToWrite; i != e; ++i) {
1685 Out << LS;
1686 writeAsOperandInternal(Out, CPA->getOperand(i), WriterCtx,
1687 /*PrintType=*/true);
1688 }
1689 Out << ')';
1690 return;
1691 }
1692
1693 if (const auto *CA = dyn_cast<ConstantArray>(CV)) {
1694 Out << '[';
1695 ListSeparator LS;
1696 for (const Value *Op : CA->operands()) {
1697 Out << LS;
1698 writeAsOperandInternal(Out, Op, WriterCtx, /*PrintType=*/true);
1699 }
1700 Out << ']';
1701 return;
1702 }
1703
1704 if (const auto *CA = dyn_cast<ConstantDataArray>(CV)) {
1705 // As a special case, print the array as a string if it is an array of
1706 // i8 with ConstantInt values.
1707 if (CA->isString()) {
1708 Out << "c\"";
1709 printEscapedString(CA->getAsString(), Out);
1710 Out << '"';
1711 return;
1712 }
1713
1714 Out << '[';
1715 ListSeparator LS;
1716 for (uint64_t i = 0, e = CA->getNumElements(); i != e; ++i) {
1717 Out << LS;
1718 writeAsOperandInternal(Out, CA->getElementAsConstant(i), WriterCtx,
1719 /*PrintType=*/true);
1720 }
1721 Out << ']';
1722 return;
1723 }
1724
1725 if (const auto *CS = dyn_cast<ConstantStruct>(CV)) {
1726 if (CS->getType()->isPacked())
1727 Out << '<';
1728 Out << '{';
1729 if (CS->getNumOperands() != 0) {
1730 Out << ' ';
1731 ListSeparator LS;
1732 for (const Value *Op : CS->operands()) {
1733 Out << LS;
1734 writeAsOperandInternal(Out, Op, WriterCtx, /*PrintType=*/true);
1735 }
1736 Out << ' ';
1737 }
1738 Out << '}';
1739 if (CS->getType()->isPacked())
1740 Out << '>';
1741 return;
1742 }
1743
1745 auto *CVVTy = cast<FixedVectorType>(CV->getType());
1746
1747 // Use the same shorthand for splat vector (i.e. "splat(Ty val)") as is
1748 // permitted on IR input to reduce the output changes when enabling
1749 // UseConstant{Int,FP}ForFixedLengthSplat.
1750 // TODO: Remove this block when the UseConstant{Int,FP}ForFixedLengthSplat
1751 // options are removed.
1752 if (auto *SplatVal = CV->getSplatValue()) {
1753 if (isa<ConstantInt>(SplatVal) || isa<ConstantFP>(SplatVal)) {
1754 Out << "splat (";
1755 writeAsOperandInternal(Out, SplatVal, WriterCtx, /*PrintType=*/true);
1756 Out << ')';
1757 return;
1758 }
1759 }
1760
1761 Out << '<';
1762 ListSeparator LS;
1763 for (unsigned i = 0, e = CVVTy->getNumElements(); i != e; ++i) {
1764 Out << LS;
1765 writeAsOperandInternal(Out, CV->getAggregateElement(i), WriterCtx,
1766 /*PrintType=*/true);
1767 }
1768 Out << '>';
1769 return;
1770 }
1771
1772 if (isa<ConstantPointerNull>(CV)) {
1773 Out << "null";
1774 return;
1775 }
1776
1777 if (isa<ConstantTokenNone>(CV)) {
1778 Out << "none";
1779 return;
1780 }
1781
1782 if (isa<PoisonValue>(CV)) {
1783 Out << "poison";
1784 return;
1785 }
1786
1787 if (isa<UndefValue>(CV)) {
1788 Out << "undef";
1789 return;
1790 }
1791
1792 if (const auto *CE = dyn_cast<ConstantExpr>(CV)) {
1793 // Use the same shorthand for splat vector (i.e. "splat(Ty val)") as is
1794 // permitted on IR input to reduce the output changes when enabling
1795 // UseConstant{Int,FP}ForScalableSplat.
1796 // TODO: Remove this block when the UseConstant{Int,FP}ForScalableSplat
1797 // options are removed.
1798 if (CE->getOpcode() == Instruction::ShuffleVector) {
1799 if (auto *SplatVal = CE->getSplatValue()) {
1800 if (isa<ConstantInt>(SplatVal) || isa<ConstantFP>(SplatVal)) {
1801 Out << "splat (";
1802 writeAsOperandInternal(Out, SplatVal, WriterCtx, /*PrintType=*/true);
1803 Out << ')';
1804 return;
1805 }
1806 }
1807 }
1808
1809 Out << CE->getOpcodeName();
1810 writeOptimizationInfo(Out, CE);
1811 Out << " (";
1812
1813 if (const auto *GEP = dyn_cast<GEPOperator>(CE)) {
1814 WriterCtx.TypePrinter->print(GEP->getSourceElementType(), Out);
1815 Out << ", ";
1816 }
1817
1818 ListSeparator LS;
1819 for (const Value *Op : CE->operands()) {
1820 Out << LS;
1821 writeAsOperandInternal(Out, Op, WriterCtx, /*PrintType=*/true);
1822 }
1823
1824 if (CE->isCast()) {
1825 Out << " to ";
1826 WriterCtx.TypePrinter->print(CE->getType(), Out);
1827 }
1828
1829 if (CE->getOpcode() == Instruction::ShuffleVector)
1830 printShuffleMask(Out, CE->getType(), CE->getShuffleMask());
1831
1832 Out << ')';
1833 return;
1834 }
1835
1836 Out << "<placeholder or erroneous Constant>";
1837}
1838
1839static void writeMDTuple(raw_ostream &Out, const MDTuple *Node,
1840 AsmWriterContext &WriterCtx) {
1841 Out << "!{";
1842 ListSeparator LS;
1843 for (const Metadata *MD : Node->operands()) {
1844 Out << LS;
1845 if (!MD) {
1846 Out << "null";
1847 } else if (auto *MDV = dyn_cast<ValueAsMetadata>(MD)) {
1848 Value *V = MDV->getValue();
1849 writeAsOperandInternal(Out, V, WriterCtx, /*PrintType=*/true);
1850 } else {
1851 writeAsOperandInternal(Out, MD, WriterCtx);
1852 WriterCtx.onWriteMetadataAsOperand(MD);
1853 }
1854 }
1855
1856 Out << "}";
1857}
1858
1859namespace {
1860
1861struct MDFieldPrinter {
1862 raw_ostream &Out;
1863 ListSeparator FS;
1864 AsmWriterContext &WriterCtx;
1865
1866 explicit MDFieldPrinter(raw_ostream &Out)
1867 : Out(Out), WriterCtx(AsmWriterContext::getEmpty()) {}
1868 MDFieldPrinter(raw_ostream &Out, AsmWriterContext &Ctx)
1869 : Out(Out), WriterCtx(Ctx) {}
1870
1871 void printTag(const DINode *N);
1872 void printMacinfoType(const DIMacroNode *N);
1873 void printChecksum(const DIFile::ChecksumInfo<StringRef> &N);
1874 void printString(StringRef Name, StringRef Value,
1875 bool ShouldSkipEmpty = true);
1876 void printMetadata(StringRef Name, const Metadata *MD,
1877 bool ShouldSkipNull = true);
1878 void printMetadataOrInt(StringRef Name, const Metadata *MD, bool IsUnsigned,
1879 bool ShouldSkipZero = true);
1880 template <class IntTy>
1881 void printInt(StringRef Name, IntTy Int, bool ShouldSkipZero = true);
1882 void printAPInt(StringRef Name, const APInt &Int, bool IsUnsigned,
1883 bool ShouldSkipZero);
1884 void printBool(StringRef Name, bool Value,
1885 std::optional<bool> Default = std::nullopt);
1886 void printDIFlags(StringRef Name, DINode::DIFlags Flags);
1887 void printDISPFlags(StringRef Name, DISubprogram::DISPFlags Flags);
1888 template <class IntTy, class Stringifier>
1889 void printDwarfEnum(StringRef Name, IntTy Value, Stringifier toString,
1890 bool ShouldSkipZero = true);
1891 void printEmissionKind(StringRef Name, DICompileUnit::DebugEmissionKind EK);
1892 void printNameTableKind(StringRef Name,
1894 void printFixedPointKind(StringRef Name, DIFixedPointType::FixedPointKind V);
1895};
1896
1897} // end anonymous namespace
1898
1899void MDFieldPrinter::printTag(const DINode *N) {
1900 Out << FS << "tag: ";
1901 auto Tag = dwarf::TagString(N->getTag());
1902 if (!Tag.empty())
1903 Out << Tag;
1904 else
1905 Out << N->getTag();
1906}
1907
1908void MDFieldPrinter::printMacinfoType(const DIMacroNode *N) {
1909 Out << FS << "type: ";
1910 auto Type = dwarf::MacinfoString(N->getMacinfoType());
1911 if (!Type.empty())
1912 Out << Type;
1913 else
1914 Out << N->getMacinfoType();
1915}
1916
1917void MDFieldPrinter::printChecksum(
1918 const DIFile::ChecksumInfo<StringRef> &Checksum) {
1919 Out << FS << "checksumkind: " << Checksum.getKindAsString();
1920 printString("checksum", Checksum.Value, /* ShouldSkipEmpty */ false);
1921}
1922
1923void MDFieldPrinter::printString(StringRef Name, StringRef Value,
1924 bool ShouldSkipEmpty) {
1925 if (ShouldSkipEmpty && Value.empty())
1926 return;
1927
1928 Out << FS << Name << ": \"";
1930 Out << "\"";
1931}
1932
1933static void writeMetadataAsOperand(raw_ostream &Out, const Metadata *MD,
1934 AsmWriterContext &WriterCtx) {
1935 if (!MD) {
1936 Out << "null";
1937 return;
1938 }
1939 writeAsOperandInternal(Out, MD, WriterCtx);
1940 WriterCtx.onWriteMetadataAsOperand(MD);
1941}
1942
1943void MDFieldPrinter::printMetadata(StringRef Name, const Metadata *MD,
1944 bool ShouldSkipNull) {
1945 if (ShouldSkipNull && !MD)
1946 return;
1947
1948 Out << FS << Name << ": ";
1949 writeMetadataAsOperand(Out, MD, WriterCtx);
1950}
1951
1952void MDFieldPrinter::printMetadataOrInt(StringRef Name, const Metadata *MD,
1953 bool IsUnsigned, bool ShouldSkipZero) {
1954 if (!MD)
1955 return;
1956
1957 if (auto *CI = dyn_cast<ConstantAsMetadata>(MD)) {
1958 auto *CV = cast<ConstantInt>(CI->getValue());
1959 if (IsUnsigned)
1960 printInt(Name, CV->getZExtValue(), ShouldSkipZero);
1961 else
1962 printInt(Name, CV->getSExtValue(), ShouldSkipZero);
1963 } else
1964 printMetadata(Name, MD);
1965}
1966
1967template <class IntTy>
1968void MDFieldPrinter::printInt(StringRef Name, IntTy Int, bool ShouldSkipZero) {
1969 if (ShouldSkipZero && !Int)
1970 return;
1971
1972 Out << FS << Name << ": " << Int;
1973}
1974
1975void MDFieldPrinter::printAPInt(StringRef Name, const APInt &Int,
1976 bool IsUnsigned, bool ShouldSkipZero) {
1977 if (ShouldSkipZero && Int.isZero())
1978 return;
1979
1980 Out << FS << Name << ": ";
1981 Int.print(Out, !IsUnsigned);
1982}
1983
1984void MDFieldPrinter::printBool(StringRef Name, bool Value,
1985 std::optional<bool> Default) {
1986 if (Default && Value == *Default)
1987 return;
1988 Out << FS << Name << ": " << (Value ? "true" : "false");
1989}
1990
1991void MDFieldPrinter::printDIFlags(StringRef Name, DINode::DIFlags Flags) {
1992 if (!Flags)
1993 return;
1994
1995 Out << FS << Name << ": ";
1996
1998 auto Extra = DINode::splitFlags(Flags, SplitFlags);
1999
2000 ListSeparator FlagsFS(" | ");
2001 for (auto F : SplitFlags) {
2002 auto StringF = DINode::getFlagString(F);
2003 assert(!StringF.empty() && "Expected valid flag");
2004 Out << FlagsFS << StringF;
2005 }
2006 if (Extra || SplitFlags.empty())
2007 Out << FlagsFS << Extra;
2008}
2009
2010void MDFieldPrinter::printDISPFlags(StringRef Name,
2012 // Always print this field, because no flags in the IR at all will be
2013 // interpreted as old-style isDefinition: true.
2014 Out << FS << Name << ": ";
2015
2016 if (!Flags) {
2017 Out << 0;
2018 return;
2019 }
2020
2022 auto Extra = DISubprogram::splitFlags(Flags, SplitFlags);
2023
2024 ListSeparator FlagsFS(" | ");
2025 for (auto F : SplitFlags) {
2026 auto StringF = DISubprogram::getFlagString(F);
2027 assert(!StringF.empty() && "Expected valid flag");
2028 Out << FlagsFS << StringF;
2029 }
2030 if (Extra || SplitFlags.empty())
2031 Out << FlagsFS << Extra;
2032}
2033
2034void MDFieldPrinter::printEmissionKind(StringRef Name,
2036 Out << FS << Name << ": " << DICompileUnit::emissionKindString(EK);
2037}
2038
2039void MDFieldPrinter::printNameTableKind(StringRef Name,
2042 return;
2043 Out << FS << Name << ": " << DICompileUnit::nameTableKindString(NTK);
2044}
2045
2046void MDFieldPrinter::printFixedPointKind(StringRef Name,
2048 Out << FS << Name << ": " << DIFixedPointType::fixedPointKindString(V);
2049}
2050
2051template <class IntTy, class Stringifier>
2052void MDFieldPrinter::printDwarfEnum(StringRef Name, IntTy Value,
2053 Stringifier toString, bool ShouldSkipZero) {
2054 if (ShouldSkipZero && !Value)
2055 return;
2056
2057 Out << FS << Name << ": ";
2058 auto S = toString(Value);
2059 if (!S.empty())
2060 Out << S;
2061 else
2062 Out << Value;
2063}
2064
2066 AsmWriterContext &WriterCtx) {
2067 Out << "!GenericDINode(";
2068 MDFieldPrinter Printer(Out, WriterCtx);
2069 Printer.printTag(N);
2070 Printer.printString("header", N->getHeader());
2071 if (N->getNumDwarfOperands()) {
2072 Out << Printer.FS << "operands: {";
2073 ListSeparator IFS;
2074 for (auto &I : N->dwarf_operands()) {
2075 Out << IFS;
2076 writeMetadataAsOperand(Out, I, WriterCtx);
2077 }
2078 Out << "}";
2079 }
2080 Out << ")";
2081}
2082
2083static void writeDILocation(raw_ostream &Out, const DILocation *DL,
2084 AsmWriterContext &WriterCtx) {
2085 Out << "!DILocation(";
2086 MDFieldPrinter Printer(Out, WriterCtx);
2087 // Always output the line, since 0 is a relevant and important value for it.
2088 Printer.printInt("line", DL->getLine(), /* ShouldSkipZero */ false);
2089 Printer.printInt("column", DL->getColumn());
2090 Printer.printMetadata("scope", DL->getRawScope(), /* ShouldSkipNull */ false);
2091 Printer.printMetadata("inlinedAt", DL->getRawInlinedAt());
2092 Printer.printBool("isImplicitCode", DL->isImplicitCode(),
2093 /* Default */ false);
2094 Printer.printInt("atomGroup", DL->getAtomGroup());
2095 Printer.printInt<unsigned>("atomRank", DL->getAtomRank());
2096 Out << ")";
2097}
2098
2099static void writeDIAssignID(raw_ostream &Out, const DIAssignID *DL,
2100 AsmWriterContext &WriterCtx) {
2101 Out << "!DIAssignID()";
2102 MDFieldPrinter Printer(Out, WriterCtx);
2103}
2104
2105static void writeDISubrange(raw_ostream &Out, const DISubrange *N,
2106 AsmWriterContext &WriterCtx) {
2107 Out << "!DISubrange(";
2108 MDFieldPrinter Printer(Out, WriterCtx);
2109
2110 Printer.printMetadataOrInt("count", N->getRawCountNode(),
2111 /* IsUnsigned */ false,
2112 /* ShouldSkipZero */ false);
2113
2114 // A lowerBound of constant 0 should not be skipped, since it is different
2115 // from an unspecified lower bound (= nullptr).
2116 Printer.printMetadataOrInt("lowerBound", N->getRawLowerBound(),
2117 /* IsUnsigned */ false,
2118 /* ShouldSkipZero */ false);
2119 Printer.printMetadataOrInt("upperBound", N->getRawUpperBound(),
2120 /* IsUnsigned */ false,
2121 /* ShouldSkipZero */ false);
2122 Printer.printMetadataOrInt("stride", N->getRawStride(),
2123 /* IsUnsigned */ false,
2124 /* ShouldSkipZero */ false);
2125
2126 Out << ")";
2127}
2128
2130 AsmWriterContext &WriterCtx) {
2131 Out << "!DIGenericSubrange(";
2132 MDFieldPrinter Printer(Out, WriterCtx);
2133
2134 auto GetConstant = [&](Metadata *Bound) -> std::optional<int64_t> {
2135 auto *BE = dyn_cast_or_null<DIExpression>(Bound);
2136 if (!BE)
2137 return std::nullopt;
2138 if (BE->isConstant() &&
2140 *BE->isConstant()) {
2141 return static_cast<int64_t>(BE->getElement(1));
2142 }
2143 return std::nullopt;
2144 };
2145
2146 auto *Count = N->getRawCountNode();
2147 if (auto ConstantCount = GetConstant(Count))
2148 Printer.printInt("count", *ConstantCount,
2149 /* ShouldSkipZero */ false);
2150 else
2151 Printer.printMetadata("count", Count, /*ShouldSkipNull */ true);
2152
2153 auto *LBound = N->getRawLowerBound();
2154 if (auto ConstantLBound = GetConstant(LBound))
2155 Printer.printInt("lowerBound", *ConstantLBound,
2156 /* ShouldSkipZero */ false);
2157 else
2158 Printer.printMetadata("lowerBound", LBound, /*ShouldSkipNull */ true);
2159
2160 auto *UBound = N->getRawUpperBound();
2161 if (auto ConstantUBound = GetConstant(UBound))
2162 Printer.printInt("upperBound", *ConstantUBound,
2163 /* ShouldSkipZero */ false);
2164 else
2165 Printer.printMetadata("upperBound", UBound, /*ShouldSkipNull */ true);
2166
2167 auto *Stride = N->getRawStride();
2168 if (auto ConstantStride = GetConstant(Stride))
2169 Printer.printInt("stride", *ConstantStride,
2170 /* ShouldSkipZero */ false);
2171 else
2172 Printer.printMetadata("stride", Stride, /*ShouldSkipNull */ true);
2173
2174 Out << ")";
2175}
2176
2178 AsmWriterContext &) {
2179 Out << "!DIEnumerator(";
2180 MDFieldPrinter Printer(Out);
2181 Printer.printString("name", N->getName(), /* ShouldSkipEmpty */ false);
2182 Printer.printAPInt("value", N->getValue(), N->isUnsigned(),
2183 /*ShouldSkipZero=*/false);
2184 if (N->isUnsigned())
2185 Printer.printBool("isUnsigned", true);
2186 Out << ")";
2187}
2188
2190 AsmWriterContext &WriterCtx) {
2191 Out << "!DIBasicType(";
2192 MDFieldPrinter Printer(Out, WriterCtx);
2193 if (N->getTag() != dwarf::DW_TAG_base_type)
2194 Printer.printTag(N);
2195 Printer.printString("name", N->getName());
2196 Printer.printMetadataOrInt("size", N->getRawSizeInBits(), true);
2197 Printer.printInt("align", N->getAlignInBits());
2198 Printer.printDwarfEnum("encoding", N->getEncoding(),
2200 Printer.printInt("num_extra_inhabitants", N->getNumExtraInhabitants());
2201 Printer.printDIFlags("flags", N->getFlags());
2202 Out << ")";
2203}
2204
2206 AsmWriterContext &WriterCtx) {
2207 Out << "!DIFixedPointType(";
2208 MDFieldPrinter Printer(Out, WriterCtx);
2209 if (N->getTag() != dwarf::DW_TAG_base_type)
2210 Printer.printTag(N);
2211 Printer.printString("name", N->getName());
2212 Printer.printMetadataOrInt("size", N->getRawSizeInBits(), true);
2213 Printer.printInt("align", N->getAlignInBits());
2214 Printer.printDwarfEnum("encoding", N->getEncoding(),
2216 Printer.printDIFlags("flags", N->getFlags());
2217 Printer.printFixedPointKind("kind", N->getKind());
2218 if (N->isRational()) {
2219 bool IsUnsigned = !N->isSigned();
2220 Printer.printAPInt("numerator", N->getNumerator(), IsUnsigned, false);
2221 Printer.printAPInt("denominator", N->getDenominator(), IsUnsigned, false);
2222 } else {
2223 Printer.printInt("factor", N->getFactor());
2224 }
2225 Out << ")";
2226}
2227
2229 AsmWriterContext &WriterCtx) {
2230 Out << "!DIStringType(";
2231 MDFieldPrinter Printer(Out, WriterCtx);
2232 if (N->getTag() != dwarf::DW_TAG_string_type)
2233 Printer.printTag(N);
2234 Printer.printString("name", N->getName());
2235 Printer.printMetadata("stringLength", N->getRawStringLength());
2236 Printer.printMetadata("stringLengthExpression", N->getRawStringLengthExp());
2237 Printer.printMetadata("stringLocationExpression",
2238 N->getRawStringLocationExp());
2239 Printer.printMetadataOrInt("size", N->getRawSizeInBits(), true);
2240 Printer.printInt("align", N->getAlignInBits());
2241 Printer.printDwarfEnum("encoding", N->getEncoding(),
2243 Out << ")";
2244}
2245
2247 AsmWriterContext &WriterCtx) {
2248 Out << "!DIDerivedType(";
2249 MDFieldPrinter Printer(Out, WriterCtx);
2250 Printer.printTag(N);
2251 Printer.printString("name", N->getName());
2252 Printer.printMetadata("scope", N->getRawScope());
2253 Printer.printMetadata("file", N->getRawFile());
2254 Printer.printInt("line", N->getLine());
2255 Printer.printMetadata("baseType", N->getRawBaseType(),
2256 /* ShouldSkipNull */ false);
2257 Printer.printMetadataOrInt("size", N->getRawSizeInBits(), true);
2258 Printer.printInt("align", N->getAlignInBits());
2259 Printer.printMetadataOrInt("offset", N->getRawOffsetInBits(), true);
2260 Printer.printDIFlags("flags", N->getFlags());
2261 Printer.printMetadata("extraData", N->getRawExtraData());
2262 if (const auto &DWARFAddressSpace = N->getDWARFAddressSpace())
2263 Printer.printInt("dwarfAddressSpace", *DWARFAddressSpace,
2264 /* ShouldSkipZero */ false);
2265 Printer.printMetadata("annotations", N->getRawAnnotations());
2266 if (auto PtrAuthData = N->getPtrAuthData()) {
2267 Printer.printInt("ptrAuthKey", PtrAuthData->key());
2268 Printer.printBool("ptrAuthIsAddressDiscriminated",
2269 PtrAuthData->isAddressDiscriminated());
2270 Printer.printInt("ptrAuthExtraDiscriminator",
2271 PtrAuthData->extraDiscriminator());
2272 Printer.printBool("ptrAuthIsaPointer", PtrAuthData->isaPointer());
2273 Printer.printBool("ptrAuthAuthenticatesNullValues",
2274 PtrAuthData->authenticatesNullValues());
2275 }
2276 Out << ")";
2277}
2278
2280 AsmWriterContext &WriterCtx) {
2281 Out << "!DISubrangeType(";
2282 MDFieldPrinter Printer(Out, WriterCtx);
2283 Printer.printString("name", N->getName());
2284 Printer.printMetadata("scope", N->getRawScope());
2285 Printer.printMetadata("file", N->getRawFile());
2286 Printer.printInt("line", N->getLine());
2287 Printer.printMetadataOrInt("size", N->getRawSizeInBits(), true);
2288 Printer.printInt("align", N->getAlignInBits());
2289 Printer.printDIFlags("flags", N->getFlags());
2290 Printer.printMetadata("baseType", N->getRawBaseType(),
2291 /* ShouldSkipNull */ false);
2292 Printer.printMetadata("lowerBound", N->getRawLowerBound());
2293 Printer.printMetadata("upperBound", N->getRawUpperBound());
2294 Printer.printMetadata("stride", N->getRawStride());
2295 Printer.printMetadata("bias", N->getRawBias());
2296 Out << ")";
2297}
2298
2300 AsmWriterContext &WriterCtx) {
2301 Out << "!DICompositeType(";
2302 MDFieldPrinter Printer(Out, WriterCtx);
2303 Printer.printTag(N);
2304 Printer.printString("name", N->getName());
2305 Printer.printMetadata("scope", N->getRawScope());
2306 Printer.printMetadata("file", N->getRawFile());
2307 Printer.printInt("line", N->getLine());
2308 Printer.printMetadata("baseType", N->getRawBaseType());
2309 Printer.printMetadataOrInt("size", N->getRawSizeInBits(), true);
2310 Printer.printInt("align", N->getAlignInBits());
2311 Printer.printMetadataOrInt("offset", N->getRawOffsetInBits(), true);
2312 Printer.printInt("num_extra_inhabitants", N->getNumExtraInhabitants());
2313 Printer.printDIFlags("flags", N->getFlags());
2314 Printer.printMetadata("elements", N->getRawElements());
2315 Printer.printDwarfEnum("runtimeLang", N->getRuntimeLang(),
2317 Printer.printMetadata("vtableHolder", N->getRawVTableHolder());
2318 Printer.printMetadata("templateParams", N->getRawTemplateParams());
2319 Printer.printString("identifier", N->getIdentifier());
2320 Printer.printMetadata("discriminator", N->getRawDiscriminator());
2321 Printer.printMetadata("dataLocation", N->getRawDataLocation());
2322 Printer.printMetadata("associated", N->getRawAssociated());
2323 Printer.printMetadata("allocated", N->getRawAllocated());
2324 if (auto *RankConst = N->getRankConst())
2325 Printer.printInt("rank", RankConst->getSExtValue(),
2326 /* ShouldSkipZero */ false);
2327 else
2328 Printer.printMetadata("rank", N->getRawRank(), /*ShouldSkipNull */ true);
2329 Printer.printMetadata("annotations", N->getRawAnnotations());
2330 if (auto *Specification = N->getRawSpecification())
2331 Printer.printMetadata("specification", Specification);
2332
2333 if (auto EnumKind = N->getEnumKind())
2334 Printer.printDwarfEnum("enumKind", *EnumKind, dwarf::EnumKindString,
2335 /*ShouldSkipZero=*/false);
2336
2337 Printer.printMetadata("bitStride", N->getRawBitStride());
2338 Out << ")";
2339}
2340
2342 AsmWriterContext &WriterCtx) {
2343 Out << "!DISubroutineType(";
2344 MDFieldPrinter Printer(Out, WriterCtx);
2345 Printer.printDIFlags("flags", N->getFlags());
2346 Printer.printDwarfEnum("cc", N->getCC(), dwarf::ConventionString);
2347 Printer.printMetadata("types", N->getRawTypeArray(),
2348 /* ShouldSkipNull */ false);
2349 Out << ")";
2350}
2351
2352static void writeDIFile(raw_ostream &Out, const DIFile *N, AsmWriterContext &) {
2353 Out << "!DIFile(";
2354 MDFieldPrinter Printer(Out);
2355 Printer.printString("filename", N->getFilename(),
2356 /* ShouldSkipEmpty */ false);
2357 Printer.printString("directory", N->getDirectory(),
2358 /* ShouldSkipEmpty */ false);
2359 // Print all values for checksum together, or not at all.
2360 if (N->getChecksum())
2361 Printer.printChecksum(*N->getChecksum());
2362 if (N->getSource())
2363 Printer.printString("source", *N->getSource(),
2364 /* ShouldSkipEmpty */ false);
2365 Out << ")";
2366}
2367
2369 AsmWriterContext &WriterCtx) {
2370 Out << "!DICompileUnit(";
2371 MDFieldPrinter Printer(Out, WriterCtx);
2372 Printer.printDwarfEnum("language", N->getSourceLanguage(),
2373 dwarf::LanguageString, /* ShouldSkipZero */ false);
2374 Printer.printMetadata("file", N->getRawFile(), /* ShouldSkipNull */ false);
2375 Printer.printString("producer", N->getProducer());
2376 Printer.printBool("isOptimized", N->isOptimized());
2377 Printer.printString("flags", N->getFlags());
2378 Printer.printInt("runtimeVersion", N->getRuntimeVersion(),
2379 /* ShouldSkipZero */ false);
2380 Printer.printString("splitDebugFilename", N->getSplitDebugFilename());
2381 Printer.printEmissionKind("emissionKind", N->getEmissionKind());
2382 Printer.printMetadata("enums", N->getRawEnumTypes());
2383 Printer.printMetadata("retainedTypes", N->getRawRetainedTypes());
2384 Printer.printMetadata("globals", N->getRawGlobalVariables());
2385 Printer.printMetadata("imports", N->getRawImportedEntities());
2386 Printer.printMetadata("macros", N->getRawMacros());
2387 Printer.printInt("dwoId", N->getDWOId());
2388 Printer.printBool("splitDebugInlining", N->getSplitDebugInlining(), true);
2389 Printer.printBool("debugInfoForProfiling", N->getDebugInfoForProfiling(),
2390 false);
2391 Printer.printNameTableKind("nameTableKind", N->getNameTableKind());
2392 Printer.printBool("rangesBaseAddress", N->getRangesBaseAddress(), false);
2393 Printer.printString("sysroot", N->getSysRoot());
2394 Printer.printString("sdk", N->getSDK());
2395 Out << ")";
2396}
2397
2399 AsmWriterContext &WriterCtx) {
2400 Out << "!DISubprogram(";
2401 MDFieldPrinter Printer(Out, WriterCtx);
2402 Printer.printString("name", N->getName());
2403 Printer.printString("linkageName", N->getLinkageName());
2404 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2405 Printer.printMetadata("file", N->getRawFile());
2406 Printer.printInt("line", N->getLine());
2407 Printer.printMetadata("type", N->getRawType());
2408 Printer.printInt("scopeLine", N->getScopeLine());
2409 Printer.printMetadata("containingType", N->getRawContainingType());
2410 if (N->getVirtuality() != dwarf::DW_VIRTUALITY_none ||
2411 N->getVirtualIndex() != 0)
2412 Printer.printInt("virtualIndex", N->getVirtualIndex(), false);
2413 Printer.printInt("thisAdjustment", N->getThisAdjustment());
2414 Printer.printDIFlags("flags", N->getFlags());
2415 Printer.printDISPFlags("spFlags", N->getSPFlags());
2416 Printer.printMetadata("unit", N->getRawUnit());
2417 Printer.printMetadata("templateParams", N->getRawTemplateParams());
2418 Printer.printMetadata("declaration", N->getRawDeclaration());
2419 Printer.printMetadata("retainedNodes", N->getRawRetainedNodes());
2420 Printer.printMetadata("thrownTypes", N->getRawThrownTypes());
2421 Printer.printMetadata("annotations", N->getRawAnnotations());
2422 Printer.printString("targetFuncName", N->getTargetFuncName());
2423 Printer.printBool("keyInstructions", N->getKeyInstructionsEnabled(), false);
2424 Out << ")";
2425}
2426
2428 AsmWriterContext &WriterCtx) {
2429 Out << "!DILexicalBlock(";
2430 MDFieldPrinter Printer(Out, WriterCtx);
2431 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2432 Printer.printMetadata("file", N->getRawFile());
2433 Printer.printInt("line", N->getLine());
2434 Printer.printInt("column", N->getColumn());
2435 Out << ")";
2436}
2437
2439 const DILexicalBlockFile *N,
2440 AsmWriterContext &WriterCtx) {
2441 Out << "!DILexicalBlockFile(";
2442 MDFieldPrinter Printer(Out, WriterCtx);
2443 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2444 Printer.printMetadata("file", N->getRawFile());
2445 Printer.printInt("discriminator", N->getDiscriminator(),
2446 /* ShouldSkipZero */ false);
2447 Out << ")";
2448}
2449
2451 AsmWriterContext &WriterCtx) {
2452 Out << "!DINamespace(";
2453 MDFieldPrinter Printer(Out, WriterCtx);
2454 Printer.printString("name", N->getName());
2455 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2456 Printer.printBool("exportSymbols", N->getExportSymbols(), false);
2457 Out << ")";
2458}
2459
2461 AsmWriterContext &WriterCtx) {
2462 Out << "!DICommonBlock(";
2463 MDFieldPrinter Printer(Out, WriterCtx);
2464 Printer.printMetadata("scope", N->getRawScope(), false);
2465 Printer.printMetadata("declaration", N->getRawDecl(), false);
2466 Printer.printString("name", N->getName());
2467 Printer.printMetadata("file", N->getRawFile());
2468 Printer.printInt("line", N->getLineNo());
2469 Out << ")";
2470}
2471
2472static void writeDIMacro(raw_ostream &Out, const DIMacro *N,
2473 AsmWriterContext &WriterCtx) {
2474 Out << "!DIMacro(";
2475 MDFieldPrinter Printer(Out, WriterCtx);
2476 Printer.printMacinfoType(N);
2477 Printer.printInt("line", N->getLine());
2478 Printer.printString("name", N->getName());
2479 Printer.printString("value", N->getValue());
2480 Out << ")";
2481}
2482
2484 AsmWriterContext &WriterCtx) {
2485 Out << "!DIMacroFile(";
2486 MDFieldPrinter Printer(Out, WriterCtx);
2487 Printer.printInt("line", N->getLine());
2488 Printer.printMetadata("file", N->getRawFile(), /* ShouldSkipNull */ false);
2489 Printer.printMetadata("nodes", N->getRawElements());
2490 Out << ")";
2491}
2492
2493static void writeDIModule(raw_ostream &Out, const DIModule *N,
2494 AsmWriterContext &WriterCtx) {
2495 Out << "!DIModule(";
2496 MDFieldPrinter Printer(Out, WriterCtx);
2497 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2498 Printer.printString("name", N->getName());
2499 Printer.printString("configMacros", N->getConfigurationMacros());
2500 Printer.printString("includePath", N->getIncludePath());
2501 Printer.printString("apinotes", N->getAPINotesFile());
2502 Printer.printMetadata("file", N->getRawFile());
2503 Printer.printInt("line", N->getLineNo());
2504 Printer.printBool("isDecl", N->getIsDecl(), /* Default */ false);
2505 Out << ")";
2506}
2507
2510 AsmWriterContext &WriterCtx) {
2511 Out << "!DITemplateTypeParameter(";
2512 MDFieldPrinter Printer(Out, WriterCtx);
2513 Printer.printString("name", N->getName());
2514 Printer.printMetadata("type", N->getRawType(), /* ShouldSkipNull */ false);
2515 Printer.printBool("defaulted", N->isDefault(), /* Default= */ false);
2516 Out << ")";
2517}
2518
2521 AsmWriterContext &WriterCtx) {
2522 Out << "!DITemplateValueParameter(";
2523 MDFieldPrinter Printer(Out, WriterCtx);
2524 if (N->getTag() != dwarf::DW_TAG_template_value_parameter)
2525 Printer.printTag(N);
2526 Printer.printString("name", N->getName());
2527 Printer.printMetadata("type", N->getRawType());
2528 Printer.printBool("defaulted", N->isDefault(), /* Default= */ false);
2529 Printer.printMetadata("value", N->getValue(), /* ShouldSkipNull */ false);
2530 Out << ")";
2531}
2532
2534 AsmWriterContext &WriterCtx) {
2535 Out << "!DIGlobalVariable(";
2536 MDFieldPrinter Printer(Out, WriterCtx);
2537 Printer.printString("name", N->getName());
2538 Printer.printString("linkageName", N->getLinkageName());
2539 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2540 Printer.printMetadata("file", N->getRawFile());
2541 Printer.printInt("line", N->getLine());
2542 Printer.printMetadata("type", N->getRawType());
2543 Printer.printBool("isLocal", N->isLocalToUnit());
2544 Printer.printBool("isDefinition", N->isDefinition());
2545 Printer.printMetadata("declaration", N->getRawStaticDataMemberDeclaration());
2546 Printer.printMetadata("templateParams", N->getRawTemplateParams());
2547 Printer.printInt("align", N->getAlignInBits());
2548 Printer.printMetadata("annotations", N->getRawAnnotations());
2549 Out << ")";
2550}
2551
2553 AsmWriterContext &WriterCtx) {
2554 Out << "!DILocalVariable(";
2555 MDFieldPrinter Printer(Out, WriterCtx);
2556 Printer.printString("name", N->getName());
2557 Printer.printInt("arg", N->getArg());
2558 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2559 Printer.printMetadata("file", N->getRawFile());
2560 Printer.printInt("line", N->getLine());
2561 Printer.printMetadata("type", N->getRawType());
2562 Printer.printDIFlags("flags", N->getFlags());
2563 Printer.printInt("align", N->getAlignInBits());
2564 Printer.printMetadata("annotations", N->getRawAnnotations());
2565 Out << ")";
2566}
2567
2568static void writeDILabel(raw_ostream &Out, const DILabel *N,
2569 AsmWriterContext &WriterCtx) {
2570 Out << "!DILabel(";
2571 MDFieldPrinter Printer(Out, WriterCtx);
2572 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2573 Printer.printString("name", N->getName());
2574 Printer.printMetadata("file", N->getRawFile());
2575 Printer.printInt("line", N->getLine());
2576 Printer.printInt("column", N->getColumn());
2577 Printer.printBool("isArtificial", N->isArtificial(), false);
2578 if (N->getCoroSuspendIdx())
2579 Printer.printInt("coroSuspendIdx", *N->getCoroSuspendIdx(),
2580 /* ShouldSkipZero */ false);
2581 Out << ")";
2582}
2583
2585 AsmWriterContext &WriterCtx) {
2586 Out << "!DIExpression(";
2587 ListSeparator FS;
2588 if (N->isValid()) {
2589 for (const DIExpression::ExprOperand &Op : N->expr_ops()) {
2590 auto OpStr = dwarf::OperationEncodingString(Op.getOp());
2591 assert(!OpStr.empty() && "Expected valid opcode");
2592
2593 Out << FS << OpStr;
2594 if (Op.getOp() == dwarf::DW_OP_LLVM_convert) {
2595 Out << FS << Op.getArg(0);
2596 Out << FS << dwarf::AttributeEncodingString(Op.getArg(1));
2597 } else {
2598 for (unsigned A = 0, AE = Op.getNumArgs(); A != AE; ++A)
2599 Out << FS << Op.getArg(A);
2600 }
2601 }
2602 } else {
2603 for (const auto &I : N->getElements())
2604 Out << FS << I;
2605 }
2606 Out << ")";
2607}
2608
2609static void writeDIArgList(raw_ostream &Out, const DIArgList *N,
2610 AsmWriterContext &WriterCtx,
2611 bool FromValue = false) {
2612 assert(FromValue &&
2613 "Unexpected DIArgList metadata outside of value argument");
2614 Out << "!DIArgList(";
2615 ListSeparator FS;
2616 MDFieldPrinter Printer(Out, WriterCtx);
2617 for (const Metadata *Arg : N->getArgs()) {
2618 Out << FS;
2619 writeAsOperandInternal(Out, Arg, WriterCtx, true);
2620 }
2621 Out << ")";
2622}
2623
2626 AsmWriterContext &WriterCtx) {
2627 Out << "!DIGlobalVariableExpression(";
2628 MDFieldPrinter Printer(Out, WriterCtx);
2629 Printer.printMetadata("var", N->getVariable());
2630 Printer.printMetadata("expr", N->getExpression());
2631 Out << ")";
2632}
2633
2635 AsmWriterContext &WriterCtx) {
2636 Out << "!DIObjCProperty(";
2637 MDFieldPrinter Printer(Out, WriterCtx);
2638 Printer.printString("name", N->getName());
2639 Printer.printMetadata("file", N->getRawFile());
2640 Printer.printInt("line", N->getLine());
2641 Printer.printString("setter", N->getSetterName());
2642 Printer.printString("getter", N->getGetterName());
2643 Printer.printInt("attributes", N->getAttributes());
2644 Printer.printMetadata("type", N->getRawType());
2645 Out << ")";
2646}
2647
2649 AsmWriterContext &WriterCtx) {
2650 Out << "!DIImportedEntity(";
2651 MDFieldPrinter Printer(Out, WriterCtx);
2652 Printer.printTag(N);
2653 Printer.printString("name", N->getName());
2654 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2655 Printer.printMetadata("entity", N->getRawEntity());
2656 Printer.printMetadata("file", N->getRawFile());
2657 Printer.printInt("line", N->getLine());
2658 Printer.printMetadata("elements", N->getRawElements());
2659 Out << ")";
2660}
2661
2663 AsmWriterContext &Ctx) {
2664 if (Node->isDistinct())
2665 Out << "distinct ";
2666 else if (Node->isTemporary())
2667 Out << "<temporary!> "; // Handle broken code.
2668
2669 switch (Node->getMetadataID()) {
2670 default:
2671 llvm_unreachable("Expected uniquable MDNode");
2672#define HANDLE_MDNODE_LEAF(CLASS) \
2673 case Metadata::CLASS##Kind: \
2674 write##CLASS(Out, cast<CLASS>(Node), Ctx); \
2675 break;
2676#include "llvm/IR/Metadata.def"
2677 }
2678}
2679
2680// Full implementation of printing a Value as an operand with support for
2681// TypePrinting, etc.
2682static void writeAsOperandInternal(raw_ostream &Out, const Value *V,
2683 AsmWriterContext &WriterCtx,
2684 bool PrintType) {
2685 if (PrintType) {
2686 WriterCtx.TypePrinter->print(V->getType(), Out);
2687 Out << ' ';
2688 }
2689
2690 if (V->hasName()) {
2691 printLLVMName(Out, V);
2692 return;
2693 }
2694
2695 const auto *CV = dyn_cast<Constant>(V);
2696 if (CV && !isa<GlobalValue>(CV)) {
2697 assert(WriterCtx.TypePrinter && "Constants require TypePrinting!");
2698 writeConstantInternal(Out, CV, WriterCtx);
2699 return;
2700 }
2701
2702 if (const auto *IA = dyn_cast<InlineAsm>(V)) {
2703 Out << "asm ";
2704 if (IA->hasSideEffects())
2705 Out << "sideeffect ";
2706 if (IA->isAlignStack())
2707 Out << "alignstack ";
2708 // We don't emit the AD_ATT dialect as it's the assumed default.
2709 if (IA->getDialect() == InlineAsm::AD_Intel)
2710 Out << "inteldialect ";
2711 if (IA->canThrow())
2712 Out << "unwind ";
2713 Out << '"';
2714 printEscapedString(IA->getAsmString(), Out);
2715 Out << "\", \"";
2716 printEscapedString(IA->getConstraintString(), Out);
2717 Out << '"';
2718 return;
2719 }
2720
2721 if (auto *MD = dyn_cast<MetadataAsValue>(V)) {
2722 writeAsOperandInternal(Out, MD->getMetadata(), WriterCtx,
2723 /* FromValue */ true);
2724 return;
2725 }
2726
2727 char Prefix = '%';
2728 int Slot;
2729 auto *Machine = WriterCtx.Machine;
2730 // If we have a SlotTracker, use it.
2731 if (Machine) {
2732 if (const auto *GV = dyn_cast<GlobalValue>(V)) {
2733 Slot = Machine->getGlobalSlot(GV);
2734 Prefix = '@';
2735 } else {
2736 Slot = Machine->getLocalSlot(V);
2737
2738 // If the local value didn't succeed, then we may be referring to a value
2739 // from a different function. Translate it, as this can happen when using
2740 // address of blocks.
2741 if (Slot == -1)
2742 if ((Machine = createSlotTracker(V))) {
2743 Slot = Machine->getLocalSlot(V);
2744 delete Machine;
2745 }
2746 }
2747 } else if ((Machine = createSlotTracker(V))) {
2748 // Otherwise, create one to get the # and then destroy it.
2749 if (const auto *GV = dyn_cast<GlobalValue>(V)) {
2750 Slot = Machine->getGlobalSlot(GV);
2751 Prefix = '@';
2752 } else {
2753 Slot = Machine->getLocalSlot(V);
2754 }
2755 delete Machine;
2756 Machine = nullptr;
2757 } else {
2758 Slot = -1;
2759 }
2760
2761 if (Slot != -1)
2762 Out << Prefix << Slot;
2763 else
2764 Out << "<badref>";
2765}
2766
2767static void writeAsOperandInternal(raw_ostream &Out, const Metadata *MD,
2768 AsmWriterContext &WriterCtx,
2769 bool FromValue) {
2770 // Write DIExpressions and DIArgLists inline when used as a value. Improves
2771 // readability of debug info intrinsics.
2772 if (const auto *Expr = dyn_cast<DIExpression>(MD)) {
2773 writeDIExpression(Out, Expr, WriterCtx);
2774 return;
2775 }
2776 if (const auto *ArgList = dyn_cast<DIArgList>(MD)) {
2777 writeDIArgList(Out, ArgList, WriterCtx, FromValue);
2778 return;
2779 }
2780
2781 if (const auto *N = dyn_cast<MDNode>(MD)) {
2782 std::unique_ptr<SlotTracker> MachineStorage;
2783 SaveAndRestore SARMachine(WriterCtx.Machine);
2784 if (!WriterCtx.Machine) {
2785 MachineStorage = std::make_unique<SlotTracker>(WriterCtx.Context);
2786 WriterCtx.Machine = MachineStorage.get();
2787 }
2788 int Slot = WriterCtx.Machine->getMetadataSlot(N);
2789 if (Slot == -1) {
2790 if (const auto *Loc = dyn_cast<DILocation>(N)) {
2791 writeDILocation(Out, Loc, WriterCtx);
2792 return;
2793 }
2794 // Give the pointer value instead of "badref", since this comes up all
2795 // the time when debugging.
2796 Out << "<" << N << ">";
2797 } else
2798 Out << '!' << Slot;
2799 return;
2800 }
2801
2802 if (const auto *MDS = dyn_cast<MDString>(MD)) {
2803 Out << "!\"";
2804 printEscapedString(MDS->getString(), Out);
2805 Out << '"';
2806 return;
2807 }
2808
2809 auto *V = cast<ValueAsMetadata>(MD);
2810 assert(WriterCtx.TypePrinter && "TypePrinter required for metadata values");
2811 assert((FromValue || !isa<LocalAsMetadata>(V)) &&
2812 "Unexpected function-local metadata outside of value argument");
2813
2814 writeAsOperandInternal(Out, V->getValue(), WriterCtx, /*PrintType=*/true);
2815}
2816
2817namespace {
2818
2819class AssemblyWriter {
2820 formatted_raw_ostream &Out;
2821 const Module *TheModule = nullptr;
2822 const ModuleSummaryIndex *TheIndex = nullptr;
2823 std::unique_ptr<SlotTracker> SlotTrackerStorage;
2824 SlotTracker &Machine;
2825 TypePrinting TypePrinter;
2826 AssemblyAnnotationWriter *AnnotationWriter = nullptr;
2827 SetVector<const Comdat *> Comdats;
2828 bool IsForDebug;
2829 bool ShouldPreserveUseListOrder;
2830 UseListOrderMap UseListOrders;
2832 /// Synchronization scope names registered with LLVMContext.
2834 DenseMap<const GlobalValueSummary *, GlobalValue::GUID> SummaryToGUIDMap;
2835
2836public:
2837 /// Construct an AssemblyWriter with an external SlotTracker
2838 AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac, const Module *M,
2839 AssemblyAnnotationWriter *AAW, bool IsForDebug,
2840 bool ShouldPreserveUseListOrder = false);
2841
2842 AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
2843 const ModuleSummaryIndex *Index, bool IsForDebug);
2844
2845 AsmWriterContext getContext() {
2846 return AsmWriterContext(&TypePrinter, &Machine, TheModule);
2847 }
2848
2849 void printMDNodeBody(const MDNode *MD);
2850 void printNamedMDNode(const NamedMDNode *NMD);
2851
2852 void printModule(const Module *M);
2853
2854 void writeOperand(const Value *Op, bool PrintType);
2855 void writeParamOperand(const Value *Operand, AttributeSet Attrs);
2856 void writeOperandBundles(const CallBase *Call);
2857 void writeSyncScope(const LLVMContext &Context,
2858 SyncScope::ID SSID);
2859 void writeAtomic(const LLVMContext &Context,
2860 AtomicOrdering Ordering,
2861 SyncScope::ID SSID);
2862 void writeAtomicCmpXchg(const LLVMContext &Context,
2863 AtomicOrdering SuccessOrdering,
2864 AtomicOrdering FailureOrdering,
2865 SyncScope::ID SSID);
2866
2867 void writeAllMDNodes();
2868 void writeMDNode(unsigned Slot, const MDNode *Node);
2869 void writeAttribute(const Attribute &Attr, bool InAttrGroup = false);
2870 void writeAttributeSet(const AttributeSet &AttrSet, bool InAttrGroup = false);
2871 void writeAllAttributeGroups();
2872
2873 void printTypeIdentities();
2874 void printGlobal(const GlobalVariable *GV);
2875 void printAlias(const GlobalAlias *GA);
2876 void printIFunc(const GlobalIFunc *GI);
2877 void printComdat(const Comdat *C);
2878 void printFunction(const Function *F);
2879 void printArgument(const Argument *FA, AttributeSet Attrs);
2880 void printBasicBlock(const BasicBlock *BB);
2881 void printInstructionLine(const Instruction &I);
2882 void printInstruction(const Instruction &I);
2883 void printDbgMarker(const DbgMarker &DPI);
2884 void printDbgVariableRecord(const DbgVariableRecord &DVR);
2885 void printDbgLabelRecord(const DbgLabelRecord &DLR);
2886 void printDbgRecord(const DbgRecord &DR);
2887 void printDbgRecordLine(const DbgRecord &DR);
2888
2889 void printUseListOrder(const Value *V, ArrayRef<unsigned> Shuffle);
2890 void printUseLists(const Function *F);
2891
2892 void printModuleSummaryIndex();
2893 void printSummaryInfo(unsigned Slot, const ValueInfo &VI);
2894 void printSummary(const GlobalValueSummary &Summary);
2895 void printAliasSummary(const AliasSummary *AS);
2896 void printGlobalVarSummary(const GlobalVarSummary *GS);
2897 void printFunctionSummary(const FunctionSummary *FS);
2898 void printTypeIdSummary(const TypeIdSummary &TIS);
2899 void printTypeIdCompatibleVtableSummary(const TypeIdCompatibleVtableInfo &TI);
2900 void printTypeTestResolution(const TypeTestResolution &TTRes);
2901 void printArgs(ArrayRef<uint64_t> Args);
2902 void printWPDRes(const WholeProgramDevirtResolution &WPDRes);
2903 void printTypeIdInfo(const FunctionSummary::TypeIdInfo &TIDInfo);
2904 void printVFuncId(const FunctionSummary::VFuncId VFId);
2905 void printNonConstVCalls(ArrayRef<FunctionSummary::VFuncId> VCallList,
2906 const char *Tag);
2907 void printConstVCalls(ArrayRef<FunctionSummary::ConstVCall> VCallList,
2908 const char *Tag);
2909
2910private:
2911 /// Print out metadata attachments.
2912 void printMetadataAttachments(
2913 const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
2914 StringRef Separator);
2915
2916 // printInfoComment - Print a little comment after the instruction indicating
2917 // which slot it occupies.
2918 void printInfoComment(const Value &V);
2919
2920 // printGCRelocateComment - print comment after call to the gc.relocate
2921 // intrinsic indicating base and derived pointer names.
2922 void printGCRelocateComment(const GCRelocateInst &Relocate);
2923};
2924
2925} // end anonymous namespace
2926
2927AssemblyWriter::AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
2928 const Module *M, AssemblyAnnotationWriter *AAW,
2929 bool IsForDebug, bool ShouldPreserveUseListOrder)
2930 : Out(o), TheModule(M), Machine(Mac), TypePrinter(M), AnnotationWriter(AAW),
2931 IsForDebug(IsForDebug),
2932 ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {
2933 if (!TheModule)
2934 return;
2935 for (const GlobalObject &GO : TheModule->global_objects())
2936 if (const Comdat *C = GO.getComdat())
2937 Comdats.insert(C);
2938}
2939
2940AssemblyWriter::AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
2941 const ModuleSummaryIndex *Index, bool IsForDebug)
2942 : Out(o), TheIndex(Index), Machine(Mac), TypePrinter(/*Module=*/nullptr),
2943 IsForDebug(IsForDebug), ShouldPreserveUseListOrder(false) {}
2944
2945void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) {
2946 if (!Operand) {
2947 Out << "<null operand!>";
2948 return;
2949 }
2950 auto WriteCtx = getContext();
2951 writeAsOperandInternal(Out, Operand, WriteCtx, PrintType);
2952}
2953
2954void AssemblyWriter::writeSyncScope(const LLVMContext &Context,
2955 SyncScope::ID SSID) {
2956 switch (SSID) {
2957 case SyncScope::System: {
2958 break;
2959 }
2960 default: {
2961 if (SSNs.empty())
2962 Context.getSyncScopeNames(SSNs);
2963
2964 Out << " syncscope(\"";
2965 printEscapedString(SSNs[SSID], Out);
2966 Out << "\")";
2967 break;
2968 }
2969 }
2970}
2971
2972void AssemblyWriter::writeAtomic(const LLVMContext &Context,
2973 AtomicOrdering Ordering,
2974 SyncScope::ID SSID) {
2975 if (Ordering == AtomicOrdering::NotAtomic)
2976 return;
2977
2978 writeSyncScope(Context, SSID);
2979 Out << " " << toIRString(Ordering);
2980}
2981
2982void AssemblyWriter::writeAtomicCmpXchg(const LLVMContext &Context,
2983 AtomicOrdering SuccessOrdering,
2984 AtomicOrdering FailureOrdering,
2985 SyncScope::ID SSID) {
2986 assert(SuccessOrdering != AtomicOrdering::NotAtomic &&
2987 FailureOrdering != AtomicOrdering::NotAtomic);
2988
2989 writeSyncScope(Context, SSID);
2990 Out << " " << toIRString(SuccessOrdering);
2991 Out << " " << toIRString(FailureOrdering);
2992}
2993
2994void AssemblyWriter::writeParamOperand(const Value *Operand,
2995 AttributeSet Attrs) {
2996 if (!Operand) {
2997 Out << "<null operand!>";
2998 return;
2999 }
3000
3001 // Print the type
3002 TypePrinter.print(Operand->getType(), Out);
3003 // Print parameter attributes list
3004 if (Attrs.hasAttributes()) {
3005 Out << ' ';
3006 writeAttributeSet(Attrs);
3007 }
3008 Out << ' ';
3009 // Print the operand
3010 auto WriterCtx = getContext();
3011 writeAsOperandInternal(Out, Operand, WriterCtx);
3012}
3013
3014void AssemblyWriter::writeOperandBundles(const CallBase *Call) {
3015 if (!Call->hasOperandBundles())
3016 return;
3017
3018 Out << " [ ";
3019
3020 ListSeparator LS;
3021 for (unsigned i = 0, e = Call->getNumOperandBundles(); i != e; ++i) {
3022 OperandBundleUse BU = Call->getOperandBundleAt(i);
3023
3024 Out << LS << '"';
3025 printEscapedString(BU.getTagName(), Out);
3026 Out << '"';
3027
3028 Out << '(';
3029
3030 ListSeparator InnerLS;
3031 auto WriterCtx = getContext();
3032 for (const auto &Input : BU.Inputs) {
3033 Out << InnerLS;
3034 if (Input == nullptr)
3035 Out << "<null operand bundle!>";
3036 else
3037 writeAsOperandInternal(Out, Input, WriterCtx, /*PrintType=*/true);
3038 }
3039
3040 Out << ')';
3041 }
3042
3043 Out << " ]";
3044}
3045
3046void AssemblyWriter::printModule(const Module *M) {
3047 Machine.initializeIfNeeded();
3048
3049 if (ShouldPreserveUseListOrder)
3050 UseListOrders = predictUseListOrder(M);
3051
3052 if (!M->getModuleIdentifier().empty() &&
3053 // Don't print the ID if it will start a new line (which would
3054 // require a comment char before it).
3055 M->getModuleIdentifier().find('\n') == std::string::npos)
3056 Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n";
3057
3058 if (!M->getSourceFileName().empty()) {
3059 Out << "source_filename = \"";
3060 printEscapedString(M->getSourceFileName(), Out);
3061 Out << "\"\n";
3062 }
3063
3064 const std::string &DL = M->getDataLayoutStr();
3065 if (!DL.empty())
3066 Out << "target datalayout = \"" << DL << "\"\n";
3067 if (!M->getTargetTriple().empty())
3068 Out << "target triple = \"" << M->getTargetTriple().str() << "\"\n";
3069
3070 if (!M->getModuleInlineAsm().empty()) {
3071 Out << '\n';
3072
3073 // Split the string into lines, to make it easier to read the .ll file.
3074 StringRef Asm = M->getModuleInlineAsm();
3075 do {
3076 StringRef Front;
3077 std::tie(Front, Asm) = Asm.split('\n');
3078
3079 // We found a newline, print the portion of the asm string from the
3080 // last newline up to this newline.
3081 Out << "module asm \"";
3082 printEscapedString(Front, Out);
3083 Out << "\"\n";
3084 } while (!Asm.empty());
3085 }
3086
3087 printTypeIdentities();
3088
3089 // Output all comdats.
3090 if (!Comdats.empty())
3091 Out << '\n';
3092 for (const Comdat *C : Comdats) {
3093 printComdat(C);
3094 if (C != Comdats.back())
3095 Out << '\n';
3096 }
3097
3098 // Output all globals.
3099 if (!M->global_empty()) Out << '\n';
3100 for (const GlobalVariable &GV : M->globals()) {
3101 printGlobal(&GV); Out << '\n';
3102 }
3103
3104 // Output all aliases.
3105 if (!M->alias_empty()) Out << "\n";
3106 for (const GlobalAlias &GA : M->aliases())
3107 printAlias(&GA);
3108
3109 // Output all ifuncs.
3110 if (!M->ifunc_empty()) Out << "\n";
3111 for (const GlobalIFunc &GI : M->ifuncs())
3112 printIFunc(&GI);
3113
3114 // Output all of the functions.
3115 for (const Function &F : *M) {
3116 Out << '\n';
3117 printFunction(&F);
3118 }
3119
3120 // Output global use-lists.
3121 printUseLists(nullptr);
3122
3123 // Output all attribute groups.
3124 if (!Machine.as_empty()) {
3125 Out << '\n';
3126 writeAllAttributeGroups();
3127 }
3128
3129 // Output named metadata.
3130 if (!M->named_metadata_empty()) Out << '\n';
3131
3132 for (const NamedMDNode &Node : M->named_metadata())
3133 printNamedMDNode(&Node);
3134
3135 // Output metadata.
3136 if (!Machine.mdn_empty()) {
3137 Out << '\n';
3138 writeAllMDNodes();
3139 }
3140}
3141
3142void AssemblyWriter::printModuleSummaryIndex() {
3143 assert(TheIndex);
3144 int NumSlots = Machine.initializeIndexIfNeeded();
3145
3146 Out << "\n";
3147
3148 // Print module path entries. To print in order, add paths to a vector
3149 // indexed by module slot.
3150 std::vector<std::pair<std::string, ModuleHash>> moduleVec;
3151 std::string RegularLTOModuleName =
3153 moduleVec.resize(TheIndex->modulePaths().size());
3154 for (auto &[ModPath, ModHash] : TheIndex->modulePaths())
3155 moduleVec[Machine.getModulePathSlot(ModPath)] = std::make_pair(
3156 // An empty module path is a special entry for a regular LTO module
3157 // created during the thin link.
3158 ModPath.empty() ? RegularLTOModuleName : std::string(ModPath), ModHash);
3159
3160 unsigned i = 0;
3161 for (auto &ModPair : moduleVec) {
3162 Out << "^" << i++ << " = module: (";
3163 Out << "path: \"";
3164 printEscapedString(ModPair.first, Out);
3165 Out << "\", hash: (";
3166 ListSeparator FS;
3167 for (auto Hash : ModPair.second)
3168 Out << FS << Hash;
3169 Out << "))\n";
3170 }
3171
3172 // FIXME: Change AliasSummary to hold a ValueInfo instead of summary pointer
3173 // for aliasee (then update BitcodeWriter.cpp and remove get/setAliaseeGUID).
3174 for (auto &GlobalList : *TheIndex) {
3175 auto GUID = GlobalList.first;
3176 for (auto &Summary : GlobalList.second.SummaryList)
3177 SummaryToGUIDMap[Summary.get()] = GUID;
3178 }
3179
3180 // Print the global value summary entries.
3181 for (auto &GlobalList : *TheIndex) {
3182 auto GUID = GlobalList.first;
3183 auto VI = TheIndex->getValueInfo(GlobalList);
3184 printSummaryInfo(Machine.getGUIDSlot(GUID), VI);
3185 }
3186
3187 // Print the TypeIdMap entries.
3188 for (const auto &TID : TheIndex->typeIds()) {
3189 Out << "^" << Machine.getTypeIdSlot(TID.second.first)
3190 << " = typeid: (name: \"" << TID.second.first << "\"";
3191 printTypeIdSummary(TID.second.second);
3192 Out << ") ; guid = " << TID.first << "\n";
3193 }
3194
3195 // Print the TypeIdCompatibleVtableMap entries.
3196 for (auto &TId : TheIndex->typeIdCompatibleVtableMap()) {
3198 Out << "^" << Machine.getTypeIdCompatibleVtableSlot(TId.first)
3199 << " = typeidCompatibleVTable: (name: \"" << TId.first << "\"";
3200 printTypeIdCompatibleVtableSummary(TId.second);
3201 Out << ") ; guid = " << GUID << "\n";
3202 }
3203
3204 // Don't emit flags when it's not really needed (value is zero by default).
3205 if (TheIndex->getFlags()) {
3206 Out << "^" << NumSlots << " = flags: " << TheIndex->getFlags() << "\n";
3207 ++NumSlots;
3208 }
3209
3210 Out << "^" << NumSlots << " = blockcount: " << TheIndex->getBlockCount()
3211 << "\n";
3212}
3213
3214static const char *
3216 switch (K) {
3218 return "indir";
3220 return "singleImpl";
3222 return "branchFunnel";
3223 }
3224 llvm_unreachable("invalid WholeProgramDevirtResolution kind");
3225}
3226
3229 switch (K) {
3231 return "indir";
3233 return "uniformRetVal";
3235 return "uniqueRetVal";
3237 return "virtualConstProp";
3238 }
3239 llvm_unreachable("invalid WholeProgramDevirtResolution::ByArg kind");
3240}
3241
3243 switch (K) {
3245 return "unknown";
3247 return "unsat";
3249 return "byteArray";
3251 return "inline";
3253 return "single";
3255 return "allOnes";
3256 }
3257 llvm_unreachable("invalid TypeTestResolution kind");
3258}
3259
3260void AssemblyWriter::printTypeTestResolution(const TypeTestResolution &TTRes) {
3261 Out << "typeTestRes: (kind: " << getTTResKindName(TTRes.TheKind)
3262 << ", sizeM1BitWidth: " << TTRes.SizeM1BitWidth;
3263
3264 // The following fields are only used if the target does not support the use
3265 // of absolute symbols to store constants. Print only if non-zero.
3266 if (TTRes.AlignLog2)
3267 Out << ", alignLog2: " << TTRes.AlignLog2;
3268 if (TTRes.SizeM1)
3269 Out << ", sizeM1: " << TTRes.SizeM1;
3270 if (TTRes.BitMask)
3271 // BitMask is uint8_t which causes it to print the corresponding char.
3272 Out << ", bitMask: " << (unsigned)TTRes.BitMask;
3273 if (TTRes.InlineBits)
3274 Out << ", inlineBits: " << TTRes.InlineBits;
3275
3276 Out << ")";
3277}
3278
3279void AssemblyWriter::printTypeIdSummary(const TypeIdSummary &TIS) {
3280 Out << ", summary: (";
3281 printTypeTestResolution(TIS.TTRes);
3282 if (!TIS.WPDRes.empty()) {
3283 Out << ", wpdResolutions: (";
3284 ListSeparator FS;
3285 for (auto &WPDRes : TIS.WPDRes) {
3286 Out << FS;
3287 Out << "(offset: " << WPDRes.first << ", ";
3288 printWPDRes(WPDRes.second);
3289 Out << ")";
3290 }
3291 Out << ")";
3292 }
3293 Out << ")";
3294}
3295
3296void AssemblyWriter::printTypeIdCompatibleVtableSummary(
3297 const TypeIdCompatibleVtableInfo &TI) {
3298 Out << ", summary: (";
3299 ListSeparator FS;
3300 for (auto &P : TI) {
3301 Out << FS;
3302 Out << "(offset: " << P.AddressPointOffset << ", ";
3303 Out << "^" << Machine.getGUIDSlot(P.VTableVI.getGUID());
3304 Out << ")";
3305 }
3306 Out << ")";
3307}
3308
3309void AssemblyWriter::printArgs(ArrayRef<uint64_t> Args) {
3310 Out << "args: (" << llvm::interleaved(Args) << ')';
3311}
3312
3313void AssemblyWriter::printWPDRes(const WholeProgramDevirtResolution &WPDRes) {
3314 Out << "wpdRes: (kind: ";
3316
3318 Out << ", singleImplName: \"" << WPDRes.SingleImplName << "\"";
3319
3320 if (!WPDRes.ResByArg.empty()) {
3321 Out << ", resByArg: (";
3322 ListSeparator FS;
3323 for (auto &ResByArg : WPDRes.ResByArg) {
3324 Out << FS;
3325 printArgs(ResByArg.first);
3326 Out << ", byArg: (kind: ";
3327 Out << getWholeProgDevirtResByArgKindName(ResByArg.second.TheKind);
3328 if (ResByArg.second.TheKind ==
3330 ResByArg.second.TheKind ==
3332 Out << ", info: " << ResByArg.second.Info;
3333
3334 // The following fields are only used if the target does not support the
3335 // use of absolute symbols to store constants. Print only if non-zero.
3336 if (ResByArg.second.Byte || ResByArg.second.Bit)
3337 Out << ", byte: " << ResByArg.second.Byte
3338 << ", bit: " << ResByArg.second.Bit;
3339
3340 Out << ")";
3341 }
3342 Out << ")";
3343 }
3344 Out << ")";
3345}
3346
3348 switch (SK) {
3350 return "alias";
3352 return "function";
3354 return "variable";
3355 }
3356 llvm_unreachable("invalid summary kind");
3357}
3358
3359void AssemblyWriter::printAliasSummary(const AliasSummary *AS) {
3360 Out << ", aliasee: ";
3361 // The indexes emitted for distributed backends may not include the
3362 // aliasee summary (only if it is being imported directly). Handle
3363 // that case by just emitting "null" as the aliasee.
3364 if (AS->hasAliasee())
3365 Out << "^" << Machine.getGUIDSlot(SummaryToGUIDMap[&AS->getAliasee()]);
3366 else
3367 Out << "null";
3368}
3369
3370void AssemblyWriter::printGlobalVarSummary(const GlobalVarSummary *GS) {
3371 auto VTableFuncs = GS->vTableFuncs();
3372 Out << ", varFlags: (readonly: " << GS->VarFlags.MaybeReadOnly << ", "
3373 << "writeonly: " << GS->VarFlags.MaybeWriteOnly << ", "
3374 << "constant: " << GS->VarFlags.Constant;
3375 if (!VTableFuncs.empty())
3376 Out << ", "
3377 << "vcall_visibility: " << GS->VarFlags.VCallVisibility;
3378 Out << ")";
3379
3380 if (!VTableFuncs.empty()) {
3381 Out << ", vTableFuncs: (";
3382 ListSeparator FS;
3383 for (auto &P : VTableFuncs) {
3384 Out << FS;
3385 Out << "(virtFunc: ^" << Machine.getGUIDSlot(P.FuncVI.getGUID())
3386 << ", offset: " << P.VTableOffset;
3387 Out << ")";
3388 }
3389 Out << ")";
3390 }
3391}
3392
3394 switch (LT) {
3396 return "external";
3398 return "private";
3400 return "internal";
3402 return "linkonce";
3404 return "linkonce_odr";
3406 return "weak";
3408 return "weak_odr";
3410 return "common";
3412 return "appending";
3414 return "extern_weak";
3416 return "available_externally";
3417 }
3418 llvm_unreachable("invalid linkage");
3419}
3420
3421// When printing the linkage types in IR where the ExternalLinkage is
3422// not printed, and other linkage types are expected to be printed with
3423// a space after the name.
3426 return "";
3427 return getLinkageName(LT) + " ";
3428}
3429
3431 switch (Vis) {
3433 return "default";
3435 return "hidden";
3437 return "protected";
3438 }
3439 llvm_unreachable("invalid visibility");
3440}
3441
3443 switch (IK) {
3445 return "definition";
3447 return "declaration";
3448 }
3449 llvm_unreachable("invalid import kind");
3450}
3451
3452void AssemblyWriter::printFunctionSummary(const FunctionSummary *FS) {
3453 Out << ", insts: " << FS->instCount();
3454 if (FS->fflags().anyFlagSet())
3455 Out << ", " << FS->fflags();
3456
3457 if (!FS->calls().empty()) {
3458 Out << ", calls: (";
3459 ListSeparator IFS;
3460 for (auto &Call : FS->calls()) {
3461 Out << IFS;
3462 Out << "(callee: ^" << Machine.getGUIDSlot(Call.first.getGUID());
3463 if (Call.second.getHotness() != CalleeInfo::HotnessType::Unknown)
3464 Out << ", hotness: " << getHotnessName(Call.second.getHotness());
3465 else if (Call.second.RelBlockFreq)
3466 Out << ", relbf: " << Call.second.RelBlockFreq;
3467 // Follow the convention of emitting flags as a boolean value, but only
3468 // emit if true to avoid unnecessary verbosity and test churn.
3469 if (Call.second.HasTailCall)
3470 Out << ", tail: 1";
3471 Out << ")";
3472 }
3473 Out << ")";
3474 }
3475
3476 if (const auto *TIdInfo = FS->getTypeIdInfo())
3477 printTypeIdInfo(*TIdInfo);
3478
3479 // The AllocationType identifiers capture the profiled context behavior
3480 // reaching a specific static allocation site (possibly cloned).
3481 auto AllocTypeName = [](uint8_t Type) -> const char * {
3482 switch (Type) {
3483 case (uint8_t)AllocationType::None:
3484 return "none";
3485 case (uint8_t)AllocationType::NotCold:
3486 return "notcold";
3487 case (uint8_t)AllocationType::Cold:
3488 return "cold";
3489 case (uint8_t)AllocationType::Hot:
3490 return "hot";
3491 }
3492 llvm_unreachable("Unexpected alloc type");
3493 };
3494
3495 if (!FS->allocs().empty()) {
3496 Out << ", allocs: (";
3497 ListSeparator AFS;
3498 for (auto &AI : FS->allocs()) {
3499 Out << AFS;
3500 Out << "(versions: (";
3501 ListSeparator VFS;
3502 for (auto V : AI.Versions) {
3503 Out << VFS;
3504 Out << AllocTypeName(V);
3505 }
3506 Out << "), memProf: (";
3507 ListSeparator MIBFS;
3508 for (auto &MIB : AI.MIBs) {
3509 Out << MIBFS;
3510 Out << "(type: " << AllocTypeName((uint8_t)MIB.AllocType);
3511 Out << ", stackIds: (";
3512 ListSeparator SIDFS;
3513 for (auto Id : MIB.StackIdIndices) {
3514 Out << SIDFS;
3515 Out << TheIndex->getStackIdAtIndex(Id);
3516 }
3517 Out << "))";
3518 }
3519 Out << "))";
3520 }
3521 Out << ")";
3522 }
3523
3524 if (!FS->callsites().empty()) {
3525 Out << ", callsites: (";
3526 ListSeparator SNFS;
3527 for (auto &CI : FS->callsites()) {
3528 Out << SNFS;
3529 if (CI.Callee)
3530 Out << "(callee: ^" << Machine.getGUIDSlot(CI.Callee.getGUID());
3531 else
3532 Out << "(callee: null";
3533 Out << ", clones: (";
3534 ListSeparator VFS;
3535 for (auto V : CI.Clones) {
3536 Out << VFS;
3537 Out << V;
3538 }
3539 Out << "), stackIds: (";
3540 ListSeparator SIDFS;
3541 for (auto Id : CI.StackIdIndices) {
3542 Out << SIDFS;
3543 Out << TheIndex->getStackIdAtIndex(Id);
3544 }
3545 Out << "))";
3546 }
3547 Out << ")";
3548 }
3549
3550 auto PrintRange = [&](const ConstantRange &Range) {
3551 Out << "[" << Range.getSignedMin() << ", " << Range.getSignedMax() << "]";
3552 };
3553
3554 if (!FS->paramAccesses().empty()) {
3555 Out << ", params: (";
3556 ListSeparator IFS;
3557 for (auto &PS : FS->paramAccesses()) {
3558 Out << IFS;
3559 Out << "(param: " << PS.ParamNo;
3560 Out << ", offset: ";
3561 PrintRange(PS.Use);
3562 if (!PS.Calls.empty()) {
3563 Out << ", calls: (";
3564 ListSeparator IFS;
3565 for (auto &Call : PS.Calls) {
3566 Out << IFS;
3567 Out << "(callee: ^" << Machine.getGUIDSlot(Call.Callee.getGUID());
3568 Out << ", param: " << Call.ParamNo;
3569 Out << ", offset: ";
3570 PrintRange(Call.Offsets);
3571 Out << ")";
3572 }
3573 Out << ")";
3574 }
3575 Out << ")";
3576 }
3577 Out << ")";
3578 }
3579}
3580
3581void AssemblyWriter::printTypeIdInfo(
3582 const FunctionSummary::TypeIdInfo &TIDInfo) {
3583 Out << ", typeIdInfo: (";
3584 ListSeparator TIDFS;
3585 if (!TIDInfo.TypeTests.empty()) {
3586 Out << TIDFS;
3587 Out << "typeTests: (";
3588 ListSeparator FS;
3589 for (auto &GUID : TIDInfo.TypeTests) {
3590 auto TidIter = TheIndex->typeIds().equal_range(GUID);
3591 if (TidIter.first == TidIter.second) {
3592 Out << FS;
3593 Out << GUID;
3594 continue;
3595 }
3596 // Print all type id that correspond to this GUID.
3597 for (const auto &[GUID, TypeIdPair] : make_range(TidIter)) {
3598 Out << FS;
3599 auto Slot = Machine.getTypeIdSlot(TypeIdPair.first);
3600 assert(Slot != -1);
3601 Out << "^" << Slot;
3602 }
3603 }
3604 Out << ")";
3605 }
3606 if (!TIDInfo.TypeTestAssumeVCalls.empty()) {
3607 Out << TIDFS;
3608 printNonConstVCalls(TIDInfo.TypeTestAssumeVCalls, "typeTestAssumeVCalls");
3609 }
3610 if (!TIDInfo.TypeCheckedLoadVCalls.empty()) {
3611 Out << TIDFS;
3612 printNonConstVCalls(TIDInfo.TypeCheckedLoadVCalls, "typeCheckedLoadVCalls");
3613 }
3614 if (!TIDInfo.TypeTestAssumeConstVCalls.empty()) {
3615 Out << TIDFS;
3616 printConstVCalls(TIDInfo.TypeTestAssumeConstVCalls,
3617 "typeTestAssumeConstVCalls");
3618 }
3619 if (!TIDInfo.TypeCheckedLoadConstVCalls.empty()) {
3620 Out << TIDFS;
3621 printConstVCalls(TIDInfo.TypeCheckedLoadConstVCalls,
3622 "typeCheckedLoadConstVCalls");
3623 }
3624 Out << ")";
3625}
3626
3627void AssemblyWriter::printVFuncId(const FunctionSummary::VFuncId VFId) {
3628 auto TidIter = TheIndex->typeIds().equal_range(VFId.GUID);
3629 if (TidIter.first == TidIter.second) {
3630 Out << "vFuncId: (";
3631 Out << "guid: " << VFId.GUID;
3632 Out << ", offset: " << VFId.Offset;
3633 Out << ")";
3634 return;
3635 }
3636 // Print all type id that correspond to this GUID.
3637 ListSeparator FS;
3638 for (const auto &[GUID, TypeIdPair] : make_range(TidIter)) {
3639 Out << FS;
3640 Out << "vFuncId: (";
3641 auto Slot = Machine.getTypeIdSlot(TypeIdPair.first);
3642 assert(Slot != -1);
3643 Out << "^" << Slot;
3644 Out << ", offset: " << VFId.Offset;
3645 Out << ")";
3646 }
3647}
3648
3649void AssemblyWriter::printNonConstVCalls(
3650 ArrayRef<FunctionSummary::VFuncId> VCallList, const char *Tag) {
3651 Out << Tag << ": (";
3652 ListSeparator FS;
3653 for (auto &VFuncId : VCallList) {
3654 Out << FS;
3655 printVFuncId(VFuncId);
3656 }
3657 Out << ")";
3658}
3659
3660void AssemblyWriter::printConstVCalls(
3661 ArrayRef<FunctionSummary::ConstVCall> VCallList, const char *Tag) {
3662 Out << Tag << ": (";
3663 ListSeparator FS;
3664 for (auto &ConstVCall : VCallList) {
3665 Out << FS;
3666 Out << "(";
3667 printVFuncId(ConstVCall.VFunc);
3668 if (!ConstVCall.Args.empty()) {
3669 Out << ", ";
3670 printArgs(ConstVCall.Args);
3671 }
3672 Out << ")";
3673 }
3674 Out << ")";
3675}
3676
3677void AssemblyWriter::printSummary(const GlobalValueSummary &Summary) {
3678 GlobalValueSummary::GVFlags GVFlags = Summary.flags();
3680 Out << getSummaryKindName(Summary.getSummaryKind()) << ": ";
3681 Out << "(module: ^" << Machine.getModulePathSlot(Summary.modulePath())
3682 << ", flags: (";
3683 Out << "linkage: " << getLinkageName(LT);
3684 Out << ", visibility: "
3686 Out << ", notEligibleToImport: " << GVFlags.NotEligibleToImport;
3687 Out << ", live: " << GVFlags.Live;
3688 Out << ", dsoLocal: " << GVFlags.DSOLocal;
3689 Out << ", canAutoHide: " << GVFlags.CanAutoHide;
3690 Out << ", importType: "
3692 Out << ")";
3693
3694 if (Summary.getSummaryKind() == GlobalValueSummary::AliasKind)
3695 printAliasSummary(cast<AliasSummary>(&Summary));
3696 else if (Summary.getSummaryKind() == GlobalValueSummary::FunctionKind)
3697 printFunctionSummary(cast<FunctionSummary>(&Summary));
3698 else
3699 printGlobalVarSummary(cast<GlobalVarSummary>(&Summary));
3700
3701 auto RefList = Summary.refs();
3702 if (!RefList.empty()) {
3703 Out << ", refs: (";
3704 ListSeparator FS;
3705 for (auto &Ref : RefList) {
3706 Out << FS;
3707 if (Ref.isReadOnly())
3708 Out << "readonly ";
3709 else if (Ref.isWriteOnly())
3710 Out << "writeonly ";
3711 Out << "^" << Machine.getGUIDSlot(Ref.getGUID());
3712 }
3713 Out << ")";
3714 }
3715
3716 Out << ")";
3717}
3718
3719void AssemblyWriter::printSummaryInfo(unsigned Slot, const ValueInfo &VI) {
3720 Out << "^" << Slot << " = gv: (";
3721 if (VI.hasName() && !VI.name().empty())
3722 Out << "name: \"" << VI.name() << "\"";
3723 else
3724 Out << "guid: " << VI.getGUID();
3725 if (!VI.getSummaryList().empty()) {
3726 Out << ", summaries: (";
3727 ListSeparator FS;
3728 for (auto &Summary : VI.getSummaryList()) {
3729 Out << FS;
3730 printSummary(*Summary);
3731 }
3732 Out << ")";
3733 }
3734 Out << ")";
3735 if (VI.hasName() && !VI.name().empty())
3736 Out << " ; guid = " << VI.getGUID();
3737 Out << "\n";
3738}
3739
3741 formatted_raw_ostream &Out) {
3742 if (Name.empty()) {
3743 Out << "<empty name> ";
3744 } else {
3745 unsigned char FirstC = static_cast<unsigned char>(Name[0]);
3746 if (isalpha(FirstC) || FirstC == '-' || FirstC == '$' || FirstC == '.' ||
3747 FirstC == '_')
3748 Out << FirstC;
3749 else
3750 Out << '\\' << hexdigit(FirstC >> 4) << hexdigit(FirstC & 0x0F);
3751 for (unsigned i = 1, e = Name.size(); i != e; ++i) {
3752 unsigned char C = Name[i];
3753 if (isalnum(C) || C == '-' || C == '$' || C == '.' || C == '_')
3754 Out << C;
3755 else
3756 Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
3757 }
3758 }
3759}
3760
3761void AssemblyWriter::printNamedMDNode(const NamedMDNode *NMD) {
3762 Out << '!';
3763 printMetadataIdentifier(NMD->getName(), Out);
3764 Out << " = !{";
3765 ListSeparator LS;
3766 for (const MDNode *Op : NMD->operands()) {
3767 Out << LS;
3768 // Write DIExpressions inline.
3769 // FIXME: Ban DIExpressions in NamedMDNodes, they will serve no purpose.
3770 if (auto *Expr = dyn_cast<DIExpression>(Op)) {
3771 writeDIExpression(Out, Expr, AsmWriterContext::getEmpty());
3772 continue;
3773 }
3774
3775 int Slot = Machine.getMetadataSlot(Op);
3776 if (Slot == -1)
3777 Out << "<badref>";
3778 else
3779 Out << '!' << Slot;
3780 }
3781 Out << "}\n";
3782}
3783
3785 formatted_raw_ostream &Out) {
3786 switch (Vis) {
3788 case GlobalValue::HiddenVisibility: Out << "hidden "; break;
3789 case GlobalValue::ProtectedVisibility: Out << "protected "; break;
3790 }
3791}
3792
3793static void printDSOLocation(const GlobalValue &GV,
3794 formatted_raw_ostream &Out) {
3795 if (GV.isDSOLocal() && !GV.isImplicitDSOLocal())
3796 Out << "dso_local ";
3797}
3798
3800 formatted_raw_ostream &Out) {
3801 switch (SCT) {
3803 case GlobalValue::DLLImportStorageClass: Out << "dllimport "; break;
3804 case GlobalValue::DLLExportStorageClass: Out << "dllexport "; break;
3805 }
3806}
3807
3809 formatted_raw_ostream &Out) {
3810 switch (TLM) {
3812 break;
3814 Out << "thread_local ";
3815 break;
3817 Out << "thread_local(localdynamic) ";
3818 break;
3820 Out << "thread_local(initialexec) ";
3821 break;
3823 Out << "thread_local(localexec) ";
3824 break;
3825 }
3826}
3827
3829 switch (UA) {
3831 return "";
3833 return "local_unnamed_addr";
3835 return "unnamed_addr";
3836 }
3837 llvm_unreachable("Unknown UnnamedAddr");
3838}
3839
3841 const GlobalObject &GO) {
3842 const Comdat *C = GO.getComdat();
3843 if (!C)
3844 return;
3845
3846 if (isa<GlobalVariable>(GO))
3847 Out << ',';
3848 Out << " comdat";
3849
3850 if (GO.getName() == C->getName())
3851 return;
3852
3853 Out << '(';
3854 printLLVMName(Out, C->getName(), ComdatPrefix);
3855 Out << ')';
3856}
3857
3858void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
3859 if (GV->isMaterializable())
3860 Out << "; Materializable\n";
3861
3862 AsmWriterContext WriterCtx(&TypePrinter, &Machine, GV->getParent());
3863 writeAsOperandInternal(Out, GV, WriterCtx);
3864 Out << " = ";
3865
3866 if (!GV->hasInitializer() && GV->hasExternalLinkage())
3867 Out << "external ";
3868
3869 Out << getLinkageNameWithSpace(GV->getLinkage());
3870 printDSOLocation(*GV, Out);
3871 printVisibility(GV->getVisibility(), Out);
3874 StringRef UA = getUnnamedAddrEncoding(GV->getUnnamedAddr());
3875 if (!UA.empty())
3876 Out << UA << ' ';
3877
3878 if (unsigned AddressSpace = GV->getType()->getAddressSpace())
3879 Out << "addrspace(" << AddressSpace << ") ";
3880 if (GV->isExternallyInitialized()) Out << "externally_initialized ";
3881 Out << (GV->isConstant() ? "constant " : "global ");
3882 TypePrinter.print(GV->getValueType(), Out);
3883
3884 if (GV->hasInitializer()) {
3885 Out << ' ';
3886 writeOperand(GV->getInitializer(), false);
3887 }
3888
3889 if (GV->hasSection()) {
3890 Out << ", section \"";
3891 printEscapedString(GV->getSection(), Out);
3892 Out << '"';
3893 }
3894 if (GV->hasPartition()) {
3895 Out << ", partition \"";
3896 printEscapedString(GV->getPartition(), Out);
3897 Out << '"';
3898 }
3899 if (auto CM = GV->getCodeModel()) {
3900 Out << ", code_model \"";
3901 switch (*CM) {
3902 case CodeModel::Tiny:
3903 Out << "tiny";
3904 break;
3905 case CodeModel::Small:
3906 Out << "small";
3907 break;
3908 case CodeModel::Kernel:
3909 Out << "kernel";
3910 break;
3911 case CodeModel::Medium:
3912 Out << "medium";
3913 break;
3914 case CodeModel::Large:
3915 Out << "large";
3916 break;
3917 }
3918 Out << '"';
3919 }
3920
3921 using SanitizerMetadata = llvm::GlobalValue::SanitizerMetadata;
3922 if (GV->hasSanitizerMetadata()) {
3924 if (MD.NoAddress)
3925 Out << ", no_sanitize_address";
3926 if (MD.NoHWAddress)
3927 Out << ", no_sanitize_hwaddress";
3928 if (MD.Memtag)
3929 Out << ", sanitize_memtag";
3930 if (MD.IsDynInit)
3931 Out << ", sanitize_address_dyninit";
3932 }
3933
3934 maybePrintComdat(Out, *GV);
3935 if (MaybeAlign A = GV->getAlign())
3936 Out << ", align " << A->value();
3937
3939 GV->getAllMetadata(MDs);
3940 printMetadataAttachments(MDs, ", ");
3941
3942 auto Attrs = GV->getAttributes();
3943 if (Attrs.hasAttributes())
3944 Out << " #" << Machine.getAttributeGroupSlot(Attrs);
3945
3946 printInfoComment(*GV);
3947}
3948
3949void AssemblyWriter::printAlias(const GlobalAlias *GA) {
3950 if (GA->isMaterializable())
3951 Out << "; Materializable\n";
3952
3953 AsmWriterContext WriterCtx(&TypePrinter, &Machine, GA->getParent());
3954 writeAsOperandInternal(Out, GA, WriterCtx);
3955 Out << " = ";
3956
3957 Out << getLinkageNameWithSpace(GA->getLinkage());
3958 printDSOLocation(*GA, Out);
3959 printVisibility(GA->getVisibility(), Out);
3962 StringRef UA = getUnnamedAddrEncoding(GA->getUnnamedAddr());
3963 if (!UA.empty())
3964 Out << UA << ' ';
3965
3966 Out << "alias ";
3967
3968 TypePrinter.print(GA->getValueType(), Out);
3969 Out << ", ";
3970
3971 if (const Constant *Aliasee = GA->getAliasee()) {
3972 writeOperand(Aliasee, !isa<ConstantExpr>(Aliasee));
3973 } else {
3974 TypePrinter.print(GA->getType(), Out);
3975 Out << " <<NULL ALIASEE>>";
3976 }
3977
3978 if (GA->hasPartition()) {
3979 Out << ", partition \"";
3980 printEscapedString(GA->getPartition(), Out);
3981 Out << '"';
3982 }
3983
3984 printInfoComment(*GA);
3985 Out << '\n';
3986}
3987
3988void AssemblyWriter::printIFunc(const GlobalIFunc *GI) {
3989 if (GI->isMaterializable())
3990 Out << "; Materializable\n";
3991
3992 AsmWriterContext WriterCtx(&TypePrinter, &Machine, GI->getParent());
3993 writeAsOperandInternal(Out, GI, WriterCtx);
3994 Out << " = ";
3995
3996 Out << getLinkageNameWithSpace(GI->getLinkage());
3997 printDSOLocation(*GI, Out);
3998 printVisibility(GI->getVisibility(), Out);
3999
4000 Out << "ifunc ";
4001
4002 TypePrinter.print(GI->getValueType(), Out);
4003 Out << ", ";
4004
4005 if (const Constant *Resolver = GI->getResolver()) {
4006 writeOperand(Resolver, !isa<ConstantExpr>(Resolver));
4007 } else {
4008 TypePrinter.print(GI->getType(), Out);
4009 Out << " <<NULL RESOLVER>>";
4010 }
4011
4012 if (GI->hasPartition()) {
4013 Out << ", partition \"";
4014 printEscapedString(GI->getPartition(), Out);
4015 Out << '"';
4016 }
4018 GI->getAllMetadata(MDs);
4019 if (!MDs.empty()) {
4020 printMetadataAttachments(MDs, ", ");
4021 }
4022
4023 printInfoComment(*GI);
4024 Out << '\n';
4025}
4026
4027void AssemblyWriter::printComdat(const Comdat *C) {
4028 C->print(Out);
4029}
4030
4031void AssemblyWriter::printTypeIdentities() {
4032 if (TypePrinter.empty())
4033 return;
4034
4035 Out << '\n';
4036
4037 // Emit all numbered types.
4038 auto &NumberedTypes = TypePrinter.getNumberedTypes();
4039 for (unsigned I = 0, E = NumberedTypes.size(); I != E; ++I) {
4040 Out << '%' << I << " = type ";
4041
4042 // Make sure we print out at least one level of the type structure, so
4043 // that we do not get %2 = type %2
4044 TypePrinter.printStructBody(NumberedTypes[I], Out);
4045 Out << '\n';
4046 }
4047
4048 auto &NamedTypes = TypePrinter.getNamedTypes();
4049 for (StructType *NamedType : NamedTypes) {
4050 printLLVMName(Out, NamedType->getName(), LocalPrefix);
4051 Out << " = type ";
4052
4053 // Make sure we print out at least one level of the type structure, so
4054 // that we do not get %FILE = type %FILE
4055 TypePrinter.printStructBody(NamedType, Out);
4056 Out << '\n';
4057 }
4058}
4059
4060/// printFunction - Print all aspects of a function.
4061void AssemblyWriter::printFunction(const Function *F) {
4062 if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out);
4063
4064 if (F->isMaterializable())
4065 Out << "; Materializable\n";
4066
4067 const AttributeList &Attrs = F->getAttributes();
4068 if (Attrs.hasFnAttrs()) {
4069 AttributeSet AS = Attrs.getFnAttrs();
4070 std::string AttrStr;
4071
4072 for (const Attribute &Attr : AS) {
4073 if (!Attr.isStringAttribute()) {
4074 if (!AttrStr.empty()) AttrStr += ' ';
4075 AttrStr += Attr.getAsString();
4076 }
4077 }
4078
4079 if (!AttrStr.empty())
4080 Out << "; Function Attrs: " << AttrStr << '\n';
4081 }
4082
4083 if (F->isIntrinsic() && F->getIntrinsicID() == Intrinsic::not_intrinsic)
4084 Out << "; Unknown intrinsic\n";
4085
4086 Machine.incorporateFunction(F);
4087
4088 if (F->isDeclaration()) {
4089 Out << "declare";
4091 F->getAllMetadata(MDs);
4092 printMetadataAttachments(MDs, " ");
4093 Out << ' ';
4094 } else
4095 Out << "define ";
4096
4097 Out << getLinkageNameWithSpace(F->getLinkage());
4098 printDSOLocation(*F, Out);
4099 printVisibility(F->getVisibility(), Out);
4100 printDLLStorageClass(F->getDLLStorageClass(), Out);
4101
4102 // Print the calling convention.
4103 if (F->getCallingConv() != CallingConv::C) {
4104 printCallingConv(F->getCallingConv(), Out);
4105 Out << " ";
4106 }
4107
4108 FunctionType *FT = F->getFunctionType();
4109 if (Attrs.hasRetAttrs())
4110 Out << Attrs.getAsString(AttributeList::ReturnIndex) << ' ';
4111 TypePrinter.print(F->getReturnType(), Out);
4112 AsmWriterContext WriterCtx(&TypePrinter, &Machine, F->getParent());
4113 Out << ' ';
4114 writeAsOperandInternal(Out, F, WriterCtx);
4115 Out << '(';
4116
4117 // Loop over the arguments, printing them...
4118 if (F->isDeclaration() && !IsForDebug) {
4119 // We're only interested in the type here - don't print argument names.
4120 ListSeparator LS;
4121 for (unsigned I = 0, E = FT->getNumParams(); I != E; ++I) {
4122 Out << LS;
4123 // Output type.
4124 TypePrinter.print(FT->getParamType(I), Out);
4125
4126 AttributeSet ArgAttrs = Attrs.getParamAttrs(I);
4127 if (ArgAttrs.hasAttributes()) {
4128 Out << ' ';
4129 writeAttributeSet(ArgAttrs);
4130 }
4131 }
4132 } else {
4133 // The arguments are meaningful here, print them in detail.
4134 ListSeparator LS;
4135 for (const Argument &Arg : F->args()) {
4136 Out << LS;
4137 printArgument(&Arg, Attrs.getParamAttrs(Arg.getArgNo()));
4138 }
4139 }
4140
4141 // Finish printing arguments...
4142 if (FT->isVarArg()) {
4143 if (FT->getNumParams()) Out << ", ";
4144 Out << "..."; // Output varargs portion of signature!
4145 }
4146 Out << ')';
4147 StringRef UA = getUnnamedAddrEncoding(F->getUnnamedAddr());
4148 if (!UA.empty())
4149 Out << ' ' << UA;
4150 // We print the function address space if it is non-zero or if we are writing
4151 // a module with a non-zero program address space or if there is no valid
4152 // Module* so that the file can be parsed without the datalayout string.
4153 const Module *Mod = F->getParent();
4154 if (F->getAddressSpace() != 0 || !Mod ||
4155 Mod->getDataLayout().getProgramAddressSpace() != 0)
4156 Out << " addrspace(" << F->getAddressSpace() << ")";
4157 if (Attrs.hasFnAttrs())
4158 Out << " #" << Machine.getAttributeGroupSlot(Attrs.getFnAttrs());
4159 if (F->hasSection()) {
4160 Out << " section \"";
4161 printEscapedString(F->getSection(), Out);
4162 Out << '"';
4163 }
4164 if (F->hasPartition()) {
4165 Out << " partition \"";
4166 printEscapedString(F->getPartition(), Out);
4167 Out << '"';
4168 }
4169 maybePrintComdat(Out, *F);
4170 if (MaybeAlign A = F->getAlign())
4171 Out << " align " << A->value();
4172 if (F->hasGC())
4173 Out << " gc \"" << F->getGC() << '"';
4174 if (F->hasPrefixData()) {
4175 Out << " prefix ";
4176 writeOperand(F->getPrefixData(), true);
4177 }
4178 if (F->hasPrologueData()) {
4179 Out << " prologue ";
4180 writeOperand(F->getPrologueData(), true);
4181 }
4182 if (F->hasPersonalityFn()) {
4183 Out << " personality ";
4184 writeOperand(F->getPersonalityFn(), /*PrintType=*/true);
4185 }
4186
4187 if (PrintProfData) {
4188 if (auto *MDProf = F->getMetadata(LLVMContext::MD_prof)) {
4189 Out << " ";
4190 MDProf->print(Out, TheModule, /*IsForDebug=*/true);
4191 }
4192 }
4193
4194 if (F->isDeclaration()) {
4195 Out << '\n';
4196 } else {
4198 F->getAllMetadata(MDs);
4199 printMetadataAttachments(MDs, " ");
4200
4201 Out << " {";
4202 // Output all of the function's basic blocks.
4203 for (const BasicBlock &BB : *F)
4204 printBasicBlock(&BB);
4205
4206 // Output the function's use-lists.
4207 printUseLists(F);
4208
4209 Out << "}\n";
4210 }
4211
4212 Machine.purgeFunction();
4213}
4214
4215/// printArgument - This member is called for every argument that is passed into
4216/// the function. Simply print it out
4217void AssemblyWriter::printArgument(const Argument *Arg, AttributeSet Attrs) {
4218 // Output type...
4219 TypePrinter.print(Arg->getType(), Out);
4220
4221 // Output parameter attributes list
4222 if (Attrs.hasAttributes()) {
4223 Out << ' ';
4224 writeAttributeSet(Attrs);
4225 }
4226
4227 // Output name, if available...
4228 if (Arg->hasName()) {
4229 Out << ' ';
4230 printLLVMName(Out, Arg);
4231 } else {
4232 int Slot = Machine.getLocalSlot(Arg);
4233 assert(Slot != -1 && "expect argument in function here");
4234 Out << " %" << Slot;
4235 }
4236}
4237
4238/// printBasicBlock - This member is called for each basic block in a method.
4239void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
4240 bool IsEntryBlock = BB->getParent() && BB->isEntryBlock();
4241 if (BB->hasName()) { // Print out the label if it exists...
4242 Out << "\n";
4243 printLLVMName(Out, BB->getName(), LabelPrefix);
4244 Out << ':';
4245 } else if (!IsEntryBlock) {
4246 Out << "\n";
4247 int Slot = Machine.getLocalSlot(BB);
4248 if (Slot != -1)
4249 Out << Slot << ":";
4250 else
4251 Out << "<badref>:";
4252 }
4253
4254 if (!IsEntryBlock) {
4255 // Output predecessors for the block.
4256 Out.PadToColumn(50);
4257 Out << ";";
4258 if (pred_empty(BB)) {
4259 Out << " No predecessors!";
4260 } else {
4261 Out << " preds = ";
4262 ListSeparator LS;
4263 for (const BasicBlock *Pred : predecessors(BB)) {
4264 Out << LS;
4265 writeOperand(Pred, false);
4266 }
4267 }
4268 }
4269
4270 Out << "\n";
4271
4272 if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out);
4273
4274 // Output all of the instructions in the basic block...
4275 for (const Instruction &I : *BB) {
4276 for (const DbgRecord &DR : I.getDbgRecordRange())
4277 printDbgRecordLine(DR);
4278 printInstructionLine(I);
4279 }
4280
4281 if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out);
4282}
4283
4284/// printInstructionLine - Print an instruction and a newline character.
4285void AssemblyWriter::printInstructionLine(const Instruction &I) {
4286 printInstruction(I);
4287 Out << '\n';
4288}
4289
4290/// printGCRelocateComment - print comment after call to the gc.relocate
4291/// intrinsic indicating base and derived pointer names.
4292void AssemblyWriter::printGCRelocateComment(const GCRelocateInst &Relocate) {
4293 Out << " ; (";
4294 writeOperand(Relocate.getBasePtr(), false);
4295 Out << ", ";
4296 writeOperand(Relocate.getDerivedPtr(), false);
4297 Out << ")";
4298}
4299
4300/// printInfoComment - Print a little comment after the instruction indicating
4301/// which slot it occupies.
4302void AssemblyWriter::printInfoComment(const Value &V) {
4303 if (const auto *Relocate = dyn_cast<GCRelocateInst>(&V))
4304 printGCRelocateComment(*Relocate);
4305
4306 if (AnnotationWriter) {
4307 AnnotationWriter->printInfoComment(V, Out);
4308 }
4309
4310 if (PrintInstDebugLocs) {
4311 if (auto *I = dyn_cast<Instruction>(&V)) {
4312 if (I->getDebugLoc()) {
4313 Out << " ; ";
4314 I->getDebugLoc().print(Out);
4315 }
4316 }
4317 }
4318 if (PrintProfData) {
4319 if (auto *I = dyn_cast<Instruction>(&V)) {
4320 if (auto *MD = I->getMetadata(LLVMContext::MD_prof)) {
4321 Out << " ; ";
4322 MD->print(Out, TheModule, /*IsForDebug=*/true);
4323 }
4324 }
4325 }
4326
4327 if (PrintInstAddrs)
4328 Out << " ; " << &V;
4329}
4330
4331static void maybePrintCallAddrSpace(const Value *Operand, const Instruction *I,
4332 raw_ostream &Out) {
4333 // We print the address space of the call if it is non-zero.
4334 if (Operand == nullptr) {
4335 Out << " <cannot get addrspace!>";
4336 return;
4337 }
4338 unsigned CallAddrSpace = Operand->getType()->getPointerAddressSpace();
4339 bool PrintAddrSpace = CallAddrSpace != 0;
4340 if (!PrintAddrSpace) {
4341 const Module *Mod = getModuleFromVal(I);
4342 // We also print it if it is zero but not equal to the program address space
4343 // or if we can't find a valid Module* to make it possible to parse
4344 // the resulting file even without a datalayout string.
4345 if (!Mod || Mod->getDataLayout().getProgramAddressSpace() != 0)
4346 PrintAddrSpace = true;
4347 }
4348 if (PrintAddrSpace)
4349 Out << " addrspace(" << CallAddrSpace << ")";
4350}
4351
4352// This member is called for each Instruction in a function..
4353void AssemblyWriter::printInstruction(const Instruction &I) {
4354 if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out);
4355
4356 // Print out indentation for an instruction.
4357 Out << " ";
4358
4359 // Print out name if it exists...
4360 if (I.hasName()) {
4361 printLLVMName(Out, &I);
4362 Out << " = ";
4363 } else if (!I.getType()->isVoidTy()) {
4364 // Print out the def slot taken.
4365 int SlotNum = Machine.getLocalSlot(&I);
4366 if (SlotNum == -1)
4367 Out << "<badref> = ";
4368 else
4369 Out << '%' << SlotNum << " = ";
4370 }
4371
4372 if (const auto *CI = dyn_cast<CallInst>(&I)) {
4373 if (CI->isMustTailCall())
4374 Out << "musttail ";
4375 else if (CI->isTailCall())
4376 Out << "tail ";
4377 else if (CI->isNoTailCall())
4378 Out << "notail ";
4379 }
4380
4381 // Print out the opcode...
4382 Out << I.getOpcodeName();
4383
4384 // If this is an atomic load or store, print out the atomic marker.
4385 if ((isa<LoadInst>(I) && cast<LoadInst>(I).isAtomic()) ||
4386 (isa<StoreInst>(I) && cast<StoreInst>(I).isAtomic()))
4387 Out << " atomic";
4388
4390 Out << " weak";
4391
4392 // If this is a volatile operation, print out the volatile marker.
4393 if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) ||
4394 (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile()) ||
4395 (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).isVolatile()) ||
4396 (isa<AtomicRMWInst>(I) && cast<AtomicRMWInst>(I).isVolatile()))
4397 Out << " volatile";
4398
4399 // Print out optimization information.
4400 writeOptimizationInfo(Out, &I);
4401
4402 // Print out the compare instruction predicates
4403 if (const auto *CI = dyn_cast<CmpInst>(&I))
4404 Out << ' ' << CI->getPredicate();
4405
4406 // Print out the atomicrmw operation
4407 if (const auto *RMWI = dyn_cast<AtomicRMWInst>(&I))
4408 Out << ' ' << AtomicRMWInst::getOperationName(RMWI->getOperation());
4409
4410 // Print out the type of the operands...
4411 const Value *Operand = I.getNumOperands() ? I.getOperand(0) : nullptr;
4412
4413 // Special case conditional branches to swizzle the condition out to the front
4414 if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) {
4415 const BranchInst &BI(cast<BranchInst>(I));
4416 Out << ' ';
4417 writeOperand(BI.getCondition(), true);
4418 Out << ", ";
4419 writeOperand(BI.getSuccessor(0), true);
4420 Out << ", ";
4421 writeOperand(BI.getSuccessor(1), true);
4422
4423 } else if (isa<SwitchInst>(I)) {
4424 const SwitchInst& SI(cast<SwitchInst>(I));
4425 // Special case switch instruction to get formatting nice and correct.
4426 Out << ' ';
4427 writeOperand(SI.getCondition(), true);
4428 Out << ", ";
4429 writeOperand(SI.getDefaultDest(), true);
4430 Out << " [";
4431 for (auto Case : SI.cases()) {
4432 Out << "\n ";
4433 writeOperand(Case.getCaseValue(), true);
4434 Out << ", ";
4435 writeOperand(Case.getCaseSuccessor(), true);
4436 }
4437 Out << "\n ]";
4438 } else if (isa<IndirectBrInst>(I)) {
4439 // Special case indirectbr instruction to get formatting nice and correct.
4440 Out << ' ';
4441 writeOperand(Operand, true);
4442 Out << ", [";
4443
4444 ListSeparator LS;
4445 for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) {
4446 Out << LS;
4447 writeOperand(I.getOperand(i), true);
4448 }
4449 Out << ']';
4450 } else if (const auto *PN = dyn_cast<PHINode>(&I)) {
4451 Out << ' ';
4452 TypePrinter.print(I.getType(), Out);
4453 Out << ' ';
4454
4455 ListSeparator LS;
4456 for (const auto &[V, Block] :
4457 zip_equal(PN->incoming_values(), PN->blocks())) {
4458 Out << LS << "[ ";
4459 writeOperand(V, false);
4460 Out << ", ";
4461 writeOperand(Block, false);
4462 Out << " ]";
4463 }
4464 } else if (const auto *EVI = dyn_cast<ExtractValueInst>(&I)) {
4465 Out << ' ';
4466 writeOperand(I.getOperand(0), true);
4467 Out << ", ";
4468 Out << llvm::interleaved(EVI->indices());
4469 } else if (const auto *IVI = dyn_cast<InsertValueInst>(&I)) {
4470 Out << ' ';
4471 writeOperand(I.getOperand(0), true); Out << ", ";
4472 writeOperand(I.getOperand(1), true);
4473 Out << ", ";
4474 Out << llvm::interleaved(IVI->indices());
4475 } else if (const auto *LPI = dyn_cast<LandingPadInst>(&I)) {
4476 Out << ' ';
4477 TypePrinter.print(I.getType(), Out);
4478 if (LPI->isCleanup() || LPI->getNumClauses() != 0)
4479 Out << '\n';
4480
4481 if (LPI->isCleanup())
4482 Out << " cleanup";
4483
4484 for (unsigned i = 0, e = LPI->getNumClauses(); i != e; ++i) {
4485 if (i != 0 || LPI->isCleanup()) Out << "\n";
4486 if (LPI->isCatch(i))
4487 Out << " catch ";
4488 else
4489 Out << " filter ";
4490
4491 writeOperand(LPI->getClause(i), true);
4492 }
4493 } else if (const auto *CatchSwitch = dyn_cast<CatchSwitchInst>(&I)) {
4494 Out << " within ";
4495 writeOperand(CatchSwitch->getParentPad(), /*PrintType=*/false);
4496 Out << " [";
4497 ListSeparator LS;
4498 for (const BasicBlock *PadBB : CatchSwitch->handlers()) {
4499 Out << LS;
4500 writeOperand(PadBB, /*PrintType=*/true);
4501 }
4502 Out << "] unwind ";
4503 if (const BasicBlock *UnwindDest = CatchSwitch->getUnwindDest())
4504 writeOperand(UnwindDest, /*PrintType=*/true);
4505 else
4506 Out << "to caller";
4507 } else if (const auto *FPI = dyn_cast<FuncletPadInst>(&I)) {
4508 Out << " within ";
4509 writeOperand(FPI->getParentPad(), /*PrintType=*/false);
4510 Out << " [";
4511 ListSeparator LS;
4512 for (const Value *Op : FPI->arg_operands()) {
4513 Out << LS;
4514 writeOperand(Op, /*PrintType=*/true);
4515 }
4516 Out << ']';
4517 } else if (isa<ReturnInst>(I) && !Operand) {
4518 Out << " void";
4519 } else if (const auto *CRI = dyn_cast<CatchReturnInst>(&I)) {
4520 Out << " from ";
4521 writeOperand(CRI->getOperand(0), /*PrintType=*/false);
4522
4523 Out << " to ";
4524 writeOperand(CRI->getOperand(1), /*PrintType=*/true);
4525 } else if (const auto *CRI = dyn_cast<CleanupReturnInst>(&I)) {
4526 Out << " from ";
4527 writeOperand(CRI->getOperand(0), /*PrintType=*/false);
4528
4529 Out << " unwind ";
4530 if (CRI->hasUnwindDest())
4531 writeOperand(CRI->getOperand(1), /*PrintType=*/true);
4532 else
4533 Out << "to caller";
4534 } else if (const auto *CI = dyn_cast<CallInst>(&I)) {
4535 // Print the calling convention being used.
4536 if (CI->getCallingConv() != CallingConv::C) {
4537 Out << " ";
4538 printCallingConv(CI->getCallingConv(), Out);
4539 }
4540
4541 Operand = CI->getCalledOperand();
4542 FunctionType *FTy = CI->getFunctionType();
4543 Type *RetTy = FTy->getReturnType();
4544 const AttributeList &PAL = CI->getAttributes();
4545
4546 if (PAL.hasRetAttrs())
4547 Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
4548
4549 // Only print addrspace(N) if necessary:
4550 maybePrintCallAddrSpace(Operand, &I, Out);
4551
4552 // If possible, print out the short form of the call instruction. We can
4553 // only do this if the first argument is a pointer to a nonvararg function,
4554 // and if the return type is not a pointer to a function.
4555 Out << ' ';
4556 TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
4557 Out << ' ';
4558 writeOperand(Operand, false);
4559 Out << '(';
4560 ListSeparator LS;
4561 for (unsigned op = 0, Eop = CI->arg_size(); op < Eop; ++op) {
4562 Out << LS;
4563 writeParamOperand(CI->getArgOperand(op), PAL.getParamAttrs(op));
4564 }
4565
4566 // Emit an ellipsis if this is a musttail call in a vararg function. This
4567 // is only to aid readability, musttail calls forward varargs by default.
4568 if (CI->isMustTailCall() && CI->getParent() &&
4569 CI->getParent()->getParent() &&
4570 CI->getParent()->getParent()->isVarArg()) {
4571 if (CI->arg_size() > 0)
4572 Out << ", ";
4573 Out << "...";
4574 }
4575
4576 Out << ')';
4577 if (PAL.hasFnAttrs())
4578 Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttrs());
4579
4580 writeOperandBundles(CI);
4581 } else if (const auto *II = dyn_cast<InvokeInst>(&I)) {
4582 Operand = II->getCalledOperand();
4583 FunctionType *FTy = II->getFunctionType();
4584 Type *RetTy = FTy->getReturnType();
4585 const AttributeList &PAL = II->getAttributes();
4586
4587 // Print the calling convention being used.
4588 if (II->getCallingConv() != CallingConv::C) {
4589 Out << " ";
4590 printCallingConv(II->getCallingConv(), Out);
4591 }
4592
4593 if (PAL.hasRetAttrs())
4594 Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
4595
4596 // Only print addrspace(N) if necessary:
4597 maybePrintCallAddrSpace(Operand, &I, Out);
4598
4599 // If possible, print out the short form of the invoke instruction. We can
4600 // only do this if the first argument is a pointer to a nonvararg function,
4601 // and if the return type is not a pointer to a function.
4602 //
4603 Out << ' ';
4604 TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
4605 Out << ' ';
4606 writeOperand(Operand, false);
4607 Out << '(';
4608 ListSeparator LS;
4609 for (unsigned op = 0, Eop = II->arg_size(); op < Eop; ++op) {
4610 Out << LS;
4611 writeParamOperand(II->getArgOperand(op), PAL.getParamAttrs(op));
4612 }
4613
4614 Out << ')';
4615 if (PAL.hasFnAttrs())
4616 Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttrs());
4617
4618 writeOperandBundles(II);
4619
4620 Out << "\n to ";
4621 writeOperand(II->getNormalDest(), true);
4622 Out << " unwind ";
4623 writeOperand(II->getUnwindDest(), true);
4624 } else if (const auto *CBI = dyn_cast<CallBrInst>(&I)) {
4625 Operand = CBI->getCalledOperand();
4626 FunctionType *FTy = CBI->getFunctionType();
4627 Type *RetTy = FTy->getReturnType();
4628 const AttributeList &PAL = CBI->getAttributes();
4629
4630 // Print the calling convention being used.
4631 if (CBI->getCallingConv() != CallingConv::C) {
4632 Out << " ";
4633 printCallingConv(CBI->getCallingConv(), Out);
4634 }
4635
4636 if (PAL.hasRetAttrs())
4637 Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
4638
4639 // If possible, print out the short form of the callbr instruction. We can
4640 // only do this if the first argument is a pointer to a nonvararg function,
4641 // and if the return type is not a pointer to a function.
4642 //
4643 Out << ' ';
4644 TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
4645 Out << ' ';
4646 writeOperand(Operand, false);
4647 Out << '(';
4648 ListSeparator ArgLS;
4649 for (unsigned op = 0, Eop = CBI->arg_size(); op < Eop; ++op) {
4650 Out << ArgLS;
4651 writeParamOperand(CBI->getArgOperand(op), PAL.getParamAttrs(op));
4652 }
4653
4654 Out << ')';
4655 if (PAL.hasFnAttrs())
4656 Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttrs());
4657
4658 writeOperandBundles(CBI);
4659
4660 Out << "\n to ";
4661 writeOperand(CBI->getDefaultDest(), true);
4662 Out << " [";
4663 ListSeparator DestLS;
4664 for (const BasicBlock *Dest : CBI->getIndirectDests()) {
4665 Out << DestLS;
4666 writeOperand(Dest, true);
4667 }
4668 Out << ']';
4669 } else if (const auto *AI = dyn_cast<AllocaInst>(&I)) {
4670 Out << ' ';
4671 if (AI->isUsedWithInAlloca())
4672 Out << "inalloca ";
4673 if (AI->isSwiftError())
4674 Out << "swifterror ";
4675 TypePrinter.print(AI->getAllocatedType(), Out);
4676
4677 // Explicitly write the array size if the code is broken, if it's an array
4678 // allocation, or if the type is not canonical for scalar allocations. The
4679 // latter case prevents the type from mutating when round-tripping through
4680 // assembly.
4681 if (!AI->getArraySize() || AI->isArrayAllocation() ||
4682 !AI->getArraySize()->getType()->isIntegerTy(32)) {
4683 Out << ", ";
4684 writeOperand(AI->getArraySize(), true);
4685 }
4686 if (MaybeAlign A = AI->getAlign()) {
4687 Out << ", align " << A->value();
4688 }
4689
4690 unsigned AddrSpace = AI->getAddressSpace();
4691 if (AddrSpace != 0)
4692 Out << ", addrspace(" << AddrSpace << ')';
4693 } else if (isa<CastInst>(I)) {
4694 if (Operand) {
4695 Out << ' ';
4696 writeOperand(Operand, true); // Work with broken code
4697 }
4698 Out << " to ";
4699 TypePrinter.print(I.getType(), Out);
4700 } else if (isa<VAArgInst>(I)) {
4701 if (Operand) {
4702 Out << ' ';
4703 writeOperand(Operand, true); // Work with broken code
4704 }
4705 Out << ", ";
4706 TypePrinter.print(I.getType(), Out);
4707 } else if (Operand) { // Print the normal way.
4708 if (const auto *GEP = dyn_cast<GetElementPtrInst>(&I)) {
4709 Out << ' ';
4710 TypePrinter.print(GEP->getSourceElementType(), Out);
4711 Out << ',';
4712 } else if (const auto *LI = dyn_cast<LoadInst>(&I)) {
4713 Out << ' ';
4714 TypePrinter.print(LI->getType(), Out);
4715 Out << ',';
4716 }
4717
4718 // PrintAllTypes - Instructions who have operands of all the same type
4719 // omit the type from all but the first operand. If the instruction has
4720 // different type operands (for example br), then they are all printed.
4721 bool PrintAllTypes = false;
4722 Type *TheType = Operand->getType();
4723
4724 // Select, Store, ShuffleVector, CmpXchg and AtomicRMW always print all
4725 // types.
4729 PrintAllTypes = true;
4730 } else {
4731 for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) {
4732 Operand = I.getOperand(i);
4733 // note that Operand shouldn't be null, but the test helps make dump()
4734 // more tolerant of malformed IR
4735 if (Operand && Operand->getType() != TheType) {
4736 PrintAllTypes = true; // We have differing types! Print them all!
4737 break;
4738 }
4739 }
4740 }
4741
4742 if (!PrintAllTypes) {
4743 Out << ' ';
4744 TypePrinter.print(TheType, Out);
4745 }
4746
4747 Out << ' ';
4748 ListSeparator LS;
4749 for (const Value *Op : I.operands()) {
4750 Out << LS;
4751 writeOperand(Op, PrintAllTypes);
4752 }
4753 }
4754
4755 // Print atomic ordering/alignment for memory operations
4756 if (const auto *LI = dyn_cast<LoadInst>(&I)) {
4757 if (LI->isAtomic())
4758 writeAtomic(LI->getContext(), LI->getOrdering(), LI->getSyncScopeID());
4759 if (MaybeAlign A = LI->getAlign())
4760 Out << ", align " << A->value();
4761 } else if (const auto *SI = dyn_cast<StoreInst>(&I)) {
4762 if (SI->isAtomic())
4763 writeAtomic(SI->getContext(), SI->getOrdering(), SI->getSyncScopeID());
4764 if (MaybeAlign A = SI->getAlign())
4765 Out << ", align " << A->value();
4766 } else if (const auto *CXI = dyn_cast<AtomicCmpXchgInst>(&I)) {
4767 writeAtomicCmpXchg(CXI->getContext(), CXI->getSuccessOrdering(),
4768 CXI->getFailureOrdering(), CXI->getSyncScopeID());
4769 Out << ", align " << CXI->getAlign().value();
4770 } else if (const auto *RMWI = dyn_cast<AtomicRMWInst>(&I)) {
4771 writeAtomic(RMWI->getContext(), RMWI->getOrdering(),
4772 RMWI->getSyncScopeID());
4773 Out << ", align " << RMWI->getAlign().value();
4774 } else if (const auto *FI = dyn_cast<FenceInst>(&I)) {
4775 writeAtomic(FI->getContext(), FI->getOrdering(), FI->getSyncScopeID());
4776 } else if (const auto *SVI = dyn_cast<ShuffleVectorInst>(&I)) {
4777 printShuffleMask(Out, SVI->getType(), SVI->getShuffleMask());
4778 }
4779
4780 // Print Metadata info.
4782 I.getAllMetadata(InstMD);
4783 printMetadataAttachments(InstMD, ", ");
4784
4785 // Print a nice comment.
4786 printInfoComment(I);
4787}
4788
4789void AssemblyWriter::printDbgMarker(const DbgMarker &Marker) {
4790 // There's no formal representation of a DbgMarker -- print purely as a
4791 // debugging aid.
4792 for (const DbgRecord &DPR : Marker.StoredDbgRecords) {
4793 printDbgRecord(DPR);
4794 Out << "\n";
4795 }
4796
4797 Out << " DbgMarker -> { ";
4798 printInstruction(*Marker.MarkedInstr);
4799 Out << " }";
4800}
4801
4802void AssemblyWriter::printDbgRecord(const DbgRecord &DR) {
4803 if (auto *DVR = dyn_cast<DbgVariableRecord>(&DR))
4804 printDbgVariableRecord(*DVR);
4805 else if (auto *DLR = dyn_cast<DbgLabelRecord>(&DR))
4806 printDbgLabelRecord(*DLR);
4807 else
4808 llvm_unreachable("Unexpected DbgRecord kind");
4809}
4810
4811void AssemblyWriter::printDbgVariableRecord(const DbgVariableRecord &DVR) {
4812 auto WriterCtx = getContext();
4813 Out << "#dbg_";
4814 switch (DVR.getType()) {
4815 case DbgVariableRecord::LocationType::Value:
4816 Out << "value";
4817 break;
4818 case DbgVariableRecord::LocationType::Declare:
4819 Out << "declare";
4820 break;
4821 case DbgVariableRecord::LocationType::Assign:
4822 Out << "assign";
4823 break;
4824 default:
4826 "Tried to print a DbgVariableRecord with an invalid LocationType!");
4827 }
4828
4829 auto PrintOrNull = [&](Metadata *M) {
4830 if (!M)
4831 Out << "(null)";
4832 else
4833 writeAsOperandInternal(Out, M, WriterCtx, true);
4834 };
4835
4836 Out << "(";
4837 PrintOrNull(DVR.getRawLocation());
4838 Out << ", ";
4839 PrintOrNull(DVR.getRawVariable());
4840 Out << ", ";
4841 PrintOrNull(DVR.getRawExpression());
4842 Out << ", ";
4843 if (DVR.isDbgAssign()) {
4844 PrintOrNull(DVR.getRawAssignID());
4845 Out << ", ";
4846 PrintOrNull(DVR.getRawAddress());
4847 Out << ", ";
4848 PrintOrNull(DVR.getRawAddressExpression());
4849 Out << ", ";
4850 }
4851 PrintOrNull(DVR.getDebugLoc().getAsMDNode());
4852 Out << ")";
4853}
4854
4855/// printDbgRecordLine - Print a DbgRecord with indentation and a newline
4856/// character.
4857void AssemblyWriter::printDbgRecordLine(const DbgRecord &DR) {
4858 // Print lengthier indentation to bring out-of-line with instructions.
4859 Out << " ";
4860 printDbgRecord(DR);
4861 Out << '\n';
4862}
4863
4864void AssemblyWriter::printDbgLabelRecord(const DbgLabelRecord &Label) {
4865 auto WriterCtx = getContext();
4866 Out << "#dbg_label(";
4867 writeAsOperandInternal(Out, Label.getRawLabel(), WriterCtx, true);
4868 Out << ", ";
4869 writeAsOperandInternal(Out, Label.getDebugLoc(), WriterCtx, true);
4870 Out << ")";
4871}
4872
4873void AssemblyWriter::printMetadataAttachments(
4874 const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
4875 StringRef Separator) {
4876 if (MDs.empty())
4877 return;
4878
4879 if (MDNames.empty())
4880 MDs[0].second->getContext().getMDKindNames(MDNames);
4881
4882 auto WriterCtx = getContext();
4883 for (const auto &I : MDs) {
4884 unsigned Kind = I.first;
4885 Out << Separator;
4886 if (Kind < MDNames.size()) {
4887 Out << "!";
4888 printMetadataIdentifier(MDNames[Kind], Out);
4889 } else
4890 Out << "!<unknown kind #" << Kind << ">";
4891 Out << ' ';
4892 writeAsOperandInternal(Out, I.second, WriterCtx);
4893 }
4894}
4895
4896void AssemblyWriter::writeMDNode(unsigned Slot, const MDNode *Node) {
4897 Out << '!' << Slot << " = ";
4898 printMDNodeBody(Node);
4899 Out << "\n";
4900}
4901
4902void AssemblyWriter::writeAllMDNodes() {
4904 Nodes.resize(Machine.mdn_size());
4905 for (auto &I : llvm::make_range(Machine.mdn_begin(), Machine.mdn_end()))
4906 Nodes[I.second] = cast<MDNode>(I.first);
4907
4908 for (unsigned i = 0, e = Nodes.size(); i != e; ++i) {
4909 writeMDNode(i, Nodes[i]);
4910 }
4911}
4912
4913void AssemblyWriter::printMDNodeBody(const MDNode *Node) {
4914 auto WriterCtx = getContext();
4915 writeMDNodeBodyInternal(Out, Node, WriterCtx);
4916}
4917
4918void AssemblyWriter::writeAttribute(const Attribute &Attr, bool InAttrGroup) {
4919 if (!Attr.isTypeAttribute()) {
4920 Out << Attr.getAsString(InAttrGroup);
4921 return;
4922 }
4923
4924 Out << Attribute::getNameFromAttrKind(Attr.getKindAsEnum());
4925 if (Type *Ty = Attr.getValueAsType()) {
4926 Out << '(';
4927 TypePrinter.print(Ty, Out);
4928 Out << ')';
4929 }
4930}
4931
4932void AssemblyWriter::writeAttributeSet(const AttributeSet &AttrSet,
4933 bool InAttrGroup) {
4934 ListSeparator LS(" ");
4935 for (const auto &Attr : AttrSet) {
4936 Out << LS;
4937 writeAttribute(Attr, InAttrGroup);
4938 }
4939}
4940
4941void AssemblyWriter::writeAllAttributeGroups() {
4942 std::vector<std::pair<AttributeSet, unsigned>> asVec;
4943 asVec.resize(Machine.as_size());
4944
4945 for (auto &I : llvm::make_range(Machine.as_begin(), Machine.as_end()))
4946 asVec[I.second] = I;
4947
4948 for (const auto &I : asVec)
4949 Out << "attributes #" << I.second << " = { "
4950 << I.first.getAsString(true) << " }\n";
4951}
4952
4953void AssemblyWriter::printUseListOrder(const Value *V,
4954 ArrayRef<unsigned> Shuffle) {
4955 bool IsInFunction = Machine.getFunction();
4956 if (IsInFunction)
4957 Out << " ";
4958
4959 Out << "uselistorder";
4960 if (const BasicBlock *BB = IsInFunction ? nullptr : dyn_cast<BasicBlock>(V)) {
4961 Out << "_bb ";
4962 writeOperand(BB->getParent(), false);
4963 Out << ", ";
4964 writeOperand(BB, false);
4965 } else {
4966 Out << " ";
4967 writeOperand(V, true);
4968 }
4969
4970 assert(Shuffle.size() >= 2 && "Shuffle too small");
4971 Out << ", { " << llvm::interleaved(Shuffle) << " }\n";
4972}
4973
4974void AssemblyWriter::printUseLists(const Function *F) {
4975 auto It = UseListOrders.find(F);
4976 if (It == UseListOrders.end())
4977 return;
4978
4979 Out << "\n; uselistorder directives\n";
4980 for (const auto &Pair : It->second)
4981 printUseListOrder(Pair.first, Pair.second);
4982}
4983
4984//===----------------------------------------------------------------------===//
4985// External Interface declarations
4986//===----------------------------------------------------------------------===//
4987
4989 bool ShouldPreserveUseListOrder,
4990 bool IsForDebug) const {
4991 SlotTracker SlotTable(this->getParent());
4992 formatted_raw_ostream OS(ROS);
4993 AssemblyWriter W(OS, SlotTable, this->getParent(), AAW,
4994 IsForDebug,
4995 ShouldPreserveUseListOrder);
4996 W.printFunction(this);
4997}
4998
5000 bool ShouldPreserveUseListOrder,
5001 bool IsForDebug) const {
5002 SlotTracker SlotTable(this->getParent());
5003 formatted_raw_ostream OS(ROS);
5004 AssemblyWriter W(OS, SlotTable, this->getModule(), AAW,
5005 IsForDebug,
5006 ShouldPreserveUseListOrder);
5007 W.printBasicBlock(this);
5008}
5009
5011 bool ShouldPreserveUseListOrder, bool IsForDebug) const {
5012 SlotTracker SlotTable(this);
5013 formatted_raw_ostream OS(ROS);
5014 AssemblyWriter W(OS, SlotTable, this, AAW, IsForDebug,
5015 ShouldPreserveUseListOrder);
5016 W.printModule(this);
5017}
5018
5019void NamedMDNode::print(raw_ostream &ROS, bool IsForDebug) const {
5020 SlotTracker SlotTable(getParent());
5021 formatted_raw_ostream OS(ROS);
5022 AssemblyWriter W(OS, SlotTable, getParent(), nullptr, IsForDebug);
5023 W.printNamedMDNode(this);
5024}
5025
5027 bool IsForDebug) const {
5028 std::optional<SlotTracker> LocalST;
5029 SlotTracker *SlotTable;
5030 if (auto *ST = MST.getMachine())
5031 SlotTable = ST;
5032 else {
5033 LocalST.emplace(getParent());
5034 SlotTable = &*LocalST;
5035 }
5036
5037 formatted_raw_ostream OS(ROS);
5038 AssemblyWriter W(OS, *SlotTable, getParent(), nullptr, IsForDebug);
5039 W.printNamedMDNode(this);
5040}
5041
5042void Comdat::print(raw_ostream &ROS, bool /*IsForDebug*/) const {
5044 ROS << " = comdat ";
5045
5046 switch (getSelectionKind()) {
5047 case Comdat::Any:
5048 ROS << "any";
5049 break;
5050 case Comdat::ExactMatch:
5051 ROS << "exactmatch";
5052 break;
5053 case Comdat::Largest:
5054 ROS << "largest";
5055 break;
5057 ROS << "nodeduplicate";
5058 break;
5059 case Comdat::SameSize:
5060 ROS << "samesize";
5061 break;
5062 }
5063
5064 ROS << '\n';
5065}
5066
5067void Type::print(raw_ostream &OS, bool /*IsForDebug*/, bool NoDetails) const {
5068 TypePrinting TP;
5069 TP.print(const_cast<Type*>(this), OS);
5070
5071 if (NoDetails)
5072 return;
5073
5074 // If the type is a named struct type, print the body as well.
5075 if (auto *STy = dyn_cast<StructType>(const_cast<Type *>(this)))
5076 if (!STy->isLiteral()) {
5077 OS << " = type ";
5078 TP.printStructBody(STy, OS);
5079 }
5080}
5081
5082static bool isReferencingMDNode(const Instruction &I) {
5083 if (const auto *CI = dyn_cast<CallInst>(&I))
5084 if (Function *F = CI->getCalledFunction())
5085 if (F->isIntrinsic())
5086 for (auto &Op : I.operands())
5088 if (isa<MDNode>(V->getMetadata()))
5089 return true;
5090 return false;
5091}
5092
5093void DbgMarker::print(raw_ostream &ROS, bool IsForDebug) const {
5094
5095 ModuleSlotTracker MST(getModuleFromDPI(this), true);
5096 print(ROS, MST, IsForDebug);
5097}
5098
5099void DbgVariableRecord::print(raw_ostream &ROS, bool IsForDebug) const {
5100
5101 ModuleSlotTracker MST(getModuleFromDPI(this), true);
5102 print(ROS, MST, IsForDebug);
5103}
5104
5106 bool IsForDebug) const {
5107 formatted_raw_ostream OS(ROS);
5108 SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));
5109 SlotTracker &SlotTable =
5110 MST.getMachine() ? *MST.getMachine() : EmptySlotTable;
5111 const Function *F = getParent() ? getParent()->getParent() : nullptr;
5112 if (F)
5113 MST.incorporateFunction(*F);
5114 AssemblyWriter W(OS, SlotTable, getModuleFromDPI(this), nullptr, IsForDebug);
5115 W.printDbgMarker(*this);
5116}
5117
5118void DbgLabelRecord::print(raw_ostream &ROS, bool IsForDebug) const {
5119
5120 ModuleSlotTracker MST(getModuleFromDPI(this), true);
5121 print(ROS, MST, IsForDebug);
5122}
5123
5125 bool IsForDebug) const {
5126 formatted_raw_ostream OS(ROS);
5127 SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));
5128 SlotTracker &SlotTable =
5129 MST.getMachine() ? *MST.getMachine() : EmptySlotTable;
5130 const Function *F = Marker && Marker->getParent()
5131 ? Marker->getParent()->getParent()
5132 : nullptr;
5133 if (F)
5134 MST.incorporateFunction(*F);
5135 AssemblyWriter W(OS, SlotTable, getModuleFromDPI(this), nullptr, IsForDebug);
5136 W.printDbgVariableRecord(*this);
5137}
5138
5140 bool IsForDebug) const {
5141 formatted_raw_ostream OS(ROS);
5142 SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));
5143 SlotTracker &SlotTable =
5144 MST.getMachine() ? *MST.getMachine() : EmptySlotTable;
5145 const Function *F =
5146 Marker->getParent() ? Marker->getParent()->getParent() : nullptr;
5147 if (F)
5148 MST.incorporateFunction(*F);
5149
5150 AssemblyWriter W(OS, SlotTable, getModuleFromDPI(this), nullptr, IsForDebug);
5151 W.printDbgLabelRecord(*this);
5152}
5153
5154void Value::print(raw_ostream &ROS, bool IsForDebug) const {
5155 bool ShouldInitializeAllMetadata = false;
5156 if (auto *I = dyn_cast<Instruction>(this))
5157 ShouldInitializeAllMetadata = isReferencingMDNode(*I);
5158 else if (isa<Function>(this) || isa<MetadataAsValue>(this))
5159 ShouldInitializeAllMetadata = true;
5160
5161 ModuleSlotTracker MST(getModuleFromVal(this), ShouldInitializeAllMetadata);
5162 print(ROS, MST, IsForDebug);
5163}
5164
5166 bool IsForDebug) const {
5167 formatted_raw_ostream OS(ROS);
5168 SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));
5169 SlotTracker &SlotTable =
5170 MST.getMachine() ? *MST.getMachine() : EmptySlotTable;
5171 auto IncorporateFunction = [&](const Function *F) {
5172 if (F)
5173 MST.incorporateFunction(*F);
5174 };
5175
5176 if (const auto *I = dyn_cast<Instruction>(this)) {
5177 IncorporateFunction(I->getParent() ? I->getParent()->getParent() : nullptr);
5178 AssemblyWriter W(OS, SlotTable, getModuleFromVal(I), nullptr, IsForDebug);
5179 W.printInstruction(*I);
5180 } else if (const auto *BB = dyn_cast<BasicBlock>(this)) {
5181 IncorporateFunction(BB->getParent());
5182 AssemblyWriter W(OS, SlotTable, getModuleFromVal(BB), nullptr, IsForDebug);
5183 W.printBasicBlock(BB);
5184 } else if (const auto *GV = dyn_cast<GlobalValue>(this)) {
5185 AssemblyWriter W(OS, SlotTable, GV->getParent(), nullptr, IsForDebug);
5186 if (const auto *V = dyn_cast<GlobalVariable>(GV))
5187 W.printGlobal(V);
5188 else if (const auto *F = dyn_cast<Function>(GV))
5189 W.printFunction(F);
5190 else if (const auto *A = dyn_cast<GlobalAlias>(GV))
5191 W.printAlias(A);
5192 else if (const auto *I = dyn_cast<GlobalIFunc>(GV))
5193 W.printIFunc(I);
5194 else
5195 llvm_unreachable("Unknown GlobalValue to print out!");
5196 } else if (const auto *V = dyn_cast<MetadataAsValue>(this)) {
5197 V->getMetadata()->print(ROS, MST, getModuleFromVal(V));
5198 } else if (const auto *C = dyn_cast<Constant>(this)) {
5199 TypePrinting TypePrinter;
5200 TypePrinter.print(C->getType(), OS);
5201 OS << ' ';
5202 AsmWriterContext WriterCtx(&TypePrinter, MST.getMachine());
5203 writeConstantInternal(OS, C, WriterCtx);
5204 } else if (isa<InlineAsm>(this) || isa<Argument>(this)) {
5205 this->printAsOperand(OS, /* PrintType */ true, MST);
5206 } else {
5207 llvm_unreachable("Unknown value to print out!");
5208 }
5209}
5210
5211/// Print without a type, skipping the TypePrinting object.
5212///
5213/// \return \c true iff printing was successful.
5214static bool printWithoutType(const Value &V, raw_ostream &O,
5215 SlotTracker *Machine, const Module *M) {
5216 if (V.hasName() || isa<GlobalValue>(V) ||
5217 (!isa<Constant>(V) && !isa<MetadataAsValue>(V))) {
5218 AsmWriterContext WriterCtx(nullptr, Machine, M);
5219 writeAsOperandInternal(O, &V, WriterCtx);
5220 return true;
5221 }
5222 return false;
5223}
5224
5225static void printAsOperandImpl(const Value &V, raw_ostream &O, bool PrintType,
5226 ModuleSlotTracker &MST) {
5227 TypePrinting TypePrinter(MST.getModule());
5228 AsmWriterContext WriterCtx(&TypePrinter, MST.getMachine(), MST.getModule());
5229 writeAsOperandInternal(O, &V, WriterCtx, PrintType);
5230}
5231
5232void Value::printAsOperand(raw_ostream &O, bool PrintType,
5233 const Module *M) const {
5234 if (!M)
5235 M = getModuleFromVal(this);
5236
5237 if (!PrintType)
5238 if (printWithoutType(*this, O, nullptr, M))
5239 return;
5240
5242 M, /* ShouldInitializeAllMetadata */ isa<MetadataAsValue>(this));
5243 ModuleSlotTracker MST(Machine, M);
5244 printAsOperandImpl(*this, O, PrintType, MST);
5245}
5246
5247void Value::printAsOperand(raw_ostream &O, bool PrintType,
5248 ModuleSlotTracker &MST) const {
5249 if (!PrintType)
5250 if (printWithoutType(*this, O, MST.getMachine(), MST.getModule()))
5251 return;
5252
5253 printAsOperandImpl(*this, O, PrintType, MST);
5254}
5255
5256/// Recursive version of printMetadataImpl.
5257static void printMetadataImplRec(raw_ostream &ROS, const Metadata &MD,
5258 AsmWriterContext &WriterCtx) {
5259 formatted_raw_ostream OS(ROS);
5260 writeAsOperandInternal(OS, &MD, WriterCtx, /* FromValue */ true);
5261
5262 auto *N = dyn_cast<MDNode>(&MD);
5263 if (!N || isa<DIExpression>(MD))
5264 return;
5265
5266 OS << " = ";
5267 writeMDNodeBodyInternal(OS, N, WriterCtx);
5268}
5269
5270namespace {
5271struct MDTreeAsmWriterContext : public AsmWriterContext {
5272 unsigned Level;
5273 // {Level, Printed string}
5274 using EntryTy = std::pair<unsigned, std::string>;
5276
5277 // Used to break the cycle in case there is any.
5278 SmallPtrSet<const Metadata *, 4> Visited;
5279
5280 raw_ostream &MainOS;
5281
5282 MDTreeAsmWriterContext(TypePrinting *TP, SlotTracker *ST, const Module *M,
5283 raw_ostream &OS, const Metadata *InitMD)
5284 : AsmWriterContext(TP, ST, M), Level(0U), Visited({InitMD}), MainOS(OS) {}
5285
5286 void onWriteMetadataAsOperand(const Metadata *MD) override {
5287 if (!Visited.insert(MD).second)
5288 return;
5289
5290 std::string Str;
5291 raw_string_ostream SS(Str);
5292 ++Level;
5293 // A placeholder entry to memorize the correct
5294 // position in buffer.
5295 Buffer.emplace_back(std::make_pair(Level, ""));
5296 unsigned InsertIdx = Buffer.size() - 1;
5297
5298 printMetadataImplRec(SS, *MD, *this);
5299 Buffer[InsertIdx].second = std::move(SS.str());
5300 --Level;
5301 }
5302
5303 ~MDTreeAsmWriterContext() {
5304 for (const auto &Entry : Buffer) {
5305 MainOS << "\n";
5306 unsigned NumIndent = Entry.first * 2U;
5307 MainOS.indent(NumIndent) << Entry.second;
5308 }
5309 }
5310};
5311} // end anonymous namespace
5312
5313static void printMetadataImpl(raw_ostream &ROS, const Metadata &MD,
5314 ModuleSlotTracker &MST, const Module *M,
5315 bool OnlyAsOperand, bool PrintAsTree = false) {
5316 formatted_raw_ostream OS(ROS);
5317
5318 TypePrinting TypePrinter(M);
5319
5320 std::unique_ptr<AsmWriterContext> WriterCtx;
5321 if (PrintAsTree && !OnlyAsOperand)
5322 WriterCtx = std::make_unique<MDTreeAsmWriterContext>(
5323 &TypePrinter, MST.getMachine(), M, OS, &MD);
5324 else
5325 WriterCtx =
5326 std::make_unique<AsmWriterContext>(&TypePrinter, MST.getMachine(), M);
5327
5328 writeAsOperandInternal(OS, &MD, *WriterCtx, /* FromValue */ true);
5329
5330 auto *N = dyn_cast<MDNode>(&MD);
5331 if (OnlyAsOperand || !N || isa<DIExpression>(MD))
5332 return;
5333
5334 OS << " = ";
5335 writeMDNodeBodyInternal(OS, N, *WriterCtx);
5336}
5337
5339 ModuleSlotTracker MST(M, isa<MDNode>(this));
5340 printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ true);
5341}
5342
5344 const Module *M) const {
5345 printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ true);
5346}
5347
5349 bool /*IsForDebug*/) const {
5350 ModuleSlotTracker MST(M, isa<MDNode>(this));
5351 printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
5352}
5353
5355 const Module *M, bool /*IsForDebug*/) const {
5356 printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
5357}
5358
5359void MDNode::printTree(raw_ostream &OS, const Module *M) const {
5360 ModuleSlotTracker MST(M, true);
5361 printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false,
5362 /*PrintAsTree=*/true);
5363}
5364
5366 const Module *M) const {
5367 printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false,
5368 /*PrintAsTree=*/true);
5369}
5370
5371void ModuleSummaryIndex::print(raw_ostream &ROS, bool IsForDebug) const {
5372 SlotTracker SlotTable(this);
5373 formatted_raw_ostream OS(ROS);
5374 AssemblyWriter W(OS, SlotTable, this, IsForDebug);
5375 W.printModuleSummaryIndex();
5376}
5377
5379 unsigned UB) const {
5380 SlotTracker *ST = MachineStorage.get();
5381 if (!ST)
5382 return;
5383
5384 for (auto &I : llvm::make_range(ST->mdn_begin(), ST->mdn_end()))
5385 if (I.second >= LB && I.second < UB)
5386 L.push_back(std::make_pair(I.second, I.first));
5387}
5388
5389#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
5390// Value::dump - allow easy printing of Values from the debugger.
5392void Value::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
5393
5394// Value::dump - allow easy printing of Values from the debugger.
5396void DbgMarker::dump() const {
5397 print(dbgs(), /*IsForDebug=*/true);
5398 dbgs() << '\n';
5399}
5400
5401// Value::dump - allow easy printing of Values from the debugger.
5403void DbgRecord::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
5404
5405// Type::dump - allow easy printing of Types from the debugger.
5407void Type::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
5408
5409// Module::dump() - Allow printing of Modules from the debugger.
5411void Module::dump() const {
5412 print(dbgs(), nullptr,
5413 /*ShouldPreserveUseListOrder=*/false, /*IsForDebug=*/true);
5414}
5415
5416// Allow printing of Comdats from the debugger.
5418void Comdat::dump() const { print(dbgs(), /*IsForDebug=*/true); }
5419
5420// NamedMDNode::dump() - Allow printing of NamedMDNodes from the debugger.
5422void NamedMDNode::dump() const { print(dbgs(), /*IsForDebug=*/true); }
5423
5425void Metadata::dump() const { dump(nullptr); }
5426
5428void Metadata::dump(const Module *M) const {
5429 print(dbgs(), M, /*IsForDebug=*/true);
5430 dbgs() << '\n';
5431}
5432
5434void MDNode::dumpTree() const { dumpTree(nullptr); }
5435
5437void MDNode::dumpTree(const Module *M) const {
5438 printTree(dbgs(), M);
5439 dbgs() << '\n';
5440}
5441
5442// Allow printing of ModuleSummaryIndex from the debugger.
5444void ModuleSummaryIndex::dump() const { print(dbgs(), /*IsForDebug=*/true); }
5445#endif
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 MachineBasicBlock::iterator DebugLoc DL
static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)
static void writeDIMacro(raw_ostream &Out, const DIMacro *N, AsmWriterContext &WriterCtx)
static void writeMetadataAsOperand(raw_ostream &Out, const Metadata *MD, AsmWriterContext &WriterCtx)
static void writeDIGlobalVariableExpression(raw_ostream &Out, const DIGlobalVariableExpression *N, AsmWriterContext &WriterCtx)
static void writeDICompositeType(raw_ostream &Out, const DICompositeType *N, AsmWriterContext &WriterCtx)
static void writeDIFixedPointType(raw_ostream &Out, const DIFixedPointType *N, AsmWriterContext &WriterCtx)
static void printDSOLocation(const GlobalValue &GV, formatted_raw_ostream &Out)
static const char * getWholeProgDevirtResKindName(WholeProgramDevirtResolution::Kind K)
static void writeDISubrangeType(raw_ostream &Out, const DISubrangeType *N, AsmWriterContext &WriterCtx)
static void writeAPFloatInternal(raw_ostream &Out, const APFloat &APF)
static void printMetadataImpl(raw_ostream &ROS, const Metadata &MD, ModuleSlotTracker &MST, const Module *M, bool OnlyAsOperand, bool PrintAsTree=false)
static void writeDIStringType(raw_ostream &Out, const DIStringType *N, AsmWriterContext &WriterCtx)
static std::string getLinkageNameWithSpace(GlobalValue::LinkageTypes LT)
static std::vector< unsigned > predictValueUseListOrder(const Value *V, unsigned ID, const OrderMap &OM)
static void writeDIGlobalVariable(raw_ostream &Out, const DIGlobalVariable *N, AsmWriterContext &WriterCtx)
static void orderValue(const Value *V, OrderMap &OM)
static void writeDIBasicType(raw_ostream &Out, const DIBasicType *N, AsmWriterContext &WriterCtx)
static StringRef getUnnamedAddrEncoding(GlobalVariable::UnnamedAddr UA)
static const char * getWholeProgDevirtResByArgKindName(WholeProgramDevirtResolution::ByArg::Kind K)
static void writeMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node, AsmWriterContext &Ctx)
static void writeDIModule(raw_ostream &Out, const DIModule *N, AsmWriterContext &WriterCtx)
static void writeDIFile(raw_ostream &Out, const DIFile *N, AsmWriterContext &)
static void writeDISubroutineType(raw_ostream &Out, const DISubroutineType *N, AsmWriterContext &WriterCtx)
static void writeOptimizationInfo(raw_ostream &Out, const User *U)
static bool isReferencingMDNode(const Instruction &I)
#define CC_VLS_CASE(ABI_VLEN)
static void writeDILabel(raw_ostream &Out, const DILabel *N, AsmWriterContext &WriterCtx)
static void writeDIDerivedType(raw_ostream &Out, const DIDerivedType *N, AsmWriterContext &WriterCtx)
static void printMetadataIdentifier(StringRef Name, formatted_raw_ostream &Out)
static void printShuffleMask(raw_ostream &Out, Type *Ty, ArrayRef< int > Mask)
static void writeDIImportedEntity(raw_ostream &Out, const DIImportedEntity *N, AsmWriterContext &WriterCtx)
static const Module * getModuleFromDPI(const DbgMarker *Marker)
static void printAsOperandImpl(const Value &V, raw_ostream &O, bool PrintType, ModuleSlotTracker &MST)
static void writeDIObjCProperty(raw_ostream &Out, const DIObjCProperty *N, AsmWriterContext &WriterCtx)
static void writeDISubprogram(raw_ostream &Out, const DISubprogram *N, AsmWriterContext &WriterCtx)
static const char * getSummaryKindName(GlobalValueSummary::SummaryKind SK)
static OrderMap orderModule(const Module *M)
static const char * getVisibilityName(GlobalValue::VisibilityTypes Vis)
static void printCallingConv(unsigned cc, raw_ostream &Out)
static cl::opt< bool > PrintInstDebugLocs("print-inst-debug-locs", cl::Hidden, cl::desc("Pretty print debug locations of instructions when dumping"))
static void printMetadataImplRec(raw_ostream &ROS, const Metadata &MD, AsmWriterContext &WriterCtx)
Recursive version of printMetadataImpl.
static SlotTracker * createSlotTracker(const Value *V)
static void writeDILocation(raw_ostream &Out, const DILocation *DL, AsmWriterContext &WriterCtx)
static void writeDINamespace(raw_ostream &Out, const DINamespace *N, AsmWriterContext &WriterCtx)
DenseMap< const Function *, MapVector< const Value *, std::vector< unsigned > > > UseListOrderMap
static void writeDICommonBlock(raw_ostream &Out, const DICommonBlock *N, AsmWriterContext &WriterCtx)
static UseListOrderMap predictUseListOrder(const Module *M)
static void printThreadLocalModel(GlobalVariable::ThreadLocalMode TLM, formatted_raw_ostream &Out)
static std::string getLinkageName(GlobalValue::LinkageTypes LT)
static void writeGenericDINode(raw_ostream &Out, const GenericDINode *N, AsmWriterContext &WriterCtx)
static void writeDILocalVariable(raw_ostream &Out, const DILocalVariable *N, AsmWriterContext &WriterCtx)
static const char * getTTResKindName(TypeTestResolution::Kind K)
static void writeDITemplateTypeParameter(raw_ostream &Out, const DITemplateTypeParameter *N, AsmWriterContext &WriterCtx)
static const char * getImportTypeName(GlobalValueSummary::ImportKind IK)
static void writeDICompileUnit(raw_ostream &Out, const DICompileUnit *N, AsmWriterContext &WriterCtx)
static const Module * getModuleFromVal(const Value *V)
static void printLLVMName(raw_ostream &OS, StringRef Name, PrefixType Prefix)
Turn the specified name into an 'LLVM name', which is either prefixed with % (if the string only cont...
static void maybePrintCallAddrSpace(const Value *Operand, const Instruction *I, raw_ostream &Out)
static void writeDIGenericSubrange(raw_ostream &Out, const DIGenericSubrange *N, AsmWriterContext &WriterCtx)
static void writeDISubrange(raw_ostream &Out, const DISubrange *N, AsmWriterContext &WriterCtx)
static void writeDILexicalBlockFile(raw_ostream &Out, const DILexicalBlockFile *N, AsmWriterContext &WriterCtx)
static void writeConstantInternal(raw_ostream &Out, const Constant *CV, AsmWriterContext &WriterCtx)
static void writeDIEnumerator(raw_ostream &Out, const DIEnumerator *N, AsmWriterContext &)
static void writeAsOperandInternal(raw_ostream &Out, const Value *V, AsmWriterContext &WriterCtx, bool PrintType=false)
static void printVisibility(GlobalValue::VisibilityTypes Vis, formatted_raw_ostream &Out)
static cl::opt< bool > PrintProfData("print-prof-data", cl::Hidden, cl::desc("Pretty print perf data (branch weights, etc) when dumping"))
static void writeMDTuple(raw_ostream &Out, const MDTuple *Node, AsmWriterContext &WriterCtx)
static void writeDIExpression(raw_ostream &Out, const DIExpression *N, AsmWriterContext &WriterCtx)
static cl::opt< bool > PrintInstAddrs("print-inst-addrs", cl::Hidden, cl::desc("Print addresses of instructions when dumping"))
static void writeDIAssignID(raw_ostream &Out, const DIAssignID *DL, AsmWriterContext &WriterCtx)
static void writeDILexicalBlock(raw_ostream &Out, const DILexicalBlock *N, AsmWriterContext &WriterCtx)
PrefixType
@ GlobalPrefix
@ LabelPrefix
@ LocalPrefix
@ NoPrefix
@ ComdatPrefix
static void maybePrintComdat(formatted_raw_ostream &Out, const GlobalObject &GO)
static void printDLLStorageClass(GlobalValue::DLLStorageClassTypes SCT, formatted_raw_ostream &Out)
static bool printWithoutType(const Value &V, raw_ostream &O, SlotTracker *Machine, const Module *M)
Print without a type, skipping the TypePrinting object.
#define ST_DEBUG(X)
static void writeDIArgList(raw_ostream &Out, const DIArgList *N, AsmWriterContext &WriterCtx, bool FromValue=false)
static void writeDITemplateValueParameter(raw_ostream &Out, const DITemplateValueParameter *N, AsmWriterContext &WriterCtx)
static const Value * skipMetadataWrapper(const Value *V)
Look for a value that might be wrapped as metadata, e.g.
static void writeDIMacroFile(raw_ostream &Out, const DIMacroFile *N, AsmWriterContext &WriterCtx)
Atomic ordering constants.
This file contains the simple types necessary to represent the attributes associated with functions a...
static const Function * getParent(const Value *V)
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
Definition Compiler.h:638
This file contains the declarations for the subclasses of Constant, which represent the different fla...
dxil pretty DXIL Metadata Pretty Printer
dxil translate DXIL Translate Metadata
This file defines the DenseMap class.
@ Default
This file contains constants used for implementing Dwarf debug support.
This file contains the declaration of the GlobalIFunc class, which represents a single indirect funct...
GlobalValue::SanitizerMetadata SanitizerMetadata
Definition Globals.cpp:244
#define op(i)
Hexagon Common GEP
#define _
IRTranslator LLVM IR MI
This file provides various utilities for inspecting and working with the control flow graph in LLVM I...
This file contains an interface for creating legacy passes to print out IR in various granularities.
Module.h This file contains the declarations for the Module class.
This defines the Use class.
#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
Machine Check Debug Module
This file contains the declarations for metadata subclasses.
static bool InRange(int64_t Value, unsigned short Shift, int LBound, int HBound)
ModuleSummaryIndex.h This file contains the declarations the classes that hold the module index and s...
static bool processFunction(Function &F, NVPTXTargetMachine &TM)
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
uint64_t IntrinsicInst * II
#define P(N)
Function const char TargetMachine * Machine
if(auto Err=PB.parsePassPipeline(MPM, Passes)) return wrap(std MPM run * Mod
if(PassOpts->AAPipeline)
static StringRef getName(Value *V)
This file contains some templates that are useful if you are working with the STL at all.
This file provides utility classes that use RAII to save and restore values.
This file implements a set that has insertion order iteration characteristics.
This file defines the SmallPtrSet class.
This file defines the SmallString class.
This file defines the SmallVector class.
This file contains some functions that are useful when dealing with strings.
LocallyHashedType DenseMapInfo< LocallyHashedType >::Empty
static UseListOrderStack predictUseListOrder(const Module &M)
static APFloat getSNaN(const fltSemantics &Sem, bool Negative=false, const APInt *payload=nullptr)
Factory for SNaN values.
Definition APFloat.h:1128
LLVM_ABI opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
Definition APFloat.cpp:6057
bool isNegative() const
Definition APFloat.h:1449
LLVM_ABI double convertToDouble() const
Converts this APFloat to host double value.
Definition APFloat.cpp:6115
void toString(SmallVectorImpl< char > &Str, unsigned FormatPrecision=0, unsigned FormatMaxPadding=3, bool TruncateZero=true) const
Definition APFloat.h:1478
const fltSemantics & getSemantics() const
Definition APFloat.h:1457
bool isNaN() const
Definition APFloat.h:1447
bool isSignaling() const
Definition APFloat.h:1451
APInt bitcastToAPInt() const
Definition APFloat.h:1353
bool isInfinity() const
Definition APFloat.h:1446
Class for arbitrary precision integers.
Definition APInt.h:78
LLVM_ABI APInt getLoBits(unsigned numBits) const
Compute an APInt containing numBits lowbits from this APInt.
Definition APInt.cpp:644
uint64_t getZExtValue() const
Get zero extended value.
Definition APInt.h:1540
LLVM_ABI APInt getHiBits(unsigned numBits) const
Compute an APInt containing numBits highbits from this APInt.
Definition APInt.cpp:639
Abstract interface of slot tracker storage.
const GlobalValueSummary & getAliasee() const
This class represents an incoming formal argument to a Function.
Definition Argument.h:32
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition ArrayRef.h:41
size_t size() const
size - Get the array size.
Definition ArrayRef.h:147
virtual void emitBasicBlockStartAnnot(const BasicBlock *, formatted_raw_ostream &)
emitBasicBlockStartAnnot - This may be implemented to emit a string right after the basic block label...
virtual void emitBasicBlockEndAnnot(const BasicBlock *, formatted_raw_ostream &)
emitBasicBlockEndAnnot - This may be implemented to emit a string right after the basic block.
virtual void emitFunctionAnnot(const Function *, formatted_raw_ostream &)
emitFunctionAnnot - This may be implemented to emit a string right before the start of a function.
virtual void emitInstructionAnnot(const Instruction *, formatted_raw_ostream &)
emitInstructionAnnot - This may be implemented to emit a string right before an instruction is emitte...
virtual void printInfoComment(const Value &, formatted_raw_ostream &)
printInfoComment - This may be implemented to emit a comment to the right of an instruction or global...
static LLVM_ABI StringRef getOperationName(BinOp Op)
This class holds the attributes for a particular argument, parameter, function, or return value.
Definition Attributes.h:361
bool hasAttributes() const
Return true if attributes exists in this set.
Definition Attributes.h:431
LLVM_ABI std::string getAsString(bool InAttrGrp=false) const
The Attribute is converted to a string of equivalent mnemonic.
LLVM_ABI Attribute::AttrKind getKindAsEnum() const
Return the attribute's kind as an enum (Attribute::AttrKind).
LLVM_ABI bool isTypeAttribute() const
Return true if the attribute is a type attribute.
LLVM_ABI Type * getValueAsType() const
Return the attribute's value as a Type.
LLVM Basic Block Representation.
Definition BasicBlock.h:62
const Function * getParent() const
Return the enclosing method, or null if none.
Definition BasicBlock.h:213
LLVM_ABI void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW=nullptr, bool ShouldPreserveUseListOrder=false, bool IsForDebug=false) const
Print the basic block to an output stream with an optional AssemblyAnnotationWriter.
LLVM_ABI bool isEntryBlock() const
Return true if this is the entry block of the containing function.
LLVM_ABI const Module * getModule() const
Return the module owning the function this basic block belongs to, or nullptr if the function does no...
OperandBundleUse getOperandBundleAt(unsigned Index) const
Return the operand bundle at a specific index.
unsigned getNumOperandBundles() const
Return the number of operand bundles associated with this User.
AttributeList getAttributes() const
Return the attributes for this call.
bool hasOperandBundles() const
Return true if this User has any operand bundles.
LLVM_ABI void print(raw_ostream &OS, bool IsForDebug=false) const
LLVM_ABI void dump() const
@ Largest
The linker will choose the largest COMDAT.
Definition Comdat.h:39
@ SameSize
The data referenced by the COMDAT must be the same size.
Definition Comdat.h:41
@ Any
The linker may choose any COMDAT.
Definition Comdat.h:37
@ NoDeduplicate
No deduplication is performed.
Definition Comdat.h:40
@ ExactMatch
The data referenced by the COMDAT must be the same.
Definition Comdat.h:38
SelectionKind getSelectionKind() const
Definition Comdat.h:47
LLVM_ABI APInt getSignedMin() const
Return the smallest signed value contained in the ConstantRange.
LLVM_ABI APInt getSignedMax() const
Return the largest signed value contained in the ConstantRange.
This is an important base class in LLVM.
Definition Constant.h:43
LLVM_ABI Constant * getSplatValue(bool AllowPoison=false) const
If all elements of the vector constant have the same value, return that value.
LLVM_ABI Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
List of ValueAsMetadata, to be used as an argument to a dbg.value intrinsic.
Basic type, like 'int' or 'float'.
Debug common block.
static LLVM_ABI const char * nameTableKindString(DebugNameTableKind PK)
static LLVM_ABI const char * emissionKindString(DebugEmissionKind EK)
Enumeration value.
A lightweight wrapper around an expression operand.
DWARF expression.
static LLVM_ABI const char * fixedPointKindString(FixedPointKind)
A pair of DIGlobalVariable and DIExpression.
An imported module (C++ using directive or similar).
Debug lexical block.
Macro Info DWARF-like metadata node.
Represents a module in the programming language, for example, a Clang module, or a Fortran module.
Debug lexical block.
Tagged DWARF-like metadata node.
static LLVM_ABI DIFlags splitFlags(DIFlags Flags, SmallVectorImpl< DIFlags > &SplitFlags)
Split up a flags bitfield.
static LLVM_ABI StringRef getFlagString(DIFlags Flag)
DIFlags
Debug info flags.
String type, Fortran CHARACTER(n)
Subprogram description. Uses SubclassData1.
static LLVM_ABI DISPFlags splitFlags(DISPFlags Flags, SmallVectorImpl< DISPFlags > &SplitFlags)
Split up a flags bitfield for easier printing.
static LLVM_ABI StringRef getFlagString(DISPFlags Flag)
DISPFlags
Debug info subprogram flags.
Array subrange.
Type array for a subprogram.
LLVM_ABI void print(raw_ostream &O, bool IsForDebug=false) const
Per-instruction record of debug-info.
LLVM_ABI void dump() const
Instruction * MarkedInstr
Link back to the Instruction that owns this marker.
LLVM_ABI void print(raw_ostream &O, bool IsForDebug=false) const
Implement operator<< on DbgMarker.
LLVM_ABI const BasicBlock * getParent() const
simple_ilist< DbgRecord > StoredDbgRecords
List of DbgRecords, the non-instruction equivalent of llvm.dbg.
Base class for non-instruction debug metadata records that have positions within IR.
DebugLoc getDebugLoc() const
LLVM_ABI void dump() const
DbgMarker * Marker
Marker that this DbgRecord is linked into.
Record of a variable value-assignment, aka a non instruction representation of the dbg....
LLVM_ABI void print(raw_ostream &O, bool IsForDebug=false) const
Metadata * getRawLocation() const
Returns the metadata operand for the first location description.
MDNode * getAsMDNode() const
Return this as a bar MDNode.
Definition DebugLoc.h:291
DenseMapIterator< KeyT, ValueT, KeyInfoT, BucketT > iterator
Definition DenseMap.h:74
void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW=nullptr, bool ShouldPreserveUseListOrder=false, bool IsForDebug=false) const
Print the function to an output stream with an optional AssemblyAnnotationWriter.
const Function & getFunction() const
Definition Function.h:164
const Argument * const_arg_iterator
Definition Function.h:73
LLVM_ABI Value * getBasePtr() const
LLVM_ABI Value * getDerivedPtr() const
Generic tagged DWARF-like metadata node.
const Constant * getAliasee() const
Definition GlobalAlias.h:87
const Constant * getResolver() const
Definition GlobalIFunc.h:73
StringRef getSection() const
Get the custom section of this global if it has one.
LLVM_ABI void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode * > > &MDs) const
Appends all metadata attached to this value to MDs, sorting by KindID.
const Comdat * getComdat() const
bool hasSection() const
Check if this global has a custom object file section.
SummaryKind
Sububclass discriminator (for dyn_cast<> et al.)
bool hasPartition() const
static LLVM_ABI GUID getGUIDAssumingExternalLinkage(StringRef GlobalName)
Return a 64-bit global unique ID constructed from the name of a global symbol.
Definition Globals.cpp:77
LLVM_ABI const SanitizerMetadata & getSanitizerMetadata() const
Definition Globals.cpp:245
bool hasExternalLinkage() const
bool isDSOLocal() const
VisibilityTypes getVisibility() const
bool isImplicitDSOLocal() const
LinkageTypes getLinkage() const
uint64_t GUID
Declare a type to represent a global unique identifier for a global value.
ThreadLocalMode getThreadLocalMode() const
DLLStorageClassTypes
Storage classes of global values for PE targets.
Definition GlobalValue.h:74
@ DLLExportStorageClass
Function to be accessible from DLL.
Definition GlobalValue.h:77
@ DLLImportStorageClass
Function to be imported from DLL.
Definition GlobalValue.h:76
bool hasSanitizerMetadata() const
LLVM_ABI StringRef getPartition() const
Definition Globals.cpp:222
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 bool isMaterializable() const
If this function's Module is being lazily streamed in functions from disk or some other source,...
Definition Globals.cpp:44
UnnamedAddr getUnnamedAddr() 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
DLLStorageClassTypes getDLLStorageClass() const
Type * getValueType() const
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
bool isExternallyInitialized() const
bool hasInitializer() const
Definitions have initializers, declarations don't.
AttributeSet getAttributes() const
Return the attribute set for this global.
std::optional< CodeModel::Model > getCodeModel() const
Get the custom code model of this global if it has one.
MaybeAlign getAlign() const
Returns the alignment of the given variable.
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
A helper class to return the specified delimiter string after the first invocation of operator String...
Metadata node.
Definition Metadata.h:1078
LLVM_ABI void printTree(raw_ostream &OS, const Module *M=nullptr) const
Print in tree shape.
LLVM_ABI void dumpTree() const
User-friendly dump in tree shape.
Tuple of metadata.
Definition Metadata.h:1497
This class implements a map that also provides access to all stored values in a deterministic order.
Definition MapVector.h:36
Root of the metadata hierarchy.
Definition Metadata.h:64
LLVM_ABI void print(raw_ostream &OS, const Module *M=nullptr, bool IsForDebug=false) const
Print.
LLVM_ABI void printAsOperand(raw_ostream &OS, const Module *M=nullptr) const
Print as operand.
LLVM_ABI void dump() const
User-friendly dump.
Manage lifetime of a slot tracker for printing IR.
const Module * getModule() const
ModuleSlotTracker(SlotTracker &Machine, const Module *M, const Function *F=nullptr)
Wrap a preinitialized SlotTracker.
virtual ~ModuleSlotTracker()
Destructor to clean up storage.
std::vector< std::pair< unsigned, const MDNode * > > MachineMDNodeListType
int getLocalSlot(const Value *V)
Return the slot number of the specified local value.
void collectMDNodes(MachineMDNodeListType &L, unsigned LB, unsigned UB) const
SlotTracker * getMachine()
Lazily creates a slot tracker.
void setProcessHook(std::function< void(AbstractSlotTrackerStorage *, const Module *, bool)>)
void incorporateFunction(const Function &F)
Incorporate the given function.
Class to hold module path string table and global value map, and encapsulate methods for operating on...
static constexpr const char * getRegularLTOModuleName()
LLVM_ABI void dump() const
Dump to stderr (for debugging).
LLVM_ABI void print(raw_ostream &OS, bool IsForDebug=false) const
Print to an output stream.
A Module instance is used to store all the information related to an LLVM module.
Definition Module.h:67
iterator_range< alias_iterator > aliases()
Definition Module.h:724
iterator_range< global_iterator > globals()
Definition Module.h:684
void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW, bool ShouldPreserveUseListOrder=false, bool IsForDebug=false) const
Print the module to an output stream with an optional AssemblyAnnotationWriter.
void dump() const
Dump the module to stderr (for debugging).
LLVM_ABI void dump() const
LLVM_ABI StringRef getName() const
LLVM_ABI void print(raw_ostream &ROS, bool IsForDebug=false) const
iterator_range< op_iterator > operands()
Definition Metadata.h:1853
unsigned getAddressSpace() const
Return the address space of the Pointer type.
This class provides computation of slot numbers for LLVM Assembly writing.
DenseMap< const Value *, unsigned > ValueMap
ValueMap - A mapping of Values to slot numbers.
bool mdn_empty() const
int getMetadataSlot(const MDNode *N) override
getMetadataSlot - Get the slot number of a MDNode.
int getTypeIdCompatibleVtableSlot(StringRef Id)
int getModulePathSlot(StringRef Path)
bool as_empty() const
unsigned mdn_size() const
SlotTracker(const SlotTracker &)=delete
void purgeFunction()
After calling incorporateFunction, use this method to remove the most recently incorporated function ...
mdn_iterator mdn_end()
int getTypeIdSlot(StringRef Id)
void initializeIfNeeded()
These functions do the actual initialization.
int getGlobalSlot(const GlobalValue *V)
getGlobalSlot - Get the slot number of a global value.
as_iterator as_begin()
const Function * getFunction() const
unsigned getNextMetadataSlot() override
DenseMap< GlobalValue::GUID, unsigned >::iterator guid_iterator
GUID map iterators.
void incorporateFunction(const Function *F)
If you'd like to deal with a function instead of just a module, use this method to get its data into ...
int getLocalSlot(const Value *V)
Return the slot number of the specified value in it's type plane.
int getAttributeGroupSlot(AttributeSet AS)
SlotTracker(const Module *M, bool ShouldInitializeAllMetadata=false)
Construct from a module.
void createMetadataSlot(const MDNode *N) override
getMetadataSlot - Get the slot number of a MDNode.
void setProcessHook(std::function< void(AbstractSlotTrackerStorage *, const Module *, bool)>)
~SlotTracker()=default
DenseMap< const MDNode *, unsigned >::iterator mdn_iterator
MDNode map iterators.
as_iterator as_end()
unsigned as_size() const
SlotTracker & operator=(const SlotTracker &)=delete
int getGUIDSlot(GlobalValue::GUID GUID)
mdn_iterator mdn_begin()
int initializeIndexIfNeeded()
DenseMap< AttributeSet, unsigned >::iterator as_iterator
AttributeSet map iterators.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition SmallString.h:26
reference emplace_back(ArgTypes &&... Args)
void resize(size_type N)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition StringMap.h:133
StringRef - Represent a constant reference to a string, i.e.
Definition StringRef.h:55
constexpr bool empty() const
empty - Check if the string is empty.
Definition StringRef.h:143
ArrayRef< Type * > elements() const
bool isPacked() const
unsigned getNumElements() const
Random access to the elements.
bool isLiteral() const
Return true if this type is uniqued by structural equivalence, false if it is a struct definition.
bool isOpaque() const
Return true if this is a type with an identity that has no body specified yet.
LLVM_ABI StringRef getName() const
Return the name for this struct type if it has an identity.
Definition Type.cpp:697
ArrayRef< Type * > type_params() const
Return the type parameters for this particular target extension type.
ArrayRef< unsigned > int_params() const
Return the integer parameters for this particular target extension type.
TypeFinder - Walk over a module, identifying all of the types that are used by the module.
Definition TypeFinder.h:31
void run(const Module &M, bool onlyNamed)
iterator begin()
Definition TypeFinder.h:51
bool empty() const
Definition TypeFinder.h:57
The instances of the Type class are immutable: once they are created, they are never changed.
Definition Type.h:45
LLVM_ABI unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
LLVM_ABI StringRef getTargetExtName() const
Type(LLVMContext &C, TypeID tid)
Definition Type.h:93
LLVM_ABI void dump() const
LLVM_ABI void print(raw_ostream &O, bool IsForDebug=false, bool NoDetails=false) const
Print the current type.
TypeID getTypeID() const
Return the type id for the type.
Definition Type.h:136
Type * getElementType() const
unsigned getAddressSpace() const
Return the address space of the Pointer type.
A Use represents the edge between a Value definition and its users.
Definition Use.h:35
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 void print(raw_ostream &O, bool IsForDebug=false) const
Implement operator<< on Value.
LLVM_ABI void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode * > > &MDs) const
Appends all metadata attached to this value to MDs, sorting by KindID.
iterator_range< user_iterator > users()
Definition Value.h:426
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.
iterator_range< use_iterator > uses()
Definition Value.h:380
bool hasName() const
Definition Value.h:262
LLVM_ABI StringRef getName() const
Return a constant reference to the value's name.
Definition Value.cpp:322
LLVM_ABI void dump() const
Support for debugging, callable in GDB: V->dump()
formatted_raw_ostream - A raw_ostream that wraps another one and keeps track of line and column posit...
formatted_raw_ostream & PadToColumn(unsigned NewCol)
PadToColumn - Align the output to some column number.
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.
CallInst * Call
LLVM_ABI StringRef EnumKindString(unsigned EnumKind)
Definition Dwarf.cpp:393
LLVM_ABI StringRef LanguageString(unsigned Language)
Definition Dwarf.cpp:412
LLVM_ABI StringRef AttributeEncodingString(unsigned Encoding)
Definition Dwarf.cpp:263
LLVM_ABI StringRef ConventionString(unsigned Convention)
Definition Dwarf.cpp:489
LLVM_ABI StringRef MacinfoString(unsigned Encoding)
Definition Dwarf.cpp:553
LLVM_ABI StringRef OperationEncodingString(unsigned Encoding)
Definition Dwarf.cpp:138
LLVM_ABI StringRef TagString(unsigned Tag)
Definition Dwarf.cpp:21
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
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.
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
@ Entry
Definition COFF.h:862
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition CallingConv.h:24
@ AArch64_VectorCall
Used between AArch64 Advanced SIMD functions.
@ X86_64_SysV
The C convention as specified in the x86-64 supplement to the System V ABI, used on most non-Windows ...
@ RISCV_VectorCall
Calling convention used for RISC-V V-extension.
@ AMDGPU_CS
Used for Mesa/AMDPAL compute shaders.
@ AMDGPU_VS
Used for Mesa vertex shaders, or AMDPAL last shader stage before rasterization (vertex shader if tess...
@ AVR_SIGNAL
Used for AVR signal routines.
@ Swift
Calling convention for Swift.
Definition CallingConv.h:69
@ AMDGPU_KERNEL
Used for AMDGPU code object kernels.
@ AArch64_SVE_VectorCall
Used between AArch64 SVE functions.
@ ARM_APCS
ARM Procedure Calling Standard (obsolete, but still used on some targets).
@ CHERIoT_CompartmentCall
Calling convention used for CHERIoT when crossing a protection boundary.
@ CFGuard_Check
Special calling convention on Windows for calling the Control Guard Check ICall funtion.
Definition CallingConv.h:82
@ AVR_INTR
Used for AVR interrupt routines.
@ PreserveMost
Used for runtime calls that preserves most registers.
Definition CallingConv.h:63
@ AnyReg
OBSOLETED - Used for stack based JavaScript calls.
Definition CallingConv.h:60
@ AMDGPU_Gfx
Used for AMD graphics targets.
@ DUMMY_HHVM
Placeholders for HHVM calling conventions (deprecated, removed).
@ AMDGPU_CS_ChainPreserve
Used on AMDGPUs to give the middle-end more control over argument placement.
@ AMDGPU_HS
Used for Mesa/AMDPAL hull shaders (= tessellation control shaders).
@ ARM_AAPCS
ARM Architecture Procedure Calling Standard calling convention (aka EABI).
@ CHERIoT_CompartmentCallee
Calling convention used for the callee of CHERIoT_CompartmentCall.
@ AMDGPU_GS
Used for Mesa/AMDPAL geometry shaders.
@ AArch64_SME_ABI_Support_Routines_PreserveMost_From_X2
Preserve X2-X15, X19-X29, SP, Z0-Z31, P0-P15.
@ CHERIoT_LibraryCall
Calling convention used for CHERIoT for cross-library calls to a stateless compartment.
@ CXX_FAST_TLS
Used for access functions.
Definition CallingConv.h:72
@ X86_INTR
x86 hardware interrupt context.
@ AArch64_SME_ABI_Support_Routines_PreserveMost_From_X0
Preserve X0-X13, X19-X29, SP, Z0-Z31, P0-P15.
@ AMDGPU_CS_Chain
Used on AMDGPUs to give the middle-end more control over argument placement.
@ GHC
Used by the Glasgow Haskell Compiler (GHC).
Definition CallingConv.h:50
@ AMDGPU_PS
Used for Mesa/AMDPAL pixel shaders.
@ Cold
Attempts to make code in the caller as efficient as possible under the assumption that the call is no...
Definition CallingConv.h:47
@ AArch64_SME_ABI_Support_Routines_PreserveMost_From_X1
Preserve X1-X15, X19-X29, SP, Z0-Z31, P0-P15.
@ X86_ThisCall
Similar to X86_StdCall.
@ PTX_Device
Call to a PTX device function.
@ SPIR_KERNEL
Used for SPIR kernel functions.
@ PreserveAll
Used for runtime calls that preserves (almost) all registers.
Definition CallingConv.h:66
@ X86_StdCall
stdcall is mostly used by the Win32 API.
Definition CallingConv.h:99
@ SPIR_FUNC
Used for SPIR non-kernel device functions.
@ Fast
Attempts to make calls as fast as possible (e.g.
Definition CallingConv.h:41
@ MSP430_INTR
Used for MSP430 interrupt routines.
@ X86_VectorCall
MSVC calling convention that passes vectors and vector aggregates in SSE registers.
@ Intel_OCL_BI
Used for Intel OpenCL built-ins.
@ PreserveNone
Used for runtime calls that preserves none general registers.
Definition CallingConv.h:90
@ AMDGPU_ES
Used for AMDPAL shader stage before geometry shader if geometry is in use.
@ Tail
Attemps to make calls as fast as possible while guaranteeing that tail call optimization can always b...
Definition CallingConv.h:76
@ Win64
The C convention as implemented on Windows/x86-64 and AArch64.
@ PTX_Kernel
Call to a PTX kernel. Passes all arguments in parameter space.
@ SwiftTail
This follows the Swift calling convention in how arguments are passed but guarantees tail calls will ...
Definition CallingConv.h:87
@ GRAAL
Used by GraalVM. Two additional registers are reserved.
@ AMDGPU_LS
Used for AMDPAL vertex shader if tessellation is in use.
@ ARM_AAPCS_VFP
Same as ARM_AAPCS, but uses hard floating point ABI.
@ X86_RegCall
Register calling convention used for parameters transfer optimization.
@ M68k_RTD
Used for M68k rtd-based CC (similar to X86's stdcall).
@ C
The default llvm calling convention, compatible with C.
Definition CallingConv.h:34
@ X86_FastCall
'fast' analog of X86_StdCall.
@ System
Synchronized with respect to all concurrently executing threads.
Definition LLVMContext.h:58
@ DW_OP_LLVM_convert
Only used in LLVM metadata.
Definition Dwarf.h:145
bool empty() const
Definition BasicBlock.h:101
Context & getContext() const
Definition BasicBlock.h:99
This is an optimization pass for GlobalISel generic memory operations.
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
FunctionAddr VTableAddr Value
Definition InstrProf.h:137
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Definition STLExtras.h:1705
Printable print(const GCNRegPressure &RP, const GCNSubtarget *ST=nullptr, unsigned DynamicVGPRBlockSize=0)
detail::zippy< detail::zip_first, T, U, Args... > zip_equal(T &&t, U &&u, Args &&...args)
zip iterator that assumes that all iteratees have the same length.
Definition STLExtras.h:841
InterleavedRange< Range > interleaved(const Range &R, StringRef Separator=", ", StringRef Prefix="", StringRef Suffix="")
Output range R as a sequence of interleaved elements.
const char * getHotnessName(CalleeInfo::HotnessType HT)
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:644
auto dyn_cast_if_present(const Y &Val)
dyn_cast_if_present<X> - Functionally identical to dyn_cast, except that a null (or none in the case ...
Definition Casting.h:733
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
LLVM_ABI void printEscapedString(StringRef Name, raw_ostream &Out)
Print each character of the specified string, escaping it if it is not printable or if it is an escap...
const char * toIRString(AtomicOrdering ao)
String used by LLVM IR to represent atomic ordering.
auto dyn_cast_or_null(const Y &Val)
Definition Casting.h:754
void sort(IteratorTy Start, IteratorTy End)
Definition STLExtras.h:1624
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition Debug.cpp:207
char hexdigit(unsigned X, bool LowerCase=false)
hexdigit - Return the hexadecimal character for the given number X (which should be less than 16).
bool isDigit(char C)
Checks if character C is one of the 10 decimal digits.
FunctionAddr VTableAddr Count
Definition InstrProf.h:139
bool is_sorted(R &&Range, Compare C)
Wrapper function around std::is_sorted to check if elements in a range R are sorted with respect to a...
Definition STLExtras.h:1900
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
FormattedNumber format_hex(uint64_t N, unsigned Width, bool Upper=false)
format_hex - Output N as a fixed width hexadecimal.
Definition Format.h:180
FormattedNumber format_hex_no_prefix(uint64_t N, unsigned Width, bool Upper=false)
format_hex_no_prefix - Output N as a fixed width hexadecimal.
Definition Format.h:193
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:548
constexpr int PoisonMaskElem
AtomicOrdering
Atomic ordering for LLVM's memory model.
@ Ref
The access may reference the value stored in memory.
Definition ModRef.h:32
DWARFExpression::Operation Op
ArrayRef(const T &OneElt) -> ArrayRef< T >
std::string toString(const APInt &I, unsigned Radix, bool Signed, bool formatAsCLiteral=false, bool UpperCase=true, bool InsertSeparators=false)
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:560
auto predecessors(const MachineBasicBlock *BB)
bool pred_empty(const BasicBlock *BB)
Definition CFG.h:119
std::vector< TypeIdOffsetVtableInfo > TypeIdCompatibleVtableInfo
List of vtable definitions decorated by a particular type identifier, and their corresponding offsets...
@ Default
The result values are uniform if and only if all operands are uniform.
Definition Uniformity.h:20
static auto filterDbgVars(iterator_range< simple_ilist< DbgRecord >::iterator > R)
Filter the DbgRecord range to DbgVariableRecord types only and downcast.
LLVM_ABI void printLLVMNameWithoutPrefix(raw_ostream &OS, StringRef Name)
Print out a name of an LLVM value without any prefixes.
#define N
#define NC
Definition regutils.h:42
static LLVM_ABI const fltSemantics & IEEEsingle() LLVM_READNONE
Definition APFloat.cpp:266
static constexpr roundingMode rmNearestTiesToEven
Definition APFloat.h:304
static LLVM_ABI const fltSemantics & PPCDoubleDouble() LLVM_READNONE
Definition APFloat.cpp:269
static LLVM_ABI const fltSemantics & x87DoubleExtended() LLVM_READNONE
Definition APFloat.cpp:289
static LLVM_ABI const fltSemantics & IEEEquad() LLVM_READNONE
Definition APFloat.cpp:268
static LLVM_ABI const fltSemantics & IEEEdouble() LLVM_READNONE
Definition APFloat.cpp:267
static LLVM_ABI const fltSemantics & IEEEhalf() LLVM_READNONE
Definition APFloat.cpp:264
static LLVM_ABI const fltSemantics & BFloat() LLVM_READNONE
Definition APFloat.cpp:265
A single checksum, represented by a Kind and a Value (a string).
T Value
The string value of the checksum.
StringRef getKindAsString() const
std::vector< ConstVCall > TypeCheckedLoadConstVCalls
std::vector< VFuncId > TypeCheckedLoadVCalls
std::vector< ConstVCall > TypeTestAssumeConstVCalls
List of virtual calls made by this function using (respectively) llvm.assume(llvm....
std::vector< GlobalValue::GUID > TypeTests
List of type identifiers used by this function in llvm.type.test intrinsics referenced by something o...
std::vector< VFuncId > TypeTestAssumeVCalls
List of virtual calls made by this function using (respectively) llvm.assume(llvm....
unsigned DSOLocal
Indicates that the linker resolved the symbol to a definition from within the same linkage unit.
unsigned CanAutoHide
In the per-module summary, indicates that the global value is linkonce_odr and global unnamed addr (s...
unsigned ImportType
This field is written by the ThinLTO indexing step to postlink combined summary.
unsigned NotEligibleToImport
Indicate if the global value cannot be imported (e.g.
unsigned Linkage
The linkage type of the associated global value.
unsigned Visibility
Indicates the visibility.
unsigned Live
In per-module summary, indicate that the global value must be considered a live root for index-based ...
StringRef getTagName() const
Return the tag of this operand bundle as a string.
ArrayRef< Use > Inputs
A utility class that uses RAII to save and restore the value of a variable.
std::map< uint64_t, WholeProgramDevirtResolution > WPDRes
Mapping from byte offset to whole-program devirt resolution for that (typeid, byte offset) pair.
TypeTestResolution TTRes
Kind
Specifies which kind of type check we should emit for this byte array.
@ Unknown
Unknown (analysis not performed, don't lower)
@ Single
Single element (last example in "Short Inline Bit Vectors")
@ Inline
Inlined bit vector ("Short Inline Bit Vectors")
@ Unsat
Unsatisfiable type (i.e. no global has this type metadata)
@ AllOnes
All-ones bit vector ("Eliminating Bit Vector Checks for All-Ones Bit Vectors")
@ ByteArray
Test a byte array (first example)
unsigned SizeM1BitWidth
Range of size-1 expressed as a bit width.
enum llvm::TypeTestResolution::Kind TheKind
@ UniformRetVal
Uniform return value optimization.
@ VirtualConstProp
Virtual constant propagation.
@ UniqueRetVal
Unique return value optimization.
@ Indir
Just do a regular virtual call.
enum llvm::WholeProgramDevirtResolution::Kind TheKind
std::map< std::vector< uint64_t >, ByArg > ResByArg
Resolutions for calls with all constant integer arguments (excluding the first argument,...
@ SingleImpl
Single implementation devirtualization.
@ Indir
Just do a regular virtual call.
@ BranchFunnel
When retpoline mitigation is enabled, use a branch funnel that is defined in the merged module.
Function object to check whether the second component of a container supported by std::get (like std:...
Definition STLExtras.h:1436