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