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