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