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