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 Constant *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 Argument *MA = dyn_cast<Argument>(V))
306 return MA->getParent() ? MA->getParent()->getParent() : nullptr;
307
308 if (const BasicBlock *BB = dyn_cast<BasicBlock>(V))
309 return BB->getParent() ? BB->getParent()->getParent() : nullptr;
310
311 if (const Instruction *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 GlobalValue *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 Argument *FA = dyn_cast<Argument>(V))
1003 return new SlotTracker(FA->getParent());
1004
1005 if (const Instruction *I = dyn_cast<Instruction>(V))
1006 if (I->getParent())
1007 return new SlotTracker(I->getParent()->getParent());
1008
1009 if (const BasicBlock *BB = dyn_cast<BasicBlock>(V))
1010 return new SlotTracker(BB->getParent());
1011
1012 if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V))
1013 return new SlotTracker(GV->getParent());
1014
1015 if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(V))
1016 return new SlotTracker(GA->getParent());
1017
1018 if (const GlobalIFunc *GIF = dyn_cast<GlobalIFunc>(V))
1019 return new SlotTracker(GIF->getParent());
1020
1021 if (const Function *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 DbgVariableRecord *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 DbgLabelRecord *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 CallInst *CI = dyn_cast<CallInst>(&I))
1248 if (Function *F = CI->getCalledFunction())
1249 if (F->isIntrinsic())
1250 for (auto &Op : I.operands())
1252 if (MDNode *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 MDNode *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
1470static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
1471 AsmWriterContext &WriterCtx,
1472 bool FromValue = false);
1473
1474static void WriteOptimizationInfo(raw_ostream &Out, const User *U) {
1476 Out << FPO->getFastMathFlags();
1477
1478 if (const OverflowingBinaryOperator *OBO =
1480 if (OBO->hasNoUnsignedWrap())
1481 Out << " nuw";
1482 if (OBO->hasNoSignedWrap())
1483 Out << " nsw";
1484 } else if (const PossiblyExactOperator *Div =
1486 if (Div->isExact())
1487 Out << " exact";
1488 } else if (const PossiblyDisjointInst *PDI =
1490 if (PDI->isDisjoint())
1491 Out << " disjoint";
1492 } else if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) {
1493 if (GEP->isInBounds())
1494 Out << " inbounds";
1495 else if (GEP->hasNoUnsignedSignedWrap())
1496 Out << " nusw";
1497 if (GEP->hasNoUnsignedWrap())
1498 Out << " nuw";
1499 if (auto InRange = GEP->getInRange()) {
1500 Out << " inrange(" << InRange->getLower() << ", " << InRange->getUpper()
1501 << ")";
1502 }
1503 } else if (const auto *NNI = dyn_cast<PossiblyNonNegInst>(U)) {
1504 if (NNI->hasNonNeg())
1505 Out << " nneg";
1506 } else if (const auto *TI = dyn_cast<TruncInst>(U)) {
1507 if (TI->hasNoUnsignedWrap())
1508 Out << " nuw";
1509 if (TI->hasNoSignedWrap())
1510 Out << " nsw";
1511 } else if (const auto *ICmp = dyn_cast<ICmpInst>(U)) {
1512 if (ICmp->hasSameSign())
1513 Out << " samesign";
1514 }
1515}
1516
1517static void WriteAPFloatInternal(raw_ostream &Out, const APFloat &APF) {
1518 if (&APF.getSemantics() == &APFloat::IEEEsingle() ||
1519 &APF.getSemantics() == &APFloat::IEEEdouble()) {
1520 // We would like to output the FP constant value in exponential notation,
1521 // but we cannot do this if doing so will lose precision. Check here to
1522 // make sure that we only output it in exponential format if we can parse
1523 // the value back and get the same value.
1524 //
1525 bool ignored;
1526 bool isDouble = &APF.getSemantics() == &APFloat::IEEEdouble();
1527 bool isInf = APF.isInfinity();
1528 bool isNaN = APF.isNaN();
1529
1530 if (!isInf && !isNaN) {
1531 double Val = APF.convertToDouble();
1532 SmallString<128> StrVal;
1533 APF.toString(StrVal, 6, 0, false);
1534 // Check to make sure that the stringized number is not some string like
1535 // "Inf" or NaN, that atof will accept, but the lexer will not. Check
1536 // that the string matches the "[-+]?[0-9]" regex.
1537 //
1538 assert((isDigit(StrVal[0]) ||
1539 ((StrVal[0] == '-' || StrVal[0] == '+') && isDigit(StrVal[1]))) &&
1540 "[-+]?[0-9] regex does not match!");
1541 // Reparse stringized version!
1542 if (APFloat(APFloat::IEEEdouble(), StrVal).convertToDouble() == Val) {
1543 Out << StrVal;
1544 return;
1545 }
1546 }
1547
1548 // Otherwise we could not reparse it to exactly the same value, so we must
1549 // output the string in hexadecimal format! Note that loading and storing
1550 // floating point types changes the bits of NaNs on some hosts, notably
1551 // x86, so we must not use these types.
1552 static_assert(sizeof(double) == sizeof(uint64_t),
1553 "assuming that double is 64 bits!");
1554 APFloat apf = APF;
1555
1556 // Floats are represented in ASCII IR as double, convert.
1557 // FIXME: We should allow 32-bit hex float and remove this.
1558 if (!isDouble) {
1559 // A signaling NaN is quieted on conversion, so we need to recreate the
1560 // expected value after convert (quiet bit of the payload is clear).
1561 bool IsSNAN = apf.isSignaling();
1563 &ignored);
1564 if (IsSNAN) {
1565 APInt Payload = apf.bitcastToAPInt();
1566 apf =
1568 }
1569 }
1570
1571 Out << format_hex(apf.bitcastToAPInt().getZExtValue(), 0, /*Upper=*/true);
1572 return;
1573 }
1574
1575 // Either half, bfloat or some form of long double.
1576 // These appear as a magic letter identifying the type, then a
1577 // fixed number of hex digits.
1578 Out << "0x";
1579 APInt API = APF.bitcastToAPInt();
1580 if (&APF.getSemantics() == &APFloat::x87DoubleExtended()) {
1581 Out << 'K';
1582 Out << format_hex_no_prefix(API.getHiBits(16).getZExtValue(), 4,
1583 /*Upper=*/true);
1584 Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
1585 /*Upper=*/true);
1586 } else if (&APF.getSemantics() == &APFloat::IEEEquad()) {
1587 Out << 'L';
1588 Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
1589 /*Upper=*/true);
1590 Out << format_hex_no_prefix(API.getHiBits(64).getZExtValue(), 16,
1591 /*Upper=*/true);
1592 } else if (&APF.getSemantics() == &APFloat::PPCDoubleDouble()) {
1593 Out << 'M';
1594 Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
1595 /*Upper=*/true);
1596 Out << format_hex_no_prefix(API.getHiBits(64).getZExtValue(), 16,
1597 /*Upper=*/true);
1598 } else if (&APF.getSemantics() == &APFloat::IEEEhalf()) {
1599 Out << 'H';
1600 Out << format_hex_no_prefix(API.getZExtValue(), 4,
1601 /*Upper=*/true);
1602 } else if (&APF.getSemantics() == &APFloat::BFloat()) {
1603 Out << 'R';
1604 Out << format_hex_no_prefix(API.getZExtValue(), 4,
1605 /*Upper=*/true);
1606 } else
1607 llvm_unreachable("Unsupported floating point type");
1608}
1609
1610static void WriteConstantInternal(raw_ostream &Out, const Constant *CV,
1611 AsmWriterContext &WriterCtx) {
1612 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
1613 Type *Ty = CI->getType();
1614
1615 if (Ty->isVectorTy()) {
1616 Out << "splat (";
1617 WriterCtx.TypePrinter->print(Ty->getScalarType(), Out);
1618 Out << " ";
1619 }
1620
1621 if (Ty->getScalarType()->isIntegerTy(1))
1622 Out << (CI->getZExtValue() ? "true" : "false");
1623 else
1624 Out << CI->getValue();
1625
1626 if (Ty->isVectorTy())
1627 Out << ")";
1628
1629 return;
1630 }
1631
1632 if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
1633 Type *Ty = CFP->getType();
1634
1635 if (Ty->isVectorTy()) {
1636 Out << "splat (";
1637 WriterCtx.TypePrinter->print(Ty->getScalarType(), Out);
1638 Out << " ";
1639 }
1640
1641 WriteAPFloatInternal(Out, CFP->getValueAPF());
1642
1643 if (Ty->isVectorTy())
1644 Out << ")";
1645
1646 return;
1647 }
1648
1650 Out << "zeroinitializer";
1651 return;
1652 }
1653
1654 if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV)) {
1655 Out << "blockaddress(";
1656 WriteAsOperandInternal(Out, BA->getFunction(), WriterCtx);
1657 Out << ", ";
1658 WriteAsOperandInternal(Out, BA->getBasicBlock(), WriterCtx);
1659 Out << ")";
1660 return;
1661 }
1662
1663 if (const auto *Equiv = dyn_cast<DSOLocalEquivalent>(CV)) {
1664 Out << "dso_local_equivalent ";
1665 WriteAsOperandInternal(Out, Equiv->getGlobalValue(), WriterCtx);
1666 return;
1667 }
1668
1669 if (const auto *NC = dyn_cast<NoCFIValue>(CV)) {
1670 Out << "no_cfi ";
1671 WriteAsOperandInternal(Out, NC->getGlobalValue(), WriterCtx);
1672 return;
1673 }
1674
1675 if (const ConstantPtrAuth *CPA = dyn_cast<ConstantPtrAuth>(CV)) {
1676 Out << "ptrauth (";
1677
1678 // ptrauth (ptr CST, i32 KEY[, i64 DISC[, ptr ADDRDISC]?]?)
1679 unsigned NumOpsToWrite = 2;
1680 if (!CPA->getOperand(2)->isNullValue())
1681 NumOpsToWrite = 3;
1682 if (!CPA->getOperand(3)->isNullValue())
1683 NumOpsToWrite = 4;
1684
1685 ListSeparator LS;
1686 for (unsigned i = 0, e = NumOpsToWrite; i != e; ++i) {
1687 Out << LS;
1688 WriterCtx.TypePrinter->print(CPA->getOperand(i)->getType(), Out);
1689 Out << ' ';
1690 WriteAsOperandInternal(Out, CPA->getOperand(i), WriterCtx);
1691 }
1692 Out << ')';
1693 return;
1694 }
1695
1696 if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) {
1697 Type *ETy = CA->getType()->getElementType();
1698 Out << '[';
1699 ListSeparator LS;
1700 for (const Value *Op : CA->operands()) {
1701 Out << LS;
1702 WriterCtx.TypePrinter->print(ETy, Out);
1703 Out << ' ';
1704 WriteAsOperandInternal(Out, Op, WriterCtx);
1705 }
1706 Out << ']';
1707 return;
1708 }
1709
1710 if (const ConstantDataArray *CA = dyn_cast<ConstantDataArray>(CV)) {
1711 // As a special case, print the array as a string if it is an array of
1712 // i8 with ConstantInt values.
1713 if (CA->isString()) {
1714 Out << "c\"";
1715 printEscapedString(CA->getAsString(), Out);
1716 Out << '"';
1717 return;
1718 }
1719
1720 Type *ETy = CA->getType()->getElementType();
1721 Out << '[';
1722 ListSeparator LS;
1723 for (uint64_t i = 0, e = CA->getNumElements(); i != e; ++i) {
1724 Out << LS;
1725 WriterCtx.TypePrinter->print(ETy, Out);
1726 Out << ' ';
1727 WriteAsOperandInternal(Out, CA->getElementAsConstant(i), WriterCtx);
1728 }
1729 Out << ']';
1730 return;
1731 }
1732
1733 if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) {
1734 if (CS->getType()->isPacked())
1735 Out << '<';
1736 Out << '{';
1737 if (CS->getNumOperands() != 0) {
1738 Out << ' ';
1739 ListSeparator LS;
1740 for (const Value *Op : CS->operands()) {
1741 Out << LS;
1742 WriterCtx.TypePrinter->print(Op->getType(), Out);
1743 Out << ' ';
1744 WriteAsOperandInternal(Out, Op, WriterCtx);
1745 }
1746 Out << ' ';
1747 }
1748 Out << '}';
1749 if (CS->getType()->isPacked())
1750 Out << '>';
1751 return;
1752 }
1753
1755 auto *CVVTy = cast<FixedVectorType>(CV->getType());
1756 Type *ETy = CVVTy->getElementType();
1757
1758 // Use the same shorthand for splat vector (i.e. "splat(Ty val)") as is
1759 // permitted on IR input to reduce the output changes when enabling
1760 // UseConstant{Int,FP}ForFixedLengthSplat.
1761 // TODO: Remove this block when the UseConstant{Int,FP}ForFixedLengthSplat
1762 // options are removed.
1763 if (auto *SplatVal = CV->getSplatValue()) {
1764 if (isa<ConstantInt>(SplatVal) || isa<ConstantFP>(SplatVal)) {
1765 Out << "splat (";
1766 WriterCtx.TypePrinter->print(ETy, Out);
1767 Out << ' ';
1768 WriteAsOperandInternal(Out, SplatVal, WriterCtx);
1769 Out << ')';
1770 return;
1771 }
1772 }
1773
1774 Out << '<';
1775 ListSeparator LS;
1776 for (unsigned i = 0, e = CVVTy->getNumElements(); i != e; ++i) {
1777 Out << LS;
1778 WriterCtx.TypePrinter->print(ETy, Out);
1779 Out << ' ';
1780 WriteAsOperandInternal(Out, CV->getAggregateElement(i), WriterCtx);
1781 }
1782 Out << '>';
1783 return;
1784 }
1785
1786 if (isa<ConstantPointerNull>(CV)) {
1787 Out << "null";
1788 return;
1789 }
1790
1791 if (isa<ConstantTokenNone>(CV)) {
1792 Out << "none";
1793 return;
1794 }
1795
1796 if (isa<PoisonValue>(CV)) {
1797 Out << "poison";
1798 return;
1799 }
1800
1801 if (isa<UndefValue>(CV)) {
1802 Out << "undef";
1803 return;
1804 }
1805
1806 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
1807 // Use the same shorthand for splat vector (i.e. "splat(Ty val)") as is
1808 // permitted on IR input to reduce the output changes when enabling
1809 // UseConstant{Int,FP}ForScalableSplat.
1810 // TODO: Remove this block when the UseConstant{Int,FP}ForScalableSplat
1811 // options are removed.
1812 if (CE->getOpcode() == Instruction::ShuffleVector) {
1813 if (auto *SplatVal = CE->getSplatValue()) {
1814 if (isa<ConstantInt>(SplatVal) || isa<ConstantFP>(SplatVal)) {
1815 Out << "splat (";
1816 WriterCtx.TypePrinter->print(SplatVal->getType(), Out);
1817 Out << ' ';
1818 WriteAsOperandInternal(Out, SplatVal, WriterCtx);
1819 Out << ')';
1820 return;
1821 }
1822 }
1823 }
1824
1825 Out << CE->getOpcodeName();
1826 WriteOptimizationInfo(Out, CE);
1827 Out << " (";
1828
1829 if (const GEPOperator *GEP = dyn_cast<GEPOperator>(CE)) {
1830 WriterCtx.TypePrinter->print(GEP->getSourceElementType(), Out);
1831 Out << ", ";
1832 }
1833
1834 ListSeparator LS;
1835 for (const Value *Op : CE->operands()) {
1836 Out << LS;
1837 WriterCtx.TypePrinter->print(Op->getType(), Out);
1838 Out << ' ';
1839 WriteAsOperandInternal(Out, Op, WriterCtx);
1840 }
1841
1842 if (CE->isCast()) {
1843 Out << " to ";
1844 WriterCtx.TypePrinter->print(CE->getType(), Out);
1845 }
1846
1847 if (CE->getOpcode() == Instruction::ShuffleVector)
1848 PrintShuffleMask(Out, CE->getType(), CE->getShuffleMask());
1849
1850 Out << ')';
1851 return;
1852 }
1853
1854 Out << "<placeholder or erroneous Constant>";
1855}
1856
1857static void writeMDTuple(raw_ostream &Out, const MDTuple *Node,
1858 AsmWriterContext &WriterCtx) {
1859 Out << "!{";
1860 ListSeparator LS;
1861 for (const Metadata *MD : Node->operands()) {
1862 Out << LS;
1863 if (!MD) {
1864 Out << "null";
1865 } else if (auto *MDV = dyn_cast<ValueAsMetadata>(MD)) {
1866 Value *V = MDV->getValue();
1867 WriterCtx.TypePrinter->print(V->getType(), Out);
1868 Out << ' ';
1869 WriteAsOperandInternal(Out, V, WriterCtx);
1870 } else {
1871 WriteAsOperandInternal(Out, MD, WriterCtx);
1872 WriterCtx.onWriteMetadataAsOperand(MD);
1873 }
1874 }
1875
1876 Out << "}";
1877}
1878
1879namespace {
1880
1881struct MDFieldPrinter {
1882 raw_ostream &Out;
1883 ListSeparator FS;
1884 AsmWriterContext &WriterCtx;
1885
1886 explicit MDFieldPrinter(raw_ostream &Out)
1887 : Out(Out), WriterCtx(AsmWriterContext::getEmpty()) {}
1888 MDFieldPrinter(raw_ostream &Out, AsmWriterContext &Ctx)
1889 : Out(Out), WriterCtx(Ctx) {}
1890
1891 void printTag(const DINode *N);
1892 void printMacinfoType(const DIMacroNode *N);
1893 void printChecksum(const DIFile::ChecksumInfo<StringRef> &N);
1894 void printString(StringRef Name, StringRef Value,
1895 bool ShouldSkipEmpty = true);
1896 void printMetadata(StringRef Name, const Metadata *MD,
1897 bool ShouldSkipNull = true);
1898 void printMetadataOrInt(StringRef Name, const Metadata *MD, bool IsUnsigned,
1899 bool ShouldSkipZero = true);
1900 template <class IntTy>
1901 void printInt(StringRef Name, IntTy Int, bool ShouldSkipZero = true);
1902 void printAPInt(StringRef Name, const APInt &Int, bool IsUnsigned,
1903 bool ShouldSkipZero);
1904 void printBool(StringRef Name, bool Value,
1905 std::optional<bool> Default = std::nullopt);
1906 void printDIFlags(StringRef Name, DINode::DIFlags Flags);
1907 void printDISPFlags(StringRef Name, DISubprogram::DISPFlags Flags);
1908 template <class IntTy, class Stringifier>
1909 void printDwarfEnum(StringRef Name, IntTy Value, Stringifier toString,
1910 bool ShouldSkipZero = true);
1911 void printEmissionKind(StringRef Name, DICompileUnit::DebugEmissionKind EK);
1912 void printNameTableKind(StringRef Name,
1914 void printFixedPointKind(StringRef Name, DIFixedPointType::FixedPointKind V);
1915};
1916
1917} // end anonymous namespace
1918
1919void MDFieldPrinter::printTag(const DINode *N) {
1920 Out << FS << "tag: ";
1921 auto Tag = dwarf::TagString(N->getTag());
1922 if (!Tag.empty())
1923 Out << Tag;
1924 else
1925 Out << N->getTag();
1926}
1927
1928void MDFieldPrinter::printMacinfoType(const DIMacroNode *N) {
1929 Out << FS << "type: ";
1930 auto Type = dwarf::MacinfoString(N->getMacinfoType());
1931 if (!Type.empty())
1932 Out << Type;
1933 else
1934 Out << N->getMacinfoType();
1935}
1936
1937void MDFieldPrinter::printChecksum(
1938 const DIFile::ChecksumInfo<StringRef> &Checksum) {
1939 Out << FS << "checksumkind: " << Checksum.getKindAsString();
1940 printString("checksum", Checksum.Value, /* ShouldSkipEmpty */ false);
1941}
1942
1943void MDFieldPrinter::printString(StringRef Name, StringRef Value,
1944 bool ShouldSkipEmpty) {
1945 if (ShouldSkipEmpty && Value.empty())
1946 return;
1947
1948 Out << FS << Name << ": \"";
1950 Out << "\"";
1951}
1952
1953static void writeMetadataAsOperand(raw_ostream &Out, const Metadata *MD,
1954 AsmWriterContext &WriterCtx) {
1955 if (!MD) {
1956 Out << "null";
1957 return;
1958 }
1959 WriteAsOperandInternal(Out, MD, WriterCtx);
1960 WriterCtx.onWriteMetadataAsOperand(MD);
1961}
1962
1963void MDFieldPrinter::printMetadata(StringRef Name, const Metadata *MD,
1964 bool ShouldSkipNull) {
1965 if (ShouldSkipNull && !MD)
1966 return;
1967
1968 Out << FS << Name << ": ";
1969 writeMetadataAsOperand(Out, MD, WriterCtx);
1970}
1971
1972void MDFieldPrinter::printMetadataOrInt(StringRef Name, const Metadata *MD,
1973 bool IsUnsigned, bool ShouldSkipZero) {
1974 if (!MD)
1975 return;
1976
1977 if (auto *CI = dyn_cast<ConstantAsMetadata>(MD)) {
1978 auto *CV = cast<ConstantInt>(CI->getValue());
1979 if (IsUnsigned)
1980 printInt(Name, CV->getZExtValue(), ShouldSkipZero);
1981 else
1982 printInt(Name, CV->getSExtValue(), ShouldSkipZero);
1983 } else
1984 printMetadata(Name, MD);
1985}
1986
1987template <class IntTy>
1988void MDFieldPrinter::printInt(StringRef Name, IntTy Int, bool ShouldSkipZero) {
1989 if (ShouldSkipZero && !Int)
1990 return;
1991
1992 Out << FS << Name << ": " << Int;
1993}
1994
1995void MDFieldPrinter::printAPInt(StringRef Name, const APInt &Int,
1996 bool IsUnsigned, bool ShouldSkipZero) {
1997 if (ShouldSkipZero && Int.isZero())
1998 return;
1999
2000 Out << FS << Name << ": ";
2001 Int.print(Out, !IsUnsigned);
2002}
2003
2004void MDFieldPrinter::printBool(StringRef Name, bool Value,
2005 std::optional<bool> Default) {
2006 if (Default && Value == *Default)
2007 return;
2008 Out << FS << Name << ": " << (Value ? "true" : "false");
2009}
2010
2011void MDFieldPrinter::printDIFlags(StringRef Name, DINode::DIFlags Flags) {
2012 if (!Flags)
2013 return;
2014
2015 Out << FS << Name << ": ";
2016
2018 auto Extra = DINode::splitFlags(Flags, SplitFlags);
2019
2020 ListSeparator FlagsFS(" | ");
2021 for (auto F : SplitFlags) {
2022 auto StringF = DINode::getFlagString(F);
2023 assert(!StringF.empty() && "Expected valid flag");
2024 Out << FlagsFS << StringF;
2025 }
2026 if (Extra || SplitFlags.empty())
2027 Out << FlagsFS << Extra;
2028}
2029
2030void MDFieldPrinter::printDISPFlags(StringRef Name,
2032 // Always print this field, because no flags in the IR at all will be
2033 // interpreted as old-style isDefinition: true.
2034 Out << FS << Name << ": ";
2035
2036 if (!Flags) {
2037 Out << 0;
2038 return;
2039 }
2040
2042 auto Extra = DISubprogram::splitFlags(Flags, SplitFlags);
2043
2044 ListSeparator FlagsFS(" | ");
2045 for (auto F : SplitFlags) {
2046 auto StringF = DISubprogram::getFlagString(F);
2047 assert(!StringF.empty() && "Expected valid flag");
2048 Out << FlagsFS << StringF;
2049 }
2050 if (Extra || SplitFlags.empty())
2051 Out << FlagsFS << Extra;
2052}
2053
2054void MDFieldPrinter::printEmissionKind(StringRef Name,
2056 Out << FS << Name << ": " << DICompileUnit::emissionKindString(EK);
2057}
2058
2059void MDFieldPrinter::printNameTableKind(StringRef Name,
2062 return;
2063 Out << FS << Name << ": " << DICompileUnit::nameTableKindString(NTK);
2064}
2065
2066void MDFieldPrinter::printFixedPointKind(StringRef Name,
2068 Out << FS << Name << ": " << DIFixedPointType::fixedPointKindString(V);
2069}
2070
2071template <class IntTy, class Stringifier>
2072void MDFieldPrinter::printDwarfEnum(StringRef Name, IntTy Value,
2073 Stringifier toString, bool ShouldSkipZero) {
2074 if (ShouldSkipZero && !Value)
2075 return;
2076
2077 Out << FS << Name << ": ";
2078 auto S = toString(Value);
2079 if (!S.empty())
2080 Out << S;
2081 else
2082 Out << Value;
2083}
2084
2086 AsmWriterContext &WriterCtx) {
2087 Out << "!GenericDINode(";
2088 MDFieldPrinter Printer(Out, WriterCtx);
2089 Printer.printTag(N);
2090 Printer.printString("header", N->getHeader());
2091 if (N->getNumDwarfOperands()) {
2092 Out << Printer.FS << "operands: {";
2093 ListSeparator IFS;
2094 for (auto &I : N->dwarf_operands()) {
2095 Out << IFS;
2096 writeMetadataAsOperand(Out, I, WriterCtx);
2097 }
2098 Out << "}";
2099 }
2100 Out << ")";
2101}
2102
2103static void writeDILocation(raw_ostream &Out, const DILocation *DL,
2104 AsmWriterContext &WriterCtx) {
2105 Out << "!DILocation(";
2106 MDFieldPrinter Printer(Out, WriterCtx);
2107 // Always output the line, since 0 is a relevant and important value for it.
2108 Printer.printInt("line", DL->getLine(), /* ShouldSkipZero */ false);
2109 Printer.printInt("column", DL->getColumn());
2110 Printer.printMetadata("scope", DL->getRawScope(), /* ShouldSkipNull */ false);
2111 Printer.printMetadata("inlinedAt", DL->getRawInlinedAt());
2112 Printer.printBool("isImplicitCode", DL->isImplicitCode(),
2113 /* Default */ false);
2114 Printer.printInt("atomGroup", DL->getAtomGroup());
2115 Printer.printInt<unsigned>("atomRank", DL->getAtomRank());
2116 Out << ")";
2117}
2118
2119static void writeDIAssignID(raw_ostream &Out, const DIAssignID *DL,
2120 AsmWriterContext &WriterCtx) {
2121 Out << "!DIAssignID()";
2122 MDFieldPrinter Printer(Out, WriterCtx);
2123}
2124
2125static void writeDISubrange(raw_ostream &Out, const DISubrange *N,
2126 AsmWriterContext &WriterCtx) {
2127 Out << "!DISubrange(";
2128 MDFieldPrinter Printer(Out, WriterCtx);
2129
2130 Printer.printMetadataOrInt("count", N->getRawCountNode(),
2131 /* IsUnsigned */ false,
2132 /* ShouldSkipZero */ false);
2133
2134 // A lowerBound of constant 0 should not be skipped, since it is different
2135 // from an unspecified lower bound (= nullptr).
2136 Printer.printMetadataOrInt("lowerBound", N->getRawLowerBound(),
2137 /* IsUnsigned */ false,
2138 /* ShouldSkipZero */ false);
2139 Printer.printMetadataOrInt("upperBound", N->getRawUpperBound(),
2140 /* IsUnsigned */ false,
2141 /* ShouldSkipZero */ false);
2142 Printer.printMetadataOrInt("stride", N->getRawStride(),
2143 /* IsUnsigned */ false,
2144 /* ShouldSkipZero */ false);
2145
2146 Out << ")";
2147}
2148
2150 AsmWriterContext &WriterCtx) {
2151 Out << "!DIGenericSubrange(";
2152 MDFieldPrinter Printer(Out, WriterCtx);
2153
2154 auto GetConstant = [&](Metadata *Bound) -> std::optional<int64_t> {
2155 auto *BE = dyn_cast_or_null<DIExpression>(Bound);
2156 if (!BE)
2157 return std::nullopt;
2158 if (BE->isConstant() &&
2160 *BE->isConstant()) {
2161 return static_cast<int64_t>(BE->getElement(1));
2162 }
2163 return std::nullopt;
2164 };
2165
2166 auto *Count = N->getRawCountNode();
2167 if (auto ConstantCount = GetConstant(Count))
2168 Printer.printInt("count", *ConstantCount,
2169 /* ShouldSkipZero */ false);
2170 else
2171 Printer.printMetadata("count", Count, /*ShouldSkipNull */ true);
2172
2173 auto *LBound = N->getRawLowerBound();
2174 if (auto ConstantLBound = GetConstant(LBound))
2175 Printer.printInt("lowerBound", *ConstantLBound,
2176 /* ShouldSkipZero */ false);
2177 else
2178 Printer.printMetadata("lowerBound", LBound, /*ShouldSkipNull */ true);
2179
2180 auto *UBound = N->getRawUpperBound();
2181 if (auto ConstantUBound = GetConstant(UBound))
2182 Printer.printInt("upperBound", *ConstantUBound,
2183 /* ShouldSkipZero */ false);
2184 else
2185 Printer.printMetadata("upperBound", UBound, /*ShouldSkipNull */ true);
2186
2187 auto *Stride = N->getRawStride();
2188 if (auto ConstantStride = GetConstant(Stride))
2189 Printer.printInt("stride", *ConstantStride,
2190 /* ShouldSkipZero */ false);
2191 else
2192 Printer.printMetadata("stride", Stride, /*ShouldSkipNull */ true);
2193
2194 Out << ")";
2195}
2196
2198 AsmWriterContext &) {
2199 Out << "!DIEnumerator(";
2200 MDFieldPrinter Printer(Out);
2201 Printer.printString("name", N->getName(), /* ShouldSkipEmpty */ false);
2202 Printer.printAPInt("value", N->getValue(), N->isUnsigned(),
2203 /*ShouldSkipZero=*/false);
2204 if (N->isUnsigned())
2205 Printer.printBool("isUnsigned", true);
2206 Out << ")";
2207}
2208
2210 AsmWriterContext &WriterCtx) {
2211 Out << "!DIBasicType(";
2212 MDFieldPrinter Printer(Out, WriterCtx);
2213 if (N->getTag() != dwarf::DW_TAG_base_type)
2214 Printer.printTag(N);
2215 Printer.printString("name", N->getName());
2216 Printer.printMetadataOrInt("size", N->getRawSizeInBits(), true);
2217 Printer.printInt("align", N->getAlignInBits());
2218 Printer.printDwarfEnum("encoding", N->getEncoding(),
2220 Printer.printInt("num_extra_inhabitants", N->getNumExtraInhabitants());
2221 Printer.printDIFlags("flags", N->getFlags());
2222 Out << ")";
2223}
2224
2226 AsmWriterContext &WriterCtx) {
2227 Out << "!DIFixedPointType(";
2228 MDFieldPrinter Printer(Out, WriterCtx);
2229 if (N->getTag() != dwarf::DW_TAG_base_type)
2230 Printer.printTag(N);
2231 Printer.printString("name", N->getName());
2232 Printer.printMetadataOrInt("size", N->getRawSizeInBits(), true);
2233 Printer.printInt("align", N->getAlignInBits());
2234 Printer.printDwarfEnum("encoding", N->getEncoding(),
2236 Printer.printDIFlags("flags", N->getFlags());
2237 Printer.printFixedPointKind("kind", N->getKind());
2238 if (N->isRational()) {
2239 bool IsUnsigned = !N->isSigned();
2240 Printer.printAPInt("numerator", N->getNumerator(), IsUnsigned, false);
2241 Printer.printAPInt("denominator", N->getDenominator(), IsUnsigned, false);
2242 } else {
2243 Printer.printInt("factor", N->getFactor());
2244 }
2245 Out << ")";
2246}
2247
2249 AsmWriterContext &WriterCtx) {
2250 Out << "!DIStringType(";
2251 MDFieldPrinter Printer(Out, WriterCtx);
2252 if (N->getTag() != dwarf::DW_TAG_string_type)
2253 Printer.printTag(N);
2254 Printer.printString("name", N->getName());
2255 Printer.printMetadata("stringLength", N->getRawStringLength());
2256 Printer.printMetadata("stringLengthExpression", N->getRawStringLengthExp());
2257 Printer.printMetadata("stringLocationExpression",
2258 N->getRawStringLocationExp());
2259 Printer.printMetadataOrInt("size", N->getRawSizeInBits(), true);
2260 Printer.printInt("align", N->getAlignInBits());
2261 Printer.printDwarfEnum("encoding", N->getEncoding(),
2263 Out << ")";
2264}
2265
2267 AsmWriterContext &WriterCtx) {
2268 Out << "!DIDerivedType(";
2269 MDFieldPrinter Printer(Out, WriterCtx);
2270 Printer.printTag(N);
2271 Printer.printString("name", N->getName());
2272 Printer.printMetadata("scope", N->getRawScope());
2273 Printer.printMetadata("file", N->getRawFile());
2274 Printer.printInt("line", N->getLine());
2275 Printer.printMetadata("baseType", N->getRawBaseType(),
2276 /* ShouldSkipNull */ false);
2277 Printer.printMetadataOrInt("size", N->getRawSizeInBits(), true);
2278 Printer.printInt("align", N->getAlignInBits());
2279 Printer.printMetadataOrInt("offset", N->getRawOffsetInBits(), true);
2280 Printer.printDIFlags("flags", N->getFlags());
2281 Printer.printMetadata("extraData", N->getRawExtraData());
2282 if (const auto &DWARFAddressSpace = N->getDWARFAddressSpace())
2283 Printer.printInt("dwarfAddressSpace", *DWARFAddressSpace,
2284 /* ShouldSkipZero */ false);
2285 Printer.printMetadata("annotations", N->getRawAnnotations());
2286 if (auto PtrAuthData = N->getPtrAuthData()) {
2287 Printer.printInt("ptrAuthKey", PtrAuthData->key());
2288 Printer.printBool("ptrAuthIsAddressDiscriminated",
2289 PtrAuthData->isAddressDiscriminated());
2290 Printer.printInt("ptrAuthExtraDiscriminator",
2291 PtrAuthData->extraDiscriminator());
2292 Printer.printBool("ptrAuthIsaPointer", PtrAuthData->isaPointer());
2293 Printer.printBool("ptrAuthAuthenticatesNullValues",
2294 PtrAuthData->authenticatesNullValues());
2295 }
2296 Out << ")";
2297}
2298
2300 AsmWriterContext &WriterCtx) {
2301 Out << "!DISubrangeType(";
2302 MDFieldPrinter Printer(Out, WriterCtx);
2303 Printer.printString("name", N->getName());
2304 Printer.printMetadata("scope", N->getRawScope());
2305 Printer.printMetadata("file", N->getRawFile());
2306 Printer.printInt("line", N->getLine());
2307 Printer.printMetadataOrInt("size", N->getRawSizeInBits(), true);
2308 Printer.printInt("align", N->getAlignInBits());
2309 Printer.printDIFlags("flags", N->getFlags());
2310 Printer.printMetadata("baseType", N->getRawBaseType(),
2311 /* ShouldSkipNull */ false);
2312 Printer.printMetadata("lowerBound", N->getRawLowerBound());
2313 Printer.printMetadata("upperBound", N->getRawUpperBound());
2314 Printer.printMetadata("stride", N->getRawStride());
2315 Printer.printMetadata("bias", N->getRawBias());
2316 Out << ")";
2317}
2318
2320 AsmWriterContext &WriterCtx) {
2321 Out << "!DICompositeType(";
2322 MDFieldPrinter Printer(Out, WriterCtx);
2323 Printer.printTag(N);
2324 Printer.printString("name", N->getName());
2325 Printer.printMetadata("scope", N->getRawScope());
2326 Printer.printMetadata("file", N->getRawFile());
2327 Printer.printInt("line", N->getLine());
2328 Printer.printMetadata("baseType", N->getRawBaseType());
2329 Printer.printMetadataOrInt("size", N->getRawSizeInBits(), true);
2330 Printer.printInt("align", N->getAlignInBits());
2331 Printer.printMetadataOrInt("offset", N->getRawOffsetInBits(), true);
2332 Printer.printInt("num_extra_inhabitants", N->getNumExtraInhabitants());
2333 Printer.printDIFlags("flags", N->getFlags());
2334 Printer.printMetadata("elements", N->getRawElements());
2335 Printer.printDwarfEnum("runtimeLang", N->getRuntimeLang(),
2337 Printer.printMetadata("vtableHolder", N->getRawVTableHolder());
2338 Printer.printMetadata("templateParams", N->getRawTemplateParams());
2339 Printer.printString("identifier", N->getIdentifier());
2340 Printer.printMetadata("discriminator", N->getRawDiscriminator());
2341 Printer.printMetadata("dataLocation", N->getRawDataLocation());
2342 Printer.printMetadata("associated", N->getRawAssociated());
2343 Printer.printMetadata("allocated", N->getRawAllocated());
2344 if (auto *RankConst = N->getRankConst())
2345 Printer.printInt("rank", RankConst->getSExtValue(),
2346 /* ShouldSkipZero */ false);
2347 else
2348 Printer.printMetadata("rank", N->getRawRank(), /*ShouldSkipNull */ true);
2349 Printer.printMetadata("annotations", N->getRawAnnotations());
2350 if (auto *Specification = N->getRawSpecification())
2351 Printer.printMetadata("specification", Specification);
2352
2353 if (auto EnumKind = N->getEnumKind())
2354 Printer.printDwarfEnum("enumKind", *EnumKind, dwarf::EnumKindString,
2355 /*ShouldSkipZero=*/false);
2356
2357 Printer.printMetadata("bitStride", N->getRawBitStride());
2358 Out << ")";
2359}
2360
2362 AsmWriterContext &WriterCtx) {
2363 Out << "!DISubroutineType(";
2364 MDFieldPrinter Printer(Out, WriterCtx);
2365 Printer.printDIFlags("flags", N->getFlags());
2366 Printer.printDwarfEnum("cc", N->getCC(), dwarf::ConventionString);
2367 Printer.printMetadata("types", N->getRawTypeArray(),
2368 /* ShouldSkipNull */ false);
2369 Out << ")";
2370}
2371
2372static void writeDIFile(raw_ostream &Out, const DIFile *N, AsmWriterContext &) {
2373 Out << "!DIFile(";
2374 MDFieldPrinter Printer(Out);
2375 Printer.printString("filename", N->getFilename(),
2376 /* ShouldSkipEmpty */ false);
2377 Printer.printString("directory", N->getDirectory(),
2378 /* ShouldSkipEmpty */ false);
2379 // Print all values for checksum together, or not at all.
2380 if (N->getChecksum())
2381 Printer.printChecksum(*N->getChecksum());
2382 if (N->getSource())
2383 Printer.printString("source", *N->getSource(),
2384 /* ShouldSkipEmpty */ false);
2385 Out << ")";
2386}
2387
2389 AsmWriterContext &WriterCtx) {
2390 Out << "!DICompileUnit(";
2391 MDFieldPrinter Printer(Out, WriterCtx);
2392 Printer.printDwarfEnum("language", N->getSourceLanguage(),
2393 dwarf::LanguageString, /* ShouldSkipZero */ false);
2394 Printer.printMetadata("file", N->getRawFile(), /* ShouldSkipNull */ false);
2395 Printer.printString("producer", N->getProducer());
2396 Printer.printBool("isOptimized", N->isOptimized());
2397 Printer.printString("flags", N->getFlags());
2398 Printer.printInt("runtimeVersion", N->getRuntimeVersion(),
2399 /* ShouldSkipZero */ false);
2400 Printer.printString("splitDebugFilename", N->getSplitDebugFilename());
2401 Printer.printEmissionKind("emissionKind", N->getEmissionKind());
2402 Printer.printMetadata("enums", N->getRawEnumTypes());
2403 Printer.printMetadata("retainedTypes", N->getRawRetainedTypes());
2404 Printer.printMetadata("globals", N->getRawGlobalVariables());
2405 Printer.printMetadata("imports", N->getRawImportedEntities());
2406 Printer.printMetadata("macros", N->getRawMacros());
2407 Printer.printInt("dwoId", N->getDWOId());
2408 Printer.printBool("splitDebugInlining", N->getSplitDebugInlining(), true);
2409 Printer.printBool("debugInfoForProfiling", N->getDebugInfoForProfiling(),
2410 false);
2411 Printer.printNameTableKind("nameTableKind", N->getNameTableKind());
2412 Printer.printBool("rangesBaseAddress", N->getRangesBaseAddress(), false);
2413 Printer.printString("sysroot", N->getSysRoot());
2414 Printer.printString("sdk", N->getSDK());
2415 Out << ")";
2416}
2417
2419 AsmWriterContext &WriterCtx) {
2420 Out << "!DISubprogram(";
2421 MDFieldPrinter Printer(Out, WriterCtx);
2422 Printer.printString("name", N->getName());
2423 Printer.printString("linkageName", N->getLinkageName());
2424 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2425 Printer.printMetadata("file", N->getRawFile());
2426 Printer.printInt("line", N->getLine());
2427 Printer.printMetadata("type", N->getRawType());
2428 Printer.printInt("scopeLine", N->getScopeLine());
2429 Printer.printMetadata("containingType", N->getRawContainingType());
2430 if (N->getVirtuality() != dwarf::DW_VIRTUALITY_none ||
2431 N->getVirtualIndex() != 0)
2432 Printer.printInt("virtualIndex", N->getVirtualIndex(), false);
2433 Printer.printInt("thisAdjustment", N->getThisAdjustment());
2434 Printer.printDIFlags("flags", N->getFlags());
2435 Printer.printDISPFlags("spFlags", N->getSPFlags());
2436 Printer.printMetadata("unit", N->getRawUnit());
2437 Printer.printMetadata("templateParams", N->getRawTemplateParams());
2438 Printer.printMetadata("declaration", N->getRawDeclaration());
2439 Printer.printMetadata("retainedNodes", N->getRawRetainedNodes());
2440 Printer.printMetadata("thrownTypes", N->getRawThrownTypes());
2441 Printer.printMetadata("annotations", N->getRawAnnotations());
2442 Printer.printString("targetFuncName", N->getTargetFuncName());
2443 Printer.printBool("keyInstructions", N->getKeyInstructionsEnabled(), false);
2444 Out << ")";
2445}
2446
2448 AsmWriterContext &WriterCtx) {
2449 Out << "!DILexicalBlock(";
2450 MDFieldPrinter Printer(Out, WriterCtx);
2451 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2452 Printer.printMetadata("file", N->getRawFile());
2453 Printer.printInt("line", N->getLine());
2454 Printer.printInt("column", N->getColumn());
2455 Out << ")";
2456}
2457
2459 const DILexicalBlockFile *N,
2460 AsmWriterContext &WriterCtx) {
2461 Out << "!DILexicalBlockFile(";
2462 MDFieldPrinter Printer(Out, WriterCtx);
2463 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2464 Printer.printMetadata("file", N->getRawFile());
2465 Printer.printInt("discriminator", N->getDiscriminator(),
2466 /* ShouldSkipZero */ false);
2467 Out << ")";
2468}
2469
2471 AsmWriterContext &WriterCtx) {
2472 Out << "!DINamespace(";
2473 MDFieldPrinter Printer(Out, WriterCtx);
2474 Printer.printString("name", N->getName());
2475 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2476 Printer.printBool("exportSymbols", N->getExportSymbols(), false);
2477 Out << ")";
2478}
2479
2481 AsmWriterContext &WriterCtx) {
2482 Out << "!DICommonBlock(";
2483 MDFieldPrinter Printer(Out, WriterCtx);
2484 Printer.printMetadata("scope", N->getRawScope(), false);
2485 Printer.printMetadata("declaration", N->getRawDecl(), false);
2486 Printer.printString("name", N->getName());
2487 Printer.printMetadata("file", N->getRawFile());
2488 Printer.printInt("line", N->getLineNo());
2489 Out << ")";
2490}
2491
2492static void writeDIMacro(raw_ostream &Out, const DIMacro *N,
2493 AsmWriterContext &WriterCtx) {
2494 Out << "!DIMacro(";
2495 MDFieldPrinter Printer(Out, WriterCtx);
2496 Printer.printMacinfoType(N);
2497 Printer.printInt("line", N->getLine());
2498 Printer.printString("name", N->getName());
2499 Printer.printString("value", N->getValue());
2500 Out << ")";
2501}
2502
2504 AsmWriterContext &WriterCtx) {
2505 Out << "!DIMacroFile(";
2506 MDFieldPrinter Printer(Out, WriterCtx);
2507 Printer.printInt("line", N->getLine());
2508 Printer.printMetadata("file", N->getRawFile(), /* ShouldSkipNull */ false);
2509 Printer.printMetadata("nodes", N->getRawElements());
2510 Out << ")";
2511}
2512
2513static void writeDIModule(raw_ostream &Out, const DIModule *N,
2514 AsmWriterContext &WriterCtx) {
2515 Out << "!DIModule(";
2516 MDFieldPrinter Printer(Out, WriterCtx);
2517 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2518 Printer.printString("name", N->getName());
2519 Printer.printString("configMacros", N->getConfigurationMacros());
2520 Printer.printString("includePath", N->getIncludePath());
2521 Printer.printString("apinotes", N->getAPINotesFile());
2522 Printer.printMetadata("file", N->getRawFile());
2523 Printer.printInt("line", N->getLineNo());
2524 Printer.printBool("isDecl", N->getIsDecl(), /* Default */ false);
2525 Out << ")";
2526}
2527
2530 AsmWriterContext &WriterCtx) {
2531 Out << "!DITemplateTypeParameter(";
2532 MDFieldPrinter Printer(Out, WriterCtx);
2533 Printer.printString("name", N->getName());
2534 Printer.printMetadata("type", N->getRawType(), /* ShouldSkipNull */ false);
2535 Printer.printBool("defaulted", N->isDefault(), /* Default= */ false);
2536 Out << ")";
2537}
2538
2541 AsmWriterContext &WriterCtx) {
2542 Out << "!DITemplateValueParameter(";
2543 MDFieldPrinter Printer(Out, WriterCtx);
2544 if (N->getTag() != dwarf::DW_TAG_template_value_parameter)
2545 Printer.printTag(N);
2546 Printer.printString("name", N->getName());
2547 Printer.printMetadata("type", N->getRawType());
2548 Printer.printBool("defaulted", N->isDefault(), /* Default= */ false);
2549 Printer.printMetadata("value", N->getValue(), /* ShouldSkipNull */ false);
2550 Out << ")";
2551}
2552
2554 AsmWriterContext &WriterCtx) {
2555 Out << "!DIGlobalVariable(";
2556 MDFieldPrinter Printer(Out, WriterCtx);
2557 Printer.printString("name", N->getName());
2558 Printer.printString("linkageName", N->getLinkageName());
2559 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2560 Printer.printMetadata("file", N->getRawFile());
2561 Printer.printInt("line", N->getLine());
2562 Printer.printMetadata("type", N->getRawType());
2563 Printer.printBool("isLocal", N->isLocalToUnit());
2564 Printer.printBool("isDefinition", N->isDefinition());
2565 Printer.printMetadata("declaration", N->getRawStaticDataMemberDeclaration());
2566 Printer.printMetadata("templateParams", N->getRawTemplateParams());
2567 Printer.printInt("align", N->getAlignInBits());
2568 Printer.printMetadata("annotations", N->getRawAnnotations());
2569 Out << ")";
2570}
2571
2573 AsmWriterContext &WriterCtx) {
2574 Out << "!DILocalVariable(";
2575 MDFieldPrinter Printer(Out, WriterCtx);
2576 Printer.printString("name", N->getName());
2577 Printer.printInt("arg", N->getArg());
2578 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2579 Printer.printMetadata("file", N->getRawFile());
2580 Printer.printInt("line", N->getLine());
2581 Printer.printMetadata("type", N->getRawType());
2582 Printer.printDIFlags("flags", N->getFlags());
2583 Printer.printInt("align", N->getAlignInBits());
2584 Printer.printMetadata("annotations", N->getRawAnnotations());
2585 Out << ")";
2586}
2587
2588static void writeDILabel(raw_ostream &Out, const DILabel *N,
2589 AsmWriterContext &WriterCtx) {
2590 Out << "!DILabel(";
2591 MDFieldPrinter Printer(Out, WriterCtx);
2592 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2593 Printer.printString("name", N->getName());
2594 Printer.printMetadata("file", N->getRawFile());
2595 Printer.printInt("line", N->getLine());
2596 Printer.printInt("column", N->getColumn());
2597 Printer.printBool("isArtificial", N->isArtificial(), false);
2598 if (N->getCoroSuspendIdx())
2599 Printer.printInt("coroSuspendIdx", *N->getCoroSuspendIdx(),
2600 /* ShouldSkipZero */ false);
2601 Out << ")";
2602}
2603
2605 AsmWriterContext &WriterCtx) {
2606 Out << "!DIExpression(";
2607 ListSeparator FS;
2608 if (N->isValid()) {
2609 for (const DIExpression::ExprOperand &Op : N->expr_ops()) {
2610 auto OpStr = dwarf::OperationEncodingString(Op.getOp());
2611 assert(!OpStr.empty() && "Expected valid opcode");
2612
2613 Out << FS << OpStr;
2614 if (Op.getOp() == dwarf::DW_OP_LLVM_convert) {
2615 Out << FS << Op.getArg(0);
2616 Out << FS << dwarf::AttributeEncodingString(Op.getArg(1));
2617 } else {
2618 for (unsigned A = 0, AE = Op.getNumArgs(); A != AE; ++A)
2619 Out << FS << Op.getArg(A);
2620 }
2621 }
2622 } else {
2623 for (const auto &I : N->getElements())
2624 Out << FS << I;
2625 }
2626 Out << ")";
2627}
2628
2629static void writeDIArgList(raw_ostream &Out, const DIArgList *N,
2630 AsmWriterContext &WriterCtx,
2631 bool FromValue = false) {
2632 assert(FromValue &&
2633 "Unexpected DIArgList metadata outside of value argument");
2634 Out << "!DIArgList(";
2635 ListSeparator FS;
2636 MDFieldPrinter Printer(Out, WriterCtx);
2637 for (Metadata *Arg : N->getArgs()) {
2638 Out << FS;
2639 WriteAsOperandInternal(Out, Arg, WriterCtx, true);
2640 }
2641 Out << ")";
2642}
2643
2646 AsmWriterContext &WriterCtx) {
2647 Out << "!DIGlobalVariableExpression(";
2648 MDFieldPrinter Printer(Out, WriterCtx);
2649 Printer.printMetadata("var", N->getVariable());
2650 Printer.printMetadata("expr", N->getExpression());
2651 Out << ")";
2652}
2653
2655 AsmWriterContext &WriterCtx) {
2656 Out << "!DIObjCProperty(";
2657 MDFieldPrinter Printer(Out, WriterCtx);
2658 Printer.printString("name", N->getName());
2659 Printer.printMetadata("file", N->getRawFile());
2660 Printer.printInt("line", N->getLine());
2661 Printer.printString("setter", N->getSetterName());
2662 Printer.printString("getter", N->getGetterName());
2663 Printer.printInt("attributes", N->getAttributes());
2664 Printer.printMetadata("type", N->getRawType());
2665 Out << ")";
2666}
2667
2669 AsmWriterContext &WriterCtx) {
2670 Out << "!DIImportedEntity(";
2671 MDFieldPrinter Printer(Out, WriterCtx);
2672 Printer.printTag(N);
2673 Printer.printString("name", N->getName());
2674 Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2675 Printer.printMetadata("entity", N->getRawEntity());
2676 Printer.printMetadata("file", N->getRawFile());
2677 Printer.printInt("line", N->getLine());
2678 Printer.printMetadata("elements", N->getRawElements());
2679 Out << ")";
2680}
2681
2683 AsmWriterContext &Ctx) {
2684 if (Node->isDistinct())
2685 Out << "distinct ";
2686 else if (Node->isTemporary())
2687 Out << "<temporary!> "; // Handle broken code.
2688
2689 switch (Node->getMetadataID()) {
2690 default:
2691 llvm_unreachable("Expected uniquable MDNode");
2692#define HANDLE_MDNODE_LEAF(CLASS) \
2693 case Metadata::CLASS##Kind: \
2694 write##CLASS(Out, cast<CLASS>(Node), Ctx); \
2695 break;
2696#include "llvm/IR/Metadata.def"
2697 }
2698}
2699
2700// Full implementation of printing a Value as an operand with support for
2701// TypePrinting, etc.
2702static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
2703 AsmWriterContext &WriterCtx) {
2704 if (V->hasName()) {
2705 PrintLLVMName(Out, V);
2706 return;
2707 }
2708
2709 const Constant *CV = dyn_cast<Constant>(V);
2710 if (CV && !isa<GlobalValue>(CV)) {
2711 assert(WriterCtx.TypePrinter && "Constants require TypePrinting!");
2712 WriteConstantInternal(Out, CV, WriterCtx);
2713 return;
2714 }
2715
2716 if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
2717 Out << "asm ";
2718 if (IA->hasSideEffects())
2719 Out << "sideeffect ";
2720 if (IA->isAlignStack())
2721 Out << "alignstack ";
2722 // We don't emit the AD_ATT dialect as it's the assumed default.
2723 if (IA->getDialect() == InlineAsm::AD_Intel)
2724 Out << "inteldialect ";
2725 if (IA->canThrow())
2726 Out << "unwind ";
2727 Out << '"';
2728 printEscapedString(IA->getAsmString(), Out);
2729 Out << "\", \"";
2730 printEscapedString(IA->getConstraintString(), Out);
2731 Out << '"';
2732 return;
2733 }
2734
2735 if (auto *MD = dyn_cast<MetadataAsValue>(V)) {
2736 WriteAsOperandInternal(Out, MD->getMetadata(), WriterCtx,
2737 /* FromValue */ true);
2738 return;
2739 }
2740
2741 char Prefix = '%';
2742 int Slot;
2743 auto *Machine = WriterCtx.Machine;
2744 // If we have a SlotTracker, use it.
2745 if (Machine) {
2746 if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
2747 Slot = Machine->getGlobalSlot(GV);
2748 Prefix = '@';
2749 } else {
2750 Slot = Machine->getLocalSlot(V);
2751
2752 // If the local value didn't succeed, then we may be referring to a value
2753 // from a different function. Translate it, as this can happen when using
2754 // address of blocks.
2755 if (Slot == -1)
2756 if ((Machine = createSlotTracker(V))) {
2757 Slot = Machine->getLocalSlot(V);
2758 delete Machine;
2759 }
2760 }
2761 } else if ((Machine = createSlotTracker(V))) {
2762 // Otherwise, create one to get the # and then destroy it.
2763 if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
2764 Slot = Machine->getGlobalSlot(GV);
2765 Prefix = '@';
2766 } else {
2767 Slot = Machine->getLocalSlot(V);
2768 }
2769 delete Machine;
2770 Machine = nullptr;
2771 } else {
2772 Slot = -1;
2773 }
2774
2775 if (Slot != -1)
2776 Out << Prefix << Slot;
2777 else
2778 Out << "<badref>";
2779}
2780
2781static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
2782 AsmWriterContext &WriterCtx,
2783 bool FromValue) {
2784 // Write DIExpressions and DIArgLists inline when used as a value. Improves
2785 // readability of debug info intrinsics.
2786 if (const DIExpression *Expr = dyn_cast<DIExpression>(MD)) {
2787 writeDIExpression(Out, Expr, WriterCtx);
2788 return;
2789 }
2790 if (const DIArgList *ArgList = dyn_cast<DIArgList>(MD)) {
2791 writeDIArgList(Out, ArgList, WriterCtx, FromValue);
2792 return;
2793 }
2794
2795 if (const MDNode *N = dyn_cast<MDNode>(MD)) {
2796 std::unique_ptr<SlotTracker> MachineStorage;
2797 SaveAndRestore SARMachine(WriterCtx.Machine);
2798 if (!WriterCtx.Machine) {
2799 MachineStorage = std::make_unique<SlotTracker>(WriterCtx.Context);
2800 WriterCtx.Machine = MachineStorage.get();
2801 }
2802 int Slot = WriterCtx.Machine->getMetadataSlot(N);
2803 if (Slot == -1) {
2804 if (const DILocation *Loc = dyn_cast<DILocation>(N)) {
2805 writeDILocation(Out, Loc, WriterCtx);
2806 return;
2807 }
2808 // Give the pointer value instead of "badref", since this comes up all
2809 // the time when debugging.
2810 Out << "<" << N << ">";
2811 } else
2812 Out << '!' << Slot;
2813 return;
2814 }
2815
2816 if (const MDString *MDS = dyn_cast<MDString>(MD)) {
2817 Out << "!\"";
2818 printEscapedString(MDS->getString(), Out);
2819 Out << '"';
2820 return;
2821 }
2822
2823 auto *V = cast<ValueAsMetadata>(MD);
2824 assert(WriterCtx.TypePrinter && "TypePrinter required for metadata values");
2825 assert((FromValue || !isa<LocalAsMetadata>(V)) &&
2826 "Unexpected function-local metadata outside of value argument");
2827
2828 WriterCtx.TypePrinter->print(V->getValue()->getType(), Out);
2829 Out << ' ';
2830 WriteAsOperandInternal(Out, V->getValue(), WriterCtx);
2831}
2832
2833namespace {
2834
2835class AssemblyWriter {
2836 formatted_raw_ostream &Out;
2837 const Module *TheModule = nullptr;
2838 const ModuleSummaryIndex *TheIndex = nullptr;
2839 std::unique_ptr<SlotTracker> SlotTrackerStorage;
2840 SlotTracker &Machine;
2841 TypePrinting TypePrinter;
2842 AssemblyAnnotationWriter *AnnotationWriter = nullptr;
2843 SetVector<const Comdat *> Comdats;
2844 bool IsForDebug;
2845 bool ShouldPreserveUseListOrder;
2846 UseListOrderMap UseListOrders;
2848 /// Synchronization scope names registered with LLVMContext.
2850 DenseMap<const GlobalValueSummary *, GlobalValue::GUID> SummaryToGUIDMap;
2851
2852public:
2853 /// Construct an AssemblyWriter with an external SlotTracker
2854 AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac, const Module *M,
2855 AssemblyAnnotationWriter *AAW, bool IsForDebug,
2856 bool ShouldPreserveUseListOrder = false);
2857
2858 AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
2859 const ModuleSummaryIndex *Index, bool IsForDebug);
2860
2861 AsmWriterContext getContext() {
2862 return AsmWriterContext(&TypePrinter, &Machine, TheModule);
2863 }
2864
2865 void printMDNodeBody(const MDNode *MD);
2866 void printNamedMDNode(const NamedMDNode *NMD);
2867
2868 void printModule(const Module *M);
2869
2870 void writeOperand(const Value *Op, bool PrintType);
2871 void writeParamOperand(const Value *Operand, AttributeSet Attrs);
2872 void writeOperandBundles(const CallBase *Call);
2873 void writeSyncScope(const LLVMContext &Context,
2874 SyncScope::ID SSID);
2875 void writeAtomic(const LLVMContext &Context,
2876 AtomicOrdering Ordering,
2877 SyncScope::ID SSID);
2878 void writeAtomicCmpXchg(const LLVMContext &Context,
2879 AtomicOrdering SuccessOrdering,
2880 AtomicOrdering FailureOrdering,
2881 SyncScope::ID SSID);
2882
2883 void writeAllMDNodes();
2884 void writeMDNode(unsigned Slot, const MDNode *Node);
2885 void writeAttribute(const Attribute &Attr, bool InAttrGroup = false);
2886 void writeAttributeSet(const AttributeSet &AttrSet, bool InAttrGroup = false);
2887 void writeAllAttributeGroups();
2888
2889 void printTypeIdentities();
2890 void printGlobal(const GlobalVariable *GV);
2891 void printAlias(const GlobalAlias *GA);
2892 void printIFunc(const GlobalIFunc *GI);
2893 void printComdat(const Comdat *C);
2894 void printFunction(const Function *F);
2895 void printArgument(const Argument *FA, AttributeSet Attrs);
2896 void printBasicBlock(const BasicBlock *BB);
2897 void printInstructionLine(const Instruction &I);
2898 void printInstruction(const Instruction &I);
2899 void printDbgMarker(const DbgMarker &DPI);
2900 void printDbgVariableRecord(const DbgVariableRecord &DVR);
2901 void printDbgLabelRecord(const DbgLabelRecord &DLR);
2902 void printDbgRecord(const DbgRecord &DR);
2903 void printDbgRecordLine(const DbgRecord &DR);
2904
2905 void printUseListOrder(const Value *V, const std::vector<unsigned> &Shuffle);
2906 void printUseLists(const Function *F);
2907
2908 void printModuleSummaryIndex();
2909 void printSummaryInfo(unsigned Slot, const ValueInfo &VI);
2910 void printSummary(const GlobalValueSummary &Summary);
2911 void printAliasSummary(const AliasSummary *AS);
2912 void printGlobalVarSummary(const GlobalVarSummary *GS);
2913 void printFunctionSummary(const FunctionSummary *FS);
2914 void printTypeIdSummary(const TypeIdSummary &TIS);
2915 void printTypeIdCompatibleVtableSummary(const TypeIdCompatibleVtableInfo &TI);
2916 void printTypeTestResolution(const TypeTestResolution &TTRes);
2917 void printArgs(const std::vector<uint64_t> &Args);
2918 void printWPDRes(const WholeProgramDevirtResolution &WPDRes);
2919 void printTypeIdInfo(const FunctionSummary::TypeIdInfo &TIDInfo);
2920 void printVFuncId(const FunctionSummary::VFuncId VFId);
2921 void
2922 printNonConstVCalls(const std::vector<FunctionSummary::VFuncId> &VCallList,
2923 const char *Tag);
2924 void
2925 printConstVCalls(const std::vector<FunctionSummary::ConstVCall> &VCallList,
2926 const char *Tag);
2927
2928private:
2929 /// Print out metadata attachments.
2930 void printMetadataAttachments(
2931 const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
2932 StringRef Separator);
2933
2934 // printInfoComment - Print a little comment after the instruction indicating
2935 // which slot it occupies.
2936 void printInfoComment(const Value &V);
2937
2938 // printGCRelocateComment - print comment after call to the gc.relocate
2939 // intrinsic indicating base and derived pointer names.
2940 void printGCRelocateComment(const GCRelocateInst &Relocate);
2941};
2942
2943} // end anonymous namespace
2944
2945AssemblyWriter::AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
2946 const Module *M, AssemblyAnnotationWriter *AAW,
2947 bool IsForDebug, bool ShouldPreserveUseListOrder)
2948 : Out(o), TheModule(M), Machine(Mac), TypePrinter(M), AnnotationWriter(AAW),
2949 IsForDebug(IsForDebug),
2950 ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {
2951 if (!TheModule)
2952 return;
2953 for (const GlobalObject &GO : TheModule->global_objects())
2954 if (const Comdat *C = GO.getComdat())
2955 Comdats.insert(C);
2956}
2957
2958AssemblyWriter::AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
2959 const ModuleSummaryIndex *Index, bool IsForDebug)
2960 : Out(o), TheIndex(Index), Machine(Mac), TypePrinter(/*Module=*/nullptr),
2961 IsForDebug(IsForDebug), ShouldPreserveUseListOrder(false) {}
2962
2963void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) {
2964 if (!Operand) {
2965 Out << "<null operand!>";
2966 return;
2967 }
2968 if (PrintType) {
2969 TypePrinter.print(Operand->getType(), Out);
2970 Out << ' ';
2971 }
2972 auto WriterCtx = getContext();
2973 WriteAsOperandInternal(Out, Operand, WriterCtx);
2974}
2975
2976void AssemblyWriter::writeSyncScope(const LLVMContext &Context,
2977 SyncScope::ID SSID) {
2978 switch (SSID) {
2979 case SyncScope::System: {
2980 break;
2981 }
2982 default: {
2983 if (SSNs.empty())
2984 Context.getSyncScopeNames(SSNs);
2985
2986 Out << " syncscope(\"";
2987 printEscapedString(SSNs[SSID], Out);
2988 Out << "\")";
2989 break;
2990 }
2991 }
2992}
2993
2994void AssemblyWriter::writeAtomic(const LLVMContext &Context,
2995 AtomicOrdering Ordering,
2996 SyncScope::ID SSID) {
2997 if (Ordering == AtomicOrdering::NotAtomic)
2998 return;
2999
3000 writeSyncScope(Context, SSID);
3001 Out << " " << toIRString(Ordering);
3002}
3003
3004void AssemblyWriter::writeAtomicCmpXchg(const LLVMContext &Context,
3005 AtomicOrdering SuccessOrdering,
3006 AtomicOrdering FailureOrdering,
3007 SyncScope::ID SSID) {
3008 assert(SuccessOrdering != AtomicOrdering::NotAtomic &&
3009 FailureOrdering != AtomicOrdering::NotAtomic);
3010
3011 writeSyncScope(Context, SSID);
3012 Out << " " << toIRString(SuccessOrdering);
3013 Out << " " << toIRString(FailureOrdering);
3014}
3015
3016void AssemblyWriter::writeParamOperand(const Value *Operand,
3017 AttributeSet Attrs) {
3018 if (!Operand) {
3019 Out << "<null operand!>";
3020 return;
3021 }
3022
3023 // Print the type
3024 TypePrinter.print(Operand->getType(), Out);
3025 // Print parameter attributes list
3026 if (Attrs.hasAttributes()) {
3027 Out << ' ';
3028 writeAttributeSet(Attrs);
3029 }
3030 Out << ' ';
3031 // Print the operand
3032 auto WriterCtx = getContext();
3033 WriteAsOperandInternal(Out, Operand, WriterCtx);
3034}
3035
3036void AssemblyWriter::writeOperandBundles(const CallBase *Call) {
3037 if (!Call->hasOperandBundles())
3038 return;
3039
3040 Out << " [ ";
3041
3042 ListSeparator LS;
3043 for (unsigned i = 0, e = Call->getNumOperandBundles(); i != e; ++i) {
3044 OperandBundleUse BU = Call->getOperandBundleAt(i);
3045
3046 Out << LS << '"';
3047 printEscapedString(BU.getTagName(), Out);
3048 Out << '"';
3049
3050 Out << '(';
3051
3052 bool FirstInput = true;
3053 auto WriterCtx = getContext();
3054 for (const auto &Input : BU.Inputs) {
3055 if (!FirstInput)
3056 Out << ", ";
3057 FirstInput = false;
3058
3059 if (Input == nullptr)
3060 Out << "<null operand bundle!>";
3061 else {
3062 TypePrinter.print(Input->getType(), Out);
3063 Out << " ";
3064 WriteAsOperandInternal(Out, Input, WriterCtx);
3065 }
3066 }
3067
3068 Out << ')';
3069 }
3070
3071 Out << " ]";
3072}
3073
3074void AssemblyWriter::printModule(const Module *M) {
3075 Machine.initializeIfNeeded();
3076
3077 if (ShouldPreserveUseListOrder)
3078 UseListOrders = predictUseListOrder(M);
3079
3080 if (!M->getModuleIdentifier().empty() &&
3081 // Don't print the ID if it will start a new line (which would
3082 // require a comment char before it).
3083 M->getModuleIdentifier().find('\n') == std::string::npos)
3084 Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n";
3085
3086 if (!M->getSourceFileName().empty()) {
3087 Out << "source_filename = \"";
3088 printEscapedString(M->getSourceFileName(), Out);
3089 Out << "\"\n";
3090 }
3091
3092 const std::string &DL = M->getDataLayoutStr();
3093 if (!DL.empty())
3094 Out << "target datalayout = \"" << DL << "\"\n";
3095 if (!M->getTargetTriple().empty())
3096 Out << "target triple = \"" << M->getTargetTriple().str() << "\"\n";
3097
3098 if (!M->getModuleInlineAsm().empty()) {
3099 Out << '\n';
3100
3101 // Split the string into lines, to make it easier to read the .ll file.
3102 StringRef Asm = M->getModuleInlineAsm();
3103 do {
3104 StringRef Front;
3105 std::tie(Front, Asm) = Asm.split('\n');
3106
3107 // We found a newline, print the portion of the asm string from the
3108 // last newline up to this newline.
3109 Out << "module asm \"";
3110 printEscapedString(Front, Out);
3111 Out << "\"\n";
3112 } while (!Asm.empty());
3113 }
3114
3115 printTypeIdentities();
3116
3117 // Output all comdats.
3118 if (!Comdats.empty())
3119 Out << '\n';
3120 for (const Comdat *C : Comdats) {
3121 printComdat(C);
3122 if (C != Comdats.back())
3123 Out << '\n';
3124 }
3125
3126 // Output all globals.
3127 if (!M->global_empty()) Out << '\n';
3128 for (const GlobalVariable &GV : M->globals()) {
3129 printGlobal(&GV); Out << '\n';
3130 }
3131
3132 // Output all aliases.
3133 if (!M->alias_empty()) Out << "\n";
3134 for (const GlobalAlias &GA : M->aliases())
3135 printAlias(&GA);
3136
3137 // Output all ifuncs.
3138 if (!M->ifunc_empty()) Out << "\n";
3139 for (const GlobalIFunc &GI : M->ifuncs())
3140 printIFunc(&GI);
3141
3142 // Output all of the functions.
3143 for (const Function &F : *M) {
3144 Out << '\n';
3145 printFunction(&F);
3146 }
3147
3148 // Output global use-lists.
3149 printUseLists(nullptr);
3150
3151 // Output all attribute groups.
3152 if (!Machine.as_empty()) {
3153 Out << '\n';
3154 writeAllAttributeGroups();
3155 }
3156
3157 // Output named metadata.
3158 if (!M->named_metadata_empty()) Out << '\n';
3159
3160 for (const NamedMDNode &Node : M->named_metadata())
3161 printNamedMDNode(&Node);
3162
3163 // Output metadata.
3164 if (!Machine.mdn_empty()) {
3165 Out << '\n';
3166 writeAllMDNodes();
3167 }
3168}
3169
3170void AssemblyWriter::printModuleSummaryIndex() {
3171 assert(TheIndex);
3172 int NumSlots = Machine.initializeIndexIfNeeded();
3173
3174 Out << "\n";
3175
3176 // Print module path entries. To print in order, add paths to a vector
3177 // indexed by module slot.
3178 std::vector<std::pair<std::string, ModuleHash>> moduleVec;
3179 std::string RegularLTOModuleName =
3181 moduleVec.resize(TheIndex->modulePaths().size());
3182 for (auto &[ModPath, ModHash] : TheIndex->modulePaths())
3183 moduleVec[Machine.getModulePathSlot(ModPath)] = std::make_pair(
3184 // An empty module path is a special entry for a regular LTO module
3185 // created during the thin link.
3186 ModPath.empty() ? RegularLTOModuleName : std::string(ModPath), ModHash);
3187
3188 unsigned i = 0;
3189 for (auto &ModPair : moduleVec) {
3190 Out << "^" << i++ << " = module: (";
3191 Out << "path: \"";
3192 printEscapedString(ModPair.first, Out);
3193 Out << "\", hash: (";
3194 ListSeparator FS;
3195 for (auto Hash : ModPair.second)
3196 Out << FS << Hash;
3197 Out << "))\n";
3198 }
3199
3200 // FIXME: Change AliasSummary to hold a ValueInfo instead of summary pointer
3201 // for aliasee (then update BitcodeWriter.cpp and remove get/setAliaseeGUID).
3202 for (auto &GlobalList : *TheIndex) {
3203 auto GUID = GlobalList.first;
3204 for (auto &Summary : GlobalList.second.SummaryList)
3205 SummaryToGUIDMap[Summary.get()] = GUID;
3206 }
3207
3208 // Print the global value summary entries.
3209 for (auto &GlobalList : *TheIndex) {
3210 auto GUID = GlobalList.first;
3211 auto VI = TheIndex->getValueInfo(GlobalList);
3212 printSummaryInfo(Machine.getGUIDSlot(GUID), VI);
3213 }
3214
3215 // Print the TypeIdMap entries.
3216 for (const auto &TID : TheIndex->typeIds()) {
3217 Out << "^" << Machine.getTypeIdSlot(TID.second.first)
3218 << " = typeid: (name: \"" << TID.second.first << "\"";
3219 printTypeIdSummary(TID.second.second);
3220 Out << ") ; guid = " << TID.first << "\n";
3221 }
3222
3223 // Print the TypeIdCompatibleVtableMap entries.
3224 for (auto &TId : TheIndex->typeIdCompatibleVtableMap()) {
3226 Out << "^" << Machine.getTypeIdCompatibleVtableSlot(TId.first)
3227 << " = typeidCompatibleVTable: (name: \"" << TId.first << "\"";
3228 printTypeIdCompatibleVtableSummary(TId.second);
3229 Out << ") ; guid = " << GUID << "\n";
3230 }
3231
3232 // Don't emit flags when it's not really needed (value is zero by default).
3233 if (TheIndex->getFlags()) {
3234 Out << "^" << NumSlots << " = flags: " << TheIndex->getFlags() << "\n";
3235 ++NumSlots;
3236 }
3237
3238 Out << "^" << NumSlots << " = blockcount: " << TheIndex->getBlockCount()
3239 << "\n";
3240}
3241
3242static const char *
3244 switch (K) {
3246 return "indir";
3248 return "singleImpl";
3250 return "branchFunnel";
3251 }
3252 llvm_unreachable("invalid WholeProgramDevirtResolution kind");
3253}
3254
3257 switch (K) {
3259 return "indir";
3261 return "uniformRetVal";
3263 return "uniqueRetVal";
3265 return "virtualConstProp";
3266 }
3267 llvm_unreachable("invalid WholeProgramDevirtResolution::ByArg kind");
3268}
3269
3271 switch (K) {
3273 return "unknown";
3275 return "unsat";
3277 return "byteArray";
3279 return "inline";
3281 return "single";
3283 return "allOnes";
3284 }
3285 llvm_unreachable("invalid TypeTestResolution kind");
3286}
3287
3288void AssemblyWriter::printTypeTestResolution(const TypeTestResolution &TTRes) {
3289 Out << "typeTestRes: (kind: " << getTTResKindName(TTRes.TheKind)
3290 << ", sizeM1BitWidth: " << TTRes.SizeM1BitWidth;
3291
3292 // The following fields are only used if the target does not support the use
3293 // of absolute symbols to store constants. Print only if non-zero.
3294 if (TTRes.AlignLog2)
3295 Out << ", alignLog2: " << TTRes.AlignLog2;
3296 if (TTRes.SizeM1)
3297 Out << ", sizeM1: " << TTRes.SizeM1;
3298 if (TTRes.BitMask)
3299 // BitMask is uint8_t which causes it to print the corresponding char.
3300 Out << ", bitMask: " << (unsigned)TTRes.BitMask;
3301 if (TTRes.InlineBits)
3302 Out << ", inlineBits: " << TTRes.InlineBits;
3303
3304 Out << ")";
3305}
3306
3307void AssemblyWriter::printTypeIdSummary(const TypeIdSummary &TIS) {
3308 Out << ", summary: (";
3309 printTypeTestResolution(TIS.TTRes);
3310 if (!TIS.WPDRes.empty()) {
3311 Out << ", wpdResolutions: (";
3312 ListSeparator FS;
3313 for (auto &WPDRes : TIS.WPDRes) {
3314 Out << FS;
3315 Out << "(offset: " << WPDRes.first << ", ";
3316 printWPDRes(WPDRes.second);
3317 Out << ")";
3318 }
3319 Out << ")";
3320 }
3321 Out << ")";
3322}
3323
3324void AssemblyWriter::printTypeIdCompatibleVtableSummary(
3325 const TypeIdCompatibleVtableInfo &TI) {
3326 Out << ", summary: (";
3327 ListSeparator FS;
3328 for (auto &P : TI) {
3329 Out << FS;
3330 Out << "(offset: " << P.AddressPointOffset << ", ";
3331 Out << "^" << Machine.getGUIDSlot(P.VTableVI.getGUID());
3332 Out << ")";
3333 }
3334 Out << ")";
3335}
3336
3337void AssemblyWriter::printArgs(const std::vector<uint64_t> &Args) {
3338 Out << "args: (";
3339 ListSeparator FS;
3340 for (auto arg : Args) {
3341 Out << FS;
3342 Out << arg;
3343 }
3344 Out << ")";
3345}
3346
3347void AssemblyWriter::printWPDRes(const WholeProgramDevirtResolution &WPDRes) {
3348 Out << "wpdRes: (kind: ";
3350
3352 Out << ", singleImplName: \"" << WPDRes.SingleImplName << "\"";
3353
3354 if (!WPDRes.ResByArg.empty()) {
3355 Out << ", resByArg: (";
3356 ListSeparator FS;
3357 for (auto &ResByArg : WPDRes.ResByArg) {
3358 Out << FS;
3359 printArgs(ResByArg.first);
3360 Out << ", byArg: (kind: ";
3361 Out << getWholeProgDevirtResByArgKindName(ResByArg.second.TheKind);
3362 if (ResByArg.second.TheKind ==
3364 ResByArg.second.TheKind ==
3366 Out << ", info: " << ResByArg.second.Info;
3367
3368 // The following fields are only used if the target does not support the
3369 // use of absolute symbols to store constants. Print only if non-zero.
3370 if (ResByArg.second.Byte || ResByArg.second.Bit)
3371 Out << ", byte: " << ResByArg.second.Byte
3372 << ", bit: " << ResByArg.second.Bit;
3373
3374 Out << ")";
3375 }
3376 Out << ")";
3377 }
3378 Out << ")";
3379}
3380
3382 switch (SK) {
3384 return "alias";
3386 return "function";
3388 return "variable";
3389 }
3390 llvm_unreachable("invalid summary kind");
3391}
3392
3393void AssemblyWriter::printAliasSummary(const AliasSummary *AS) {
3394 Out << ", aliasee: ";
3395 // The indexes emitted for distributed backends may not include the
3396 // aliasee summary (only if it is being imported directly). Handle
3397 // that case by just emitting "null" as the aliasee.
3398 if (AS->hasAliasee())
3399 Out << "^" << Machine.getGUIDSlot(SummaryToGUIDMap[&AS->getAliasee()]);
3400 else
3401 Out << "null";
3402}
3403
3404void AssemblyWriter::printGlobalVarSummary(const GlobalVarSummary *GS) {
3405 auto VTableFuncs = GS->vTableFuncs();
3406 Out << ", varFlags: (readonly: " << GS->VarFlags.MaybeReadOnly << ", "
3407 << "writeonly: " << GS->VarFlags.MaybeWriteOnly << ", "
3408 << "constant: " << GS->VarFlags.Constant;
3409 if (!VTableFuncs.empty())
3410 Out << ", "
3411 << "vcall_visibility: " << GS->VarFlags.VCallVisibility;
3412 Out << ")";
3413
3414 if (!VTableFuncs.empty()) {
3415 Out << ", vTableFuncs: (";
3416 ListSeparator FS;
3417 for (auto &P : VTableFuncs) {
3418 Out << FS;
3419 Out << "(virtFunc: ^" << Machine.getGUIDSlot(P.FuncVI.getGUID())
3420 << ", offset: " << P.VTableOffset;
3421 Out << ")";
3422 }
3423 Out << ")";
3424 }
3425}
3426
3428 switch (LT) {
3430 return "external";
3432 return "private";
3434 return "internal";
3436 return "linkonce";
3438 return "linkonce_odr";
3440 return "weak";
3442 return "weak_odr";
3444 return "common";
3446 return "appending";
3448 return "extern_weak";
3450 return "available_externally";
3451 }
3452 llvm_unreachable("invalid linkage");
3453}
3454
3455// When printing the linkage types in IR where the ExternalLinkage is
3456// not printed, and other linkage types are expected to be printed with
3457// a space after the name.
3460 return "";
3461 return getLinkageName(LT) + " ";
3462}
3463
3465 switch (Vis) {
3467 return "default";
3469 return "hidden";
3471 return "protected";
3472 }
3473 llvm_unreachable("invalid visibility");
3474}
3475
3477 switch (IK) {
3479 return "definition";
3481 return "declaration";
3482 }
3483 llvm_unreachable("invalid import kind");
3484}
3485
3486void AssemblyWriter::printFunctionSummary(const FunctionSummary *FS) {
3487 Out << ", insts: " << FS->instCount();
3488 if (FS->fflags().anyFlagSet())
3489 Out << ", " << FS->fflags();
3490
3491 if (!FS->calls().empty()) {
3492 Out << ", calls: (";
3493 ListSeparator IFS;
3494 for (auto &Call : FS->calls()) {
3495 Out << IFS;
3496 Out << "(callee: ^" << Machine.getGUIDSlot(Call.first.getGUID());
3497 if (Call.second.getHotness() != CalleeInfo::HotnessType::Unknown)
3498 Out << ", hotness: " << getHotnessName(Call.second.getHotness());
3499 else if (Call.second.RelBlockFreq)
3500 Out << ", relbf: " << Call.second.RelBlockFreq;
3501 // Follow the convention of emitting flags as a boolean value, but only
3502 // emit if true to avoid unnecessary verbosity and test churn.
3503 if (Call.second.HasTailCall)
3504 Out << ", tail: 1";
3505 Out << ")";
3506 }
3507 Out << ")";
3508 }
3509
3510 if (const auto *TIdInfo = FS->getTypeIdInfo())
3511 printTypeIdInfo(*TIdInfo);
3512
3513 // The AllocationType identifiers capture the profiled context behavior
3514 // reaching a specific static allocation site (possibly cloned).
3515 auto AllocTypeName = [](uint8_t Type) -> const char * {
3516 switch (Type) {
3517 case (uint8_t)AllocationType::None:
3518 return "none";
3519 case (uint8_t)AllocationType::NotCold:
3520 return "notcold";
3521 case (uint8_t)AllocationType::Cold:
3522 return "cold";
3523 case (uint8_t)AllocationType::Hot:
3524 return "hot";
3525 }
3526 llvm_unreachable("Unexpected alloc type");
3527 };
3528
3529 if (!FS->allocs().empty()) {
3530 Out << ", allocs: (";
3531 ListSeparator AFS;
3532 for (auto &AI : FS->allocs()) {
3533 Out << AFS;
3534 Out << "(versions: (";
3535 ListSeparator VFS;
3536 for (auto V : AI.Versions) {
3537 Out << VFS;
3538 Out << AllocTypeName(V);
3539 }
3540 Out << "), memProf: (";
3541 ListSeparator MIBFS;
3542 for (auto &MIB : AI.MIBs) {
3543 Out << MIBFS;
3544 Out << "(type: " << AllocTypeName((uint8_t)MIB.AllocType);
3545 Out << ", stackIds: (";
3546 ListSeparator SIDFS;
3547 for (auto Id : MIB.StackIdIndices) {
3548 Out << SIDFS;
3549 Out << TheIndex->getStackIdAtIndex(Id);
3550 }
3551 Out << "))";
3552 }
3553 Out << "))";
3554 }
3555 Out << ")";
3556 }
3557
3558 if (!FS->callsites().empty()) {
3559 Out << ", callsites: (";
3560 ListSeparator SNFS;
3561 for (auto &CI : FS->callsites()) {
3562 Out << SNFS;
3563 if (CI.Callee)
3564 Out << "(callee: ^" << Machine.getGUIDSlot(CI.Callee.getGUID());
3565 else
3566 Out << "(callee: null";
3567 Out << ", clones: (";
3568 ListSeparator VFS;
3569 for (auto V : CI.Clones) {
3570 Out << VFS;
3571 Out << V;
3572 }
3573 Out << "), stackIds: (";
3574 ListSeparator SIDFS;
3575 for (auto Id : CI.StackIdIndices) {
3576 Out << SIDFS;
3577 Out << TheIndex->getStackIdAtIndex(Id);
3578 }
3579 Out << "))";
3580 }
3581 Out << ")";
3582 }
3583
3584 auto PrintRange = [&](const ConstantRange &Range) {
3585 Out << "[" << Range.getSignedMin() << ", " << Range.getSignedMax() << "]";
3586 };
3587
3588 if (!FS->paramAccesses().empty()) {
3589 Out << ", params: (";
3590 ListSeparator IFS;
3591 for (auto &PS : FS->paramAccesses()) {
3592 Out << IFS;
3593 Out << "(param: " << PS.ParamNo;
3594 Out << ", offset: ";
3595 PrintRange(PS.Use);
3596 if (!PS.Calls.empty()) {
3597 Out << ", calls: (";
3598 ListSeparator IFS;
3599 for (auto &Call : PS.Calls) {
3600 Out << IFS;
3601 Out << "(callee: ^" << Machine.getGUIDSlot(Call.Callee.getGUID());
3602 Out << ", param: " << Call.ParamNo;
3603 Out << ", offset: ";
3604 PrintRange(Call.Offsets);
3605 Out << ")";
3606 }
3607 Out << ")";
3608 }
3609 Out << ")";
3610 }
3611 Out << ")";
3612 }
3613}
3614
3615void AssemblyWriter::printTypeIdInfo(
3616 const FunctionSummary::TypeIdInfo &TIDInfo) {
3617 Out << ", typeIdInfo: (";
3618 ListSeparator TIDFS;
3619 if (!TIDInfo.TypeTests.empty()) {
3620 Out << TIDFS;
3621 Out << "typeTests: (";
3622 ListSeparator FS;
3623 for (auto &GUID : TIDInfo.TypeTests) {
3624 auto TidIter = TheIndex->typeIds().equal_range(GUID);
3625 if (TidIter.first == TidIter.second) {
3626 Out << FS;
3627 Out << GUID;
3628 continue;
3629 }
3630 // Print all type id that correspond to this GUID.
3631 for (const auto &[GUID, TypeIdPair] : make_range(TidIter)) {
3632 Out << FS;
3633 auto Slot = Machine.getTypeIdSlot(TypeIdPair.first);
3634 assert(Slot != -1);
3635 Out << "^" << Slot;
3636 }
3637 }
3638 Out << ")";
3639 }
3640 if (!TIDInfo.TypeTestAssumeVCalls.empty()) {
3641 Out << TIDFS;
3642 printNonConstVCalls(TIDInfo.TypeTestAssumeVCalls, "typeTestAssumeVCalls");
3643 }
3644 if (!TIDInfo.TypeCheckedLoadVCalls.empty()) {
3645 Out << TIDFS;
3646 printNonConstVCalls(TIDInfo.TypeCheckedLoadVCalls, "typeCheckedLoadVCalls");
3647 }
3648 if (!TIDInfo.TypeTestAssumeConstVCalls.empty()) {
3649 Out << TIDFS;
3650 printConstVCalls(TIDInfo.TypeTestAssumeConstVCalls,
3651 "typeTestAssumeConstVCalls");
3652 }
3653 if (!TIDInfo.TypeCheckedLoadConstVCalls.empty()) {
3654 Out << TIDFS;
3655 printConstVCalls(TIDInfo.TypeCheckedLoadConstVCalls,
3656 "typeCheckedLoadConstVCalls");
3657 }
3658 Out << ")";
3659}
3660
3661void AssemblyWriter::printVFuncId(const FunctionSummary::VFuncId VFId) {
3662 auto TidIter = TheIndex->typeIds().equal_range(VFId.GUID);
3663 if (TidIter.first == TidIter.second) {
3664 Out << "vFuncId: (";
3665 Out << "guid: " << VFId.GUID;
3666 Out << ", offset: " << VFId.Offset;
3667 Out << ")";
3668 return;
3669 }
3670 // Print all type id that correspond to this GUID.
3671 ListSeparator FS;
3672 for (const auto &[GUID, TypeIdPair] : make_range(TidIter)) {
3673 Out << FS;
3674 Out << "vFuncId: (";
3675 auto Slot = Machine.getTypeIdSlot(TypeIdPair.first);
3676 assert(Slot != -1);
3677 Out << "^" << Slot;
3678 Out << ", offset: " << VFId.Offset;
3679 Out << ")";
3680 }
3681}
3682
3683void AssemblyWriter::printNonConstVCalls(
3684 const std::vector<FunctionSummary::VFuncId> &VCallList, const char *Tag) {
3685 Out << Tag << ": (";
3686 ListSeparator FS;
3687 for (auto &VFuncId : VCallList) {
3688 Out << FS;
3689 printVFuncId(VFuncId);
3690 }
3691 Out << ")";
3692}
3693
3694void AssemblyWriter::printConstVCalls(
3695 const std::vector<FunctionSummary::ConstVCall> &VCallList,
3696 const char *Tag) {
3697 Out << Tag << ": (";
3698 ListSeparator FS;
3699 for (auto &ConstVCall : VCallList) {
3700 Out << FS;
3701 Out << "(";
3702 printVFuncId(ConstVCall.VFunc);
3703 if (!ConstVCall.Args.empty()) {
3704 Out << ", ";
3705 printArgs(ConstVCall.Args);
3706 }
3707 Out << ")";
3708 }
3709 Out << ")";
3710}
3711
3712void AssemblyWriter::printSummary(const GlobalValueSummary &Summary) {
3713 GlobalValueSummary::GVFlags GVFlags = Summary.flags();
3715 Out << getSummaryKindName(Summary.getSummaryKind()) << ": ";
3716 Out << "(module: ^" << Machine.getModulePathSlot(Summary.modulePath())
3717 << ", flags: (";
3718 Out << "linkage: " << getLinkageName(LT);
3719 Out << ", visibility: "
3721 Out << ", notEligibleToImport: " << GVFlags.NotEligibleToImport;
3722 Out << ", live: " << GVFlags.Live;
3723 Out << ", dsoLocal: " << GVFlags.DSOLocal;
3724 Out << ", canAutoHide: " << GVFlags.CanAutoHide;
3725 Out << ", importType: "
3727 Out << ")";
3728
3729 if (Summary.getSummaryKind() == GlobalValueSummary::AliasKind)
3730 printAliasSummary(cast<AliasSummary>(&Summary));
3731 else if (Summary.getSummaryKind() == GlobalValueSummary::FunctionKind)
3732 printFunctionSummary(cast<FunctionSummary>(&Summary));
3733 else
3734 printGlobalVarSummary(cast<GlobalVarSummary>(&Summary));
3735
3736 auto RefList = Summary.refs();
3737 if (!RefList.empty()) {
3738 Out << ", refs: (";
3739 ListSeparator FS;
3740 for (auto &Ref : RefList) {
3741 Out << FS;
3742 if (Ref.isReadOnly())
3743 Out << "readonly ";
3744 else if (Ref.isWriteOnly())
3745 Out << "writeonly ";
3746 Out << "^" << Machine.getGUIDSlot(Ref.getGUID());
3747 }
3748 Out << ")";
3749 }
3750
3751 Out << ")";
3752}
3753
3754void AssemblyWriter::printSummaryInfo(unsigned Slot, const ValueInfo &VI) {
3755 Out << "^" << Slot << " = gv: (";
3756 if (VI.hasName() && !VI.name().empty())
3757 Out << "name: \"" << VI.name() << "\"";
3758 else
3759 Out << "guid: " << VI.getGUID();
3760 if (!VI.getSummaryList().empty()) {
3761 Out << ", summaries: (";
3762 ListSeparator FS;
3763 for (auto &Summary : VI.getSummaryList()) {
3764 Out << FS;
3765 printSummary(*Summary);
3766 }
3767 Out << ")";
3768 }
3769 Out << ")";
3770 if (VI.hasName() && !VI.name().empty())
3771 Out << " ; guid = " << VI.getGUID();
3772 Out << "\n";
3773}
3774
3776 formatted_raw_ostream &Out) {
3777 if (Name.empty()) {
3778 Out << "<empty name> ";
3779 } else {
3780 unsigned char FirstC = static_cast<unsigned char>(Name[0]);
3781 if (isalpha(FirstC) || FirstC == '-' || FirstC == '$' || FirstC == '.' ||
3782 FirstC == '_')
3783 Out << FirstC;
3784 else
3785 Out << '\\' << hexdigit(FirstC >> 4) << hexdigit(FirstC & 0x0F);
3786 for (unsigned i = 1, e = Name.size(); i != e; ++i) {
3787 unsigned char C = Name[i];
3788 if (isalnum(C) || C == '-' || C == '$' || C == '.' || C == '_')
3789 Out << C;
3790 else
3791 Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
3792 }
3793 }
3794}
3795
3796void AssemblyWriter::printNamedMDNode(const NamedMDNode *NMD) {
3797 Out << '!';
3798 printMetadataIdentifier(NMD->getName(), Out);
3799 Out << " = !{";
3800 ListSeparator LS;
3801 for (const MDNode *Op : NMD->operands()) {
3802 Out << LS;
3803 // Write DIExpressions inline.
3804 // FIXME: Ban DIExpressions in NamedMDNodes, they will serve no purpose.
3805 if (auto *Expr = dyn_cast<DIExpression>(Op)) {
3806 writeDIExpression(Out, Expr, AsmWriterContext::getEmpty());
3807 continue;
3808 }
3809
3810 int Slot = Machine.getMetadataSlot(Op);
3811 if (Slot == -1)
3812 Out << "<badref>";
3813 else
3814 Out << '!' << Slot;
3815 }
3816 Out << "}\n";
3817}
3818
3820 formatted_raw_ostream &Out) {
3821 switch (Vis) {
3823 case GlobalValue::HiddenVisibility: Out << "hidden "; break;
3824 case GlobalValue::ProtectedVisibility: Out << "protected "; break;
3825 }
3826}
3827
3828static void PrintDSOLocation(const GlobalValue &GV,
3829 formatted_raw_ostream &Out) {
3830 if (GV.isDSOLocal() && !GV.isImplicitDSOLocal())
3831 Out << "dso_local ";
3832}
3833
3835 formatted_raw_ostream &Out) {
3836 switch (SCT) {
3838 case GlobalValue::DLLImportStorageClass: Out << "dllimport "; break;
3839 case GlobalValue::DLLExportStorageClass: Out << "dllexport "; break;
3840 }
3841}
3842
3844 formatted_raw_ostream &Out) {
3845 switch (TLM) {
3847 break;
3849 Out << "thread_local ";
3850 break;
3852 Out << "thread_local(localdynamic) ";
3853 break;
3855 Out << "thread_local(initialexec) ";
3856 break;
3858 Out << "thread_local(localexec) ";
3859 break;
3860 }
3861}
3862
3864 switch (UA) {
3866 return "";
3868 return "local_unnamed_addr";
3870 return "unnamed_addr";
3871 }
3872 llvm_unreachable("Unknown UnnamedAddr");
3873}
3874
3876 const GlobalObject &GO) {
3877 const Comdat *C = GO.getComdat();
3878 if (!C)
3879 return;
3880
3881 if (isa<GlobalVariable>(GO))
3882 Out << ',';
3883 Out << " comdat";
3884
3885 if (GO.getName() == C->getName())
3886 return;
3887
3888 Out << '(';
3889 PrintLLVMName(Out, C->getName(), ComdatPrefix);
3890 Out << ')';
3891}
3892
3893void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
3894 if (GV->isMaterializable())
3895 Out << "; Materializable\n";
3896
3897 AsmWriterContext WriterCtx(&TypePrinter, &Machine, GV->getParent());
3898 WriteAsOperandInternal(Out, GV, WriterCtx);
3899 Out << " = ";
3900
3901 if (!GV->hasInitializer() && GV->hasExternalLinkage())
3902 Out << "external ";
3903
3904 Out << getLinkageNameWithSpace(GV->getLinkage());
3905 PrintDSOLocation(*GV, Out);
3906 PrintVisibility(GV->getVisibility(), Out);
3909 StringRef UA = getUnnamedAddrEncoding(GV->getUnnamedAddr());
3910 if (!UA.empty())
3911 Out << UA << ' ';
3912
3913 if (unsigned AddressSpace = GV->getType()->getAddressSpace())
3914 Out << "addrspace(" << AddressSpace << ") ";
3915 if (GV->isExternallyInitialized()) Out << "externally_initialized ";
3916 Out << (GV->isConstant() ? "constant " : "global ");
3917 TypePrinter.print(GV->getValueType(), Out);
3918
3919 if (GV->hasInitializer()) {
3920 Out << ' ';
3921 writeOperand(GV->getInitializer(), false);
3922 }
3923
3924 if (GV->hasSection()) {
3925 Out << ", section \"";
3926 printEscapedString(GV->getSection(), Out);
3927 Out << '"';
3928 }
3929 if (GV->hasPartition()) {
3930 Out << ", partition \"";
3931 printEscapedString(GV->getPartition(), Out);
3932 Out << '"';
3933 }
3934 if (auto CM = GV->getCodeModel()) {
3935 Out << ", code_model \"";
3936 switch (*CM) {
3937 case CodeModel::Tiny:
3938 Out << "tiny";
3939 break;
3940 case CodeModel::Small:
3941 Out << "small";
3942 break;
3943 case CodeModel::Kernel:
3944 Out << "kernel";
3945 break;
3946 case CodeModel::Medium:
3947 Out << "medium";
3948 break;
3949 case CodeModel::Large:
3950 Out << "large";
3951 break;
3952 }
3953 Out << '"';
3954 }
3955
3956 using SanitizerMetadata = llvm::GlobalValue::SanitizerMetadata;
3957 if (GV->hasSanitizerMetadata()) {
3959 if (MD.NoAddress)
3960 Out << ", no_sanitize_address";
3961 if (MD.NoHWAddress)
3962 Out << ", no_sanitize_hwaddress";
3963 if (MD.Memtag)
3964 Out << ", sanitize_memtag";
3965 if (MD.IsDynInit)
3966 Out << ", sanitize_address_dyninit";
3967 }
3968
3969 maybePrintComdat(Out, *GV);
3970 if (MaybeAlign A = GV->getAlign())
3971 Out << ", align " << A->value();
3972
3974 GV->getAllMetadata(MDs);
3975 printMetadataAttachments(MDs, ", ");
3976
3977 auto Attrs = GV->getAttributes();
3978 if (Attrs.hasAttributes())
3979 Out << " #" << Machine.getAttributeGroupSlot(Attrs);
3980
3981 printInfoComment(*GV);
3982}
3983
3984void AssemblyWriter::printAlias(const GlobalAlias *GA) {
3985 if (GA->isMaterializable())
3986 Out << "; Materializable\n";
3987
3988 AsmWriterContext WriterCtx(&TypePrinter, &Machine, GA->getParent());
3989 WriteAsOperandInternal(Out, GA, WriterCtx);
3990 Out << " = ";
3991
3992 Out << getLinkageNameWithSpace(GA->getLinkage());
3993 PrintDSOLocation(*GA, Out);
3994 PrintVisibility(GA->getVisibility(), Out);
3997 StringRef UA = getUnnamedAddrEncoding(GA->getUnnamedAddr());
3998 if (!UA.empty())
3999 Out << UA << ' ';
4000
4001 Out << "alias ";
4002
4003 TypePrinter.print(GA->getValueType(), Out);
4004 Out << ", ";
4005
4006 if (const Constant *Aliasee = GA->getAliasee()) {
4007 writeOperand(Aliasee, !isa<ConstantExpr>(Aliasee));
4008 } else {
4009 TypePrinter.print(GA->getType(), Out);
4010 Out << " <<NULL ALIASEE>>";
4011 }
4012
4013 if (GA->hasPartition()) {
4014 Out << ", partition \"";
4015 printEscapedString(GA->getPartition(), Out);
4016 Out << '"';
4017 }
4018
4019 printInfoComment(*GA);
4020 Out << '\n';
4021}
4022
4023void AssemblyWriter::printIFunc(const GlobalIFunc *GI) {
4024 if (GI->isMaterializable())
4025 Out << "; Materializable\n";
4026
4027 AsmWriterContext WriterCtx(&TypePrinter, &Machine, GI->getParent());
4028 WriteAsOperandInternal(Out, GI, WriterCtx);
4029 Out << " = ";
4030
4031 Out << getLinkageNameWithSpace(GI->getLinkage());
4032 PrintDSOLocation(*GI, Out);
4033 PrintVisibility(GI->getVisibility(), Out);
4034
4035 Out << "ifunc ";
4036
4037 TypePrinter.print(GI->getValueType(), Out);
4038 Out << ", ";
4039
4040 if (const Constant *Resolver = GI->getResolver()) {
4041 writeOperand(Resolver, !isa<ConstantExpr>(Resolver));
4042 } else {
4043 TypePrinter.print(GI->getType(), Out);
4044 Out << " <<NULL RESOLVER>>";
4045 }
4046
4047 if (GI->hasPartition()) {
4048 Out << ", partition \"";
4049 printEscapedString(GI->getPartition(), Out);
4050 Out << '"';
4051 }
4053 GI->getAllMetadata(MDs);
4054 if (!MDs.empty()) {
4055 printMetadataAttachments(MDs, ", ");
4056 }
4057
4058 printInfoComment(*GI);
4059 Out << '\n';
4060}
4061
4062void AssemblyWriter::printComdat(const Comdat *C) {
4063 C->print(Out);
4064}
4065
4066void AssemblyWriter::printTypeIdentities() {
4067 if (TypePrinter.empty())
4068 return;
4069
4070 Out << '\n';
4071
4072 // Emit all numbered types.
4073 auto &NumberedTypes = TypePrinter.getNumberedTypes();
4074 for (unsigned I = 0, E = NumberedTypes.size(); I != E; ++I) {
4075 Out << '%' << I << " = type ";
4076
4077 // Make sure we print out at least one level of the type structure, so
4078 // that we do not get %2 = type %2
4079 TypePrinter.printStructBody(NumberedTypes[I], Out);
4080 Out << '\n';
4081 }
4082
4083 auto &NamedTypes = TypePrinter.getNamedTypes();
4084 for (StructType *NamedType : NamedTypes) {
4085 PrintLLVMName(Out, NamedType->getName(), LocalPrefix);
4086 Out << " = type ";
4087
4088 // Make sure we print out at least one level of the type structure, so
4089 // that we do not get %FILE = type %FILE
4090 TypePrinter.printStructBody(NamedType, Out);
4091 Out << '\n';
4092 }
4093}
4094
4095/// printFunction - Print all aspects of a function.
4096void AssemblyWriter::printFunction(const Function *F) {
4097 if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out);
4098
4099 if (F->isMaterializable())
4100 Out << "; Materializable\n";
4101
4102 const AttributeList &Attrs = F->getAttributes();
4103 if (Attrs.hasFnAttrs()) {
4104 AttributeSet AS = Attrs.getFnAttrs();
4105 std::string AttrStr;
4106
4107 for (const Attribute &Attr : AS) {
4108 if (!Attr.isStringAttribute()) {
4109 if (!AttrStr.empty()) AttrStr += ' ';
4110 AttrStr += Attr.getAsString();
4111 }
4112 }
4113
4114 if (!AttrStr.empty())
4115 Out << "; Function Attrs: " << AttrStr << '\n';
4116 }
4117
4118 if (F->isIntrinsic() && F->getIntrinsicID() == Intrinsic::not_intrinsic)
4119 Out << "; Unknown intrinsic\n";
4120
4121 Machine.incorporateFunction(F);
4122
4123 if (F->isDeclaration()) {
4124 Out << "declare";
4126 F->getAllMetadata(MDs);
4127 printMetadataAttachments(MDs, " ");
4128 Out << ' ';
4129 } else
4130 Out << "define ";
4131
4132 Out << getLinkageNameWithSpace(F->getLinkage());
4133 PrintDSOLocation(*F, Out);
4134 PrintVisibility(F->getVisibility(), Out);
4135 PrintDLLStorageClass(F->getDLLStorageClass(), Out);
4136
4137 // Print the calling convention.
4138 if (F->getCallingConv() != CallingConv::C) {
4139 PrintCallingConv(F->getCallingConv(), Out);
4140 Out << " ";
4141 }
4142
4143 FunctionType *FT = F->getFunctionType();
4144 if (Attrs.hasRetAttrs())
4145 Out << Attrs.getAsString(AttributeList::ReturnIndex) << ' ';
4146 TypePrinter.print(F->getReturnType(), Out);
4147 AsmWriterContext WriterCtx(&TypePrinter, &Machine, F->getParent());
4148 Out << ' ';
4149 WriteAsOperandInternal(Out, F, WriterCtx);
4150 Out << '(';
4151
4152 // Loop over the arguments, printing them...
4153 if (F->isDeclaration() && !IsForDebug) {
4154 // We're only interested in the type here - don't print argument names.
4155 ListSeparator LS;
4156 for (unsigned I = 0, E = FT->getNumParams(); I != E; ++I) {
4157 Out << LS;
4158 // Output type.
4159 TypePrinter.print(FT->getParamType(I), Out);
4160
4161 AttributeSet ArgAttrs = Attrs.getParamAttrs(I);
4162 if (ArgAttrs.hasAttributes()) {
4163 Out << ' ';
4164 writeAttributeSet(ArgAttrs);
4165 }
4166 }
4167 } else {
4168 // The arguments are meaningful here, print them in detail.
4169 ListSeparator LS;
4170 for (const Argument &Arg : F->args()) {
4171 Out << LS;
4172 printArgument(&Arg, Attrs.getParamAttrs(Arg.getArgNo()));
4173 }
4174 }
4175
4176 // Finish printing arguments...
4177 if (FT->isVarArg()) {
4178 if (FT->getNumParams()) Out << ", ";
4179 Out << "..."; // Output varargs portion of signature!
4180 }
4181 Out << ')';
4182 StringRef UA = getUnnamedAddrEncoding(F->getUnnamedAddr());
4183 if (!UA.empty())
4184 Out << ' ' << UA;
4185 // We print the function address space if it is non-zero or if we are writing
4186 // a module with a non-zero program address space or if there is no valid
4187 // Module* so that the file can be parsed without the datalayout string.
4188 const Module *Mod = F->getParent();
4189 if (F->getAddressSpace() != 0 || !Mod ||
4190 Mod->getDataLayout().getProgramAddressSpace() != 0)
4191 Out << " addrspace(" << F->getAddressSpace() << ")";
4192 if (Attrs.hasFnAttrs())
4193 Out << " #" << Machine.getAttributeGroupSlot(Attrs.getFnAttrs());
4194 if (F->hasSection()) {
4195 Out << " section \"";
4196 printEscapedString(F->getSection(), Out);
4197 Out << '"';
4198 }
4199 if (F->hasPartition()) {
4200 Out << " partition \"";
4201 printEscapedString(F->getPartition(), Out);
4202 Out << '"';
4203 }
4204 maybePrintComdat(Out, *F);
4205 if (MaybeAlign A = F->getAlign())
4206 Out << " align " << A->value();
4207 if (F->hasGC())
4208 Out << " gc \"" << F->getGC() << '"';
4209 if (F->hasPrefixData()) {
4210 Out << " prefix ";
4211 writeOperand(F->getPrefixData(), true);
4212 }
4213 if (F->hasPrologueData()) {
4214 Out << " prologue ";
4215 writeOperand(F->getPrologueData(), true);
4216 }
4217 if (F->hasPersonalityFn()) {
4218 Out << " personality ";
4219 writeOperand(F->getPersonalityFn(), /*PrintType=*/true);
4220 }
4221
4222 if (PrintProfData) {
4223 if (auto *MDProf = F->getMetadata(LLVMContext::MD_prof)) {
4224 Out << " ";
4225 MDProf->print(Out, TheModule, /*IsForDebug=*/true);
4226 }
4227 }
4228
4229 if (F->isDeclaration()) {
4230 Out << '\n';
4231 } else {
4233 F->getAllMetadata(MDs);
4234 printMetadataAttachments(MDs, " ");
4235
4236 Out << " {";
4237 // Output all of the function's basic blocks.
4238 for (const BasicBlock &BB : *F)
4239 printBasicBlock(&BB);
4240
4241 // Output the function's use-lists.
4242 printUseLists(F);
4243
4244 Out << "}\n";
4245 }
4246
4247 Machine.purgeFunction();
4248}
4249
4250/// printArgument - This member is called for every argument that is passed into
4251/// the function. Simply print it out
4252void AssemblyWriter::printArgument(const Argument *Arg, AttributeSet Attrs) {
4253 // Output type...
4254 TypePrinter.print(Arg->getType(), Out);
4255
4256 // Output parameter attributes list
4257 if (Attrs.hasAttributes()) {
4258 Out << ' ';
4259 writeAttributeSet(Attrs);
4260 }
4261
4262 // Output name, if available...
4263 if (Arg->hasName()) {
4264 Out << ' ';
4265 PrintLLVMName(Out, Arg);
4266 } else {
4267 int Slot = Machine.getLocalSlot(Arg);
4268 assert(Slot != -1 && "expect argument in function here");
4269 Out << " %" << Slot;
4270 }
4271}
4272
4273/// printBasicBlock - This member is called for each basic block in a method.
4274void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
4275 bool IsEntryBlock = BB->getParent() && BB->isEntryBlock();
4276 if (BB->hasName()) { // Print out the label if it exists...
4277 Out << "\n";
4278 PrintLLVMName(Out, BB->getName(), LabelPrefix);
4279 Out << ':';
4280 } else if (!IsEntryBlock) {
4281 Out << "\n";
4282 int Slot = Machine.getLocalSlot(BB);
4283 if (Slot != -1)
4284 Out << Slot << ":";
4285 else
4286 Out << "<badref>:";
4287 }
4288
4289 if (!IsEntryBlock) {
4290 // Output predecessors for the block.
4291 Out.PadToColumn(50);
4292 Out << ";";
4293 if (pred_empty(BB)) {
4294 Out << " No predecessors!";
4295 } else {
4296 Out << " preds = ";
4297 ListSeparator LS;
4298 for (const BasicBlock *Pred : predecessors(BB)) {
4299 Out << LS;
4300 writeOperand(Pred, false);
4301 }
4302 }
4303 }
4304
4305 Out << "\n";
4306
4307 if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out);
4308
4309 // Output all of the instructions in the basic block...
4310 for (const Instruction &I : *BB) {
4311 for (const DbgRecord &DR : I.getDbgRecordRange())
4312 printDbgRecordLine(DR);
4313 printInstructionLine(I);
4314 }
4315
4316 if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out);
4317}
4318
4319/// printInstructionLine - Print an instruction and a newline character.
4320void AssemblyWriter::printInstructionLine(const Instruction &I) {
4321 printInstruction(I);
4322 Out << '\n';
4323}
4324
4325/// printGCRelocateComment - print comment after call to the gc.relocate
4326/// intrinsic indicating base and derived pointer names.
4327void AssemblyWriter::printGCRelocateComment(const GCRelocateInst &Relocate) {
4328 Out << " ; (";
4329 writeOperand(Relocate.getBasePtr(), false);
4330 Out << ", ";
4331 writeOperand(Relocate.getDerivedPtr(), false);
4332 Out << ")";
4333}
4334
4335/// printInfoComment - Print a little comment after the instruction indicating
4336/// which slot it occupies.
4337void AssemblyWriter::printInfoComment(const Value &V) {
4338 if (const auto *Relocate = dyn_cast<GCRelocateInst>(&V))
4339 printGCRelocateComment(*Relocate);
4340
4341 if (AnnotationWriter) {
4342 AnnotationWriter->printInfoComment(V, Out);
4343 }
4344
4345 if (PrintInstDebugLocs) {
4346 if (auto *I = dyn_cast<Instruction>(&V)) {
4347 if (I->getDebugLoc()) {
4348 Out << " ; ";
4349 I->getDebugLoc().print(Out);
4350 }
4351 }
4352 }
4353 if (PrintProfData) {
4354 if (auto *I = dyn_cast<Instruction>(&V)) {
4355 if (auto *MD = I->getMetadata(LLVMContext::MD_prof)) {
4356 Out << " ; ";
4357 MD->print(Out, TheModule, /*IsForDebug=*/true);
4358 }
4359 }
4360 }
4361
4362 if (PrintInstAddrs)
4363 Out << " ; " << &V;
4364}
4365
4366static void maybePrintCallAddrSpace(const Value *Operand, const Instruction *I,
4367 raw_ostream &Out) {
4368 // We print the address space of the call if it is non-zero.
4369 if (Operand == nullptr) {
4370 Out << " <cannot get addrspace!>";
4371 return;
4372 }
4373 unsigned CallAddrSpace = Operand->getType()->getPointerAddressSpace();
4374 bool PrintAddrSpace = CallAddrSpace != 0;
4375 if (!PrintAddrSpace) {
4376 const Module *Mod = getModuleFromVal(I);
4377 // We also print it if it is zero but not equal to the program address space
4378 // or if we can't find a valid Module* to make it possible to parse
4379 // the resulting file even without a datalayout string.
4380 if (!Mod || Mod->getDataLayout().getProgramAddressSpace() != 0)
4381 PrintAddrSpace = true;
4382 }
4383 if (PrintAddrSpace)
4384 Out << " addrspace(" << CallAddrSpace << ")";
4385}
4386
4387// This member is called for each Instruction in a function..
4388void AssemblyWriter::printInstruction(const Instruction &I) {
4389 if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out);
4390
4391 // Print out indentation for an instruction.
4392 Out << " ";
4393
4394 // Print out name if it exists...
4395 if (I.hasName()) {
4396 PrintLLVMName(Out, &I);
4397 Out << " = ";
4398 } else if (!I.getType()->isVoidTy()) {
4399 // Print out the def slot taken.
4400 int SlotNum = Machine.getLocalSlot(&I);
4401 if (SlotNum == -1)
4402 Out << "<badref> = ";
4403 else
4404 Out << '%' << SlotNum << " = ";
4405 }
4406
4407 if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
4408 if (CI->isMustTailCall())
4409 Out << "musttail ";
4410 else if (CI->isTailCall())
4411 Out << "tail ";
4412 else if (CI->isNoTailCall())
4413 Out << "notail ";
4414 }
4415
4416 // Print out the opcode...
4417 Out << I.getOpcodeName();
4418
4419 // If this is an atomic load or store, print out the atomic marker.
4420 if ((isa<LoadInst>(I) && cast<LoadInst>(I).isAtomic()) ||
4421 (isa<StoreInst>(I) && cast<StoreInst>(I).isAtomic()))
4422 Out << " atomic";
4423
4425 Out << " weak";
4426
4427 // If this is a volatile operation, print out the volatile marker.
4428 if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) ||
4429 (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile()) ||
4430 (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).isVolatile()) ||
4431 (isa<AtomicRMWInst>(I) && cast<AtomicRMWInst>(I).isVolatile()))
4432 Out << " volatile";
4433
4434 // Print out optimization information.
4435 WriteOptimizationInfo(Out, &I);
4436
4437 // Print out the compare instruction predicates
4438 if (const CmpInst *CI = dyn_cast<CmpInst>(&I))
4439 Out << ' ' << CI->getPredicate();
4440
4441 // Print out the atomicrmw operation
4442 if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I))
4443 Out << ' ' << AtomicRMWInst::getOperationName(RMWI->getOperation());
4444
4445 // Print out the type of the operands...
4446 const Value *Operand = I.getNumOperands() ? I.getOperand(0) : nullptr;
4447
4448 // Special case conditional branches to swizzle the condition out to the front
4449 if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) {
4450 const BranchInst &BI(cast<BranchInst>(I));
4451 Out << ' ';
4452 writeOperand(BI.getCondition(), true);
4453 Out << ", ";
4454 writeOperand(BI.getSuccessor(0), true);
4455 Out << ", ";
4456 writeOperand(BI.getSuccessor(1), true);
4457
4458 } else if (isa<SwitchInst>(I)) {
4459 const SwitchInst& SI(cast<SwitchInst>(I));
4460 // Special case switch instruction to get formatting nice and correct.
4461 Out << ' ';
4462 writeOperand(SI.getCondition(), true);
4463 Out << ", ";
4464 writeOperand(SI.getDefaultDest(), true);
4465 Out << " [";
4466 for (auto Case : SI.cases()) {
4467 Out << "\n ";
4468 writeOperand(Case.getCaseValue(), true);
4469 Out << ", ";
4470 writeOperand(Case.getCaseSuccessor(), true);
4471 }
4472 Out << "\n ]";
4473 } else if (isa<IndirectBrInst>(I)) {
4474 // Special case indirectbr instruction to get formatting nice and correct.
4475 Out << ' ';
4476 writeOperand(Operand, true);
4477 Out << ", [";
4478
4479 ListSeparator LS;
4480 for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) {
4481 Out << LS;
4482 writeOperand(I.getOperand(i), true);
4483 }
4484 Out << ']';
4485 } else if (const PHINode *PN = dyn_cast<PHINode>(&I)) {
4486 Out << ' ';
4487 TypePrinter.print(I.getType(), Out);
4488 Out << ' ';
4489
4490 ListSeparator LS;
4491 for (unsigned op = 0, Eop = PN->getNumIncomingValues(); op < Eop; ++op) {
4492 Out << LS << "[ ";
4493 writeOperand(PN->getIncomingValue(op), false); Out << ", ";
4494 writeOperand(PN->getIncomingBlock(op), false); Out << " ]";
4495 }
4496 } else if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(&I)) {
4497 Out << ' ';
4498 writeOperand(I.getOperand(0), true);
4499 for (unsigned i : EVI->indices())
4500 Out << ", " << i;
4501 } else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(&I)) {
4502 Out << ' ';
4503 writeOperand(I.getOperand(0), true); Out << ", ";
4504 writeOperand(I.getOperand(1), true);
4505 for (unsigned i : IVI->indices())
4506 Out << ", " << i;
4507 } else if (const LandingPadInst *LPI = dyn_cast<LandingPadInst>(&I)) {
4508 Out << ' ';
4509 TypePrinter.print(I.getType(), Out);
4510 if (LPI->isCleanup() || LPI->getNumClauses() != 0)
4511 Out << '\n';
4512
4513 if (LPI->isCleanup())
4514 Out << " cleanup";
4515
4516 for (unsigned i = 0, e = LPI->getNumClauses(); i != e; ++i) {
4517 if (i != 0 || LPI->isCleanup()) Out << "\n";
4518 if (LPI->isCatch(i))
4519 Out << " catch ";
4520 else
4521 Out << " filter ";
4522
4523 writeOperand(LPI->getClause(i), true);
4524 }
4525 } else if (const auto *CatchSwitch = dyn_cast<CatchSwitchInst>(&I)) {
4526 Out << " within ";
4527 writeOperand(CatchSwitch->getParentPad(), /*PrintType=*/false);
4528 Out << " [";
4529 ListSeparator LS;
4530 for (const BasicBlock *PadBB : CatchSwitch->handlers()) {
4531 Out << LS;
4532 writeOperand(PadBB, /*PrintType=*/true);
4533 }
4534 Out << "] unwind ";
4535 if (const BasicBlock *UnwindDest = CatchSwitch->getUnwindDest())
4536 writeOperand(UnwindDest, /*PrintType=*/true);
4537 else
4538 Out << "to caller";
4539 } else if (const auto *FPI = dyn_cast<FuncletPadInst>(&I)) {
4540 Out << " within ";
4541 writeOperand(FPI->getParentPad(), /*PrintType=*/false);
4542 Out << " [";
4543 ListSeparator LS;
4544 for (const Value *Op : FPI->arg_operands()) {
4545 Out << LS;
4546 writeOperand(Op, /*PrintType=*/true);
4547 }
4548 Out << ']';
4549 } else if (isa<ReturnInst>(I) && !Operand) {
4550 Out << " void";
4551 } else if (const auto *CRI = dyn_cast<CatchReturnInst>(&I)) {
4552 Out << " from ";
4553 writeOperand(CRI->getOperand(0), /*PrintType=*/false);
4554
4555 Out << " to ";
4556 writeOperand(CRI->getOperand(1), /*PrintType=*/true);
4557 } else if (const auto *CRI = dyn_cast<CleanupReturnInst>(&I)) {
4558 Out << " from ";
4559 writeOperand(CRI->getOperand(0), /*PrintType=*/false);
4560
4561 Out << " unwind ";
4562 if (CRI->hasUnwindDest())
4563 writeOperand(CRI->getOperand(1), /*PrintType=*/true);
4564 else
4565 Out << "to caller";
4566 } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
4567 // Print the calling convention being used.
4568 if (CI->getCallingConv() != CallingConv::C) {
4569 Out << " ";
4570 PrintCallingConv(CI->getCallingConv(), Out);
4571 }
4572
4573 Operand = CI->getCalledOperand();
4574 FunctionType *FTy = CI->getFunctionType();
4575 Type *RetTy = FTy->getReturnType();
4576 const AttributeList &PAL = CI->getAttributes();
4577
4578 if (PAL.hasRetAttrs())
4579 Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
4580
4581 // Only print addrspace(N) if necessary:
4582 maybePrintCallAddrSpace(Operand, &I, Out);
4583
4584 // If possible, print out the short form of the call instruction. We can
4585 // only do this if the first argument is a pointer to a nonvararg function,
4586 // and if the return type is not a pointer to a function.
4587 Out << ' ';
4588 TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
4589 Out << ' ';
4590 writeOperand(Operand, false);
4591 Out << '(';
4592 ListSeparator LS;
4593 for (unsigned op = 0, Eop = CI->arg_size(); op < Eop; ++op) {
4594 Out << LS;
4595 writeParamOperand(CI->getArgOperand(op), PAL.getParamAttrs(op));
4596 }
4597
4598 // Emit an ellipsis if this is a musttail call in a vararg function. This
4599 // is only to aid readability, musttail calls forward varargs by default.
4600 if (CI->isMustTailCall() && CI->getParent() &&
4601 CI->getParent()->getParent() &&
4602 CI->getParent()->getParent()->isVarArg()) {
4603 if (CI->arg_size() > 0)
4604 Out << ", ";
4605 Out << "...";
4606 }
4607
4608 Out << ')';
4609 if (PAL.hasFnAttrs())
4610 Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttrs());
4611
4612 writeOperandBundles(CI);
4613 } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
4614 Operand = II->getCalledOperand();
4615 FunctionType *FTy = II->getFunctionType();
4616 Type *RetTy = FTy->getReturnType();
4617 const AttributeList &PAL = II->getAttributes();
4618
4619 // Print the calling convention being used.
4620 if (II->getCallingConv() != CallingConv::C) {
4621 Out << " ";
4622 PrintCallingConv(II->getCallingConv(), Out);
4623 }
4624
4625 if (PAL.hasRetAttrs())
4626 Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
4627
4628 // Only print addrspace(N) if necessary:
4629 maybePrintCallAddrSpace(Operand, &I, Out);
4630
4631 // If possible, print out the short form of the invoke instruction. We can
4632 // only do this if the first argument is a pointer to a nonvararg function,
4633 // and if the return type is not a pointer to a function.
4634 //
4635 Out << ' ';
4636 TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
4637 Out << ' ';
4638 writeOperand(Operand, false);
4639 Out << '(';
4640 ListSeparator LS;
4641 for (unsigned op = 0, Eop = II->arg_size(); op < Eop; ++op) {
4642 Out << LS;
4643 writeParamOperand(II->getArgOperand(op), PAL.getParamAttrs(op));
4644 }
4645
4646 Out << ')';
4647 if (PAL.hasFnAttrs())
4648 Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttrs());
4649
4650 writeOperandBundles(II);
4651
4652 Out << "\n to ";
4653 writeOperand(II->getNormalDest(), true);
4654 Out << " unwind ";
4655 writeOperand(II->getUnwindDest(), true);
4656 } else if (const CallBrInst *CBI = dyn_cast<CallBrInst>(&I)) {
4657 Operand = CBI->getCalledOperand();
4658 FunctionType *FTy = CBI->getFunctionType();
4659 Type *RetTy = FTy->getReturnType();
4660 const AttributeList &PAL = CBI->getAttributes();
4661
4662 // Print the calling convention being used.
4663 if (CBI->getCallingConv() != CallingConv::C) {
4664 Out << " ";
4665 PrintCallingConv(CBI->getCallingConv(), Out);
4666 }
4667
4668 if (PAL.hasRetAttrs())
4669 Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
4670
4671 // If possible, print out the short form of the callbr instruction. We can
4672 // only do this if the first argument is a pointer to a nonvararg function,
4673 // and if the return type is not a pointer to a function.
4674 //
4675 Out << ' ';
4676 TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
4677 Out << ' ';
4678 writeOperand(Operand, false);
4679 Out << '(';
4680 ListSeparator ArgLS;
4681 for (unsigned op = 0, Eop = CBI->arg_size(); op < Eop; ++op) {
4682 Out << ArgLS;
4683 writeParamOperand(CBI->getArgOperand(op), PAL.getParamAttrs(op));
4684 }
4685
4686 Out << ')';
4687 if (PAL.hasFnAttrs())
4688 Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttrs());
4689
4690 writeOperandBundles(CBI);
4691
4692 Out << "\n to ";
4693 writeOperand(CBI->getDefaultDest(), true);
4694 Out << " [";
4695 ListSeparator DestLS;
4696 for (const BasicBlock *Dest : CBI->getIndirectDests()) {
4697 Out << DestLS;
4698 writeOperand(Dest, true);
4699 }
4700 Out << ']';
4701 } else if (const AllocaInst *AI = dyn_cast<AllocaInst>(&I)) {
4702 Out << ' ';
4703 if (AI->isUsedWithInAlloca())
4704 Out << "inalloca ";
4705 if (AI->isSwiftError())
4706 Out << "swifterror ";
4707 TypePrinter.print(AI->getAllocatedType(), Out);
4708
4709 // Explicitly write the array size if the code is broken, if it's an array
4710 // allocation, or if the type is not canonical for scalar allocations. The
4711 // latter case prevents the type from mutating when round-tripping through
4712 // assembly.
4713 if (!AI->getArraySize() || AI->isArrayAllocation() ||
4714 !AI->getArraySize()->getType()->isIntegerTy(32)) {
4715 Out << ", ";
4716 writeOperand(AI->getArraySize(), true);
4717 }
4718 if (MaybeAlign A = AI->getAlign()) {
4719 Out << ", align " << A->value();
4720 }
4721
4722 unsigned AddrSpace = AI->getAddressSpace();
4723 if (AddrSpace != 0) {
4724 Out << ", addrspace(" << AddrSpace << ')';
4725 }
4726 } else if (isa<CastInst>(I)) {
4727 if (Operand) {
4728 Out << ' ';
4729 writeOperand(Operand, true); // Work with broken code
4730 }
4731 Out << " to ";
4732 TypePrinter.print(I.getType(), Out);
4733 } else if (isa<VAArgInst>(I)) {
4734 if (Operand) {
4735 Out << ' ';
4736 writeOperand(Operand, true); // Work with broken code
4737 }
4738 Out << ", ";
4739 TypePrinter.print(I.getType(), Out);
4740 } else if (Operand) { // Print the normal way.
4741 if (const auto *GEP = dyn_cast<GetElementPtrInst>(&I)) {
4742 Out << ' ';
4743 TypePrinter.print(GEP->getSourceElementType(), Out);
4744 Out << ',';
4745 } else if (const auto *LI = dyn_cast<LoadInst>(&I)) {
4746 Out << ' ';
4747 TypePrinter.print(LI->getType(), Out);
4748 Out << ',';
4749 }
4750
4751 // PrintAllTypes - Instructions who have operands of all the same type
4752 // omit the type from all but the first operand. If the instruction has
4753 // different type operands (for example br), then they are all printed.
4754 bool PrintAllTypes = false;
4755 Type *TheType = Operand->getType();
4756
4757 // Select, Store, ShuffleVector, CmpXchg and AtomicRMW always print all
4758 // types.
4762 PrintAllTypes = true;
4763 } else {
4764 for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) {
4765 Operand = I.getOperand(i);
4766 // note that Operand shouldn't be null, but the test helps make dump()
4767 // more tolerant of malformed IR
4768 if (Operand && Operand->getType() != TheType) {
4769 PrintAllTypes = true; // We have differing types! Print them all!
4770 break;
4771 }
4772 }
4773 }
4774
4775 if (!PrintAllTypes) {
4776 Out << ' ';
4777 TypePrinter.print(TheType, Out);
4778 }
4779
4780 Out << ' ';
4781 ListSeparator LS;
4782 for (const Value *Op : I.operands()) {
4783 Out << LS;
4784 writeOperand(Op, PrintAllTypes);
4785 }
4786 }
4787
4788 // Print atomic ordering/alignment for memory operations
4789 if (const LoadInst *LI = dyn_cast<LoadInst>(&I)) {
4790 if (LI->isAtomic())
4791 writeAtomic(LI->getContext(), LI->getOrdering(), LI->getSyncScopeID());
4792 if (MaybeAlign A = LI->getAlign())
4793 Out << ", align " << A->value();
4794 } else if (const StoreInst *SI = dyn_cast<StoreInst>(&I)) {
4795 if (SI->isAtomic())
4796 writeAtomic(SI->getContext(), SI->getOrdering(), SI->getSyncScopeID());
4797 if (MaybeAlign A = SI->getAlign())
4798 Out << ", align " << A->value();
4799 } else if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(&I)) {
4800 writeAtomicCmpXchg(CXI->getContext(), CXI->getSuccessOrdering(),
4801 CXI->getFailureOrdering(), CXI->getSyncScopeID());
4802 Out << ", align " << CXI->getAlign().value();
4803 } else if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I)) {
4804 writeAtomic(RMWI->getContext(), RMWI->getOrdering(),
4805 RMWI->getSyncScopeID());
4806 Out << ", align " << RMWI->getAlign().value();
4807 } else if (const FenceInst *FI = dyn_cast<FenceInst>(&I)) {
4808 writeAtomic(FI->getContext(), FI->getOrdering(), FI->getSyncScopeID());
4809 } else if (const ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(&I)) {
4810 PrintShuffleMask(Out, SVI->getType(), SVI->getShuffleMask());
4811 }
4812
4813 // Print Metadata info.
4815 I.getAllMetadata(InstMD);
4816 printMetadataAttachments(InstMD, ", ");
4817
4818 // Print a nice comment.
4819 printInfoComment(I);
4820}
4821
4822void AssemblyWriter::printDbgMarker(const DbgMarker &Marker) {
4823 // There's no formal representation of a DbgMarker -- print purely as a
4824 // debugging aid.
4825 for (const DbgRecord &DPR : Marker.StoredDbgRecords) {
4826 printDbgRecord(DPR);
4827 Out << "\n";
4828 }
4829
4830 Out << " DbgMarker -> { ";
4831 printInstruction(*Marker.MarkedInstr);
4832 Out << " }";
4833}
4834
4835void AssemblyWriter::printDbgRecord(const DbgRecord &DR) {
4836 if (auto *DVR = dyn_cast<DbgVariableRecord>(&DR))
4837 printDbgVariableRecord(*DVR);
4838 else if (auto *DLR = dyn_cast<DbgLabelRecord>(&DR))
4839 printDbgLabelRecord(*DLR);
4840 else
4841 llvm_unreachable("Unexpected DbgRecord kind");
4842}
4843
4844void AssemblyWriter::printDbgVariableRecord(const DbgVariableRecord &DVR) {
4845 auto WriterCtx = getContext();
4846 Out << "#dbg_";
4847 switch (DVR.getType()) {
4848 case DbgVariableRecord::LocationType::Value:
4849 Out << "value";
4850 break;
4851 case DbgVariableRecord::LocationType::Declare:
4852 Out << "declare";
4853 break;
4854 case DbgVariableRecord::LocationType::Assign:
4855 Out << "assign";
4856 break;
4857 default:
4859 "Tried to print a DbgVariableRecord with an invalid LocationType!");
4860 }
4861
4862 auto PrintOrNull = [&](Metadata *M) {
4863 if (!M)
4864 Out << "(null)";
4865 else
4866 WriteAsOperandInternal(Out, M, WriterCtx, true);
4867 };
4868
4869 Out << "(";
4870 PrintOrNull(DVR.getRawLocation());
4871 Out << ", ";
4872 PrintOrNull(DVR.getRawVariable());
4873 Out << ", ";
4874 PrintOrNull(DVR.getRawExpression());
4875 Out << ", ";
4876 if (DVR.isDbgAssign()) {
4877 PrintOrNull(DVR.getRawAssignID());
4878 Out << ", ";
4879 PrintOrNull(DVR.getRawAddress());
4880 Out << ", ";
4881 PrintOrNull(DVR.getRawAddressExpression());
4882 Out << ", ";
4883 }
4884 PrintOrNull(DVR.getDebugLoc().getAsMDNode());
4885 Out << ")";
4886}
4887
4888/// printDbgRecordLine - Print a DbgRecord with indentation and a newline
4889/// character.
4890void AssemblyWriter::printDbgRecordLine(const DbgRecord &DR) {
4891 // Print lengthier indentation to bring out-of-line with instructions.
4892 Out << " ";
4893 printDbgRecord(DR);
4894 Out << '\n';
4895}
4896
4897void AssemblyWriter::printDbgLabelRecord(const DbgLabelRecord &Label) {
4898 auto WriterCtx = getContext();
4899 Out << "#dbg_label(";
4900 WriteAsOperandInternal(Out, Label.getRawLabel(), WriterCtx, true);
4901 Out << ", ";
4902 WriteAsOperandInternal(Out, Label.getDebugLoc(), WriterCtx, true);
4903 Out << ")";
4904}
4905
4906void AssemblyWriter::printMetadataAttachments(
4907 const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
4908 StringRef Separator) {
4909 if (MDs.empty())
4910 return;
4911
4912 if (MDNames.empty())
4913 MDs[0].second->getContext().getMDKindNames(MDNames);
4914
4915 auto WriterCtx = getContext();
4916 for (const auto &I : MDs) {
4917 unsigned Kind = I.first;
4918 Out << Separator;
4919 if (Kind < MDNames.size()) {
4920 Out << "!";
4921 printMetadataIdentifier(MDNames[Kind], Out);
4922 } else
4923 Out << "!<unknown kind #" << Kind << ">";
4924 Out << ' ';
4925 WriteAsOperandInternal(Out, I.second, WriterCtx);
4926 }
4927}
4928
4929void AssemblyWriter::writeMDNode(unsigned Slot, const MDNode *Node) {
4930 Out << '!' << Slot << " = ";
4931 printMDNodeBody(Node);
4932 Out << "\n";
4933}
4934
4935void AssemblyWriter::writeAllMDNodes() {
4937 Nodes.resize(Machine.mdn_size());
4938 for (auto &I : llvm::make_range(Machine.mdn_begin(), Machine.mdn_end()))
4939 Nodes[I.second] = cast<MDNode>(I.first);
4940
4941 for (unsigned i = 0, e = Nodes.size(); i != e; ++i) {
4942 writeMDNode(i, Nodes[i]);
4943 }
4944}
4945
4946void AssemblyWriter::printMDNodeBody(const MDNode *Node) {
4947 auto WriterCtx = getContext();
4948 WriteMDNodeBodyInternal(Out, Node, WriterCtx);
4949}
4950
4951void AssemblyWriter::writeAttribute(const Attribute &Attr, bool InAttrGroup) {
4952 if (!Attr.isTypeAttribute()) {
4953 Out << Attr.getAsString(InAttrGroup);
4954 return;
4955 }
4956
4957 Out << Attribute::getNameFromAttrKind(Attr.getKindAsEnum());
4958 if (Type *Ty = Attr.getValueAsType()) {
4959 Out << '(';
4960 TypePrinter.print(Ty, Out);
4961 Out << ')';
4962 }
4963}
4964
4965void AssemblyWriter::writeAttributeSet(const AttributeSet &AttrSet,
4966 bool InAttrGroup) {
4967 bool FirstAttr = true;
4968 for (const auto &Attr : AttrSet) {
4969 if (!FirstAttr)
4970 Out << ' ';
4971 writeAttribute(Attr, InAttrGroup);
4972 FirstAttr = false;
4973 }
4974}
4975
4976void AssemblyWriter::writeAllAttributeGroups() {
4977 std::vector<std::pair<AttributeSet, unsigned>> asVec;
4978 asVec.resize(Machine.as_size());
4979
4980 for (auto &I : llvm::make_range(Machine.as_begin(), Machine.as_end()))
4981 asVec[I.second] = I;
4982
4983 for (const auto &I : asVec)
4984 Out << "attributes #" << I.second << " = { "
4985 << I.first.getAsString(true) << " }\n";
4986}
4987
4988void AssemblyWriter::printUseListOrder(const Value *V,
4989 const std::vector<unsigned> &Shuffle) {
4990 bool IsInFunction = Machine.getFunction();
4991 if (IsInFunction)
4992 Out << " ";
4993
4994 Out << "uselistorder";
4995 if (const BasicBlock *BB = IsInFunction ? nullptr : dyn_cast<BasicBlock>(V)) {
4996 Out << "_bb ";
4997 writeOperand(BB->getParent(), false);
4998 Out << ", ";
4999 writeOperand(BB, false);
5000 } else {
5001 Out << " ";
5002 writeOperand(V, true);
5003 }
5004
5005 assert(Shuffle.size() >= 2 && "Shuffle too small");
5006 Out << ", { " << llvm::interleaved(Shuffle) << " }\n";
5007}
5008
5009void AssemblyWriter::printUseLists(const Function *F) {
5010 auto It = UseListOrders.find(F);
5011 if (It == UseListOrders.end())
5012 return;
5013
5014 Out << "\n; uselistorder directives\n";
5015 for (const auto &Pair : It->second)
5016 printUseListOrder(Pair.first, Pair.second);
5017}
5018
5019//===----------------------------------------------------------------------===//
5020// External Interface declarations
5021//===----------------------------------------------------------------------===//
5022
5024 bool ShouldPreserveUseListOrder,
5025 bool IsForDebug) const {
5026 SlotTracker SlotTable(this->getParent());
5027 formatted_raw_ostream OS(ROS);
5028 AssemblyWriter W(OS, SlotTable, this->getParent(), AAW,
5029 IsForDebug,
5030 ShouldPreserveUseListOrder);
5031 W.printFunction(this);
5032}
5033
5035 bool ShouldPreserveUseListOrder,
5036 bool IsForDebug) const {
5037 SlotTracker SlotTable(this->getParent());
5038 formatted_raw_ostream OS(ROS);
5039 AssemblyWriter W(OS, SlotTable, this->getModule(), AAW,
5040 IsForDebug,
5041 ShouldPreserveUseListOrder);
5042 W.printBasicBlock(this);
5043}
5044
5046 bool ShouldPreserveUseListOrder, bool IsForDebug) const {
5047 SlotTracker SlotTable(this);
5048 formatted_raw_ostream OS(ROS);
5049 AssemblyWriter W(OS, SlotTable, this, AAW, IsForDebug,
5050 ShouldPreserveUseListOrder);
5051 W.printModule(this);
5052}
5053
5054void NamedMDNode::print(raw_ostream &ROS, bool IsForDebug) const {
5055 SlotTracker SlotTable(getParent());
5056 formatted_raw_ostream OS(ROS);
5057 AssemblyWriter W(OS, SlotTable, getParent(), nullptr, IsForDebug);
5058 W.printNamedMDNode(this);
5059}
5060
5062 bool IsForDebug) const {
5063 std::optional<SlotTracker> LocalST;
5064 SlotTracker *SlotTable;
5065 if (auto *ST = MST.getMachine())
5066 SlotTable = ST;
5067 else {
5068 LocalST.emplace(getParent());
5069 SlotTable = &*LocalST;
5070 }
5071
5072 formatted_raw_ostream OS(ROS);
5073 AssemblyWriter W(OS, *SlotTable, getParent(), nullptr, IsForDebug);
5074 W.printNamedMDNode(this);
5075}
5076
5077void Comdat::print(raw_ostream &ROS, bool /*IsForDebug*/) const {
5079 ROS << " = comdat ";
5080
5081 switch (getSelectionKind()) {
5082 case Comdat::Any:
5083 ROS << "any";
5084 break;
5085 case Comdat::ExactMatch:
5086 ROS << "exactmatch";
5087 break;
5088 case Comdat::Largest:
5089 ROS << "largest";
5090 break;
5092 ROS << "nodeduplicate";
5093 break;
5094 case Comdat::SameSize:
5095 ROS << "samesize";
5096 break;
5097 }
5098
5099 ROS << '\n';
5100}
5101
5102void Type::print(raw_ostream &OS, bool /*IsForDebug*/, bool NoDetails) const {
5103 TypePrinting TP;
5104 TP.print(const_cast<Type*>(this), OS);
5105
5106 if (NoDetails)
5107 return;
5108
5109 // If the type is a named struct type, print the body as well.
5110 if (StructType *STy = dyn_cast<StructType>(const_cast<Type*>(this)))
5111 if (!STy->isLiteral()) {
5112 OS << " = type ";
5113 TP.printStructBody(STy, OS);
5114 }
5115}
5116
5117static bool isReferencingMDNode(const Instruction &I) {
5118 if (const auto *CI = dyn_cast<CallInst>(&I))
5119 if (Function *F = CI->getCalledFunction())
5120 if (F->isIntrinsic())
5121 for (auto &Op : I.operands())
5123 if (isa<MDNode>(V->getMetadata()))
5124 return true;
5125 return false;
5126}
5127
5128void DbgMarker::print(raw_ostream &ROS, bool IsForDebug) const {
5129
5130 ModuleSlotTracker MST(getModuleFromDPI(this), true);
5131 print(ROS, MST, IsForDebug);
5132}
5133
5134void DbgVariableRecord::print(raw_ostream &ROS, bool IsForDebug) const {
5135
5136 ModuleSlotTracker MST(getModuleFromDPI(this), true);
5137 print(ROS, MST, IsForDebug);
5138}
5139
5141 bool IsForDebug) const {
5142 formatted_raw_ostream OS(ROS);
5143 SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));
5144 SlotTracker &SlotTable =
5145 MST.getMachine() ? *MST.getMachine() : EmptySlotTable;
5146 auto incorporateFunction = [&](const Function *F) {
5147 if (F)
5148 MST.incorporateFunction(*F);
5149 };
5150 incorporateFunction(getParent() ? getParent()->getParent() : nullptr);
5151 AssemblyWriter W(OS, SlotTable, getModuleFromDPI(this), nullptr, IsForDebug);
5152 W.printDbgMarker(*this);
5153}
5154
5155void DbgLabelRecord::print(raw_ostream &ROS, bool IsForDebug) const {
5156
5157 ModuleSlotTracker MST(getModuleFromDPI(this), true);
5158 print(ROS, MST, IsForDebug);
5159}
5160
5162 bool IsForDebug) const {
5163 formatted_raw_ostream OS(ROS);
5164 SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));
5165 SlotTracker &SlotTable =
5166 MST.getMachine() ? *MST.getMachine() : EmptySlotTable;
5167 auto incorporateFunction = [&](const Function *F) {
5168 if (F)
5169 MST.incorporateFunction(*F);
5170 };
5171 incorporateFunction(Marker && Marker->getParent()
5172 ? Marker->getParent()->getParent()
5173 : nullptr);
5174 AssemblyWriter W(OS, SlotTable, getModuleFromDPI(this), nullptr, IsForDebug);
5175 W.printDbgVariableRecord(*this);
5176}
5177
5179 bool IsForDebug) const {
5180 formatted_raw_ostream OS(ROS);
5181 SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));
5182 SlotTracker &SlotTable =
5183 MST.getMachine() ? *MST.getMachine() : EmptySlotTable;
5184 auto incorporateFunction = [&](const Function *F) {
5185 if (F)
5186 MST.incorporateFunction(*F);
5187 };
5188 incorporateFunction(Marker->getParent() ? Marker->getParent()->getParent()
5189 : nullptr);
5190 AssemblyWriter W(OS, SlotTable, getModuleFromDPI(this), nullptr, IsForDebug);
5191 W.printDbgLabelRecord(*this);
5192}
5193
5194void Value::print(raw_ostream &ROS, bool IsForDebug) const {
5195 bool ShouldInitializeAllMetadata = false;
5196 if (auto *I = dyn_cast<Instruction>(this))
5197 ShouldInitializeAllMetadata = isReferencingMDNode(*I);
5198 else if (isa<Function>(this) || isa<MetadataAsValue>(this))
5199 ShouldInitializeAllMetadata = true;
5200
5201 ModuleSlotTracker MST(getModuleFromVal(this), ShouldInitializeAllMetadata);
5202 print(ROS, MST, IsForDebug);
5203}
5204
5206 bool IsForDebug) const {
5207 formatted_raw_ostream OS(ROS);
5208 SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));
5209 SlotTracker &SlotTable =
5210 MST.getMachine() ? *MST.getMachine() : EmptySlotTable;
5211 auto incorporateFunction = [&](const Function *F) {
5212 if (F)
5213 MST.incorporateFunction(*F);
5214 };
5215
5216 if (const Instruction *I = dyn_cast<Instruction>(this)) {
5217 incorporateFunction(I->getParent() ? I->getParent()->getParent() : nullptr);
5218 AssemblyWriter W(OS, SlotTable, getModuleFromVal(I), nullptr, IsForDebug);
5219 W.printInstruction(*I);
5220 } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(this)) {
5221 incorporateFunction(BB->getParent());
5222 AssemblyWriter W(OS, SlotTable, getModuleFromVal(BB), nullptr, IsForDebug);
5223 W.printBasicBlock(BB);
5224 } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(this)) {
5225 AssemblyWriter W(OS, SlotTable, GV->getParent(), nullptr, IsForDebug);
5226 if (const GlobalVariable *V = dyn_cast<GlobalVariable>(GV))
5227 W.printGlobal(V);
5228 else if (const Function *F = dyn_cast<Function>(GV))
5229 W.printFunction(F);
5230 else if (const GlobalAlias *A = dyn_cast<GlobalAlias>(GV))
5231 W.printAlias(A);
5232 else if (const GlobalIFunc *I = dyn_cast<GlobalIFunc>(GV))
5233 W.printIFunc(I);
5234 else
5235 llvm_unreachable("Unknown GlobalValue to print out!");
5236 } else if (const MetadataAsValue *V = dyn_cast<MetadataAsValue>(this)) {
5237 V->getMetadata()->print(ROS, MST, getModuleFromVal(V));
5238 } else if (const Constant *C = dyn_cast<Constant>(this)) {
5239 TypePrinting TypePrinter;
5240 TypePrinter.print(C->getType(), OS);
5241 OS << ' ';
5242 AsmWriterContext WriterCtx(&TypePrinter, MST.getMachine());
5243 WriteConstantInternal(OS, C, WriterCtx);
5244 } else if (isa<InlineAsm>(this) || isa<Argument>(this)) {
5245 this->printAsOperand(OS, /* PrintType */ true, MST);
5246 } else {
5247 llvm_unreachable("Unknown value to print out!");
5248 }
5249}
5250
5251/// Print without a type, skipping the TypePrinting object.
5252///
5253/// \return \c true iff printing was successful.
5254static bool printWithoutType(const Value &V, raw_ostream &O,
5255 SlotTracker *Machine, const Module *M) {
5256 if (V.hasName() || isa<GlobalValue>(V) ||
5257 (!isa<Constant>(V) && !isa<MetadataAsValue>(V))) {
5258 AsmWriterContext WriterCtx(nullptr, Machine, M);
5259 WriteAsOperandInternal(O, &V, WriterCtx);
5260 return true;
5261 }
5262 return false;
5263}
5264
5265static void printAsOperandImpl(const Value &V, raw_ostream &O, bool PrintType,
5266 ModuleSlotTracker &MST) {
5267 TypePrinting TypePrinter(MST.getModule());
5268 if (PrintType) {
5269 TypePrinter.print(V.getType(), O);
5270 O << ' ';
5271 }
5272
5273 AsmWriterContext WriterCtx(&TypePrinter, MST.getMachine(), MST.getModule());
5274 WriteAsOperandInternal(O, &V, WriterCtx);
5275}
5276
5277void Value::printAsOperand(raw_ostream &O, bool PrintType,
5278 const Module *M) const {
5279 if (!M)
5280 M = getModuleFromVal(this);
5281
5282 if (!PrintType)
5283 if (printWithoutType(*this, O, nullptr, M))
5284 return;
5285
5287 M, /* ShouldInitializeAllMetadata */ isa<MetadataAsValue>(this));
5288 ModuleSlotTracker MST(Machine, M);
5289 printAsOperandImpl(*this, O, PrintType, MST);
5290}
5291
5292void Value::printAsOperand(raw_ostream &O, bool PrintType,
5293 ModuleSlotTracker &MST) const {
5294 if (!PrintType)
5295 if (printWithoutType(*this, O, MST.getMachine(), MST.getModule()))
5296 return;
5297
5298 printAsOperandImpl(*this, O, PrintType, MST);
5299}
5300
5301/// Recursive version of printMetadataImpl.
5302static void printMetadataImplRec(raw_ostream &ROS, const Metadata &MD,
5303 AsmWriterContext &WriterCtx) {
5304 formatted_raw_ostream OS(ROS);
5305 WriteAsOperandInternal(OS, &MD, WriterCtx, /* FromValue */ true);
5306
5307 auto *N = dyn_cast<MDNode>(&MD);
5308 if (!N || isa<DIExpression>(MD))
5309 return;
5310
5311 OS << " = ";
5312 WriteMDNodeBodyInternal(OS, N, WriterCtx);
5313}
5314
5315namespace {
5316struct MDTreeAsmWriterContext : public AsmWriterContext {
5317 unsigned Level;
5318 // {Level, Printed string}
5319 using EntryTy = std::pair<unsigned, std::string>;
5321
5322 // Used to break the cycle in case there is any.
5323 SmallPtrSet<const Metadata *, 4> Visited;
5324
5325 raw_ostream &MainOS;
5326
5327 MDTreeAsmWriterContext(TypePrinting *TP, SlotTracker *ST, const Module *M,
5328 raw_ostream &OS, const Metadata *InitMD)
5329 : AsmWriterContext(TP, ST, M), Level(0U), Visited({InitMD}), MainOS(OS) {}
5330
5331 void onWriteMetadataAsOperand(const Metadata *MD) override {
5332 if (!Visited.insert(MD).second)
5333 return;
5334
5335 std::string Str;
5336 raw_string_ostream SS(Str);
5337 ++Level;
5338 // A placeholder entry to memorize the correct
5339 // position in buffer.
5340 Buffer.emplace_back(std::make_pair(Level, ""));
5341 unsigned InsertIdx = Buffer.size() - 1;
5342
5343 printMetadataImplRec(SS, *MD, *this);
5344 Buffer[InsertIdx].second = std::move(SS.str());
5345 --Level;
5346 }
5347
5348 ~MDTreeAsmWriterContext() {
5349 for (const auto &Entry : Buffer) {
5350 MainOS << "\n";
5351 unsigned NumIndent = Entry.first * 2U;
5352 MainOS.indent(NumIndent) << Entry.second;
5353 }
5354 }
5355};
5356} // end anonymous namespace
5357
5358static void printMetadataImpl(raw_ostream &ROS, const Metadata &MD,
5359 ModuleSlotTracker &MST, const Module *M,
5360 bool OnlyAsOperand, bool PrintAsTree = false) {
5361 formatted_raw_ostream OS(ROS);
5362
5363 TypePrinting TypePrinter(M);
5364
5365 std::unique_ptr<AsmWriterContext> WriterCtx;
5366 if (PrintAsTree && !OnlyAsOperand)
5367 WriterCtx = std::make_unique<MDTreeAsmWriterContext>(
5368 &TypePrinter, MST.getMachine(), M, OS, &MD);
5369 else
5370 WriterCtx =
5371 std::make_unique<AsmWriterContext>(&TypePrinter, MST.getMachine(), M);
5372
5373 WriteAsOperandInternal(OS, &MD, *WriterCtx, /* FromValue */ true);
5374
5375 auto *N = dyn_cast<MDNode>(&MD);
5376 if (OnlyAsOperand || !N || isa<DIExpression>(MD))
5377 return;
5378
5379 OS << " = ";
5380 WriteMDNodeBodyInternal(OS, N, *WriterCtx);
5381}
5382
5384 ModuleSlotTracker MST(M, isa<MDNode>(this));
5385 printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ true);
5386}
5387
5389 const Module *M) const {
5390 printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ true);
5391}
5392
5394 bool /*IsForDebug*/) const {
5395 ModuleSlotTracker MST(M, isa<MDNode>(this));
5396 printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
5397}
5398
5400 const Module *M, bool /*IsForDebug*/) const {
5401 printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
5402}
5403
5404void MDNode::printTree(raw_ostream &OS, const Module *M) const {
5405 ModuleSlotTracker MST(M, true);
5406 printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false,
5407 /*PrintAsTree=*/true);
5408}
5409
5411 const Module *M) const {
5412 printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false,
5413 /*PrintAsTree=*/true);
5414}
5415
5416void ModuleSummaryIndex::print(raw_ostream &ROS, bool IsForDebug) const {
5417 SlotTracker SlotTable(this);
5418 formatted_raw_ostream OS(ROS);
5419 AssemblyWriter W(OS, SlotTable, this, IsForDebug);
5420 W.printModuleSummaryIndex();
5421}
5422
5424 unsigned UB) const {
5425 SlotTracker *ST = MachineStorage.get();
5426 if (!ST)
5427 return;
5428
5429 for (auto &I : llvm::make_range(ST->mdn_begin(), ST->mdn_end()))
5430 if (I.second >= LB && I.second < UB)
5431 L.push_back(std::make_pair(I.second, I.first));
5432}
5433
5434#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
5435// Value::dump - allow easy printing of Values from the debugger.
5437void Value::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
5438
5439// Value::dump - allow easy printing of Values from the debugger.
5441void DbgMarker::dump() const {
5442 print(dbgs(), /*IsForDebug=*/true);
5443 dbgs() << '\n';
5444}
5445
5446// Value::dump - allow easy printing of Values from the debugger.
5448void DbgRecord::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
5449
5450// Type::dump - allow easy printing of Types from the debugger.
5452void Type::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
5453
5454// Module::dump() - Allow printing of Modules from the debugger.
5456void Module::dump() const {
5457 print(dbgs(), nullptr,
5458 /*ShouldPreserveUseListOrder=*/false, /*IsForDebug=*/true);
5459}
5460
5461// Allow printing of Comdats from the debugger.
5463void Comdat::dump() const { print(dbgs(), /*IsForDebug=*/true); }
5464
5465// NamedMDNode::dump() - Allow printing of NamedMDNodes from the debugger.
5467void NamedMDNode::dump() const { print(dbgs(), /*IsForDebug=*/true); }
5468
5470void Metadata::dump() const { dump(nullptr); }
5471
5473void Metadata::dump(const Module *M) const {
5474 print(dbgs(), M, /*IsForDebug=*/true);
5475 dbgs() << '\n';
5476}
5477
5479void MDNode::dumpTree() const { dumpTree(nullptr); }
5480
5482void MDNode::dumpTree(const Module *M) const {
5483 printTree(dbgs(), M);
5484 dbgs() << '\n';
5485}
5486
5487// Allow printing of ModuleSummaryIndex from the debugger.
5489void ModuleSummaryIndex::dump() const { print(dbgs(), /*IsForDebug=*/true); }
5490#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 PrintCallingConv(unsigned cc, raw_ostream &Out)
static void writeDICompositeType(raw_ostream &Out, const DICompositeType *N, AsmWriterContext &WriterCtx)
static void writeDIFixedPointType(raw_ostream &Out, const DIFixedPointType *N, AsmWriterContext &WriterCtx)
static const char * getWholeProgDevirtResKindName(WholeProgramDevirtResolution::Kind K)
static void writeDISubrangeType(raw_ostream &Out, const DISubrangeType *N, AsmWriterContext &WriterCtx)
static void printMetadataImpl(raw_ostream &ROS, const Metadata &MD, ModuleSlotTracker &MST, const Module *M, bool OnlyAsOperand, bool PrintAsTree=false)
static void WriteOptimizationInfo(raw_ostream &Out, const User *U)
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 PrintThreadLocalModel(GlobalVariable::ThreadLocalMode TLM, formatted_raw_ostream &Out)
static void writeDIBasicType(raw_ostream &Out, const DIBasicType *N, AsmWriterContext &WriterCtx)
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 StringRef getUnnamedAddrEncoding(GlobalVariable::UnnamedAddr UA)
static const char * getWholeProgDevirtResByArgKindName(WholeProgramDevirtResolution::ByArg::Kind K)
static void PrintShuffleMask(raw_ostream &Out, Type *Ty, ArrayRef< int > Mask)
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 bool isReferencingMDNode(const Instruction &I)
#define CC_VLS_CASE(ABI_VLEN)
static void writeDILabel(raw_ostream &Out, const DILabel *N, AsmWriterContext &WriterCtx)
static void WriteMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node, AsmWriterContext &Ctx)
static void writeDIDerivedType(raw_ostream &Out, const DIDerivedType *N, AsmWriterContext &WriterCtx)
static void printMetadataIdentifier(StringRef Name, formatted_raw_ostream &Out)
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 PrintDLLStorageClass(GlobalValue::DLLStorageClassTypes SCT, formatted_raw_ostream &Out)
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 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 WriteAPFloatInternal(raw_ostream &Out, const APFloat &APF)
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 WriteConstantInternal(raw_ostream &Out, const Constant *CV, AsmWriterContext &WriterCtx)
static void WriteAsOperandInternal(raw_ostream &Out, const Value *V, AsmWriterContext &WriterCtx)
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 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 PrintVisibility(GlobalValue::VisibilityTypes Vis, formatted_raw_ostream &Out)
static void writeDILexicalBlockFile(raw_ostream &Out, const DILexicalBlockFile *N, AsmWriterContext &WriterCtx)
static void writeDIEnumerator(raw_ostream &Out, const DIEnumerator *N, AsmWriterContext &)
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 void PrintDSOLocation(const GlobalValue &GV, formatted_raw_ostream &Out)
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 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
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...
The address of a basic block.
Definition Constants.h:899
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
ConstantArray - Constant Array Declarations.
Definition Constants.h:433
An array constant whose element type is a simple 1/2/4/8-byte integer or float/double,...
Definition Constants.h:702
A constant value that is initialized with an expression using other constant values.
Definition Constants.h:1120
ConstantFP - Floating Point Values [float, double].
Definition Constants.h:277
This is the shared class of boolean and integer constants.
Definition Constants.h:87
A signed pointer, in the ptrauth sense.
Definition Constants.h:1032
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
Utility class for floating point operations which can have information about relaxed accuracy require...
Definition Operator.h:200
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.
A single uniqued string.
Definition Metadata.h:721
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
Metadata wrapper in the Value hierarchy.
Definition Metadata.h:183
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
Utility class for integer operators which may exhibit overflow - Add, Sub, Mul, and Shl.
Definition Operator.h:78
unsigned getAddressSpace() const
Return the address space of the Pointer type.
An or instruction, which can be marked as "disjoint", indicating that the inputs don't have a 1 in th...
Definition InstrTypes.h:404
A udiv, sdiv, lshr, or ashr instruction, which can be marked as "exact", indicating that no bits are ...
Definition Operator.h:154
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
Class to represent struct types.
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)
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:188
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:201
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
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