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