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