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 writeDIMacro(raw_ostream &Out, const DIMacro *N,
2005  TypePrinting *TypePrinter, SlotTracker *Machine,
2006  const Module *Context) {
2007  Out << "!DIMacro(";
2008  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2009  Printer.printMacinfoType(N);
2010  Printer.printInt("line", N->getLine());
2011  Printer.printString("name", N->getName());
2012  Printer.printString("value", N->getValue());
2013  Out << ")";
2014 }
2015 
2016 static void writeDIMacroFile(raw_ostream &Out, const DIMacroFile *N,
2017  TypePrinting *TypePrinter, SlotTracker *Machine,
2018  const Module *Context) {
2019  Out << "!DIMacroFile(";
2020  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2021  Printer.printInt("line", N->getLine());
2022  Printer.printMetadata("file", N->getRawFile(), /* ShouldSkipNull */ false);
2023  Printer.printMetadata("nodes", N->getRawElements());
2024  Out << ")";
2025 }
2026 
2027 static void writeDIModule(raw_ostream &Out, const DIModule *N,
2028  TypePrinting *TypePrinter, SlotTracker *Machine,
2029  const Module *Context) {
2030  Out << "!DIModule(";
2031  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2032  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2033  Printer.printString("name", N->getName());
2034  Printer.printString("configMacros", N->getConfigurationMacros());
2035  Printer.printString("includePath", N->getIncludePath());
2036  Printer.printString("isysroot", N->getISysRoot());
2037  Out << ")";
2038 }
2039 
2040 
2041 static void writeDITemplateTypeParameter(raw_ostream &Out,
2042  const DITemplateTypeParameter *N,
2043  TypePrinting *TypePrinter,
2044  SlotTracker *Machine,
2045  const Module *Context) {
2046  Out << "!DITemplateTypeParameter(";
2047  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2048  Printer.printString("name", N->getName());
2049  Printer.printMetadata("type", N->getRawType(), /* ShouldSkipNull */ false);
2050  Out << ")";
2051 }
2052 
2053 static void writeDITemplateValueParameter(raw_ostream &Out,
2054  const DITemplateValueParameter *N,
2055  TypePrinting *TypePrinter,
2056  SlotTracker *Machine,
2057  const Module *Context) {
2058  Out << "!DITemplateValueParameter(";
2059  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2060  if (N->getTag() != dwarf::DW_TAG_template_value_parameter)
2061  Printer.printTag(N);
2062  Printer.printString("name", N->getName());
2063  Printer.printMetadata("type", N->getRawType());
2064  Printer.printMetadata("value", N->getValue(), /* ShouldSkipNull */ false);
2065  Out << ")";
2066 }
2067 
2068 static void writeDIGlobalVariable(raw_ostream &Out, const DIGlobalVariable *N,
2069  TypePrinting *TypePrinter,
2070  SlotTracker *Machine, const Module *Context) {
2071  Out << "!DIGlobalVariable(";
2072  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2073  Printer.printString("name", N->getName());
2074  Printer.printString("linkageName", N->getLinkageName());
2075  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2076  Printer.printMetadata("file", N->getRawFile());
2077  Printer.printInt("line", N->getLine());
2078  Printer.printMetadata("type", N->getRawType());
2079  Printer.printBool("isLocal", N->isLocalToUnit());
2080  Printer.printBool("isDefinition", N->isDefinition());
2081  Printer.printMetadata("declaration", N->getRawStaticDataMemberDeclaration());
2082  Printer.printMetadata("templateParams", N->getRawTemplateParams());
2083  Printer.printInt("align", N->getAlignInBits());
2084  Out << ")";
2085 }
2086 
2087 static void writeDILocalVariable(raw_ostream &Out, const DILocalVariable *N,
2088  TypePrinting *TypePrinter,
2089  SlotTracker *Machine, const Module *Context) {
2090  Out << "!DILocalVariable(";
2091  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2092  Printer.printString("name", N->getName());
2093  Printer.printInt("arg", N->getArg());
2094  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2095  Printer.printMetadata("file", N->getRawFile());
2096  Printer.printInt("line", N->getLine());
2097  Printer.printMetadata("type", N->getRawType());
2098  Printer.printDIFlags("flags", N->getFlags());
2099  Printer.printInt("align", N->getAlignInBits());
2100  Out << ")";
2101 }
2102 
2103 static void writeDILabel(raw_ostream &Out, const DILabel *N,
2104  TypePrinting *TypePrinter,
2105  SlotTracker *Machine, const Module *Context) {
2106  Out << "!DILabel(";
2107  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2108  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2109  Printer.printString("name", N->getName());
2110  Printer.printMetadata("file", N->getRawFile());
2111  Printer.printInt("line", N->getLine());
2112  Out << ")";
2113 }
2114 
2115 static void writeDIExpression(raw_ostream &Out, const DIExpression *N,
2116  TypePrinting *TypePrinter, SlotTracker *Machine,
2117  const Module *Context) {
2118  Out << "!DIExpression(";
2119  FieldSeparator FS;
2120  if (N->isValid()) {
2121  for (auto I = N->expr_op_begin(), E = N->expr_op_end(); I != E; ++I) {
2122  auto OpStr = dwarf::OperationEncodingString(I->getOp());
2123  assert(!OpStr.empty() && "Expected valid opcode");
2124 
2125  Out << FS << OpStr;
2126  if (I->getOp() == dwarf::DW_OP_LLVM_convert) {
2127  Out << FS << I->getArg(0);
2128  Out << FS << dwarf::AttributeEncodingString(I->getArg(1));
2129  } else {
2130  for (unsigned A = 0, AE = I->getNumArgs(); A != AE; ++A)
2131  Out << FS << I->getArg(A);
2132  }
2133  }
2134  } else {
2135  for (const auto &I : N->getElements())
2136  Out << FS << I;
2137  }
2138  Out << ")";
2139 }
2140 
2141 static void writeDIGlobalVariableExpression(raw_ostream &Out,
2142  const DIGlobalVariableExpression *N,
2143  TypePrinting *TypePrinter,
2144  SlotTracker *Machine,
2145  const Module *Context) {
2146  Out << "!DIGlobalVariableExpression(";
2147  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2148  Printer.printMetadata("var", N->getVariable());
2149  Printer.printMetadata("expr", N->getExpression());
2150  Out << ")";
2151 }
2152 
2153 static void writeDIObjCProperty(raw_ostream &Out, const DIObjCProperty *N,
2154  TypePrinting *TypePrinter, SlotTracker *Machine,
2155  const Module *Context) {
2156  Out << "!DIObjCProperty(";
2157  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2158  Printer.printString("name", N->getName());
2159  Printer.printMetadata("file", N->getRawFile());
2160  Printer.printInt("line", N->getLine());
2161  Printer.printString("setter", N->getSetterName());
2162  Printer.printString("getter", N->getGetterName());
2163  Printer.printInt("attributes", N->getAttributes());
2164  Printer.printMetadata("type", N->getRawType());
2165  Out << ")";
2166 }
2167 
2168 static void writeDIImportedEntity(raw_ostream &Out, const DIImportedEntity *N,
2169  TypePrinting *TypePrinter,
2170  SlotTracker *Machine, const Module *Context) {
2171  Out << "!DIImportedEntity(";
2172  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
2173  Printer.printTag(N);
2174  Printer.printString("name", N->getName());
2175  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
2176  Printer.printMetadata("entity", N->getRawEntity());
2177  Printer.printMetadata("file", N->getRawFile());
2178  Printer.printInt("line", N->getLine());
2179  Out << ")";
2180 }
2181 
2182 static void WriteMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node,
2183  TypePrinting *TypePrinter,
2184  SlotTracker *Machine,
2185  const Module *Context) {
2186  if (Node->isDistinct())
2187  Out << "distinct ";
2188  else if (Node->isTemporary())
2189  Out << "<temporary!> "; // Handle broken code.
2190 
2191  switch (Node->getMetadataID()) {
2192  default:
2193  llvm_unreachable("Expected uniquable MDNode");
2194 #define HANDLE_MDNODE_LEAF(CLASS) \
2195  case Metadata::CLASS##Kind: \
2196  write##CLASS(Out, cast<CLASS>(Node), TypePrinter, Machine, Context); \
2197  break;
2198 #include "llvm/IR/Metadata.def"
2199  }
2200 }
2201 
2202 // Full implementation of printing a Value as an operand with support for
2203 // TypePrinting, etc.
2204 static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
2205  TypePrinting *TypePrinter,
2206  SlotTracker *Machine,
2207  const Module *Context) {
2208  if (V->hasName()) {
2209  PrintLLVMName(Out, V);
2210  return;
2211  }
2212 
2213  const Constant *CV = dyn_cast<Constant>(V);
2214  if (CV && !isa<GlobalValue>(CV)) {
2215  assert(TypePrinter && "Constants require TypePrinting!");
2216  WriteConstantInternal(Out, CV, *TypePrinter, Machine, Context);
2217  return;
2218  }
2219 
2220  if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
2221  Out << "asm ";
2222  if (IA->hasSideEffects())
2223  Out << "sideeffect ";
2224  if (IA->isAlignStack())
2225  Out << "alignstack ";
2226  // We don't emit the AD_ATT dialect as it's the assumed default.
2227  if (IA->getDialect() == InlineAsm::AD_Intel)
2228  Out << "inteldialect ";
2229  Out << '"';
2230  printEscapedString(IA->getAsmString(), Out);
2231  Out << "\", \"";
2232  printEscapedString(IA->getConstraintString(), Out);
2233  Out << '"';
2234  return;
2235  }
2236 
2237  if (auto *MD = dyn_cast<MetadataAsValue>(V)) {
2238  WriteAsOperandInternal(Out, MD->getMetadata(), TypePrinter, Machine,
2239  Context, /* FromValue */ true);
2240  return;
2241  }
2242 
2243  char Prefix = '%';
2244  int Slot;
2245  // If we have a SlotTracker, use it.
2246  if (Machine) {
2247  if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
2248  Slot = Machine->getGlobalSlot(GV);
2249  Prefix = '@';
2250  } else {
2251  Slot = Machine->getLocalSlot(V);
2252 
2253  // If the local value didn't succeed, then we may be referring to a value
2254  // from a different function. Translate it, as this can happen when using
2255  // address of blocks.
2256  if (Slot == -1)
2257  if ((Machine = createSlotTracker(V))) {
2258  Slot = Machine->getLocalSlot(V);
2259  delete Machine;
2260  }
2261  }
2262  } else if ((Machine = createSlotTracker(V))) {
2263  // Otherwise, create one to get the # and then destroy it.
2264  if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
2265  Slot = Machine->getGlobalSlot(GV);
2266  Prefix = '@';
2267  } else {
2268  Slot = Machine->getLocalSlot(V);
2269  }
2270  delete Machine;
2271  Machine = nullptr;
2272  } else {
2273  Slot = -1;
2274  }
2275 
2276  if (Slot != -1)
2277  Out << Prefix << Slot;
2278  else
2279  Out << "<badref>";
2280 }
2281 
2282 static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
2283  TypePrinting *TypePrinter,
2284  SlotTracker *Machine, const Module *Context,
2285  bool FromValue) {
2286  // Write DIExpressions inline when used as a value. Improves readability of
2287  // debug info intrinsics.
2288  if (const DIExpression *Expr = dyn_cast<DIExpression>(MD)) {
2289  writeDIExpression(Out, Expr, TypePrinter, Machine, Context);
2290  return;
2291  }
2292 
2293  if (const MDNode *N = dyn_cast<MDNode>(MD)) {
2294  std::unique_ptr<SlotTracker> MachineStorage;
2295  if (!Machine) {
2296  MachineStorage = make_unique<SlotTracker>(Context);
2297  Machine = MachineStorage.get();
2298  }
2299  int Slot = Machine->getMetadataSlot(N);
2300  if (Slot == -1) {
2301  if (const DILocation *Loc = dyn_cast<DILocation>(N)) {
2302  writeDILocation(Out, Loc, TypePrinter, Machine, Context);
2303  return;
2304  }
2305  // Give the pointer value instead of "badref", since this comes up all
2306  // the time when debugging.
2307  Out << "<" << N << ">";
2308  } else
2309  Out << '!' << Slot;
2310  return;
2311  }
2312 
2313  if (const MDString *MDS = dyn_cast<MDString>(MD)) {
2314  Out << "!\"";
2315  printEscapedString(MDS->getString(), Out);
2316  Out << '"';
2317  return;
2318  }
2319 
2320  auto *V = cast<ValueAsMetadata>(MD);
2321  assert(TypePrinter && "TypePrinter required for metadata values");
2322  assert((FromValue || !isa<LocalAsMetadata>(V)) &&
2323  "Unexpected function-local metadata outside of value argument");
2324 
2325  TypePrinter->print(V->getValue()->getType(), Out);
2326  Out << ' ';
2327  WriteAsOperandInternal(Out, V->getValue(), TypePrinter, Machine, Context);
2328 }
2329 
2330 namespace {
2331 
2332 class AssemblyWriter {
2333  formatted_raw_ostream &Out;
2334  const Module *TheModule = nullptr;
2335  const ModuleSummaryIndex *TheIndex = nullptr;
2336  std::unique_ptr<SlotTracker> SlotTrackerStorage;
2338  TypePrinting TypePrinter;
2339  AssemblyAnnotationWriter *AnnotationWriter = nullptr;
2340  SetVector<const Comdat *> Comdats;
2341  bool IsForDebug;
2342  bool ShouldPreserveUseListOrder;
2343  UseListOrderStack UseListOrders;
2344  SmallVector<StringRef, 8> MDNames;
2345  /// Synchronization scope names registered with LLVMContext.
2348 
2349 public:
2350  /// Construct an AssemblyWriter with an external SlotTracker
2351  AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac, const Module *M,
2352  AssemblyAnnotationWriter *AAW, bool IsForDebug,
2353  bool ShouldPreserveUseListOrder = false);
2354 
2355  AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
2356  const ModuleSummaryIndex *Index, bool IsForDebug);
2357 
2358  void printMDNodeBody(const MDNode *MD);
2359  void printNamedMDNode(const NamedMDNode *NMD);
2360 
2361  void printModule(const Module *M);
2362 
2363  void writeOperand(const Value *Op, bool PrintType);
2364  void writeParamOperand(const Value *Operand, AttributeSet Attrs);
2365  void writeOperandBundles(const CallBase *Call);
2366  void writeSyncScope(const LLVMContext &Context,
2367  SyncScope::ID SSID);
2368  void writeAtomic(const LLVMContext &Context,
2369  AtomicOrdering Ordering,
2370  SyncScope::ID SSID);
2371  void writeAtomicCmpXchg(const LLVMContext &Context,
2372  AtomicOrdering SuccessOrdering,
2373  AtomicOrdering FailureOrdering,
2374  SyncScope::ID SSID);
2375 
2376  void writeAllMDNodes();
2377  void writeMDNode(unsigned Slot, const MDNode *Node);
2378  void writeAllAttributeGroups();
2379 
2380  void printTypeIdentities();
2381  void printGlobal(const GlobalVariable *GV);
2382  void printIndirectSymbol(const GlobalIndirectSymbol *GIS);
2383  void printComdat(const Comdat *C);
2384  void printFunction(const Function *F);
2385  void printArgument(const Argument *FA, AttributeSet Attrs);
2386  void printBasicBlock(const BasicBlock *BB);
2387  void printInstructionLine(const Instruction &I);
2388  void printInstruction(const Instruction &I);
2389 
2390  void printUseListOrder(const UseListOrder &Order);
2391  void printUseLists(const Function *F);
2392 
2393  void printModuleSummaryIndex();
2394  void printSummaryInfo(unsigned Slot, const ValueInfo &VI);
2395  void printSummary(const GlobalValueSummary &Summary);
2396  void printAliasSummary(const AliasSummary *AS);
2397  void printGlobalVarSummary(const GlobalVarSummary *GS);
2398  void printFunctionSummary(const FunctionSummary *FS);
2399  void printTypeIdSummary(const TypeIdSummary &TIS);
2400  void printTypeTestResolution(const TypeTestResolution &TTRes);
2401  void printArgs(const std::vector<uint64_t> &Args);
2402  void printWPDRes(const WholeProgramDevirtResolution &WPDRes);
2403  void printTypeIdInfo(const FunctionSummary::TypeIdInfo &TIDInfo);
2404  void printVFuncId(const FunctionSummary::VFuncId VFId);
2405  void
2406  printNonConstVCalls(const std::vector<FunctionSummary::VFuncId> VCallList,
2407  const char *Tag);
2408  void
2409  printConstVCalls(const std::vector<FunctionSummary::ConstVCall> VCallList,
2410  const char *Tag);
2411 
2412 private:
2413  /// Print out metadata attachments.
2414  void printMetadataAttachments(
2415  const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
2416  StringRef Separator);
2417 
2418  // printInfoComment - Print a little comment after the instruction indicating
2419  // which slot it occupies.
2420  void printInfoComment(const Value &V);
2421 
2422  // printGCRelocateComment - print comment after call to the gc.relocate
2423  // intrinsic indicating base and derived pointer names.
2424  void printGCRelocateComment(const GCRelocateInst &Relocate);
2425 };
2426 
2427 } // end anonymous namespace
2428 
2429 AssemblyWriter::AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
2430  const Module *M, AssemblyAnnotationWriter *AAW,
2431  bool IsForDebug, bool ShouldPreserveUseListOrder)
2432  : Out(o), TheModule(M), Machine(Mac), TypePrinter(M), AnnotationWriter(AAW),
2433  IsForDebug(IsForDebug),
2434  ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {
2435  if (!TheModule)
2436  return;
2437  for (const GlobalObject &GO : TheModule->global_objects())
2438  if (const Comdat *C = GO.getComdat())
2439  Comdats.insert(C);
2440 }
2441 
2442 AssemblyWriter::AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
2443  const ModuleSummaryIndex *Index, bool IsForDebug)
2444  : Out(o), TheIndex(Index), Machine(Mac), TypePrinter(/*Module=*/nullptr),
2445  IsForDebug(IsForDebug), ShouldPreserveUseListOrder(false) {}
2446 
2447 void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) {
2448  if (!Operand) {
2449  Out << "<null operand!>";
2450  return;
2451  }
2452  if (PrintType) {
2453  TypePrinter.print(Operand->getType(), Out);
2454  Out << ' ';
2455  }
2456  WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule);
2457 }
2458 
2459 void AssemblyWriter::writeSyncScope(const LLVMContext &Context,
2460  SyncScope::ID SSID) {
2461  switch (SSID) {
2462  case SyncScope::System: {
2463  break;
2464  }
2465  default: {
2466  if (SSNs.empty())
2467  Context.getSyncScopeNames(SSNs);
2468 
2469  Out << " syncscope(\"";
2470  printEscapedString(SSNs[SSID], Out);
2471  Out << "\")";
2472  break;
2473  }
2474  }
2475 }
2476 
2477 void AssemblyWriter::writeAtomic(const LLVMContext &Context,
2478  AtomicOrdering Ordering,
2479  SyncScope::ID SSID) {
2480  if (Ordering == AtomicOrdering::NotAtomic)
2481  return;
2482 
2483  writeSyncScope(Context, SSID);
2484  Out << " " << toIRString(Ordering);
2485 }
2486 
2487 void AssemblyWriter::writeAtomicCmpXchg(const LLVMContext &Context,
2488  AtomicOrdering SuccessOrdering,
2489  AtomicOrdering FailureOrdering,
2490  SyncScope::ID SSID) {
2491  assert(SuccessOrdering != AtomicOrdering::NotAtomic &&
2492  FailureOrdering != AtomicOrdering::NotAtomic);
2493 
2494  writeSyncScope(Context, SSID);
2495  Out << " " << toIRString(SuccessOrdering);
2496  Out << " " << toIRString(FailureOrdering);
2497 }
2498 
2499 void AssemblyWriter::writeParamOperand(const Value *Operand,
2500  AttributeSet Attrs) {
2501  if (!Operand) {
2502  Out << "<null operand!>";
2503  return;
2504  }
2505 
2506  // Print the type
2507  TypePrinter.print(Operand->getType(), Out);
2508  // Print parameter attributes list
2509  if (Attrs.hasAttributes())
2510  Out << ' ' << Attrs.getAsString();
2511  Out << ' ';
2512  // Print the operand
2513  WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule);
2514 }
2515 
2516 void AssemblyWriter::writeOperandBundles(const CallBase *Call) {
2517  if (!Call->hasOperandBundles())
2518  return;
2519 
2520  Out << " [ ";
2521 
2522  bool FirstBundle = true;
2523  for (unsigned i = 0, e = Call->getNumOperandBundles(); i != e; ++i) {
2524  OperandBundleUse BU = Call->getOperandBundleAt(i);
2525 
2526  if (!FirstBundle)
2527  Out << ", ";
2528  FirstBundle = false;
2529 
2530  Out << '"';
2531  printEscapedString(BU.getTagName(), Out);
2532  Out << '"';
2533 
2534  Out << '(';
2535 
2536  bool FirstInput = true;
2537  for (const auto &Input : BU.Inputs) {
2538  if (!FirstInput)
2539  Out << ", ";
2540  FirstInput = false;
2541 
2542  TypePrinter.print(Input->getType(), Out);
2543  Out << " ";
2544  WriteAsOperandInternal(Out, Input, &TypePrinter, &Machine, TheModule);
2545  }
2546 
2547  Out << ')';
2548  }
2549 
2550  Out << " ]";
2551 }
2552 
2553 void AssemblyWriter::printModule(const Module *M) {
2554  Machine.initializeIfNeeded();
2555 
2556  if (ShouldPreserveUseListOrder)
2557  UseListOrders = predictUseListOrder(M);
2558 
2559  if (!M->getModuleIdentifier().empty() &&
2560  // Don't print the ID if it will start a new line (which would
2561  // require a comment char before it).
2562  M->getModuleIdentifier().find('\n') == std::string::npos)
2563  Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n";
2564 
2565  if (!M->getSourceFileName().empty()) {
2566  Out << "source_filename = \"";
2568  Out << "\"\n";
2569  }
2570 
2571  const std::string &DL = M->getDataLayoutStr();
2572  if (!DL.empty())
2573  Out << "target datalayout = \"" << DL << "\"\n";
2574  if (!M->getTargetTriple().empty())
2575  Out << "target triple = \"" << M->getTargetTriple() << "\"\n";
2576 
2577  if (!M->getModuleInlineAsm().empty()) {
2578  Out << '\n';
2579 
2580  // Split the string into lines, to make it easier to read the .ll file.
2582  do {
2583  StringRef Front;
2584  std::tie(Front, Asm) = Asm.split('\n');
2585 
2586  // We found a newline, print the portion of the asm string from the
2587  // last newline up to this newline.
2588  Out << "module asm \"";
2589  printEscapedString(Front, Out);
2590  Out << "\"\n";
2591  } while (!Asm.empty());
2592  }
2593 
2594  printTypeIdentities();
2595 
2596  // Output all comdats.
2597  if (!Comdats.empty())
2598  Out << '\n';
2599  for (const Comdat *C : Comdats) {
2600  printComdat(C);
2601  if (C != Comdats.back())
2602  Out << '\n';
2603  }
2604 
2605  // Output all globals.
2606  if (!M->global_empty()) Out << '\n';
2607  for (const GlobalVariable &GV : M->globals()) {
2608  printGlobal(&GV); Out << '\n';
2609  }
2610 
2611  // Output all aliases.
2612  if (!M->alias_empty()) Out << "\n";
2613  for (const GlobalAlias &GA : M->aliases())
2614  printIndirectSymbol(&GA);
2615 
2616  // Output all ifuncs.
2617  if (!M->ifunc_empty()) Out << "\n";
2618  for (const GlobalIFunc &GI : M->ifuncs())
2619  printIndirectSymbol(&GI);
2620 
2621  // Output global use-lists.
2622  printUseLists(nullptr);
2623 
2624  // Output all of the functions.
2625  for (const Function &F : *M)
2626  printFunction(&F);
2627  assert(UseListOrders.empty() && "All use-lists should have been consumed");
2628 
2629  // Output all attribute groups.
2630  if (!Machine.as_empty()) {
2631  Out << '\n';
2632  writeAllAttributeGroups();
2633  }
2634 
2635  // Output named metadata.
2636  if (!M->named_metadata_empty()) Out << '\n';
2637 
2638  for (const NamedMDNode &Node : M->named_metadata())
2639  printNamedMDNode(&Node);
2640 
2641  // Output metadata.
2642  if (!Machine.mdn_empty()) {
2643  Out << '\n';
2644  writeAllMDNodes();
2645  }
2646 }
2647 
2648 void AssemblyWriter::printModuleSummaryIndex() {
2649  assert(TheIndex);
2650  Machine.initializeIndexIfNeeded();
2651 
2652  Out << "\n";
2653 
2654  // Print module path entries. To print in order, add paths to a vector
2655  // indexed by module slot.
2656  std::vector<std::pair<std::string, ModuleHash>> moduleVec;
2657  std::string RegularLTOModuleName = "[Regular LTO]";
2658  moduleVec.resize(TheIndex->modulePaths().size());
2659  for (auto &ModPath : TheIndex->modulePaths())
2660  moduleVec[Machine.getModulePathSlot(ModPath.first())] = std::make_pair(
2661  // A module id of -1 is a special entry for a regular LTO module created
2662  // during the thin link.
2663  ModPath.second.first == -1u ? RegularLTOModuleName
2664  : (std::string)ModPath.first(),
2665  ModPath.second.second);
2666 
2667  unsigned i = 0;
2668  for (auto &ModPair : moduleVec) {
2669  Out << "^" << i++ << " = module: (";
2670  Out << "path: \"";
2671  printEscapedString(ModPair.first, Out);
2672  Out << "\", hash: (";
2673  FieldSeparator FS;
2674  for (auto Hash : ModPair.second)
2675  Out << FS << Hash;
2676  Out << "))\n";
2677  }
2678 
2679  // FIXME: Change AliasSummary to hold a ValueInfo instead of summary pointer
2680  // for aliasee (then update BitcodeWriter.cpp and remove get/setAliaseeGUID).
2681  for (auto &GlobalList : *TheIndex) {
2682  auto GUID = GlobalList.first;
2683  for (auto &Summary : GlobalList.second.SummaryList)
2684  SummaryToGUIDMap[Summary.get()] = GUID;
2685  }
2686 
2687  // Print the global value summary entries.
2688  for (auto &GlobalList : *TheIndex) {
2689  auto GUID = GlobalList.first;
2690  auto VI = TheIndex->getValueInfo(GlobalList);
2691  printSummaryInfo(Machine.getGUIDSlot(GUID), VI);
2692  }
2693 
2694  // Print the TypeIdMap entries.
2695  for (auto TidIter = TheIndex->typeIds().begin();
2696  TidIter != TheIndex->typeIds().end(); TidIter++) {
2697  Out << "^" << Machine.getTypeIdSlot(TidIter->second.first)
2698  << " = typeid: (name: \"" << TidIter->second.first << "\"";
2699  printTypeIdSummary(TidIter->second.second);
2700  Out << ") ; guid = " << TidIter->first << "\n";
2701  }
2702 }
2703 
2704 static const char *
2706  switch (K) {
2708  return "indir";
2710  return "singleImpl";
2712  return "branchFunnel";
2713  }
2714  llvm_unreachable("invalid WholeProgramDevirtResolution kind");
2715 }
2716 
2719  switch (K) {
2721  return "indir";
2723  return "uniformRetVal";
2725  return "uniqueRetVal";
2727  return "virtualConstProp";
2728  }
2729  llvm_unreachable("invalid WholeProgramDevirtResolution::ByArg kind");
2730 }
2731 
2733  switch (K) {
2735  return "unsat";
2737  return "byteArray";
2739  return "inline";
2741  return "single";
2743  return "allOnes";
2744  }
2745  llvm_unreachable("invalid TypeTestResolution kind");
2746 }
2747 
2748 void AssemblyWriter::printTypeTestResolution(const TypeTestResolution &TTRes) {
2749  Out << "typeTestRes: (kind: " << getTTResKindName(TTRes.TheKind)
2750  << ", sizeM1BitWidth: " << TTRes.SizeM1BitWidth;
2751 
2752  // The following fields are only used if the target does not support the use
2753  // of absolute symbols to store constants. Print only if non-zero.
2754  if (TTRes.AlignLog2)
2755  Out << ", alignLog2: " << TTRes.AlignLog2;
2756  if (TTRes.SizeM1)
2757  Out << ", sizeM1: " << TTRes.SizeM1;
2758  if (TTRes.BitMask)
2759  // BitMask is uint8_t which causes it to print the corresponding char.
2760  Out << ", bitMask: " << (unsigned)TTRes.BitMask;
2761  if (TTRes.InlineBits)
2762  Out << ", inlineBits: " << TTRes.InlineBits;
2763 
2764  Out << ")";
2765 }
2766 
2767 void AssemblyWriter::printTypeIdSummary(const TypeIdSummary &TIS) {
2768  Out << ", summary: (";
2769  printTypeTestResolution(TIS.TTRes);
2770  if (!TIS.WPDRes.empty()) {
2771  Out << ", wpdResolutions: (";
2772  FieldSeparator FS;
2773  for (auto &WPDRes : TIS.WPDRes) {
2774  Out << FS;
2775  Out << "(offset: " << WPDRes.first << ", ";
2776  printWPDRes(WPDRes.second);
2777  Out << ")";
2778  }
2779  Out << ")";
2780  }
2781  Out << ")";
2782 }
2783 
2784 void AssemblyWriter::printArgs(const std::vector<uint64_t> &Args) {
2785  Out << "args: (";
2786  FieldSeparator FS;
2787  for (auto arg : Args) {
2788  Out << FS;
2789  Out << arg;
2790  }
2791  Out << ")";
2792 }
2793 
2794 void AssemblyWriter::printWPDRes(const WholeProgramDevirtResolution &WPDRes) {
2795  Out << "wpdRes: (kind: ";
2796  Out << getWholeProgDevirtResKindName(WPDRes.TheKind);
2797 
2799  Out << ", singleImplName: \"" << WPDRes.SingleImplName << "\"";
2800 
2801  if (!WPDRes.ResByArg.empty()) {
2802  Out << ", resByArg: (";
2803  FieldSeparator FS;
2804  for (auto &ResByArg : WPDRes.ResByArg) {
2805  Out << FS;
2806  printArgs(ResByArg.first);
2807  Out << ", byArg: (kind: ";
2808  Out << getWholeProgDevirtResByArgKindName(ResByArg.second.TheKind);
2809  if (ResByArg.second.TheKind ==
2811  ResByArg.second.TheKind ==
2813  Out << ", info: " << ResByArg.second.Info;
2814 
2815  // The following fields are only used if the target does not support the
2816  // use of absolute symbols to store constants. Print only if non-zero.
2817  if (ResByArg.second.Byte || ResByArg.second.Bit)
2818  Out << ", byte: " << ResByArg.second.Byte
2819  << ", bit: " << ResByArg.second.Bit;
2820 
2821  Out << ")";
2822  }
2823  Out << ")";
2824  }
2825  Out << ")";
2826 }
2827 
2829  switch (SK) {
2831  return "alias";
2833  return "function";
2835  return "variable";
2836  }
2837  llvm_unreachable("invalid summary kind");
2838 }
2839 
2840 void AssemblyWriter::printAliasSummary(const AliasSummary *AS) {
2841  Out << ", aliasee: ";
2842  // The indexes emitted for distributed backends may not include the
2843  // aliasee summary (only if it is being imported directly). Handle
2844  // that case by just emitting "null" as the aliasee.
2845  if (AS->hasAliasee())
2846  Out << "^" << Machine.getGUIDSlot(SummaryToGUIDMap[&AS->getAliasee()]);
2847  else
2848  Out << "null";
2849 }
2850 
2851 void AssemblyWriter::printGlobalVarSummary(const GlobalVarSummary *GS) {
2852  Out << ", varFlags: (readonly: " << GS->VarFlags.ReadOnly << ")";
2853 }
2854 
2856  switch (LT) {
2858  return "external";
2860  return "private";
2862  return "internal";
2864  return "linkonce";
2866  return "linkonce_odr";
2868  return "weak";
2870  return "weak_odr";
2872  return "common";
2874  return "appending";
2876  return "extern_weak";
2878  return "available_externally";
2879  }
2880  llvm_unreachable("invalid linkage");
2881 }
2882 
2883 // When printing the linkage types in IR where the ExternalLinkage is
2884 // not printed, and other linkage types are expected to be printed with
2885 // a space after the name.
2887  if (LT == GlobalValue::ExternalLinkage)
2888  return "";
2889  return getLinkageName(LT) + " ";
2890 }
2891 
2892 void AssemblyWriter::printFunctionSummary(const FunctionSummary *FS) {
2893  Out << ", insts: " << FS->instCount();
2894 
2895  FunctionSummary::FFlags FFlags = FS->fflags();
2896  if (FFlags.ReadNone | FFlags.ReadOnly | FFlags.NoRecurse |
2897  FFlags.ReturnDoesNotAlias) {
2898  Out << ", funcFlags: (";
2899  Out << "readNone: " << FFlags.ReadNone;
2900  Out << ", readOnly: " << FFlags.ReadOnly;
2901  Out << ", noRecurse: " << FFlags.NoRecurse;
2902  Out << ", returnDoesNotAlias: " << FFlags.ReturnDoesNotAlias;
2903  Out << ", noInline: " << FFlags.NoInline;
2904  Out << ")";
2905  }
2906  if (!FS->calls().empty()) {
2907  Out << ", calls: (";
2908  FieldSeparator IFS;
2909  for (auto &Call : FS->calls()) {
2910  Out << IFS;
2911  Out << "(callee: ^" << Machine.getGUIDSlot(Call.first.getGUID());
2912  if (Call.second.getHotness() != CalleeInfo::HotnessType::Unknown)
2913  Out << ", hotness: " << getHotnessName(Call.second.getHotness());
2914  else if (Call.second.RelBlockFreq)
2915  Out << ", relbf: " << Call.second.RelBlockFreq;
2916  Out << ")";
2917  }
2918  Out << ")";
2919  }
2920 
2921  if (const auto *TIdInfo = FS->getTypeIdInfo())
2922  printTypeIdInfo(*TIdInfo);
2923 }
2924 
2925 void AssemblyWriter::printTypeIdInfo(
2926  const FunctionSummary::TypeIdInfo &TIDInfo) {
2927  Out << ", typeIdInfo: (";
2928  FieldSeparator TIDFS;
2929  if (!TIDInfo.TypeTests.empty()) {
2930  Out << TIDFS;
2931  Out << "typeTests: (";
2932  FieldSeparator FS;
2933  for (auto &GUID : TIDInfo.TypeTests) {
2934  auto TidIter = TheIndex->typeIds().equal_range(GUID);
2935  if (TidIter.first == TidIter.second) {
2936  Out << FS;
2937  Out << GUID;
2938  continue;
2939  }
2940  // Print all type id that correspond to this GUID.
2941  for (auto It = TidIter.first; It != TidIter.second; ++It) {
2942  Out << FS;
2943  auto Slot = Machine.getTypeIdSlot(It->second.first);
2944  assert(Slot != -1);
2945  Out << "^" << Slot;
2946  }
2947  }
2948  Out << ")";
2949  }
2950  if (!TIDInfo.TypeTestAssumeVCalls.empty()) {
2951  Out << TIDFS;
2952  printNonConstVCalls(TIDInfo.TypeTestAssumeVCalls, "typeTestAssumeVCalls");
2953  }
2954  if (!TIDInfo.TypeCheckedLoadVCalls.empty()) {
2955  Out << TIDFS;
2956  printNonConstVCalls(TIDInfo.TypeCheckedLoadVCalls, "typeCheckedLoadVCalls");
2957  }
2958  if (!TIDInfo.TypeTestAssumeConstVCalls.empty()) {
2959  Out << TIDFS;
2960  printConstVCalls(TIDInfo.TypeTestAssumeConstVCalls,
2961  "typeTestAssumeConstVCalls");
2962  }
2963  if (!TIDInfo.TypeCheckedLoadConstVCalls.empty()) {
2964  Out << TIDFS;
2965  printConstVCalls(TIDInfo.TypeCheckedLoadConstVCalls,
2966  "typeCheckedLoadConstVCalls");
2967  }
2968  Out << ")";
2969 }
2970 
2971 void AssemblyWriter::printVFuncId(const FunctionSummary::VFuncId VFId) {
2972  auto TidIter = TheIndex->typeIds().equal_range(VFId.GUID);
2973  if (TidIter.first == TidIter.second) {
2974  Out << "vFuncId: (";
2975  Out << "guid: " << VFId.GUID;
2976  Out << ", offset: " << VFId.Offset;
2977  Out << ")";
2978  return;
2979  }
2980  // Print all type id that correspond to this GUID.
2981  FieldSeparator FS;
2982  for (auto It = TidIter.first; It != TidIter.second; ++It) {
2983  Out << FS;
2984  Out << "vFuncId: (";
2985  auto Slot = Machine.getTypeIdSlot(It->second.first);
2986  assert(Slot != -1);
2987  Out << "^" << Slot;
2988  Out << ", offset: " << VFId.Offset;
2989  Out << ")";
2990  }
2991 }
2992 
2993 void AssemblyWriter::printNonConstVCalls(
2994  const std::vector<FunctionSummary::VFuncId> VCallList, const char *Tag) {
2995  Out << Tag << ": (";
2996  FieldSeparator FS;
2997  for (auto &VFuncId : VCallList) {
2998  Out << FS;
2999  printVFuncId(VFuncId);
3000  }
3001  Out << ")";
3002 }
3003 
3004 void AssemblyWriter::printConstVCalls(
3005  const std::vector<FunctionSummary::ConstVCall> VCallList, const char *Tag) {
3006  Out << Tag << ": (";
3007  FieldSeparator FS;
3008  for (auto &ConstVCall : VCallList) {
3009  Out << FS;
3010  Out << "(";
3011  printVFuncId(ConstVCall.VFunc);
3012  if (!ConstVCall.Args.empty()) {
3013  Out << ", ";
3014  printArgs(ConstVCall.Args);
3015  }
3016  Out << ")";
3017  }
3018  Out << ")";
3019 }
3020 
3021 void AssemblyWriter::printSummary(const GlobalValueSummary &Summary) {
3022  GlobalValueSummary::GVFlags GVFlags = Summary.flags();
3024  Out << getSummaryKindName(Summary.getSummaryKind()) << ": ";
3025  Out << "(module: ^" << Machine.getModulePathSlot(Summary.modulePath())
3026  << ", flags: (";
3027  Out << "linkage: " << getLinkageName(LT);
3028  Out << ", notEligibleToImport: " << GVFlags.NotEligibleToImport;
3029  Out << ", live: " << GVFlags.Live;
3030  Out << ", dsoLocal: " << GVFlags.DSOLocal;
3031  Out << ")";
3032 
3034  printAliasSummary(cast<AliasSummary>(&Summary));
3035  else if (Summary.getSummaryKind() == GlobalValueSummary::FunctionKind)
3036  printFunctionSummary(cast<FunctionSummary>(&Summary));
3037  else
3038  printGlobalVarSummary(cast<GlobalVarSummary>(&Summary));
3039 
3040  auto RefList = Summary.refs();
3041  if (!RefList.empty()) {
3042  Out << ", refs: (";
3043  FieldSeparator FS;
3044  for (auto &Ref : RefList) {
3045  Out << FS;
3046  if (Ref.isReadOnly())
3047  Out << "readonly ";
3048  Out << "^" << Machine.getGUIDSlot(Ref.getGUID());
3049  }
3050  Out << ")";
3051  }
3052 
3053  Out << ")";
3054 }
3055 
3056 void AssemblyWriter::printSummaryInfo(unsigned Slot, const ValueInfo &VI) {
3057  Out << "^" << Slot << " = gv: (";
3058  if (!VI.name().empty())
3059  Out << "name: \"" << VI.name() << "\"";
3060  else
3061  Out << "guid: " << VI.getGUID();
3062  if (!VI.getSummaryList().empty()) {
3063  Out << ", summaries: (";
3064  FieldSeparator FS;
3065  for (auto &Summary : VI.getSummaryList()) {
3066  Out << FS;
3067  printSummary(*Summary);
3068  }
3069  Out << ")";
3070  }
3071  Out << ")";
3072  if (!VI.name().empty())
3073  Out << " ; guid = " << VI.getGUID();
3074  Out << "\n";
3075 }
3076 
3078  formatted_raw_ostream &Out) {
3079  if (Name.empty()) {
3080  Out << "<empty name> ";
3081  } else {
3082  if (isalpha(static_cast<unsigned char>(Name[0])) || Name[0] == '-' ||
3083  Name[0] == '$' || Name[0] == '.' || Name[0] == '_')
3084  Out << Name[0];
3085  else
3086  Out << '\\' << hexdigit(Name[0] >> 4) << hexdigit(Name[0] & 0x0F);
3087  for (unsigned i = 1, e = Name.size(); i != e; ++i) {
3088  unsigned char C = Name[i];
3089  if (isalnum(static_cast<unsigned char>(C)) || C == '-' || C == '$' ||
3090  C == '.' || C == '_')
3091  Out << C;
3092  else
3093  Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
3094  }
3095  }
3096 }
3097 
3098 void AssemblyWriter::printNamedMDNode(const NamedMDNode *NMD) {
3099  Out << '!';
3100  printMetadataIdentifier(NMD->getName(), Out);
3101  Out << " = !{";
3102  for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
3103  if (i)
3104  Out << ", ";
3105 
3106  // Write DIExpressions inline.
3107  // FIXME: Ban DIExpressions in NamedMDNodes, they will serve no purpose.
3108  MDNode *Op = NMD->getOperand(i);
3109  if (auto *Expr = dyn_cast<DIExpression>(Op)) {
3110  writeDIExpression(Out, Expr, nullptr, nullptr, nullptr);
3111  continue;
3112  }
3113 
3114  int Slot = Machine.getMetadataSlot(Op);
3115  if (Slot == -1)
3116  Out << "<badref>";
3117  else
3118  Out << '!' << Slot;
3119  }
3120  Out << "}\n";
3121 }
3122 
3124  formatted_raw_ostream &Out) {
3125  switch (Vis) {
3126  case GlobalValue::DefaultVisibility: break;
3127  case GlobalValue::HiddenVisibility: Out << "hidden "; break;
3128  case GlobalValue::ProtectedVisibility: Out << "protected "; break;
3129  }
3130 }
3131 
3132 static void PrintDSOLocation(const GlobalValue &GV,
3133  formatted_raw_ostream &Out) {
3134  // GVs with local linkage or non default visibility are implicitly dso_local,
3135  // so we don't print it.
3136  bool Implicit = GV.hasLocalLinkage() ||
3138  if (GV.isDSOLocal() && !Implicit)
3139  Out << "dso_local ";
3140 }
3141 
3143  formatted_raw_ostream &Out) {
3144  switch (SCT) {
3146  case GlobalValue::DLLImportStorageClass: Out << "dllimport "; break;
3147  case GlobalValue::DLLExportStorageClass: Out << "dllexport "; break;
3148  }
3149 }
3150 
3152  formatted_raw_ostream &Out) {
3153  switch (TLM) {
3155  break;
3157  Out << "thread_local ";
3158  break;
3160  Out << "thread_local(localdynamic) ";
3161  break;
3163  Out << "thread_local(initialexec) ";
3164  break;
3166  Out << "thread_local(localexec) ";
3167  break;
3168  }
3169 }
3170 
3172  switch (UA) {
3174  return "";
3176  return "local_unnamed_addr";
3178  return "unnamed_addr";
3179  }
3180  llvm_unreachable("Unknown UnnamedAddr");
3181 }
3182 
3184  const GlobalObject &GO) {
3185  const Comdat *C = GO.getComdat();
3186  if (!C)
3187  return;
3188 
3189  if (isa<GlobalVariable>(GO))
3190  Out << ',';
3191  Out << " comdat";
3192 
3193  if (GO.getName() == C->getName())
3194  return;
3195 
3196  Out << '(';
3197  PrintLLVMName(Out, C->getName(), ComdatPrefix);
3198  Out << ')';
3199 }
3200 
3201 void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
3202  if (GV->isMaterializable())
3203  Out << "; Materializable\n";
3204 
3205  WriteAsOperandInternal(Out, GV, &TypePrinter, &Machine, GV->getParent());
3206  Out << " = ";
3207 
3208  if (!GV->hasInitializer() && GV->hasExternalLinkage())
3209  Out << "external ";
3210 
3211  Out << getLinkageNameWithSpace(GV->getLinkage());
3212  PrintDSOLocation(*GV, Out);
3213  PrintVisibility(GV->getVisibility(), Out);
3217  if (!UA.empty())
3218  Out << UA << ' ';
3219 
3220  if (unsigned AddressSpace = GV->getType()->getAddressSpace())
3221  Out << "addrspace(" << AddressSpace << ") ";
3222  if (GV->isExternallyInitialized()) Out << "externally_initialized ";
3223  Out << (GV->isConstant() ? "constant " : "global ");
3224  TypePrinter.print(GV->getValueType(), Out);
3225 
3226  if (GV->hasInitializer()) {
3227  Out << ' ';
3228  writeOperand(GV->getInitializer(), false);
3229  }
3230 
3231  if (GV->hasSection()) {
3232  Out << ", section \"";
3233  printEscapedString(GV->getSection(), Out);
3234  Out << '"';
3235  }
3236  maybePrintComdat(Out, *GV);
3237  if (GV->getAlignment())
3238  Out << ", align " << GV->getAlignment();
3239 
3241  GV->getAllMetadata(MDs);
3242  printMetadataAttachments(MDs, ", ");
3243 
3244  auto Attrs = GV->getAttributes();
3245  if (Attrs.hasAttributes())
3246  Out << " #" << Machine.getAttributeGroupSlot(Attrs);
3247 
3248  printInfoComment(*GV);
3249 }
3250 
3251 void AssemblyWriter::printIndirectSymbol(const GlobalIndirectSymbol *GIS) {
3252  if (GIS->isMaterializable())
3253  Out << "; Materializable\n";
3254 
3255  WriteAsOperandInternal(Out, GIS, &TypePrinter, &Machine, GIS->getParent());
3256  Out << " = ";
3257 
3258  Out << getLinkageNameWithSpace(GIS->getLinkage());
3259  PrintDSOLocation(*GIS, Out);
3260  PrintVisibility(GIS->getVisibility(), Out);
3264  if (!UA.empty())
3265  Out << UA << ' ';
3266 
3267  if (isa<GlobalAlias>(GIS))
3268  Out << "alias ";
3269  else if (isa<GlobalIFunc>(GIS))
3270  Out << "ifunc ";
3271  else
3272  llvm_unreachable("Not an alias or ifunc!");
3273 
3274  TypePrinter.print(GIS->getValueType(), Out);
3275 
3276  Out << ", ";
3277 
3278  const Constant *IS = GIS->getIndirectSymbol();
3279 
3280  if (!IS) {
3281  TypePrinter.print(GIS->getType(), Out);
3282  Out << " <<NULL ALIASEE>>";
3283  } else {
3284  writeOperand(IS, !isa<ConstantExpr>(IS));
3285  }
3286 
3287  printInfoComment(*GIS);
3288  Out << '\n';
3289 }
3290 
3291 void AssemblyWriter::printComdat(const Comdat *C) {
3292  C->print(Out);
3293 }
3294 
3295 void AssemblyWriter::printTypeIdentities() {
3296  if (TypePrinter.empty())
3297  return;
3298 
3299  Out << '\n';
3300 
3301  // Emit all numbered types.
3302  auto &NumberedTypes = TypePrinter.getNumberedTypes();
3303  for (unsigned I = 0, E = NumberedTypes.size(); I != E; ++I) {
3304  Out << '%' << I << " = type ";
3305 
3306  // Make sure we print out at least one level of the type structure, so
3307  // that we do not get %2 = type %2
3308  TypePrinter.printStructBody(NumberedTypes[I], Out);
3309  Out << '\n';
3310  }
3311 
3312  auto &NamedTypes = TypePrinter.getNamedTypes();
3313  for (unsigned I = 0, E = NamedTypes.size(); I != E; ++I) {
3314  PrintLLVMName(Out, NamedTypes[I]->getName(), LocalPrefix);
3315  Out << " = type ";
3316 
3317  // Make sure we print out at least one level of the type structure, so
3318  // that we do not get %FILE = type %FILE
3319  TypePrinter.printStructBody(NamedTypes[I], Out);
3320  Out << '\n';
3321  }
3322 }
3323 
3324 /// printFunction - Print all aspects of a function.
3325 void AssemblyWriter::printFunction(const Function *F) {
3326  // Print out the return type and name.
3327  Out << '\n';
3328 
3329  if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out);
3330 
3331  if (F->isMaterializable())
3332  Out << "; Materializable\n";
3333 
3334  const AttributeList &Attrs = F->getAttributes();
3336  AttributeSet AS = Attrs.getFnAttributes();
3337  std::string AttrStr;
3338 
3339  for (const Attribute &Attr : AS) {
3340  if (!Attr.isStringAttribute()) {
3341  if (!AttrStr.empty()) AttrStr += ' ';
3342  AttrStr += Attr.getAsString();
3343  }
3344  }
3345 
3346  if (!AttrStr.empty())
3347  Out << "; Function Attrs: " << AttrStr << '\n';
3348  }
3349 
3350  Machine.incorporateFunction(F);
3351 
3352  if (F->isDeclaration()) {
3353  Out << "declare";
3355  F->getAllMetadata(MDs);
3356  printMetadataAttachments(MDs, " ");
3357  Out << ' ';
3358  } else
3359  Out << "define ";
3360 
3361  Out << getLinkageNameWithSpace(F->getLinkage());
3362  PrintDSOLocation(*F, Out);
3363  PrintVisibility(F->getVisibility(), Out);
3365 
3366  // Print the calling convention.
3367  if (F->getCallingConv() != CallingConv::C) {
3368  PrintCallingConv(F->getCallingConv(), Out);
3369  Out << " ";
3370  }
3371 
3372  FunctionType *FT = F->getFunctionType();
3374  Out << Attrs.getAsString(AttributeList::ReturnIndex) << ' ';
3375  TypePrinter.print(F->getReturnType(), Out);
3376  Out << ' ';
3377  WriteAsOperandInternal(Out, F, &TypePrinter, &Machine, F->getParent());
3378  Out << '(';
3379 
3380  // Loop over the arguments, printing them...
3381  if (F->isDeclaration() && !IsForDebug) {
3382  // We're only interested in the type here - don't print argument names.
3383  for (unsigned I = 0, E = FT->getNumParams(); I != E; ++I) {
3384  // Insert commas as we go... the first arg doesn't get a comma
3385  if (I)
3386  Out << ", ";
3387  // Output type...
3388  TypePrinter.print(FT->getParamType(I), Out);
3389 
3390  AttributeSet ArgAttrs = Attrs.getParamAttributes(I);
3391  if (ArgAttrs.hasAttributes())
3392  Out << ' ' << ArgAttrs.getAsString();
3393  }
3394  } else {
3395  // The arguments are meaningful here, print them in detail.
3396  for (const Argument &Arg : F->args()) {
3397  // Insert commas as we go... the first arg doesn't get a comma
3398  if (Arg.getArgNo() != 0)
3399  Out << ", ";
3400  printArgument(&Arg, Attrs.getParamAttributes(Arg.getArgNo()));
3401  }
3402  }
3403 
3404  // Finish printing arguments...
3405  if (FT->isVarArg()) {
3406  if (FT->getNumParams()) Out << ", ";
3407  Out << "..."; // Output varargs portion of signature!
3408  }
3409  Out << ')';
3411  if (!UA.empty())
3412  Out << ' ' << UA;
3413  // We print the function address space if it is non-zero or if we are writing
3414  // a module with a non-zero program address space or if there is no valid
3415  // Module* so that the file can be parsed without the datalayout string.
3416  const Module *Mod = F->getParent();
3417  if (F->getAddressSpace() != 0 || !Mod ||
3418  Mod->getDataLayout().getProgramAddressSpace() != 0)
3419  Out << " addrspace(" << F->getAddressSpace() << ")";
3421  Out << " #" << Machine.getAttributeGroupSlot(Attrs.getFnAttributes());
3422  if (F->hasSection()) {
3423  Out << " section \"";
3424  printEscapedString(F->getSection(), Out);
3425  Out << '"';
3426  }
3427  maybePrintComdat(Out, *F);
3428  if (F->getAlignment())
3429  Out << " align " << F->getAlignment();
3430  if (F->hasGC())
3431  Out << " gc \"" << F->getGC() << '"';
3432  if (F->hasPrefixData()) {
3433  Out << " prefix ";
3434  writeOperand(F->getPrefixData(), true);
3435  }
3436  if (F->hasPrologueData()) {
3437  Out << " prologue ";
3438  writeOperand(F->getPrologueData(), true);
3439  }
3440  if (F->hasPersonalityFn()) {
3441  Out << " personality ";
3442  writeOperand(F->getPersonalityFn(), /*PrintType=*/true);
3443  }
3444 
3445  if (F->isDeclaration()) {
3446  Out << '\n';
3447  } else {
3449  F->getAllMetadata(MDs);
3450  printMetadataAttachments(MDs, " ");
3451 
3452  Out << " {";
3453  // Output all of the function's basic blocks.
3454  for (const BasicBlock &BB : *F)
3455  printBasicBlock(&BB);
3456 
3457  // Output the function's use-lists.
3458  printUseLists(F);
3459 
3460  Out << "}\n";
3461  }
3462 
3463  Machine.purgeFunction();
3464 }
3465 
3466 /// printArgument - This member is called for every argument that is passed into
3467 /// the function. Simply print it out
3468 void AssemblyWriter::printArgument(const Argument *Arg, AttributeSet Attrs) {
3469  // Output type...
3470  TypePrinter.print(Arg->getType(), Out);
3471 
3472  // Output parameter attributes list
3473  if (Attrs.hasAttributes())
3474  Out << ' ' << Attrs.getAsString();
3475 
3476  // Output name, if available...
3477  if (Arg->hasName()) {
3478  Out << ' ';
3479  PrintLLVMName(Out, Arg);
3480  }
3481 }
3482 
3483 /// printBasicBlock - This member is called for each basic block in a method.
3484 void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
3485  bool IsEntryBlock = BB == &BB->getParent()->getEntryBlock();
3486  if (BB->hasName()) { // Print out the label if it exists...
3487  Out << "\n";
3488  PrintLLVMName(Out, BB->getName(), LabelPrefix);
3489  Out << ':';
3490  } else if (!IsEntryBlock) {
3491  Out << "\n";
3492  int Slot = Machine.getLocalSlot(BB);
3493  if (Slot != -1)
3494  Out << Slot << ":";
3495  else
3496  Out << "<badref>:";
3497  }
3498 
3499  if (!BB->getParent()) {
3500  Out.PadToColumn(50);
3501  Out << "; Error: Block without parent!";
3502  } else if (!IsEntryBlock) {
3503  // Output predecessors for the block.
3504  Out.PadToColumn(50);
3505  Out << ";";
3506  const_pred_iterator PI = pred_begin(BB), PE = pred_end(BB);
3507 
3508  if (PI == PE) {
3509  Out << " No predecessors!";
3510  } else {
3511  Out << " preds = ";
3512  writeOperand(*PI, false);
3513  for (++PI; PI != PE; ++PI) {
3514  Out << ", ";
3515  writeOperand(*PI, false);
3516  }
3517  }
3518  }
3519 
3520  Out << "\n";
3521 
3522  if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out);
3523 
3524  // Output all of the instructions in the basic block...
3525  for (const Instruction &I : *BB) {
3526  printInstructionLine(I);
3527  }
3528 
3529  if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out);
3530 }
3531 
3532 /// printInstructionLine - Print an instruction and a newline character.
3533 void AssemblyWriter::printInstructionLine(const Instruction &I) {
3534  printInstruction(I);
3535  Out << '\n';
3536 }
3537 
3538 /// printGCRelocateComment - print comment after call to the gc.relocate
3539 /// intrinsic indicating base and derived pointer names.
3540 void AssemblyWriter::printGCRelocateComment(const GCRelocateInst &Relocate) {
3541  Out << " ; (";
3542  writeOperand(Relocate.getBasePtr(), false);
3543  Out << ", ";
3544  writeOperand(Relocate.getDerivedPtr(), false);
3545  Out << ")";
3546 }
3547 
3548 /// printInfoComment - Print a little comment after the instruction indicating
3549 /// which slot it occupies.
3550 void AssemblyWriter::printInfoComment(const Value &V) {
3551  if (const auto *Relocate = dyn_cast<GCRelocateInst>(&V))
3552  printGCRelocateComment(*Relocate);
3553 
3554  if (AnnotationWriter)
3555  AnnotationWriter->printInfoComment(V, Out);
3556 }
3557 
3558 static void maybePrintCallAddrSpace(const Value *Operand, const Instruction *I,
3559  raw_ostream &Out) {
3560  // We print the address space of the call if it is non-zero.
3561  unsigned CallAddrSpace = Operand->getType()->getPointerAddressSpace();
3562  bool PrintAddrSpace = CallAddrSpace != 0;
3563  if (!PrintAddrSpace) {
3564  const Module *Mod = getModuleFromVal(I);
3565  // We also print it if it is zero but not equal to the program address space
3566  // or if we can't find a valid Module* to make it possible to parse
3567  // the resulting file even without a datalayout string.
3568  if (!Mod || Mod->getDataLayout().getProgramAddressSpace() != 0)
3569  PrintAddrSpace = true;
3570  }
3571  if (PrintAddrSpace)
3572  Out << " addrspace(" << CallAddrSpace << ")";
3573 }
3574 
3575 // This member is called for each Instruction in a function..
3576 void AssemblyWriter::printInstruction(const Instruction &I) {
3577  if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out);
3578 
3579  // Print out indentation for an instruction.
3580  Out << " ";
3581 
3582  // Print out name if it exists...
3583  if (I.hasName()) {
3584  PrintLLVMName(Out, &I);
3585  Out << " = ";
3586  } else if (!I.getType()->isVoidTy()) {
3587  // Print out the def slot taken.
3588  int SlotNum = Machine.getLocalSlot(&I);
3589  if (SlotNum == -1)
3590  Out << "<badref> = ";
3591  else
3592  Out << '%' << SlotNum << " = ";
3593  }
3594 
3595  if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
3596  if (CI->isMustTailCall())
3597  Out << "musttail ";
3598  else if (CI->isTailCall())
3599  Out << "tail ";
3600  else if (CI->isNoTailCall())
3601  Out << "notail ";
3602  }
3603 
3604  // Print out the opcode...
3605  Out << I.getOpcodeName();
3606 
3607  // If this is an atomic load or store, print out the atomic marker.
3608  if ((isa<LoadInst>(I) && cast<LoadInst>(I).isAtomic()) ||
3609  (isa<StoreInst>(I) && cast<StoreInst>(I).isAtomic()))
3610  Out << " atomic";
3611 
3612  if (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).isWeak())
3613  Out << " weak";
3614 
3615  // If this is a volatile operation, print out the volatile marker.
3616  if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) ||
3617  (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile()) ||
3618  (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).isVolatile()) ||
3619  (isa<AtomicRMWInst>(I) && cast<AtomicRMWInst>(I).isVolatile()))
3620  Out << " volatile";
3621 
3622  // Print out optimization information.
3623  WriteOptimizationInfo(Out, &I);
3624 
3625  // Print out the compare instruction predicates
3626  if (const CmpInst *CI = dyn_cast<CmpInst>(&I))
3627  Out << ' ' << CmpInst::getPredicateName(CI->getPredicate());
3628 
3629  // Print out the atomicrmw operation
3630  if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I))
3631  Out << ' ' << AtomicRMWInst::getOperationName(RMWI->getOperation());
3632 
3633  // Print out the type of the operands...
3634  const Value *Operand = I.getNumOperands() ? I.getOperand(0) : nullptr;
3635 
3636  // Special case conditional branches to swizzle the condition out to the front
3637  if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) {
3638  const BranchInst &BI(cast<BranchInst>(I));
3639  Out << ' ';
3640  writeOperand(BI.getCondition(), true);
3641  Out << ", ";
3642  writeOperand(BI.getSuccessor(0), true);
3643  Out << ", ";
3644  writeOperand(BI.getSuccessor(1), true);
3645 
3646  } else if (isa<SwitchInst>(I)) {
3647  const SwitchInst& SI(cast<SwitchInst>(I));
3648  // Special case switch instruction to get formatting nice and correct.
3649  Out << ' ';
3650  writeOperand(SI.getCondition(), true);
3651  Out << ", ";
3652  writeOperand(SI.getDefaultDest(), true);
3653  Out << " [";
3654  for (auto Case : SI.cases()) {
3655  Out << "\n ";
3656  writeOperand(Case.getCaseValue(), true);
3657  Out << ", ";
3658  writeOperand(Case.getCaseSuccessor(), true);
3659  }
3660  Out << "\n ]";
3661  } else if (isa<IndirectBrInst>(I)) {
3662  // Special case indirectbr instruction to get formatting nice and correct.
3663  Out << ' ';
3664  writeOperand(Operand, true);
3665  Out << ", [";
3666 
3667  for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) {
3668  if (i != 1)
3669  Out << ", ";
3670  writeOperand(I.getOperand(i), true);
3671  }
3672  Out << ']';
3673  } else if (const PHINode *PN = dyn_cast<PHINode>(&I)) {
3674  Out << ' ';
3675  TypePrinter.print(I.getType(), Out);
3676  Out << ' ';
3677 
3678  for (unsigned op = 0, Eop = PN->getNumIncomingValues(); op < Eop; ++op) {
3679  if (op) Out << ", ";
3680  Out << "[ ";
3681  writeOperand(PN->getIncomingValue(op), false); Out << ", ";
3682  writeOperand(PN->getIncomingBlock(op), false); Out << " ]";
3683  }
3684  } else if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(&I)) {
3685  Out << ' ';
3686  writeOperand(I.getOperand(0), true);
3687  for (const unsigned *i = EVI->idx_begin(), *e = EVI->idx_end(); i != e; ++i)
3688  Out << ", " << *i;
3689  } else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(&I)) {
3690  Out << ' ';
3691  writeOperand(I.getOperand(0), true); Out << ", ";
3692  writeOperand(I.getOperand(1), true);
3693  for (const unsigned *i = IVI->idx_begin(), *e = IVI->idx_end(); i != e; ++i)
3694  Out << ", " << *i;
3695  } else if (const LandingPadInst *LPI = dyn_cast<LandingPadInst>(&I)) {
3696  Out << ' ';
3697  TypePrinter.print(I.getType(), Out);
3698  if (LPI->isCleanup() || LPI->getNumClauses() != 0)
3699  Out << '\n';
3700 
3701  if (LPI->isCleanup())
3702  Out << " cleanup";
3703 
3704  for (unsigned i = 0, e = LPI->getNumClauses(); i != e; ++i) {
3705  if (i != 0 || LPI->isCleanup()) Out << "\n";
3706  if (LPI->isCatch(i))
3707  Out << " catch ";
3708  else
3709  Out << " filter ";
3710 
3711  writeOperand(LPI->getClause(i), true);
3712  }
3713  } else if (const auto *CatchSwitch = dyn_cast<CatchSwitchInst>(&I)) {
3714  Out << " within ";
3715  writeOperand(CatchSwitch->getParentPad(), /*PrintType=*/false);
3716  Out << " [";
3717  unsigned Op = 0;
3718  for (const BasicBlock *PadBB : CatchSwitch->handlers()) {
3719  if (Op > 0)
3720  Out << ", ";
3721  writeOperand(PadBB, /*PrintType=*/true);
3722  ++Op;
3723  }
3724  Out << "] unwind ";
3725  if (const BasicBlock *UnwindDest = CatchSwitch->getUnwindDest())
3726  writeOperand(UnwindDest, /*PrintType=*/true);
3727  else
3728  Out << "to caller";
3729  } else if (const auto *FPI = dyn_cast<FuncletPadInst>(&I)) {
3730  Out << " within ";
3731  writeOperand(FPI->getParentPad(), /*PrintType=*/false);
3732  Out << " [";
3733  for (unsigned Op = 0, NumOps = FPI->getNumArgOperands(); Op < NumOps;
3734  ++Op) {
3735  if (Op > 0)
3736  Out << ", ";
3737  writeOperand(FPI->getArgOperand(Op), /*PrintType=*/true);
3738  }
3739  Out << ']';
3740  } else if (isa<ReturnInst>(I) && !Operand) {
3741  Out << " void";
3742  } else if (const auto *CRI = dyn_cast<CatchReturnInst>(&I)) {
3743  Out << " from ";
3744  writeOperand(CRI->getOperand(0), /*PrintType=*/false);
3745 
3746  Out << " to ";
3747  writeOperand(CRI->getOperand(1), /*PrintType=*/true);
3748  } else if (const auto *CRI = dyn_cast<CleanupReturnInst>(&I)) {
3749  Out << " from ";
3750  writeOperand(CRI->getOperand(0), /*PrintType=*/false);
3751 
3752  Out << " unwind ";
3753  if (CRI->hasUnwindDest())
3754  writeOperand(CRI->getOperand(1), /*PrintType=*/true);
3755  else
3756  Out << "to caller";
3757  } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
3758  // Print the calling convention being used.
3759  if (CI->getCallingConv() != CallingConv::C) {
3760  Out << " ";
3761  PrintCallingConv(CI->getCallingConv(), Out);
3762  }
3763 
3764  Operand = CI->getCalledValue();
3765  FunctionType *FTy = CI->getFunctionType();
3766  Type *RetTy = FTy->getReturnType();
3767  const AttributeList &PAL = CI->getAttributes();
3768 
3770  Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
3771 
3772  // Only print addrspace(N) if necessary:
3773  maybePrintCallAddrSpace(Operand, &I, Out);
3774 
3775  // If possible, print out the short form of the call instruction. We can
3776  // only do this if the first argument is a pointer to a nonvararg function,
3777  // and if the return type is not a pointer to a function.
3778  //
3779  Out << ' ';
3780  TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
3781  Out << ' ';
3782  writeOperand(Operand, false);
3783  Out << '(';
3784  for (unsigned op = 0, Eop = CI->getNumArgOperands(); op < Eop; ++op) {
3785  if (op > 0)
3786  Out << ", ";
3787  writeParamOperand(CI->getArgOperand(op), PAL.getParamAttributes(op));
3788  }
3789 
3790  // Emit an ellipsis if this is a musttail call in a vararg function. This
3791  // is only to aid readability, musttail calls forward varargs by default.
3792  if (CI->isMustTailCall() && CI->getParent() &&
3793  CI->getParent()->getParent() &&
3794  CI->getParent()->getParent()->isVarArg())
3795  Out << ", ...";
3796 
3797  Out << ')';
3799  Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
3800 
3801  writeOperandBundles(CI);
3802  } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
3803  Operand = II->getCalledValue();
3804  FunctionType *FTy = II->getFunctionType();
3805  Type *RetTy = FTy->getReturnType();
3806  const AttributeList &PAL = II->getAttributes();
3807 
3808  // Print the calling convention being used.
3809  if (II->getCallingConv() != CallingConv::C) {
3810  Out << " ";
3811  PrintCallingConv(II->getCallingConv(), Out);
3812  }
3813 
3815  Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
3816 
3817  // Only print addrspace(N) if necessary:
3818  maybePrintCallAddrSpace(Operand, &I, Out);
3819 
3820  // If possible, print out the short form of the invoke instruction. We can
3821  // only do this if the first argument is a pointer to a nonvararg function,
3822  // and if the return type is not a pointer to a function.
3823  //
3824  Out << ' ';
3825  TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
3826  Out << ' ';
3827  writeOperand(Operand, false);
3828  Out << '(';
3829  for (unsigned op = 0, Eop = II->getNumArgOperands(); op < Eop; ++op) {
3830  if (op)
3831  Out << ", ";
3832  writeParamOperand(II->getArgOperand(op), PAL.getParamAttributes(op));
3833  }
3834 
3835  Out << ')';
3837  Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
3838 
3839  writeOperandBundles(II);
3840 
3841  Out << "\n to ";
3842  writeOperand(II->getNormalDest(), true);
3843  Out << " unwind ";
3844  writeOperand(II->getUnwindDest(), true);
3845  } else if (const CallBrInst *CBI = dyn_cast<CallBrInst>(&I)) {
3846  Operand = CBI->getCalledValue();
3847  FunctionType *FTy = CBI->getFunctionType();
3848  Type *RetTy = FTy->getReturnType();
3849  const AttributeList &PAL = CBI->getAttributes();
3850 
3851  // Print the calling convention being used.
3852  if (CBI->getCallingConv() != CallingConv::C) {
3853  Out << " ";
3854  PrintCallingConv(CBI->getCallingConv(), Out);
3855  }
3856 
3858  Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
3859 
3860  // If possible, print out the short form of the callbr instruction. We can
3861  // only do this if the first argument is a pointer to a nonvararg function,
3862  // and if the return type is not a pointer to a function.
3863  //
3864  Out << ' ';
3865  TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
3866  Out << ' ';
3867  writeOperand(Operand, false);
3868  Out << '(';
3869  for (unsigned op = 0, Eop = CBI->getNumArgOperands(); op < Eop; ++op) {
3870  if (op)
3871  Out << ", ";
3872  writeParamOperand(CBI->getArgOperand(op), PAL.getParamAttributes(op));
3873  }
3874 
3875  Out << ')';
3877  Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
3878 
3879  writeOperandBundles(CBI);
3880 
3881  Out << "\n to ";
3882  writeOperand(CBI->getDefaultDest(), true);
3883  Out << " [";
3884  for (unsigned i = 0, e = CBI->getNumIndirectDests(); i != e; ++i) {
3885  if (i != 0)
3886  Out << ", ";
3887  writeOperand(CBI->getIndirectDest(i), true);
3888  }
3889  Out << ']';
3890  } else if (const AllocaInst *AI = dyn_cast<AllocaInst>(&I)) {
3891  Out << ' ';
3892  if (AI->isUsedWithInAlloca())
3893  Out << "inalloca ";
3894  if (AI->isSwiftError())
3895  Out << "swifterror ";
3896  TypePrinter.print(AI->getAllocatedType(), Out);
3897 
3898  // Explicitly write the array size if the code is broken, if it's an array
3899  // allocation, or if the type is not canonical for scalar allocations. The
3900  // latter case prevents the type from mutating when round-tripping through
3901  // assembly.
3902  if (!AI->getArraySize() || AI->isArrayAllocation() ||
3903  !AI->getArraySize()->getType()->isIntegerTy(32)) {
3904  Out << ", ";
3905  writeOperand(AI->getArraySize(), true);
3906  }
3907  if (AI->getAlignment()) {
3908  Out << ", align " << AI->getAlignment();
3909  }
3910 
3911  unsigned AddrSpace = AI->getType()->getAddressSpace();
3912  if (AddrSpace != 0) {
3913  Out << ", addrspace(" << AddrSpace << ')';
3914  }
3915  } else if (isa<CastInst>(I)) {
3916  if (Operand) {
3917  Out << ' ';
3918  writeOperand(Operand, true); // Work with broken code
3919  }
3920  Out << " to ";
3921  TypePrinter.print(I.getType(), Out);
3922  } else if (isa<VAArgInst>(I)) {
3923  if (Operand) {
3924  Out << ' ';
3925  writeOperand(Operand, true); // Work with broken code
3926  }
3927  Out << ", ";
3928  TypePrinter.print(I.getType(), Out);
3929  } else if (Operand) { // Print the normal way.
3930  if (const auto *GEP = dyn_cast<GetElementPtrInst>(&I)) {
3931  Out << ' ';
3932  TypePrinter.print(GEP->getSourceElementType(), Out);
3933  Out << ',';
3934  } else if (const auto *LI = dyn_cast<LoadInst>(&I)) {
3935  Out << ' ';
3936  TypePrinter.print(LI->getType(), Out);
3937  Out << ',';
3938  }
3939 
3940  // PrintAllTypes - Instructions who have operands of all the same type
3941  // omit the type from all but the first operand. If the instruction has
3942  // different type operands (for example br), then they are all printed.
3943  bool PrintAllTypes = false;
3944  Type *TheType = Operand->getType();
3945 
3946  // Select, Store and ShuffleVector always print all types.
3947  if (isa<SelectInst>(I) || isa<StoreInst>(I) || isa<ShuffleVectorInst>(I)
3948  || isa<ReturnInst>(I)) {
3949  PrintAllTypes = true;
3950  } else {
3951  for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) {
3952  Operand = I.getOperand(i);
3953  // note that Operand shouldn't be null, but the test helps make dump()
3954  // more tolerant of malformed IR
3955  if (Operand && Operand->getType() != TheType) {
3956  PrintAllTypes = true; // We have differing types! Print them all!
3957  break;
3958  }
3959  }
3960  }
3961 
3962  if (!PrintAllTypes) {
3963  Out << ' ';
3964  TypePrinter.print(TheType, Out);
3965  }
3966 
3967  Out << ' ';
3968  for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) {
3969  if (i) Out << ", ";
3970  writeOperand(I.getOperand(i), PrintAllTypes);
3971  }
3972  }
3973 
3974  // Print atomic ordering/alignment for memory operations
3975  if (const LoadInst *LI = dyn_cast<LoadInst>(&I)) {
3976  if (LI->isAtomic())
3977  writeAtomic(LI->getContext(), LI->getOrdering(), LI->getSyncScopeID());
3978  if (LI->getAlignment())
3979  Out << ", align " << LI->getAlignment();
3980  } else if (const StoreInst *SI = dyn_cast<StoreInst>(&I)) {
3981  if (SI->isAtomic())
3982  writeAtomic(SI->getContext(), SI->getOrdering(), SI->getSyncScopeID());
3983  if (SI->getAlignment())
3984  Out << ", align " << SI->getAlignment();
3985  } else if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(&I)) {
3986  writeAtomicCmpXchg(CXI->getContext(), CXI->getSuccessOrdering(),
3987  CXI->getFailureOrdering(), CXI->getSyncScopeID());
3988  } else if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I)) {
3989  writeAtomic(RMWI->getContext(), RMWI->getOrdering(),
3990  RMWI->getSyncScopeID());
3991  } else if (const FenceInst *FI = dyn_cast<FenceInst>(&I)) {
3992  writeAtomic(FI->getContext(), FI->getOrdering(), FI->getSyncScopeID());
3993  }
3994 
3995  // Print Metadata info.
3997  I.getAllMetadata(InstMD);
3998  printMetadataAttachments(InstMD, ", ");
3999 
4000  // Print a nice comment.
4001  printInfoComment(I);
4002 }
4003 
4004 void AssemblyWriter::printMetadataAttachments(
4005  const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
4006  StringRef Separator) {
4007  if (MDs.empty())
4008  return;
4009 
4010  if (MDNames.empty())
4011  MDs[0].second->getContext().getMDKindNames(MDNames);
4012 
4013  for (const auto &I : MDs) {
4014  unsigned Kind = I.first;
4015  Out << Separator;
4016  if (Kind < MDNames.size()) {
4017  Out << "!";
4018  printMetadataIdentifier(MDNames[Kind], Out);
4019  } else
4020  Out << "!<unknown kind #" << Kind << ">";
4021  Out << ' ';
4022  WriteAsOperandInternal(Out, I.second, &TypePrinter, &Machine, TheModule);
4023  }
4024 }
4025 
4026 void AssemblyWriter::writeMDNode(unsigned Slot, const MDNode *Node) {
4027  Out << '!' << Slot << " = ";
4028  printMDNodeBody(Node);
4029  Out << "\n";
4030 }
4031 
4032 void AssemblyWriter::writeAllMDNodes() {
4034  Nodes.resize(Machine.mdn_size());
4035  for (SlotTracker::mdn_iterator I = Machine.mdn_begin(), E = Machine.mdn_end();
4036  I != E; ++I)
4037  Nodes[I->second] = cast<MDNode>(I->first);
4038 
4039  for (unsigned i = 0, e = Nodes.size(); i != e; ++i) {
4040  writeMDNode(i, Nodes[i]);
4041  }
4042 }
4043 
4044 void AssemblyWriter::printMDNodeBody(const MDNode *Node) {
4045  WriteMDNodeBodyInternal(Out, Node, &TypePrinter, &Machine, TheModule);
4046 }
4047 
4048 void AssemblyWriter::writeAllAttributeGroups() {
4049  std::vector<std::pair<AttributeSet, unsigned>> asVec;
4050  asVec.resize(Machine.as_size());
4051 
4052  for (SlotTracker::as_iterator I = Machine.as_begin(), E = Machine.as_end();
4053  I != E; ++I)
4054  asVec[I->second] = *I;
4055 
4056  for (const auto &I : asVec)
4057  Out << "attributes #" << I.second << " = { "
4058  << I.first.getAsString(true) << " }\n";
4059 }
4060 
4061 void AssemblyWriter::printUseListOrder(const UseListOrder &Order) {
4062  bool IsInFunction = Machine.getFunction();
4063  if (IsInFunction)
4064  Out << " ";
4065 
4066  Out << "uselistorder";
4067  if (const BasicBlock *BB =
4068  IsInFunction ? nullptr : dyn_cast<BasicBlock>(Order.V)) {
4069  Out << "_bb ";
4070  writeOperand(BB->getParent(), false);
4071  Out << ", ";
4072  writeOperand(BB, false);
4073  } else {
4074  Out << " ";
4075  writeOperand(Order.V, true);
4076  }
4077  Out << ", { ";
4078 
4079  assert(Order.Shuffle.size() >= 2 && "Shuffle too small");
4080  Out << Order.Shuffle[0];
4081  for (unsigned I = 1, E = Order.Shuffle.size(); I != E; ++I)
4082  Out << ", " << Order.Shuffle[I];
4083  Out << " }\n";
4084 }
4085 
4086 void AssemblyWriter::printUseLists(const Function *F) {
4087  auto hasMore =
4088  [&]() { return !UseListOrders.empty() && UseListOrders.back().F == F; };
4089  if (!hasMore())
4090  // Nothing to do.
4091  return;
4092 
4093  Out << "\n; uselistorder directives\n";
4094  while (hasMore()) {
4095  printUseListOrder(UseListOrders.back());
4096  UseListOrders.pop_back();
4097  }
4098 }
4099 
4100 //===----------------------------------------------------------------------===//
4101 // External Interface declarations
4102 //===----------------------------------------------------------------------===//
4103 
4105  bool ShouldPreserveUseListOrder,
4106  bool IsForDebug) const {
4107  SlotTracker SlotTable(this->getParent());
4108  formatted_raw_ostream OS(ROS);
4109  AssemblyWriter W(OS, SlotTable, this->getParent(), AAW,
4110  IsForDebug,
4111  ShouldPreserveUseListOrder);
4112  W.printFunction(this);
4113 }
4114 
4116  bool ShouldPreserveUseListOrder, bool IsForDebug) const {
4117  SlotTracker SlotTable(this);
4118  formatted_raw_ostream OS(ROS);
4119  AssemblyWriter W(OS, SlotTable, this, AAW, IsForDebug,
4120  ShouldPreserveUseListOrder);
4121  W.printModule(this);
4122 }
4123 
4124 void NamedMDNode::print(raw_ostream &ROS, bool IsForDebug) const {
4125  SlotTracker SlotTable(getParent());
4126  formatted_raw_ostream OS(ROS);
4127  AssemblyWriter W(OS, SlotTable, getParent(), nullptr, IsForDebug);
4128  W.printNamedMDNode(this);
4129 }
4130 
4132  bool IsForDebug) const {
4133  Optional<SlotTracker> LocalST;
4134  SlotTracker *SlotTable;
4135  if (auto *ST = MST.getMachine())
4136  SlotTable = ST;
4137  else {
4138  LocalST.emplace(getParent());
4139  SlotTable = &*LocalST;
4140  }
4141 
4142  formatted_raw_ostream OS(ROS);
4143  AssemblyWriter W(OS, *SlotTable, getParent(), nullptr, IsForDebug);
4144  W.printNamedMDNode(this);
4145 }
4146 
4147 void Comdat::print(raw_ostream &ROS, bool /*IsForDebug*/) const {
4149  ROS << " = comdat ";
4150 
4151  switch (getSelectionKind()) {
4152  case Comdat::Any:
4153  ROS << "any";
4154  break;
4155  case Comdat::ExactMatch:
4156  ROS << "exactmatch";
4157  break;
4158  case Comdat::Largest:
4159  ROS << "largest";
4160  break;
4161  case Comdat::NoDuplicates:
4162  ROS << "noduplicates";
4163  break;
4164  case Comdat::SameSize:
4165  ROS << "samesize";
4166  break;
4167  }
4168 
4169  ROS << '\n';
4170 }
4171 
4172 void Type::print(raw_ostream &OS, bool /*IsForDebug*/, bool NoDetails) const {
4173  TypePrinting TP;
4174  TP.print(const_cast<Type*>(this), OS);
4175 
4176  if (NoDetails)
4177  return;
4178 
4179  // If the type is a named struct type, print the body as well.
4180  if (StructType *STy = dyn_cast<StructType>(const_cast<Type*>(this)))
4181  if (!STy->isLiteral()) {
4182  OS << " = type ";
4183  TP.printStructBody(STy, OS);
4184  }
4185 }
4186 
4187 static bool isReferencingMDNode(const Instruction &I) {
4188  if (const auto *CI = dyn_cast<CallInst>(&I))
4189  if (Function *F = CI->getCalledFunction())
4190  if (F->isIntrinsic())
4191  for (auto &Op : I.operands())
4192  if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op))
4193  if (isa<MDNode>(V->getMetadata()))
4194  return true;
4195  return false;
4196 }
4197 
4198 void Value::print(raw_ostream &ROS, bool IsForDebug) const {
4199  bool ShouldInitializeAllMetadata = false;
4200  if (auto *I = dyn_cast<Instruction>(this))
4201  ShouldInitializeAllMetadata = isReferencingMDNode(*I);
4202  else if (isa<Function>(this) || isa<MetadataAsValue>(this))
4203  ShouldInitializeAllMetadata = true;
4204 
4205  ModuleSlotTracker MST(getModuleFromVal(this), ShouldInitializeAllMetadata);
4206  print(ROS, MST, IsForDebug);
4207 }
4208 
4210  bool IsForDebug) const {
4211  formatted_raw_ostream OS(ROS);
4212  SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));
4213  SlotTracker &SlotTable =
4214  MST.getMachine() ? *MST.getMachine() : EmptySlotTable;
4215  auto incorporateFunction = [&](const Function *F) {
4216  if (F)
4217  MST.incorporateFunction(*F);
4218  };
4219 
4220  if (const Instruction *I = dyn_cast<Instruction>(this)) {
4221  incorporateFunction(I->getParent() ? I->getParent()->getParent() : nullptr);
4222  AssemblyWriter W(OS, SlotTable, getModuleFromVal(I), nullptr, IsForDebug);
4223  W.printInstruction(*I);
4224  } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(this)) {
4225  incorporateFunction(BB->getParent());
4226  AssemblyWriter W(OS, SlotTable, getModuleFromVal(BB), nullptr, IsForDebug);
4227  W.printBasicBlock(BB);
4228  } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(this)) {
4229  AssemblyWriter W(OS, SlotTable, GV->getParent(), nullptr, IsForDebug);
4230  if (const GlobalVariable *V = dyn_cast<GlobalVariable>(GV))
4231  W.printGlobal(V);
4232  else if (const Function *F = dyn_cast<Function>(GV))
4233  W.printFunction(F);
4234  else
4235  W.printIndirectSymbol(cast<GlobalIndirectSymbol>(GV));
4236  } else if (const MetadataAsValue *V = dyn_cast<MetadataAsValue>(this)) {
4237  V->getMetadata()->print(ROS, MST, getModuleFromVal(V));
4238  } else if (const Constant *C = dyn_cast<Constant>(this)) {
4239  TypePrinting TypePrinter;
4240  TypePrinter.print(C->getType(), OS);
4241  OS << ' ';
4242  WriteConstantInternal(OS, C, TypePrinter, MST.getMachine(), nullptr);
4243  } else if (isa<InlineAsm>(this) || isa<Argument>(this)) {
4244  this->printAsOperand(OS, /* PrintType */ true, MST);
4245  } else {
4246  llvm_unreachable("Unknown value to print out!");
4247  }
4248 }
4249 
4250 /// Print without a type, skipping the TypePrinting object.
4251 ///
4252 /// \return \c true iff printing was successful.
4253 static bool printWithoutType(const Value &V, raw_ostream &O,
4254  SlotTracker *Machine, const Module *M) {
4255  if (V.hasName() || isa<GlobalValue>(V) ||
4256  (!isa<Constant>(V) && !isa<MetadataAsValue>(V))) {
4257  WriteAsOperandInternal(O, &V, nullptr, Machine, M);
4258  return true;
4259  }
4260  return false;
4261 }
4262 
4263 static void printAsOperandImpl(const Value &V, raw_ostream &O, bool PrintType,
4264  ModuleSlotTracker &MST) {
4265  TypePrinting TypePrinter(MST.getModule());
4266  if (PrintType) {
4267  TypePrinter.print(V.getType(), O);
4268  O << ' ';
4269  }
4270 
4271  WriteAsOperandInternal(O, &V, &TypePrinter, MST.getMachine(),
4272  MST.getModule());
4273 }
4274 
4275 void Value::printAsOperand(raw_ostream &O, bool PrintType,
4276  const Module *M) const {
4277  if (!M)
4278  M = getModuleFromVal(this);
4279 
4280  if (!PrintType)
4281  if (printWithoutType(*this, O, nullptr, M))
4282  return;
4283 
4285  M, /* ShouldInitializeAllMetadata */ isa<MetadataAsValue>(this));
4286  ModuleSlotTracker MST(Machine, M);
4287  printAsOperandImpl(*this, O, PrintType, MST);
4288 }
4289 
4290 void Value::printAsOperand(raw_ostream &O, bool PrintType,
4291  ModuleSlotTracker &MST) const {
4292  if (!PrintType)
4293  if (printWithoutType(*this, O, MST.getMachine(), MST.getModule()))
4294  return;
4295 
4296  printAsOperandImpl(*this, O, PrintType, MST);
4297 }
4298 
4299 static void printMetadataImpl(raw_ostream &ROS, const Metadata &MD,
4300  ModuleSlotTracker &MST, const Module *M,
4301  bool OnlyAsOperand) {
4302  formatted_raw_ostream OS(ROS);
4303 
4304  TypePrinting TypePrinter(M);
4305 
4306  WriteAsOperandInternal(OS, &MD, &TypePrinter, MST.getMachine(), M,
4307  /* FromValue */ true);
4308 
4309  auto *N = dyn_cast<MDNode>(&MD);
4310  if (OnlyAsOperand || !N || isa<DIExpression>(MD))
4311  return;
4312 
4313  OS << " = ";
4314  WriteMDNodeBodyInternal(OS, N, &TypePrinter, MST.getMachine(), M);
4315 }
4316 
4317 void Metadata::printAsOperand(raw_ostream &OS, const Module *M) const {
4318  ModuleSlotTracker MST(M, isa<MDNode>(this));
4319  printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ true);
4320 }
4321 
4323  const Module *M) const {
4324  printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ true);
4325 }
4326 
4328  bool /*IsForDebug*/) const {
4329  ModuleSlotTracker MST(M, isa<MDNode>(this));
4330  printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
4331 }
4332 
4334  const Module *M, bool /*IsForDebug*/) const {
4335  printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
4336 }
4337 
4338 void ModuleSummaryIndex::print(raw_ostream &ROS, bool IsForDebug) const {
4339  SlotTracker SlotTable(this);
4340  formatted_raw_ostream OS(ROS);
4341  AssemblyWriter W(OS, SlotTable, this, IsForDebug);
4342  W.printModuleSummaryIndex();
4343 }
4344 
4345 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
4346 // Value::dump - allow easy printing of Values from the debugger.
4348 void Value::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
4349 
4350 // Type::dump - allow easy printing of Types from the debugger.
4352 void Type::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
4353 
4354 // Module::dump() - Allow printing of Modules from the debugger.
4356 void Module::dump() const {
4357  print(dbgs(), nullptr,
4358  /*ShouldPreserveUseListOrder=*/false, /*IsForDebug=*/true);
4359 }
4360 
4361 // Allow printing of Comdats from the debugger.
4363 void Comdat::dump() const { print(dbgs(), /*IsForDebug=*/true); }
4364 
4365 // NamedMDNode::dump() - Allow printing of NamedMDNodes from the debugger.
4367 void NamedMDNode::dump() const { print(dbgs(), /*IsForDebug=*/true); }
4368 
4370 void Metadata::dump() const { dump(nullptr); }
4371 
4373 void Metadata::dump(const Module *M) const {
4374  print(dbgs(), M, /*IsForDebug=*/true);
4375  dbgs() << '\n';
4376 }
4377 
4378 // Allow printing of ModuleSummaryIndex from the debugger.
4380 void ModuleSummaryIndex::dump() const { print(dbgs(), /*IsForDebug=*/true); }
4381 #endif
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type.
Type * getVectorElementType() const
Definition: Type.h:370
AttributeSet getAttributes() const
Return the attribute set for this global.
uint64_t CallInst * C
bool hasOperandBundles() const
Return true if this User has any operand bundles.
Definition: InstrTypes.h:1641
static const fltSemantics & IEEEquad() LLVM_READNONE
Definition: APFloat.cpp:125
StringRef getSection() const
Get the custom section of this global if it has one.
Definition: GlobalObject.h:89
static SlotTracker * createSlotTracker(const Value *V)
Definition: AsmWriter.cpp:859
bool isIntrinsic() const
isIntrinsic - Returns true if the function&#39;s name starts with "llvm.".
Definition: Function.h:198
unsigned getAlignment() const
Definition: GlobalObject.h:58
use_iterator use_end()
Definition: Value.h:346
7: Labels
Definition: Type.h:63
const std::string & getTargetTriple() const
Get the target triple which is a string describing the target host.
Definition: Module.h:240
ThreadLocalMode getThreadLocalMode() const
Definition: GlobalValue.h:254
static void WriteOptimizationInfo(raw_ostream &Out, const User *U)
Definition: AsmWriter.cpp:1242
This class is the base class for the comparison instructions.
Definition: InstrTypes.h:636
unsigned Live
In per-module summary, indicate that the global value must be considered a live root for index-based ...
iterator_range< use_iterator > uses()
Definition: Value.h:354
static std::string getLinkageName(GlobalValue::LinkageTypes LT)
Definition: AsmWriter.cpp:2855
bool hasLocalLinkage() const
Definition: GlobalValue.h:435
This instruction extracts a struct member or array element value from an aggregate value...
Special purpose, only applies to global arrays.
Definition: GlobalValue.h:54
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1562
iterator_range< CaseIt > cases()
Iteration adapter for range-for loops.
This class represents an incoming formal argument to a Function.
Definition: Argument.h:29
void purgeFunction()
After calling incorporateFunction, use this method to remove the most recently incorporated function ...
Definition: AsmWriter.cpp:1078
LLVMContext & Context
static bool printWithoutType(const Value &V, raw_ostream &O, SlotTracker *Machine, const Module *M)
Print without a type, skipping the TypePrinting object.
Definition: AsmWriter.cpp:4253
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
MSP430_INTR - Calling convention used for MSP430 interrupt routines.
Definition: CallingConv.h:105
X86_FastCall - &#39;fast&#39; analog of X86_StdCall.
Definition: CallingConv.h:91
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds...
Definition: Compiler.h:464
Type * getParamType(unsigned i) const
Parameter type accessors.
Definition: DerivedTypes.h:134
unsigned Linkage
The linkage type of the associated global value.
const GlobalValueSummary & getAliasee() const
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
2: 32-bit floating point type
Definition: Type.h:58
An instruction for ordering other memory operations.
Definition: Instructions.h:454
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:53
static StringRef getUnnamedAddrEncoding(GlobalVariable::UnnamedAddr UA)
Definition: AsmWriter.cpp:3171
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
an instruction that atomically checks whether a specified value is in a memory location, and, if it is, stores a new value there.
Definition: Instructions.h:528
FormattedNumber format_hex(uint64_t N, unsigned Width, bool Upper=false)
format_hex - Output N as a fixed width hexadecimal.
Definition: Format.h:185
Global variable summary information to aid decisions and implementation of importing.
formatted_raw_ostream - A raw_ostream that wraps another one and keeps track of line and column posit...
Unsatisfiable type (i.e. no global has this type metadata)
bool isMaterializable() const
If this function&#39;s Module is being lazily streamed in functions from disk or some other source...
Definition: Globals.cpp:44
Available for inspection, not emission.
Definition: GlobalValue.h:49
PrefixType
Definition: AsmWriter.cpp:389
This provides a very simple, boring adaptor for a begin and end iterator into a range type...
ArrayRef< ValueInfo > refs() const
Return the list of values referenced by this global value definition.
This class represents a function call, abstracting a target machine&#39;s calling convention.
This file contains the declarations for metadata subclasses.
void emplace(ArgTypes &&... Args)
Create a new object by constructing it in place with the given arguments.
Definition: Optional.h:237
Value * getCondition() const
float convertToFloat() const
Definition: APFloat.h:1097
This file contains the declaration of the Comdat class, which represents a single COMDAT in LLVM...
Like Internal, but omit from symbol table.
Definition: GlobalValue.h:56
static void PrintDLLStorageClass(GlobalValue::DLLStorageClassTypes SCT, formatted_raw_ostream &Out)
Definition: AsmWriter.cpp:3142
Fast - This calling convention attempts to make calls as fast as possible (e.g.
Definition: CallingConv.h:42
bool global_empty() const
Definition: Module.h:585
Externally visible function.
Definition: GlobalValue.h:48
void printEscapedString(StringRef Name, raw_ostream &Out)
Print each character of the specified string, escaping it if it is not printable or if it is an escap...
std::vector< VFuncId > TypeTestAssumeVCalls
List of virtual calls made by this function using (respectively) llvm.assume(llvm.type.test) or llvm.type.checked.load intrinsics that do not have all constant integer arguments.
bool hasPrologueData() const
Check whether this function has prologue data.
Definition: Function.h:719
The data referenced by the COMDAT must be the same size.
Definition: Comdat.h:38
const std::string & getDataLayoutStr() const
Get the data layout string for the module&#39;s target platform.
Definition: Module.h:231
unsigned second
BasicBlock * getSuccessor(unsigned i) const
13: Structures
Definition: Type.h:72
Metadata node.
Definition: Metadata.h:863
int getGlobalSlot(const GlobalValue *V)
getGlobalSlot - Get the slot number of a global value.
Definition: AsmWriter.cpp:1087
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1014
F(f)
4: 80-bit floating point type (X87)
Definition: Type.h:60
const fltSemantics & getSemantics() const
Definition: APFloat.h:1154
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1068
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
Definition: DerivedTypes.h:534
param_iterator param_end() const
Definition: DerivedTypes.h:128
An instruction for reading from memory.
Definition: Instructions.h:167
Manage lifetime of a slot tracker for printing IR.
1: 16-bit floating point type
Definition: Type.h:57
bool hasExternalWeakLinkage() const
Definition: GlobalValue.h:436
an instruction that atomically reads a memory location, combines it with another value, and then stores the result back.
Definition: Instructions.h:691
Hexagon Common GEP
Value * getCondition() const
Kind
Specifies which kind of type check we should emit for this byte array.
#define op(i)
OperandBundleUse getOperandBundleAt(unsigned Index) const
Return the operand bundle at a specific index.
Definition: InstrTypes.h:1685
static void writeDILocation(raw_ostream &Out, const DILocation *DL, TypePrinting *TypePrinter, SlotTracker *Machine, const Module *Context)
Definition: AsmWriter.cpp:1776
15: Pointers
Definition: Type.h:74
This defines the Use class.
void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode *>> &MDs) const
Appends all attachments for the global to MDs, sorting by attachment ID.
Definition: Metadata.cpp:1416
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:4380
static void PrintDSOLocation(const GlobalValue &GV, formatted_raw_ostream &Out)
Definition: AsmWriter.cpp:3132
Constant * getPrologueData() const
Get the prologue data associated with this function.
Definition: Function.cpp:1322
TypeTestResolution TTRes
SlotTracker * getMachine()
Lazily creates a slot tracker.
Definition: AsmWriter.cpp:829
static void predictValueUseListOrder(const Value *V, const Function *F, OrderMap &OM, UseListOrderStack &Stack)
Definition: AsmWriter.cpp:244
struct llvm::GlobalVarSummary::GVarFlags VarFlags
SPIR_KERNEL - Calling convention for SPIR kernel functions.
Definition: CallingConv.h:136
const TypeIdInfo * getTypeIdInfo() const
void print(raw_ostream &OS, bool IsForDebug=false) const
Print to an output stream.
Definition: AsmWriter.cpp:4338
static std::string getLinkageNameWithSpace(GlobalValue::LinkageTypes LT)
Definition: AsmWriter.cpp:2886
void dump() const
Support for debugging, callable in GDB: V->dump()
Definition: AsmWriter.cpp:4348
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:710
APInt getLoBits(unsigned numBits) const
Compute an APInt containing numBits lowbits from this APInt.
Definition: APInt.cpp:515
std::vector< unsigned > Shuffle
Definition: UseListOrder.h:29
static OrderMap orderModule(const Module *M)
Definition: AsmWriter.cpp:134
static void printMetadataImpl(raw_ostream &ROS, const Metadata &MD, ModuleSlotTracker &MST, const Module *M, bool OnlyAsOperand)
Definition: AsmWriter.cpp:4299
const DataLayout & getDataLayout() const
Get the data layout for the module&#39;s target platform.
Definition: Module.cpp:369
const Value * V
Definition: UseListOrder.h:27
TypeID getTypeID() const
Return the type id for the type.
Definition: Type.h:137
bool isDSOLocal() const
Definition: GlobalValue.h:279
When retpoline mitigation is enabled, use a branch funnel that is defined in the merged module...
Class to represent struct types.
Definition: DerivedTypes.h:232
A Use represents the edge between a Value definition and its users.
Definition: Use.h:55
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
Value * getDerivedPtr() const
Definition: Statepoint.h:390
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:41
std::vector< ConstVCall > TypeCheckedLoadConstVCalls
const Module * getModule() const
UnnamedAddr getUnnamedAddr() const
Definition: GlobalValue.h:212
The access may reference the value stored in memory.
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:3077
static const uint16_t * lookup(unsigned opcode, unsigned domain, ArrayRef< uint16_t[3]> Table)
HHVM calling convention for invoking C/C++ helpers.
Definition: CallingConv.h:166
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:126
This file implements a class to represent arbitrary precision integral constant values and operations...
Constant * getPrefixData() const
Get the prefix data associated with this function.
Definition: Function.cpp:1312
AtomicOrdering
Atomic ordering for LLVM&#39;s memory model.
enum llvm::WholeProgramDevirtResolution::Kind TheKind
void dump() const
Definition: AsmWriter.cpp:4363
static StringRef getOperationName(BinOp Op)
bool hasExternalLinkage() const
Definition: GlobalValue.h:421
Class to represent function types.
Definition: DerivedTypes.h:102
bool isInfinity() const
Definition: APFloat.h:1143
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:244
reverse_iterator rend()
Definition: Module.h:604
opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
Definition: APFloat.cpp:4443
void toString(SmallVectorImpl< char > &Str, unsigned FormatPrecision=0, unsigned FormatMaxPadding=3, bool TruncateZero=true) const
Definition: APFloat.h:1166
X86_StdCall - stdcall is the calling conventions mostly used by the Win32 API.
Definition: CallingConv.h:86
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:4104
Class to represent array types.
Definition: DerivedTypes.h:400
AttributeSet getParamAttributes(unsigned ArgNo) const
The attributes for the argument or parameter at the given index are returned.
VisibilityTypes
An enumeration for the kinds of visibility of global values.
Definition: GlobalValue.h:62
int getModulePathSlot(StringRef Path)
Definition: AsmWriter.cpp:1126
bool isVarArg() const
Definition: DerivedTypes.h:122
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:130
const std::string & getGC() const
Definition: Function.cpp:464
AttributeList getAttributes() const
Return the attribute list for this Function.
Definition: Function.h:223
An instruction for storing to memory.
Definition: Instructions.h:320
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:701
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
Intel_OCL_BI - Calling conventions for Intel OpenCL built-ins.
Definition: CallingConv.h:139
static void PrintVisibility(GlobalValue::VisibilityTypes Vis, formatted_raw_ostream &Out)
Definition: AsmWriter.cpp:3123
unsigned getNumOperandBundles() const
Return the number of operand bundles associated with this User.
Definition: InstrTypes.h:1636
Debug location.
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
Structure to hold a use-list order.
Definition: UseListOrder.h:26
Class to hold module path string table and global value map, and encapsulate methods for operating on...
ArrayRef< std::unique_ptr< GlobalValueSummary > > getSummaryList() const
Value * getOperand(unsigned i) const
Definition: User.h:169
int getLocalSlot(const Value *V)
Return the slot number of the specified value in it&#39;s type plane.
Definition: AsmWriter.cpp:1107
Class to represent pointers.
Definition: DerivedTypes.h:498
const std::string & getSourceFileName() const
Get the module&#39;s original source file name.
Definition: Module.h:221
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
Definition: Constants.cpp:344
The C convention as specified in the x86-64 supplement to the System V ABI, used on most non-Windows ...
Definition: CallingConv.h:143
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:639
This class provides computation of slot numbers for LLVM Assembly writing.
Definition: AsmWriter.cpp:665
ARM_AAPCS_VFP - Same as ARM_AAPCS, but uses hard floating point ABI.
Definition: CallingConv.h:102
0: type with no size
Definition: Type.h:56
#define P(N)
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:51
Synchronized with respect to all concurrently executing threads.
Definition: LLVMContext.h:54
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...
X86_INTR - x86 hardware interrupt context.
Definition: CallingConv.h:173
Calling convention used for Mesa/AMDPAL pixel shaders.
Definition: CallingConv.h:194
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:4147
Calling convention for AMDGPU code object kernels.
Definition: CallingConv.h:200
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:915
void dump() const
Dump the module to stderr (for debugging).
Definition: AsmWriter.cpp:4356
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.
MSVC calling convention that passes vectors and vector aggregates in SSE registers.
Definition: CallingConv.h:157
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:4124
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
Calling convention used by HipHop Virtual Machine (HHVM) to perform calls to and from translation cac...
Definition: CallingConv.h:163
double convertToDouble() const
Definition: APFloat.h:1096
ARM_AAPCS - ARM Architecture Procedure Calling Standard calling convention (aka EABI).
Definition: CallingConv.h:99
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
Register calling convention used for parameters transfer optimization.
Definition: CallingConv.h:203
BasicBlock * getDefaultDest() const
PTX_Device - Call to a PTX device function.
Definition: CallingConv.h:118
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:2204
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:4198
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:4263
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
C - The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
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.
SPIR_FUNC - Calling convention for SPIR non-kernel device functions.
Definition: CallingConv.h:128
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
Used for AVR interrupt routines.
Definition: CallingConv.h:176
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:3151
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:4275
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
The C convention as implemented on Windows/x86-64 and AArch64.
Definition: CallingConv.h:153
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:4352
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:4115
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:4327
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
Calling convention used for Mesa/AMDPAL hull shaders (= tessellation control shaders).
Definition: CallingConv.h:207
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
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
X86_ThisCall - Similar to X86_StdCall.
Definition: CallingConv.h:110
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
Alias summary information.
The linker will choose the largest COMDAT.
Definition: Comdat.h:36
Calling convention used for AMDPAL shader stage before geometry shader if geometry is in use...
Definition: CallingConv.h:220
static bool isReferencingMDNode(const Instruction &I)
Definition: AsmWriter.cpp:4187
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
StringRef getName() const
Definition: Metadata.cpp:1097
A lightweight accessor for an operand bundle meant to be passed around by value.
Definition: InstrTypes.h:914
iterator_range< user_iterator > users()
Definition: Value.h:399
SummaryKind
Sububclass discriminator (for dyn_cast<> et al.)
static const char * getWholeProgDevirtResByArgKindName(WholeProgramDevirtResolution::ByArg::Kind K)
Definition: AsmWriter.cpp:2717
void initializeIndexIfNeeded()
Definition: AsmWriter.cpp:915
FFlags fflags() const
Get function summary flags.
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)
Calling convention used for AMDPAL vertex shader if tessellation is in use.
Definition: CallingConv.h:215
This file provides various utilities for inspecting and working with the control flow graph in LLVM I...
Function to be accessible from DLL.
Definition: GlobalValue.h:72
bool hasGC() const
hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm to use during code generatio...
Definition: Function.h:348
std::map< std::vector< uint64_t >, ByArg > ResByArg
Resolutions for calls with all constant integer arguments (excluding the first argument, "this"), where the key is the argument vector.
Calling convention used for Mesa vertex shaders, or AMDPAL last shader stage before rasterization (ve...
Definition: CallingConv.h:188
static const char * getTTResKindName(TypeTestResolution::Kind K)
Definition: AsmWriter.cpp:2732
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:4172
Calling convention used for Mesa/AMDPAL compute shaders.
Definition: CallingConv.h:197
static void writeDIExpression(raw_ostream &Out, const DIExpression *N, TypePrinting *TypePrinter, SlotTracker *Machine, const Module *Context)
Definition: AsmWriter.cpp:2115
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
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:4370
StringRef getTagName() const
Return the tag of this operand bundle as a string.
Definition: InstrTypes.h:933
static void maybePrintComdat(formatted_raw_ostream &Out, const GlobalObject &GO)
Definition: AsmWriter.cpp:3183
static const char * getSummaryKindName(GlobalValueSummary::SummaryKind SK)
Definition: AsmWriter.cpp:2828
ARM_APCS - ARM Procedure Calling Standard calling convention (obsolete, but still used on some target...
Definition: CallingConv.h:95
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:322
ArrayRef< EdgeTy > calls() const
Return the list of <CalleeValueInfo, CalleeInfo> pairs.
Type * getValueType() const
Definition: GlobalValue.h:275
int getGUIDSlot(GlobalValue::GUID GUID)
Definition: AsmWriter.cpp:1135
Keep one copy of named function when linking (weak)
Definition: GlobalValue.h:52
static void WriteMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node, TypePrinting *TypePrinter, SlotTracker *Machine, const Module *Context)
Definition: AsmWriter.cpp:2182
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:4317
ModuleSummaryIndex.h This file contains the declarations the classes that hold the module index and s...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
bool hasAttributes() const
Return true if attributes exists in this set.
Definition: Attributes.h:264
Represents calls to the gc.relocate intrinsic.
Definition: Statepoint.h:363
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:565
LLVM Value Representation.
Definition: Value.h:72
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1302
A vector that has set insertion semantics.
Definition: SetVector.h:40
bool hasInitializer() const
Definitions have initializers, declarations don&#39;t.
static const Function * getParent(const Value *V)
AttributeSet getFnAttributes() const
The function attributes are returned.
Group flags (Linkage, NotEligibleToImport, etc.) as a bitfield.
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
Invoke instruction.
bool hasDefaultVisibility() const
Definition: GlobalValue.h:233
Type * getElementType() const
Definition: DerivedTypes.h:391
iterator_range< global_iterator > globals()
Definition: Module.h:587
IRTranslator LLVM IR MI
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
A single uniqued string.
Definition: Metadata.h:603
void dump() const
Definition: AsmWriter.cpp:4367
APInt bitcastToAPInt() const
Definition: APFloat.h:1093
Value * getBasePtr() const
Definition: Statepoint.h:386
static bool isVolatile(Instruction *Inst)
9: MMX vectors (64 bits, X86 specific)
Definition: Type.h:65
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1074
for(unsigned i=Desc.getNumOperands(), e=OldMI.getNumOperands();i !=e;++i)
static const char * getWholeProgDevirtResKindName(WholeProgramDevirtResolution::Kind K)
Definition: AsmWriter.cpp:2705
Calling convention used for Mesa/AMDPAL geometry shaders.
Definition: CallingConv.h:191
TypeFinder - Walk over a module, identifying all of the types that are used by the module...
Definition: TypeFinder.h:30
Root of the metadata hierarchy.
Definition: Metadata.h:57
bool isExternallyInitialized() const
static UseListOrderStack predictUseListOrder(const Module *M)
Definition: AsmWriter.cpp:265
bool use_empty() const
Definition: Value.h:322
static void maybePrintCallAddrSpace(const Value *Operand, const Instruction *I, raw_ostream &Out)
Definition: AsmWriter.cpp:3558
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
PTX_Kernel - Call to a PTX kernel.
Definition: CallingConv.h:114
Type * getElementType() const
Definition: DerivedTypes.h:517
TLM
Definition: LLParser.cpp:1520
int getAttributeGroupSlot(AttributeSet AS)
Definition: AsmWriter.cpp:1117
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:273
iterator_range< arg_iterator > args()
Definition: Function.h:688
Calling convention used for AVR signal routines.
Definition: CallingConv.h:179
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