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