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