Bug Summary

File:llvm/lib/IR/AsmWriter.cpp
Warning:line 1944, column 33
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name AsmWriter.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/IR -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/IR -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/IR -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include -D NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/IR -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-09-04-040900-46481-1 -x c++ /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/IR/AsmWriter.cpp

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/IR/AsmWriter.cpp

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

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include/llvm/IR/Metadata.def

1//===- llvm/IR/Metadata.def - Metadata definitions --------------*- C++ -*-===//
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// Macros for running through all types of metadata.
10//
11//===----------------------------------------------------------------------===//
12
13#if !(defined HANDLE_METADATA || defined HANDLE_METADATA_LEAF || \
14 defined HANDLE_METADATA_BRANCH || defined HANDLE_MDNODE_LEAF || \
15 defined HANDLE_MDNODE_LEAF_UNIQUABLE || defined HANDLE_MDNODE_BRANCH || \
16 defined HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE || \
17 defined HANDLE_SPECIALIZED_MDNODE_LEAF || \
18 defined HANDLE_SPECIALIZED_MDNODE_BRANCH)
19#error "Missing macro definition of HANDLE_METADATA*"
20#endif
21
22// Handler for all types of metadata.
23#ifndef HANDLE_METADATA
24#define HANDLE_METADATA(CLASS)
25#endif
26
27// Handler for leaf nodes in the class hierarchy.
28#ifndef HANDLE_METADATA_LEAF
29#define HANDLE_METADATA_LEAF(CLASS) HANDLE_METADATA(CLASS)
30#endif
31
32// Handler for non-leaf nodes in the class hierarchy.
33#ifndef HANDLE_METADATA_BRANCH
34#define HANDLE_METADATA_BRANCH(CLASS) HANDLE_METADATA(CLASS)
35#endif
36
37// Handler for specialized and uniquable leaf nodes under MDNode. Defers to
38// HANDLE_MDNODE_LEAF_UNIQUABLE if it's defined, otherwise to
39// HANDLE_SPECIALIZED_MDNODE_LEAF.
40#ifndef HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE
41#ifdef HANDLE_MDNODE_LEAF_UNIQUABLE
42#define HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(CLASS) \
43 HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)
44#else
45#define HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(CLASS) \
46 HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS)
47#endif
48#endif
49
50// Handler for leaf nodes under MDNode.
51#ifndef HANDLE_MDNODE_LEAF_UNIQUABLE
52#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) HANDLE_MDNODE_LEAF(CLASS)
53#endif
54
55// Handler for leaf nodes under MDNode.
56#ifndef HANDLE_MDNODE_LEAF
57#define HANDLE_MDNODE_LEAF(CLASS) HANDLE_METADATA_LEAF(CLASS)
58#endif
59
60// Handler for non-leaf nodes under MDNode.
61#ifndef HANDLE_MDNODE_BRANCH
62#define HANDLE_MDNODE_BRANCH(CLASS) HANDLE_METADATA_BRANCH(CLASS)
63#endif
64
65// Handler for specialized leaf nodes under MDNode.
66#ifndef HANDLE_SPECIALIZED_MDNODE_LEAF
67#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) HANDLE_MDNODE_LEAF(CLASS)
68#endif
69
70// Handler for specialized non-leaf nodes under MDNode.
71#ifndef HANDLE_SPECIALIZED_MDNODE_BRANCH
72#define HANDLE_SPECIALIZED_MDNODE_BRANCH(CLASS) HANDLE_MDNODE_BRANCH(CLASS)
73#endif
74
75HANDLE_METADATA_LEAF(MDString)
76HANDLE_METADATA_BRANCH(ValueAsMetadata)
77HANDLE_METADATA_LEAF(ConstantAsMetadata)
78HANDLE_METADATA_LEAF(LocalAsMetadata)
79HANDLE_METADATA_LEAF(DistinctMDOperandPlaceholder)
80HANDLE_MDNODE_BRANCH(MDNode)
81HANDLE_MDNODE_LEAF_UNIQUABLE(MDTuple)
82HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILocation)
83HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIExpression)
84HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIGlobalVariableExpression)
85HANDLE_SPECIALIZED_MDNODE_BRANCH(DINode)
86HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(GenericDINode)
87HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DISubrange)
88HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIEnumerator)
89HANDLE_SPECIALIZED_MDNODE_BRANCH(DIScope)
90HANDLE_SPECIALIZED_MDNODE_BRANCH(DIType)
91HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIBasicType)
92HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIDerivedType)
93HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DICompositeType)
94HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DISubroutineType)
95HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIFile)
96HANDLE_SPECIALIZED_MDNODE_LEAF(DICompileUnit)
97HANDLE_SPECIALIZED_MDNODE_BRANCH(DILocalScope)
98HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DISubprogram)
99HANDLE_SPECIALIZED_MDNODE_BRANCH(DILexicalBlockBase)
100HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILexicalBlock)
101HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILexicalBlockFile)
102HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DINamespace)
103HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIModule)
104HANDLE_SPECIALIZED_MDNODE_BRANCH(DITemplateParameter)
105HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DITemplateTypeParameter)
106HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DITemplateValueParameter)
107HANDLE_SPECIALIZED_MDNODE_BRANCH(DIVariable)
108HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIGlobalVariable)
109HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILocalVariable)
110HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILabel)
111HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIObjCProperty)
112HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIImportedEntity)
113HANDLE_SPECIALIZED_MDNODE_BRANCH(DIMacroNode)
114HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIMacro)
115HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIMacroFile)
116HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DICommonBlock)
117HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIArgList)
118HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIStringType)
119HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIGenericSubrange)
26
'Node' is a 'DIGenericSubrange'
27
Calling 'writeDIGenericSubrange'
120
121#undef HANDLE_METADATA
122#undef HANDLE_METADATA_LEAF
123#undef HANDLE_METADATA_BRANCH
124#undef HANDLE_MDNODE_LEAF
125#undef HANDLE_MDNODE_LEAF_UNIQUABLE
126#undef HANDLE_MDNODE_BRANCH
127#undef HANDLE_SPECIALIZED_MDNODE_LEAF
128#undef HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE
129#undef HANDLE_SPECIALIZED_MDNODE_BRANCH