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