LLVM  6.0.0svn
AsmWriter.cpp
Go to the documentation of this file.
1 //===- AsmWriter.cpp - Printing LLVM as an assembly file ------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This library implements the functionality defined in llvm/IR/Writer.h
11 //
12 // Note that these routines must be extremely tolerant of various errors in the
13 // LLVM code, because it can be used for debugging transformations.
14 //
15 //===----------------------------------------------------------------------===//
16 
17 #include "llvm/ADT/APFloat.h"
18 #include "llvm/ADT/APInt.h"
19 #include "llvm/ADT/ArrayRef.h"
20 #include "llvm/ADT/DenseMap.h"
21 #include "llvm/ADT/None.h"
22 #include "llvm/ADT/Optional.h"
23 #include "llvm/ADT/STLExtras.h"
24 #include "llvm/ADT/SetVector.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/IR/Argument.h"
33 #include "llvm/IR/Attributes.h"
34 #include "llvm/IR/BasicBlock.h"
35 #include "llvm/IR/CFG.h"
36 #include "llvm/IR/CallSite.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"
47 #include "llvm/IR/GlobalObject.h"
48 #include "llvm/IR/GlobalValue.h"
49 #include "llvm/IR/GlobalVariable.h"
51 #include "llvm/IR/InlineAsm.h"
52 #include "llvm/IR/InstrTypes.h"
53 #include "llvm/IR/Instruction.h"
54 #include "llvm/IR/Instructions.h"
55 #include "llvm/IR/LLVMContext.h"
56 #include "llvm/IR/Metadata.h"
57 #include "llvm/IR/Module.h"
59 #include "llvm/IR/Operator.h"
60 #include "llvm/IR/Statepoint.h"
61 #include "llvm/IR/Type.h"
62 #include "llvm/IR/TypeFinder.h"
63 #include "llvm/IR/Use.h"
64 #include "llvm/IR/UseListOrder.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"
75 #include <algorithm>
76 #include <cassert>
77 #include <cctype>
78 #include <cstddef>
79 #include <cstdint>
80 #include <iterator>
81 #include <memory>
82 #include <string>
83 #include <tuple>
84 #include <utility>
85 #include <vector>
86 
87 using namespace llvm;
88 
89 // Make virtual table appear in this compilation unit.
91 
92 //===----------------------------------------------------------------------===//
93 // Helper Functions
94 //===----------------------------------------------------------------------===//
95 
96 namespace {
97 
98 struct OrderMap {
100 
101  unsigned size() const { return IDs.size(); }
102  std::pair<unsigned, bool> &operator[](const Value *V) { return IDs[V]; }
103 
104  std::pair<unsigned, bool> lookup(const Value *V) const {
105  return IDs.lookup(V);
106  }
107 
108  void index(const Value *V) {
109  // Explicitly sequence get-size and insert-value operations to avoid UB.
110  unsigned ID = IDs.size() + 1;
111  IDs[V].first = ID;
112  }
113 };
114 
115 } // end anonymous namespace
116 
117 static void orderValue(const Value *V, OrderMap &OM) {
118  if (OM.lookup(V).first)
119  return;
120 
121  if (const Constant *C = dyn_cast<Constant>(V))
122  if (C->getNumOperands() && !isa<GlobalValue>(C))
123  for (const Value *Op : C->operands())
124  if (!isa<BasicBlock>(Op) && !isa<GlobalValue>(Op))
125  orderValue(Op, OM);
126 
127  // Note: we cannot cache this lookup above, since inserting into the map
128  // changes the map's size, and thus affects the other IDs.
129  OM.index(V);
130 }
131 
132 static OrderMap orderModule(const Module *M) {
133  // This needs to match the order used by ValueEnumerator::ValueEnumerator()
134  // and ValueEnumerator::incorporateFunction().
135  OrderMap OM;
136 
137  for (const GlobalVariable &G : M->globals()) {
138  if (G.hasInitializer())
139  if (!isa<GlobalValue>(G.getInitializer()))
140  orderValue(G.getInitializer(), OM);
141  orderValue(&G, OM);
142  }
143  for (const GlobalAlias &A : M->aliases()) {
144  if (!isa<GlobalValue>(A.getAliasee()))
145  orderValue(A.getAliasee(), OM);
146  orderValue(&A, OM);
147  }
148  for (const GlobalIFunc &I : M->ifuncs()) {
149  if (!isa<GlobalValue>(I.getResolver()))
150  orderValue(I.getResolver(), OM);
151  orderValue(&I, OM);
152  }
153  for (const Function &F : *M) {
154  for (const Use &U : F.operands())
155  if (!isa<GlobalValue>(U.get()))
156  orderValue(U.get(), OM);
157 
158  orderValue(&F, OM);
159 
160  if (F.isDeclaration())
161  continue;
162 
163  for (const Argument &A : F.args())
164  orderValue(&A, OM);
165  for (const BasicBlock &BB : F) {
166  orderValue(&BB, OM);
167  for (const Instruction &I : BB) {
168  for (const Value *Op : I.operands())
169  if ((isa<Constant>(*Op) && !isa<GlobalValue>(*Op)) ||
170  isa<InlineAsm>(*Op))
171  orderValue(Op, OM);
172  orderValue(&I, OM);
173  }
174  }
175  }
176  return OM;
177 }
178 
179 static void predictValueUseListOrderImpl(const Value *V, const Function *F,
180  unsigned ID, const OrderMap &OM,
181  UseListOrderStack &Stack) {
182  // Predict use-list order for this one.
183  using Entry = std::pair<const Use *, unsigned>;
185  for (const Use &U : V->uses())
186  // Check if this user will be serialized.
187  if (OM.lookup(U.getUser()).first)
188  List.push_back(std::make_pair(&U, List.size()));
189 
190  if (List.size() < 2)
191  // We may have lost some users.
192  return;
193 
194  bool GetsReversed =
195  !isa<GlobalVariable>(V) && !isa<Function>(V) && !isa<BasicBlock>(V);
196  if (auto *BA = dyn_cast<BlockAddress>(V))
197  ID = OM.lookup(BA->getBasicBlock()).first;
198  std::sort(List.begin(), List.end(), [&](const Entry &L, const Entry &R) {
199  const Use *LU = L.first;
200  const Use *RU = R.first;
201  if (LU == RU)
202  return false;
203 
204  auto LID = OM.lookup(LU->getUser()).first;
205  auto RID = OM.lookup(RU->getUser()).first;
206 
207  // If ID is 4, then expect: 7 6 5 1 2 3.
208  if (LID < RID) {
209  if (GetsReversed)
210  if (RID <= ID)
211  return true;
212  return false;
213  }
214  if (RID < LID) {
215  if (GetsReversed)
216  if (LID <= ID)
217  return false;
218  return true;
219  }
220 
221  // LID and RID are equal, so we have different operands of the same user.
222  // Assume operands are added in order for all instructions.
223  if (GetsReversed)
224  if (LID <= ID)
225  return LU->getOperandNo() < RU->getOperandNo();
226  return LU->getOperandNo() > RU->getOperandNo();
227  });
228 
229  if (std::is_sorted(
230  List.begin(), List.end(),
231  [](const Entry &L, const Entry &R) { return L.second < R.second; }))
232  // Order is already correct.
233  return;
234 
235  // Store the shuffle.
236  Stack.emplace_back(V, F, List.size());
237  assert(List.size() == Stack.back().Shuffle.size() && "Wrong size");
238  for (size_t I = 0, E = List.size(); I != E; ++I)
239  Stack.back().Shuffle[I] = List[I].second;
240 }
241 
242 static void predictValueUseListOrder(const Value *V, const Function *F,
243  OrderMap &OM, UseListOrderStack &Stack) {
244  auto &IDPair = OM[V];
245  assert(IDPair.first && "Unmapped value");
246  if (IDPair.second)
247  // Already predicted.
248  return;
249 
250  // Do the actual prediction.
251  IDPair.second = true;
252  if (!V->use_empty() && std::next(V->use_begin()) != V->use_end())
253  predictValueUseListOrderImpl(V, F, IDPair.first, OM, Stack);
254 
255  // Recursive descent into constants.
256  if (const Constant *C = dyn_cast<Constant>(V))
257  if (C->getNumOperands()) // Visit GlobalValues.
258  for (const Value *Op : C->operands())
259  if (isa<Constant>(Op)) // Visit GlobalValues.
260  predictValueUseListOrder(Op, F, OM, Stack);
261 }
262 
264  OrderMap OM = orderModule(M);
265 
266  // Use-list orders need to be serialized after all the users have been added
267  // to a value, or else the shuffles will be incomplete. Store them per
268  // function in a stack.
269  //
270  // Aside from function order, the order of values doesn't matter much here.
271  UseListOrderStack Stack;
272 
273  // We want to visit the functions backward now so we can list function-local
274  // constants in the last Function they're used in. Module-level constants
275  // have already been visited above.
276  for (const Function &F : make_range(M->rbegin(), M->rend())) {
277  if (F.isDeclaration())
278  continue;
279  for (const BasicBlock &BB : F)
280  predictValueUseListOrder(&BB, &F, OM, Stack);
281  for (const Argument &A : F.args())
282  predictValueUseListOrder(&A, &F, OM, Stack);
283  for (const BasicBlock &BB : F)
284  for (const Instruction &I : BB)
285  for (const Value *Op : I.operands())
286  if (isa<Constant>(*Op) || isa<InlineAsm>(*Op)) // Visit GlobalValues.
287  predictValueUseListOrder(Op, &F, OM, Stack);
288  for (const BasicBlock &BB : F)
289  for (const Instruction &I : BB)
290  predictValueUseListOrder(&I, &F, OM, Stack);
291  }
292 
293  // Visit globals last.
294  for (const GlobalVariable &G : M->globals())
295  predictValueUseListOrder(&G, nullptr, OM, Stack);
296  for (const Function &F : *M)
297  predictValueUseListOrder(&F, nullptr, OM, Stack);
298  for (const GlobalAlias &A : M->aliases())
299  predictValueUseListOrder(&A, nullptr, OM, Stack);
300  for (const GlobalIFunc &I : M->ifuncs())
301  predictValueUseListOrder(&I, nullptr, OM, Stack);
302  for (const GlobalVariable &G : M->globals())
303  if (G.hasInitializer())
304  predictValueUseListOrder(G.getInitializer(), nullptr, OM, Stack);
305  for (const GlobalAlias &A : M->aliases())
306  predictValueUseListOrder(A.getAliasee(), nullptr, OM, Stack);
307  for (const GlobalIFunc &I : M->ifuncs())
308  predictValueUseListOrder(I.getResolver(), nullptr, OM, Stack);
309  for (const Function &F : *M)
310  for (const Use &U : F.operands())
311  predictValueUseListOrder(U.get(), nullptr, OM, Stack);
312 
313  return Stack;
314 }
315 
316 static const Module *getModuleFromVal(const Value *V) {
317  if (const Argument *MA = dyn_cast<Argument>(V))
318  return MA->getParent() ? MA->getParent()->getParent() : nullptr;
319 
320  if (const BasicBlock *BB = dyn_cast<BasicBlock>(V))
321  return BB->getParent() ? BB->getParent()->getParent() : nullptr;
322 
323  if (const Instruction *I = dyn_cast<Instruction>(V)) {
324  const Function *M = I->getParent() ? I->getParent()->getParent() : nullptr;
325  return M ? M->getParent() : nullptr;
326  }
327 
328  if (const GlobalValue *GV = dyn_cast<GlobalValue>(V))
329  return GV->getParent();
330 
331  if (const auto *MAV = dyn_cast<MetadataAsValue>(V)) {
332  for (const User *U : MAV->users())
333  if (isa<Instruction>(U))
334  if (const Module *M = getModuleFromVal(U))
335  return M;
336  return nullptr;
337  }
338 
339  return nullptr;
340 }
341 
342 static void PrintCallingConv(unsigned cc, raw_ostream &Out) {
343  switch (cc) {
344  default: Out << "cc" << cc; break;
345  case CallingConv::Fast: Out << "fastcc"; break;
346  case CallingConv::Cold: Out << "coldcc"; break;
347  case CallingConv::WebKit_JS: Out << "webkit_jscc"; break;
348  case CallingConv::AnyReg: Out << "anyregcc"; break;
349  case CallingConv::PreserveMost: Out << "preserve_mostcc"; break;
350  case CallingConv::PreserveAll: Out << "preserve_allcc"; break;
351  case CallingConv::CXX_FAST_TLS: Out << "cxx_fast_tlscc"; break;
352  case CallingConv::GHC: Out << "ghccc"; break;
353  case CallingConv::X86_StdCall: Out << "x86_stdcallcc"; break;
354  case CallingConv::X86_FastCall: Out << "x86_fastcallcc"; break;
355  case CallingConv::X86_ThisCall: Out << "x86_thiscallcc"; break;
356  case CallingConv::X86_RegCall: Out << "x86_regcallcc"; break;
357  case CallingConv::X86_VectorCall:Out << "x86_vectorcallcc"; break;
358  case CallingConv::Intel_OCL_BI: Out << "intel_ocl_bicc"; break;
359  case CallingConv::ARM_APCS: Out << "arm_apcscc"; break;
360  case CallingConv::ARM_AAPCS: Out << "arm_aapcscc"; break;
361  case CallingConv::ARM_AAPCS_VFP: Out << "arm_aapcs_vfpcc"; break;
362  case CallingConv::MSP430_INTR: Out << "msp430_intrcc"; break;
363  case CallingConv::AVR_INTR: Out << "avr_intrcc "; break;
364  case CallingConv::AVR_SIGNAL: Out << "avr_signalcc "; break;
365  case CallingConv::PTX_Kernel: Out << "ptx_kernel"; break;
366  case CallingConv::PTX_Device: Out << "ptx_device"; break;
367  case CallingConv::X86_64_SysV: Out << "x86_64_sysvcc"; break;
368  case CallingConv::Win64: Out << "win64cc"; break;
369  case CallingConv::SPIR_FUNC: Out << "spir_func"; break;
370  case CallingConv::SPIR_KERNEL: Out << "spir_kernel"; break;
371  case CallingConv::Swift: Out << "swiftcc"; break;
372  case CallingConv::X86_INTR: Out << "x86_intrcc"; break;
373  case CallingConv::HHVM: Out << "hhvmcc"; break;
374  case CallingConv::HHVM_C: Out << "hhvm_ccc"; break;
375  case CallingConv::AMDGPU_VS: Out << "amdgpu_vs"; break;
376  case CallingConv::AMDGPU_HS: Out << "amdgpu_hs"; break;
377  case CallingConv::AMDGPU_GS: Out << "amdgpu_gs"; break;
378  case CallingConv::AMDGPU_PS: Out << "amdgpu_ps"; break;
379  case CallingConv::AMDGPU_CS: Out << "amdgpu_cs"; break;
380  case CallingConv::AMDGPU_KERNEL: Out << "amdgpu_kernel"; break;
381  }
382 }
383 
385  for (unsigned i = 0, e = Name.size(); i != e; ++i) {
386  unsigned char C = Name[i];
387  if (isprint(C) && C != '\\' && C != '"')
388  Out << C;
389  else
390  Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
391  }
392 }
393 
400 };
401 
403  assert(!Name.empty() && "Cannot get empty name!");
404 
405  // Scan the name to see if it needs quotes first.
406  bool NeedsQuotes = isdigit(static_cast<unsigned char>(Name[0]));
407  if (!NeedsQuotes) {
408  for (unsigned i = 0, e = Name.size(); i != e; ++i) {
409  // By making this unsigned, the value passed in to isalnum will always be
410  // in the range 0-255. This is important when building with MSVC because
411  // its implementation will assert. This situation can arise when dealing
412  // with UTF-8 multibyte characters.
413  unsigned char C = Name[i];
414  if (!isalnum(static_cast<unsigned char>(C)) && C != '-' && C != '.' &&
415  C != '_') {
416  NeedsQuotes = true;
417  break;
418  }
419  }
420  }
421 
422  // If we didn't need any quotes, just write out the name in one blast.
423  if (!NeedsQuotes) {
424  OS << Name;
425  return;
426  }
427 
428  // Okay, we need quotes. Output the quotes and escape any scary characters as
429  // needed.
430  OS << '"';
431  PrintEscapedString(Name, OS);
432  OS << '"';
433 }
434 
435 /// Turn the specified name into an 'LLVM name', which is either prefixed with %
436 /// (if the string only contains simple characters) or is surrounded with ""'s
437 /// (if it has special chars in it). Print it out.
439  switch (Prefix) {
440  case NoPrefix:
441  break;
442  case GlobalPrefix:
443  OS << '@';
444  break;
445  case ComdatPrefix:
446  OS << '$';
447  break;
448  case LabelPrefix:
449  break;
450  case LocalPrefix:
451  OS << '%';
452  break;
453  }
454  printLLVMNameWithoutPrefix(OS, Name);
455 }
456 
457 /// Turn the specified name into an 'LLVM name', which is either prefixed with %
458 /// (if the string only contains simple characters) or is surrounded with ""'s
459 /// (if it has special chars in it). Print it out.
460 static void PrintLLVMName(raw_ostream &OS, const Value *V) {
461  PrintLLVMName(OS, V->getName(),
462  isa<GlobalValue>(V) ? GlobalPrefix : LocalPrefix);
463 }
464 
465 namespace {
466 
467 class TypePrinting {
468 public:
469  /// NamedTypes - The named types that are used by the current module.
470  TypeFinder NamedTypes;
471 
472  /// NumberedTypes - The numbered types, along with their value.
473  DenseMap<StructType*, unsigned> NumberedTypes;
474 
475  TypePrinting() = default;
476  TypePrinting(const TypePrinting &) = delete;
477  TypePrinting &operator=(const TypePrinting &) = delete;
478 
479  void incorporateTypes(const Module &M);
480 
481  void print(Type *Ty, raw_ostream &OS);
482 
483  void printStructBody(StructType *Ty, raw_ostream &OS);
484 };
485 
486 } // end anonymous namespace
487 
488 void TypePrinting::incorporateTypes(const Module &M) {
489  NamedTypes.run(M, false);
490 
491  // The list of struct types we got back includes all the struct types, split
492  // the unnamed ones out to a numbering and remove the anonymous structs.
493  unsigned NextNumber = 0;
494 
495  std::vector<StructType*>::iterator NextToUse = NamedTypes.begin(), I, E;
496  for (I = NamedTypes.begin(), E = NamedTypes.end(); I != E; ++I) {
497  StructType *STy = *I;
498 
499  // Ignore anonymous types.
500  if (STy->isLiteral())
501  continue;
502 
503  if (STy->getName().empty())
504  NumberedTypes[STy] = NextNumber++;
505  else
506  *NextToUse++ = STy;
507  }
508 
509  NamedTypes.erase(NextToUse, NamedTypes.end());
510 }
511 
512 
513 /// CalcTypeName - Write the specified type to the specified raw_ostream, making
514 /// use of type names or up references to shorten the type name where possible.
515 void TypePrinting::print(Type *Ty, raw_ostream &OS) {
516  switch (Ty->getTypeID()) {
517  case Type::VoidTyID: OS << "void"; return;
518  case Type::HalfTyID: OS << "half"; return;
519  case Type::FloatTyID: OS << "float"; return;
520  case Type::DoubleTyID: OS << "double"; return;
521  case Type::X86_FP80TyID: OS << "x86_fp80"; return;
522  case Type::FP128TyID: OS << "fp128"; return;
523  case Type::PPC_FP128TyID: OS << "ppc_fp128"; return;
524  case Type::LabelTyID: OS << "label"; return;
525  case Type::MetadataTyID: OS << "metadata"; return;
526  case Type::X86_MMXTyID: OS << "x86_mmx"; return;
527  case Type::TokenTyID: OS << "token"; return;
528  case Type::IntegerTyID:
529  OS << 'i' << cast<IntegerType>(Ty)->getBitWidth();
530  return;
531 
532  case Type::FunctionTyID: {
533  FunctionType *FTy = cast<FunctionType>(Ty);
534  print(FTy->getReturnType(), OS);
535  OS << " (";
537  E = FTy->param_end(); I != E; ++I) {
538  if (I != FTy->param_begin())
539  OS << ", ";
540  print(*I, OS);
541  }
542  if (FTy->isVarArg()) {
543  if (FTy->getNumParams()) OS << ", ";
544  OS << "...";
545  }
546  OS << ')';
547  return;
548  }
549  case Type::StructTyID: {
550  StructType *STy = cast<StructType>(Ty);
551 
552  if (STy->isLiteral())
553  return printStructBody(STy, OS);
554 
555  if (!STy->getName().empty())
556  return PrintLLVMName(OS, STy->getName(), LocalPrefix);
557 
558  DenseMap<StructType*, unsigned>::iterator I = NumberedTypes.find(STy);
559  if (I != NumberedTypes.end())
560  OS << '%' << I->second;
561  else // Not enumerated, print the hex address.
562  OS << "%\"type " << STy << '\"';
563  return;
564  }
565  case Type::PointerTyID: {
566  PointerType *PTy = cast<PointerType>(Ty);
567  print(PTy->getElementType(), OS);
568  if (unsigned AddressSpace = PTy->getAddressSpace())
569  OS << " addrspace(" << AddressSpace << ')';
570  OS << '*';
571  return;
572  }
573  case Type::ArrayTyID: {
574  ArrayType *ATy = cast<ArrayType>(Ty);
575  OS << '[' << ATy->getNumElements() << " x ";
576  print(ATy->getElementType(), OS);
577  OS << ']';
578  return;
579  }
580  case Type::VectorTyID: {
581  VectorType *PTy = cast<VectorType>(Ty);
582  OS << "<" << PTy->getNumElements() << " x ";
583  print(PTy->getElementType(), OS);
584  OS << '>';
585  return;
586  }
587  }
588  llvm_unreachable("Invalid TypeID");
589 }
590 
591 void TypePrinting::printStructBody(StructType *STy, raw_ostream &OS) {
592  if (STy->isOpaque()) {
593  OS << "opaque";
594  return;
595  }
596 
597  if (STy->isPacked())
598  OS << '<';
599 
600  if (STy->getNumElements() == 0) {
601  OS << "{}";
602  } else {
603  StructType::element_iterator I = STy->element_begin();
604  OS << "{ ";
605  print(*I++, OS);
606  for (StructType::element_iterator E = STy->element_end(); I != E; ++I) {
607  OS << ", ";
608  print(*I, OS);
609  }
610 
611  OS << " }";
612  }
613  if (STy->isPacked())
614  OS << '>';
615 }
616 
617 namespace llvm {
618 
619 //===----------------------------------------------------------------------===//
620 // SlotTracker Class: Enumerate slot numbers for unnamed values
621 //===----------------------------------------------------------------------===//
622 /// This class provides computation of slot numbers for LLVM Assembly writing.
623 ///
624 class SlotTracker {
625 public:
626  /// ValueMap - A mapping of Values to slot numbers.
627  using ValueMap = DenseMap<const Value *, unsigned>;
628 
629 private:
630  /// TheModule - The module for which we are holding slot numbers.
631  const Module* TheModule;
632 
633  /// TheFunction - The function for which we are holding slot numbers.
634  const Function* TheFunction = nullptr;
635  bool FunctionProcessed = false;
636  bool ShouldInitializeAllMetadata;
637 
638  /// mMap - The slot map for the module level data.
639  ValueMap mMap;
640  unsigned mNext = 0;
641 
642  /// fMap - The slot map for the function level data.
643  ValueMap fMap;
644  unsigned fNext = 0;
645 
646  /// mdnMap - Map for MDNodes.
647  DenseMap<const MDNode*, unsigned> mdnMap;
648  unsigned mdnNext = 0;
649 
650  /// asMap - The slot map for attribute sets.
651  DenseMap<AttributeSet, unsigned> asMap;
652  unsigned asNext = 0;
653 
654 public:
655  /// Construct from a module.
656  ///
657  /// If \c ShouldInitializeAllMetadata, initializes all metadata in all
658  /// functions, giving correct numbering for metadata referenced only from
659  /// within a function (even if no functions have been initialized).
660  explicit SlotTracker(const Module *M,
661  bool ShouldInitializeAllMetadata = false);
662 
663  /// Construct from a function, starting out in incorp state.
664  ///
665  /// If \c ShouldInitializeAllMetadata, initializes all metadata in all
666  /// functions, giving correct numbering for metadata referenced only from
667  /// within a function (even if no functions have been initialized).
668  explicit SlotTracker(const Function *F,
669  bool ShouldInitializeAllMetadata = false);
670 
671  SlotTracker(const SlotTracker &) = delete;
672  SlotTracker &operator=(const SlotTracker &) = delete;
673 
674  /// Return the slot number of the specified value in it's type
675  /// plane. If something is not in the SlotTracker, return -1.
676  int getLocalSlot(const Value *V);
677  int getGlobalSlot(const GlobalValue *V);
678  int getMetadataSlot(const MDNode *N);
679  int getAttributeGroupSlot(AttributeSet AS);
680 
681  /// If you'd like to deal with a function instead of just a module, use
682  /// this method to get its data into the SlotTracker.
683  void incorporateFunction(const Function *F) {
684  TheFunction = F;
685  FunctionProcessed = false;
686  }
687 
688  const Function *getFunction() const { return TheFunction; }
689 
690  /// After calling incorporateFunction, use this method to remove the
691  /// most recently incorporated function from the SlotTracker. This
692  /// will reset the state of the machine back to just the module contents.
693  void purgeFunction();
694 
695  /// MDNode map iterators.
696  using mdn_iterator = DenseMap<const MDNode*, unsigned>::iterator;
697 
698  mdn_iterator mdn_begin() { return mdnMap.begin(); }
699  mdn_iterator mdn_end() { return mdnMap.end(); }
700  unsigned mdn_size() const { return mdnMap.size(); }
701  bool mdn_empty() const { return mdnMap.empty(); }
702 
703  /// AttributeSet map iterators.
704  using as_iterator = DenseMap<AttributeSet, unsigned>::iterator;
705 
706  as_iterator as_begin() { return asMap.begin(); }
707  as_iterator as_end() { return asMap.end(); }
708  unsigned as_size() const { return asMap.size(); }
709  bool as_empty() const { return asMap.empty(); }
710 
711  /// This function does the actual initialization.
712  inline void initialize();
713 
714  // Implementation Details
715 private:
716  /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
717  void CreateModuleSlot(const GlobalValue *V);
718 
719  /// CreateMetadataSlot - Insert the specified MDNode* into the slot table.
720  void CreateMetadataSlot(const MDNode *N);
721 
722  /// CreateFunctionSlot - Insert the specified Value* into the slot table.
723  void CreateFunctionSlot(const Value *V);
724 
725  /// \brief Insert the specified AttributeSet into the slot table.
726  void CreateAttributeSetSlot(AttributeSet AS);
727 
728  /// Add all of the module level global variables (and their initializers)
729  /// and function declarations, but not the contents of those functions.
730  void processModule();
731 
732  /// Add all of the functions arguments, basic blocks, and instructions.
733  void processFunction();
734 
735  /// Add the metadata directly attached to a GlobalObject.
736  void processGlobalObjectMetadata(const GlobalObject &GO);
737 
738  /// Add all of the metadata from a function.
739  void processFunctionMetadata(const Function &F);
740 
741  /// Add all of the metadata from an instruction.
742  void processInstructionMetadata(const Instruction &I);
743 };
744 
745 } // end namespace llvm
746 
747 ModuleSlotTracker::ModuleSlotTracker(SlotTracker &Machine, const Module *M,
748  const Function *F)
749  : M(M), F(F), Machine(&Machine) {}
750 
751 ModuleSlotTracker::ModuleSlotTracker(const Module *M,
752  bool ShouldInitializeAllMetadata)
753  : ShouldCreateStorage(M),
754  ShouldInitializeAllMetadata(ShouldInitializeAllMetadata), M(M) {}
755 
756 ModuleSlotTracker::~ModuleSlotTracker() = default;
757 
758 SlotTracker *ModuleSlotTracker::getMachine() {
759  if (!ShouldCreateStorage)
760  return Machine;
761 
762  ShouldCreateStorage = false;
763  MachineStorage =
764  llvm::make_unique<SlotTracker>(M, ShouldInitializeAllMetadata);
765  Machine = MachineStorage.get();
766  return Machine;
767 }
768 
769 void ModuleSlotTracker::incorporateFunction(const Function &F) {
770  // Using getMachine() may lazily create the slot tracker.
771  if (!getMachine())
772  return;
773 
774  // Nothing to do if this is the right function already.
775  if (this->F == &F)
776  return;
777  if (this->F)
778  Machine->purgeFunction();
779  Machine->incorporateFunction(&F);
780  this->F = &F;
781 }
782 
783 int ModuleSlotTracker::getLocalSlot(const Value *V) {
784  assert(F && "No function incorporated");
785  return Machine->getLocalSlot(V);
786 }
787 
788 static SlotTracker *createSlotTracker(const Value *V) {
789  if (const Argument *FA = dyn_cast<Argument>(V))
790  return new SlotTracker(FA->getParent());
791 
792  if (const Instruction *I = dyn_cast<Instruction>(V))
793  if (I->getParent())
794  return new SlotTracker(I->getParent()->getParent());
795 
796  if (const BasicBlock *BB = dyn_cast<BasicBlock>(V))
797  return new SlotTracker(BB->getParent());
798 
799  if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V))
800  return new SlotTracker(GV->getParent());
801 
802  if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(V))
803  return new SlotTracker(GA->getParent());
804 
805  if (const GlobalIFunc *GIF = dyn_cast<GlobalIFunc>(V))
806  return new SlotTracker(GIF->getParent());
807 
808  if (const Function *Func = dyn_cast<Function>(V))
809  return new SlotTracker(Func);
810 
811  return nullptr;
812 }
813 
814 #if 0
815 #define ST_DEBUG(X) dbgs() << X
816 #else
817 #define ST_DEBUG(X)
818 #endif
819 
820 // Module level constructor. Causes the contents of the Module (sans functions)
821 // to be added to the slot table.
822 SlotTracker::SlotTracker(const Module *M, bool ShouldInitializeAllMetadata)
823  : TheModule(M), ShouldInitializeAllMetadata(ShouldInitializeAllMetadata) {}
824 
825 // Function level constructor. Causes the contents of the Module and the one
826 // function provided to be added to the slot table.
827 SlotTracker::SlotTracker(const Function *F, bool ShouldInitializeAllMetadata)
828  : TheModule(F ? F->getParent() : nullptr), TheFunction(F),
829  ShouldInitializeAllMetadata(ShouldInitializeAllMetadata) {}
830 
831 inline void SlotTracker::initialize() {
832  if (TheModule) {
833  processModule();
834  TheModule = nullptr; ///< Prevent re-processing next time we're called.
835  }
836 
837  if (TheFunction && !FunctionProcessed)
838  processFunction();
839 }
840 
841 // Iterate through all the global variables, functions, and global
842 // variable initializers and create slots for them.
843 void SlotTracker::processModule() {
844  ST_DEBUG("begin processModule!\n");
845 
846  // Add all of the unnamed global variables to the value table.
847  for (const GlobalVariable &Var : TheModule->globals()) {
848  if (!Var.hasName())
849  CreateModuleSlot(&Var);
850  processGlobalObjectMetadata(Var);
851  auto Attrs = Var.getAttributes();
852  if (Attrs.hasAttributes())
853  CreateAttributeSetSlot(Attrs);
854  }
855 
856  for (const GlobalAlias &A : TheModule->aliases()) {
857  if (!A.hasName())
858  CreateModuleSlot(&A);
859  }
860 
861  for (const GlobalIFunc &I : TheModule->ifuncs()) {
862  if (!I.hasName())
863  CreateModuleSlot(&I);
864  }
865 
866  // Add metadata used by named metadata.
867  for (const NamedMDNode &NMD : TheModule->named_metadata()) {
868  for (unsigned i = 0, e = NMD.getNumOperands(); i != e; ++i)
869  CreateMetadataSlot(NMD.getOperand(i));
870  }
871 
872  for (const Function &F : *TheModule) {
873  if (!F.hasName())
874  // Add all the unnamed functions to the table.
875  CreateModuleSlot(&F);
876 
877  if (ShouldInitializeAllMetadata)
878  processFunctionMetadata(F);
879 
880  // Add all the function attributes to the table.
881  // FIXME: Add attributes of other objects?
882  AttributeSet FnAttrs = F.getAttributes().getFnAttributes();
883  if (FnAttrs.hasAttributes())
884  CreateAttributeSetSlot(FnAttrs);
885  }
886 
887  ST_DEBUG("end processModule!\n");
888 }
889 
890 // Process the arguments, basic blocks, and instructions of a function.
891 void SlotTracker::processFunction() {
892  ST_DEBUG("begin processFunction!\n");
893  fNext = 0;
894 
895  // Process function metadata if it wasn't hit at the module-level.
896  if (!ShouldInitializeAllMetadata)
897  processFunctionMetadata(*TheFunction);
898 
899  // Add all the function arguments with no names.
900  for(Function::const_arg_iterator AI = TheFunction->arg_begin(),
901  AE = TheFunction->arg_end(); AI != AE; ++AI)
902  if (!AI->hasName())
903  CreateFunctionSlot(&*AI);
904 
905  ST_DEBUG("Inserting Instructions:\n");
906 
907  // Add all of the basic blocks and instructions with no names.
908  for (auto &BB : *TheFunction) {
909  if (!BB.hasName())
910  CreateFunctionSlot(&BB);
911 
912  for (auto &I : BB) {
913  if (!I.getType()->isVoidTy() && !I.hasName())
914  CreateFunctionSlot(&I);
915 
916  // We allow direct calls to any llvm.foo function here, because the
917  // target may not be linked into the optimizer.
918  if (auto CS = ImmutableCallSite(&I)) {
919  // Add all the call attributes to the table.
920  AttributeSet Attrs = CS.getAttributes().getFnAttributes();
921  if (Attrs.hasAttributes())
922  CreateAttributeSetSlot(Attrs);
923  }
924  }
925  }
926 
927  FunctionProcessed = true;
928 
929  ST_DEBUG("end processFunction!\n");
930 }
931 
932 void SlotTracker::processGlobalObjectMetadata(const GlobalObject &GO) {
934  GO.getAllMetadata(MDs);
935  for (auto &MD : MDs)
936  CreateMetadataSlot(MD.second);
937 }
938 
939 void SlotTracker::processFunctionMetadata(const Function &F) {
940  processGlobalObjectMetadata(F);
941  for (auto &BB : F) {
942  for (auto &I : BB)
943  processInstructionMetadata(I);
944  }
945 }
946 
947 void SlotTracker::processInstructionMetadata(const Instruction &I) {
948  // Process metadata used directly by intrinsics.
949  if (const CallInst *CI = dyn_cast<CallInst>(&I))
950  if (Function *F = CI->getCalledFunction())
951  if (F->isIntrinsic())
952  for (auto &Op : I.operands())
953  if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op))
954  if (MDNode *N = dyn_cast<MDNode>(V->getMetadata()))
955  CreateMetadataSlot(N);
956 
957  // Process metadata attached to this instruction.
959  I.getAllMetadata(MDs);
960  for (auto &MD : MDs)
961  CreateMetadataSlot(MD.second);
962 }
963 
964 /// Clean up after incorporating a function. This is the only way to get out of
965 /// the function incorporation state that affects get*Slot/Create*Slot. Function
966 /// incorporation state is indicated by TheFunction != 0.
968  ST_DEBUG("begin purgeFunction!\n");
969  fMap.clear(); // Simply discard the function level map
970  TheFunction = nullptr;
971  FunctionProcessed = false;
972  ST_DEBUG("end purgeFunction!\n");
973 }
974 
975 /// getGlobalSlot - Get the slot number of a global value.
977  // Check for uninitialized state and do lazy initialization.
978  initialize();
979 
980  // Find the value in the module map
981  ValueMap::iterator MI = mMap.find(V);
982  return MI == mMap.end() ? -1 : (int)MI->second;
983 }
984 
985 /// getMetadataSlot - Get the slot number of a MDNode.
987  // Check for uninitialized state and do lazy initialization.
988  initialize();
989 
990  // Find the MDNode in the module map
991  mdn_iterator MI = mdnMap.find(N);
992  return MI == mdnMap.end() ? -1 : (int)MI->second;
993 }
994 
995 /// getLocalSlot - Get the slot number for a value that is local to a function.
997  assert(!isa<Constant>(V) && "Can't get a constant or global slot with this!");
998 
999  // Check for uninitialized state and do lazy initialization.
1000  initialize();
1001 
1002  ValueMap::iterator FI = fMap.find(V);
1003  return FI == fMap.end() ? -1 : (int)FI->second;
1004 }
1005 
1007  // Check for uninitialized state and do lazy initialization.
1008  initialize();
1009 
1010  // Find the AttributeSet in the module map.
1011  as_iterator AI = asMap.find(AS);
1012  return AI == asMap.end() ? -1 : (int)AI->second;
1013 }
1014 
1015 /// CreateModuleSlot - Insert the specified GlobalValue* into the slot table.
1016 void SlotTracker::CreateModuleSlot(const GlobalValue *V) {
1017  assert(V && "Can't insert a null Value into SlotTracker!");
1018  assert(!V->getType()->isVoidTy() && "Doesn't need a slot!");
1019  assert(!V->hasName() && "Doesn't need a slot!");
1020 
1021  unsigned DestSlot = mNext++;
1022  mMap[V] = DestSlot;
1023 
1024  ST_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" <<
1025  DestSlot << " [");
1026  // G = Global, F = Function, A = Alias, I = IFunc, o = other
1027  ST_DEBUG((isa<GlobalVariable>(V) ? 'G' :
1028  (isa<Function>(V) ? 'F' :
1029  (isa<GlobalAlias>(V) ? 'A' :
1030  (isa<GlobalIFunc>(V) ? 'I' : 'o')))) << "]\n");
1031 }
1032 
1033 /// CreateSlot - Create a new slot for the specified value if it has no name.
1034 void SlotTracker::CreateFunctionSlot(const Value *V) {
1035  assert(!V->getType()->isVoidTy() && !V->hasName() && "Doesn't need a slot!");
1036 
1037  unsigned DestSlot = fNext++;
1038  fMap[V] = DestSlot;
1039 
1040  // G = Global, F = Function, o = other
1041  ST_DEBUG(" Inserting value [" << V->getType() << "] = " << V << " slot=" <<
1042  DestSlot << " [o]\n");
1043 }
1044 
1045 /// CreateModuleSlot - Insert the specified MDNode* into the slot table.
1046 void SlotTracker::CreateMetadataSlot(const MDNode *N) {
1047  assert(N && "Can't insert a null Value into SlotTracker!");
1048 
1049  unsigned DestSlot = mdnNext;
1050  if (!mdnMap.insert(std::make_pair(N, DestSlot)).second)
1051  return;
1052  ++mdnNext;
1053 
1054  // Recursively add any MDNodes referenced by operands.
1055  for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
1056  if (const MDNode *Op = dyn_cast_or_null<MDNode>(N->getOperand(i)))
1057  CreateMetadataSlot(Op);
1058 }
1059 
1060 void SlotTracker::CreateAttributeSetSlot(AttributeSet AS) {
1061  assert(AS.hasAttributes() && "Doesn't need a slot!");
1062 
1063  as_iterator I = asMap.find(AS);
1064  if (I != asMap.end())
1065  return;
1066 
1067  unsigned DestSlot = asNext++;
1068  asMap[AS] = DestSlot;
1069 }
1070 
1071 //===----------------------------------------------------------------------===//
1072 // AsmWriter Implementation
1073 //===----------------------------------------------------------------------===//
1074 
1075 static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
1076  TypePrinting *TypePrinter,
1078  const Module *Context);
1079 
1080 static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
1081  TypePrinting *TypePrinter,
1082  SlotTracker *Machine, const Module *Context,
1083  bool FromValue = false);
1084 
1087  switch (Op) {
1088  default: Out << " <unknown operation " << Op << ">"; break;
1089  case AtomicRMWInst::Xchg: Out << " xchg"; break;
1090  case AtomicRMWInst::Add: Out << " add"; break;
1091  case AtomicRMWInst::Sub: Out << " sub"; break;
1092  case AtomicRMWInst::And: Out << " and"; break;
1093  case AtomicRMWInst::Nand: Out << " nand"; break;
1094  case AtomicRMWInst::Or: Out << " or"; break;
1095  case AtomicRMWInst::Xor: Out << " xor"; break;
1096  case AtomicRMWInst::Max: Out << " max"; break;
1097  case AtomicRMWInst::Min: Out << " min"; break;
1098  case AtomicRMWInst::UMax: Out << " umax"; break;
1099  case AtomicRMWInst::UMin: Out << " umin"; break;
1100  }
1101 }
1102 
1103 static void WriteOptimizationInfo(raw_ostream &Out, const User *U) {
1104  if (const FPMathOperator *FPO = dyn_cast<const FPMathOperator>(U)) {
1105  // Unsafe algebra implies all the others, no need to write them all out
1106  if (FPO->hasUnsafeAlgebra())
1107  Out << " fast";
1108  else {
1109  if (FPO->hasNoNaNs())
1110  Out << " nnan";
1111  if (FPO->hasNoInfs())
1112  Out << " ninf";
1113  if (FPO->hasNoSignedZeros())
1114  Out << " nsz";
1115  if (FPO->hasAllowReciprocal())
1116  Out << " arcp";
1117  if (FPO->hasAllowContract())
1118  Out << " contract";
1119  }
1120  }
1121 
1122  if (const OverflowingBinaryOperator *OBO =
1123  dyn_cast<OverflowingBinaryOperator>(U)) {
1124  if (OBO->hasNoUnsignedWrap())
1125  Out << " nuw";
1126  if (OBO->hasNoSignedWrap())
1127  Out << " nsw";
1128  } else if (const PossiblyExactOperator *Div =
1129  dyn_cast<PossiblyExactOperator>(U)) {
1130  if (Div->isExact())
1131  Out << " exact";
1132  } else if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) {
1133  if (GEP->isInBounds())
1134  Out << " inbounds";
1135  }
1136 }
1137 
1138 static void WriteConstantInternal(raw_ostream &Out, const Constant *CV,
1139  TypePrinting &TypePrinter,
1141  const Module *Context) {
1142  if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
1143  if (CI->getType()->isIntegerTy(1)) {
1144  Out << (CI->getZExtValue() ? "true" : "false");
1145  return;
1146  }
1147  Out << CI->getValue();
1148  return;
1149  }
1150 
1151  if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
1152  const APFloat &APF = CFP->getValueAPF();
1153  if (&APF.getSemantics() == &APFloat::IEEEsingle() ||
1154  &APF.getSemantics() == &APFloat::IEEEdouble()) {
1155  // We would like to output the FP constant value in exponential notation,
1156  // but we cannot do this if doing so will lose precision. Check here to
1157  // make sure that we only output it in exponential format if we can parse
1158  // the value back and get the same value.
1159  //
1160  bool ignored;
1161  bool isDouble = &APF.getSemantics() == &APFloat::IEEEdouble();
1162  bool isInf = APF.isInfinity();
1163  bool isNaN = APF.isNaN();
1164  if (!isInf && !isNaN) {
1165  double Val = isDouble ? APF.convertToDouble() : APF.convertToFloat();
1167  APF.toString(StrVal, 6, 0, false);
1168  // Check to make sure that the stringized number is not some string like
1169  // "Inf" or NaN, that atof will accept, but the lexer will not. Check
1170  // that the string matches the "[-+]?[0-9]" regex.
1171  //
1172  assert(((StrVal[0] >= '0' && StrVal[0] <= '9') ||
1173  ((StrVal[0] == '-' || StrVal[0] == '+') &&
1174  (StrVal[1] >= '0' && StrVal[1] <= '9'))) &&
1175  "[-+]?[0-9] regex does not match!");
1176  // Reparse stringized version!
1177  if (APFloat(APFloat::IEEEdouble(), StrVal).convertToDouble() == Val) {
1178  Out << StrVal;
1179  return;
1180  }
1181  }
1182  // Otherwise we could not reparse it to exactly the same value, so we must
1183  // output the string in hexadecimal format! Note that loading and storing
1184  // floating point types changes the bits of NaNs on some hosts, notably
1185  // x86, so we must not use these types.
1186  static_assert(sizeof(double) == sizeof(uint64_t),
1187  "assuming that double is 64 bits!");
1188  APFloat apf = APF;
1189  // Floats are represented in ASCII IR as double, convert.
1190  if (!isDouble)
1192  &ignored);
1193  Out << format_hex(apf.bitcastToAPInt().getZExtValue(), 0, /*Upper=*/true);
1194  return;
1195  }
1196 
1197  // Either half, or some form of long double.
1198  // These appear as a magic letter identifying the type, then a
1199  // fixed number of hex digits.
1200  Out << "0x";
1201  APInt API = APF.bitcastToAPInt();
1202  if (&APF.getSemantics() == &APFloat::x87DoubleExtended()) {
1203  Out << 'K';
1204  Out << format_hex_no_prefix(API.getHiBits(16).getZExtValue(), 4,
1205  /*Upper=*/true);
1206  Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
1207  /*Upper=*/true);
1208  return;
1209  } else if (&APF.getSemantics() == &APFloat::IEEEquad()) {
1210  Out << 'L';
1211  Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
1212  /*Upper=*/true);
1213  Out << format_hex_no_prefix(API.getHiBits(64).getZExtValue(), 16,
1214  /*Upper=*/true);
1215  } else if (&APF.getSemantics() == &APFloat::PPCDoubleDouble()) {
1216  Out << 'M';
1217  Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
1218  /*Upper=*/true);
1219  Out << format_hex_no_prefix(API.getHiBits(64).getZExtValue(), 16,
1220  /*Upper=*/true);
1221  } else if (&APF.getSemantics() == &APFloat::IEEEhalf()) {
1222  Out << 'H';
1223  Out << format_hex_no_prefix(API.getZExtValue(), 4,
1224  /*Upper=*/true);
1225  } else
1226  llvm_unreachable("Unsupported floating point type");
1227  return;
1228  }
1229 
1230  if (isa<ConstantAggregateZero>(CV)) {
1231  Out << "zeroinitializer";
1232  return;
1233  }
1234 
1235  if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV)) {
1236  Out << "blockaddress(";
1237  WriteAsOperandInternal(Out, BA->getFunction(), &TypePrinter, Machine,
1238  Context);
1239  Out << ", ";
1240  WriteAsOperandInternal(Out, BA->getBasicBlock(), &TypePrinter, Machine,
1241  Context);
1242  Out << ")";
1243  return;
1244  }
1245 
1246  if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) {
1247  Type *ETy = CA->getType()->getElementType();
1248  Out << '[';
1249  TypePrinter.print(ETy, Out);
1250  Out << ' ';
1251  WriteAsOperandInternal(Out, CA->getOperand(0),
1252  &TypePrinter, Machine,
1253  Context);
1254  for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) {
1255  Out << ", ";
1256  TypePrinter.print(ETy, Out);
1257  Out << ' ';
1258  WriteAsOperandInternal(Out, CA->getOperand(i), &TypePrinter, Machine,
1259  Context);
1260  }
1261  Out << ']';
1262  return;
1263  }
1264 
1265  if (const ConstantDataArray *CA = dyn_cast<ConstantDataArray>(CV)) {
1266  // As a special case, print the array as a string if it is an array of
1267  // i8 with ConstantInt values.
1268  if (CA->isString()) {
1269  Out << "c\"";
1270  PrintEscapedString(CA->getAsString(), Out);
1271  Out << '"';
1272  return;
1273  }
1274 
1275  Type *ETy = CA->getType()->getElementType();
1276  Out << '[';
1277  TypePrinter.print(ETy, Out);
1278  Out << ' ';
1279  WriteAsOperandInternal(Out, CA->getElementAsConstant(0),
1280  &TypePrinter, Machine,
1281  Context);
1282  for (unsigned i = 1, e = CA->getNumElements(); i != e; ++i) {
1283  Out << ", ";
1284  TypePrinter.print(ETy, Out);
1285  Out << ' ';
1286  WriteAsOperandInternal(Out, CA->getElementAsConstant(i), &TypePrinter,
1287  Machine, Context);
1288  }
1289  Out << ']';
1290  return;
1291  }
1292 
1293  if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) {
1294  if (CS->getType()->isPacked())
1295  Out << '<';
1296  Out << '{';
1297  unsigned N = CS->getNumOperands();
1298  if (N) {
1299  Out << ' ';
1300  TypePrinter.print(CS->getOperand(0)->getType(), Out);
1301  Out << ' ';
1302 
1303  WriteAsOperandInternal(Out, CS->getOperand(0), &TypePrinter, Machine,
1304  Context);
1305 
1306  for (unsigned i = 1; i < N; i++) {
1307  Out << ", ";
1308  TypePrinter.print(CS->getOperand(i)->getType(), Out);
1309  Out << ' ';
1310 
1311  WriteAsOperandInternal(Out, CS->getOperand(i), &TypePrinter, Machine,
1312  Context);
1313  }
1314  Out << ' ';
1315  }
1316 
1317  Out << '}';
1318  if (CS->getType()->isPacked())
1319  Out << '>';
1320  return;
1321  }
1322 
1323  if (isa<ConstantVector>(CV) || isa<ConstantDataVector>(CV)) {
1324  Type *ETy = CV->getType()->getVectorElementType();
1325  Out << '<';
1326  TypePrinter.print(ETy, Out);
1327  Out << ' ';
1328  WriteAsOperandInternal(Out, CV->getAggregateElement(0U), &TypePrinter,
1329  Machine, Context);
1330  for (unsigned i = 1, e = CV->getType()->getVectorNumElements(); i != e;++i){
1331  Out << ", ";
1332  TypePrinter.print(ETy, Out);
1333  Out << ' ';
1334  WriteAsOperandInternal(Out, CV->getAggregateElement(i), &TypePrinter,
1335  Machine, Context);
1336  }
1337  Out << '>';
1338  return;
1339  }
1340 
1341  if (isa<ConstantPointerNull>(CV)) {
1342  Out << "null";
1343  return;
1344  }
1345 
1346  if (isa<ConstantTokenNone>(CV)) {
1347  Out << "none";
1348  return;
1349  }
1350 
1351  if (isa<UndefValue>(CV)) {
1352  Out << "undef";
1353  return;
1354  }
1355 
1356  if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
1357  Out << CE->getOpcodeName();
1358  WriteOptimizationInfo(Out, CE);
1359  if (CE->isCompare())
1360  Out << ' ' << CmpInst::getPredicateName(
1361  static_cast<CmpInst::Predicate>(CE->getPredicate()));
1362  Out << " (";
1363 
1364  Optional<unsigned> InRangeOp;
1365  if (const GEPOperator *GEP = dyn_cast<GEPOperator>(CE)) {
1366  TypePrinter.print(GEP->getSourceElementType(), Out);
1367  Out << ", ";
1368  InRangeOp = GEP->getInRangeIndex();
1369  if (InRangeOp)
1370  ++*InRangeOp;
1371  }
1372 
1373  for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) {
1374  if (InRangeOp && unsigned(OI - CE->op_begin()) == *InRangeOp)
1375  Out << "inrange ";
1376  TypePrinter.print((*OI)->getType(), Out);
1377  Out << ' ';
1378  WriteAsOperandInternal(Out, *OI, &TypePrinter, Machine, Context);
1379  if (OI+1 != CE->op_end())
1380  Out << ", ";
1381  }
1382 
1383  if (CE->hasIndices()) {
1384  ArrayRef<unsigned> Indices = CE->getIndices();
1385  for (unsigned i = 0, e = Indices.size(); i != e; ++i)
1386  Out << ", " << Indices[i];
1387  }
1388 
1389  if (CE->isCast()) {
1390  Out << " to ";
1391  TypePrinter.print(CE->getType(), Out);
1392  }
1393 
1394  Out << ')';
1395  return;
1396  }
1397 
1398  Out << "<placeholder or erroneous Constant>";
1399 }
1400 
1401 static void writeMDTuple(raw_ostream &Out, const MDTuple *Node,
1402  TypePrinting *TypePrinter, SlotTracker *Machine,
1403  const Module *Context) {
1404  Out << "!{";
1405  for (unsigned mi = 0, me = Node->getNumOperands(); mi != me; ++mi) {
1406  const Metadata *MD = Node->getOperand(mi);
1407  if (!MD)
1408  Out << "null";
1409  else if (auto *MDV = dyn_cast<ValueAsMetadata>(MD)) {
1410  Value *V = MDV->getValue();
1411  TypePrinter->print(V->getType(), Out);
1412  Out << ' ';
1413  WriteAsOperandInternal(Out, V, TypePrinter, Machine, Context);
1414  } else {
1415  WriteAsOperandInternal(Out, MD, TypePrinter, Machine, Context);
1416  }
1417  if (mi + 1 != me)
1418  Out << ", ";
1419  }
1420 
1421  Out << "}";
1422 }
1423 
1424 namespace {
1425 
1426 struct FieldSeparator {
1427  bool Skip = true;
1428  const char *Sep;
1429 
1430  FieldSeparator(const char *Sep = ", ") : Sep(Sep) {}
1431 };
1432 
1433 raw_ostream &operator<<(raw_ostream &OS, FieldSeparator &FS) {
1434  if (FS.Skip) {
1435  FS.Skip = false;
1436  return OS;
1437  }
1438  return OS << FS.Sep;
1439 }
1440 
1441 struct MDFieldPrinter {
1442  raw_ostream &Out;
1443  FieldSeparator FS;
1444  TypePrinting *TypePrinter = nullptr;
1445  SlotTracker *Machine = nullptr;
1446  const Module *Context = nullptr;
1447 
1448  explicit MDFieldPrinter(raw_ostream &Out) : Out(Out) {}
1449  MDFieldPrinter(raw_ostream &Out, TypePrinting *TypePrinter,
1450  SlotTracker *Machine, const Module *Context)
1451  : Out(Out), TypePrinter(TypePrinter), Machine(Machine), Context(Context) {
1452  }
1453 
1454  void printTag(const DINode *N);
1455  void printMacinfoType(const DIMacroNode *N);
1456  void printChecksumKind(const DIFile *N);
1457  void printString(StringRef Name, StringRef Value,
1458  bool ShouldSkipEmpty = true);
1459  void printMetadata(StringRef Name, const Metadata *MD,
1460  bool ShouldSkipNull = true);
1461  template <class IntTy>
1462  void printInt(StringRef Name, IntTy Int, bool ShouldSkipZero = true);
1463  void printBool(StringRef Name, bool Value, Optional<bool> Default = None);
1464  void printDIFlags(StringRef Name, DINode::DIFlags Flags);
1465  template <class IntTy, class Stringifier>
1466  void printDwarfEnum(StringRef Name, IntTy Value, Stringifier toString,
1467  bool ShouldSkipZero = true);
1468  void printEmissionKind(StringRef Name, DICompileUnit::DebugEmissionKind EK);
1469 };
1470 
1471 } // end anonymous namespace
1472 
1473 void MDFieldPrinter::printTag(const DINode *N) {
1474  Out << FS << "tag: ";
1475  auto Tag = dwarf::TagString(N->getTag());
1476  if (!Tag.empty())
1477  Out << Tag;
1478  else
1479  Out << N->getTag();
1480 }
1481 
1482 void MDFieldPrinter::printMacinfoType(const DIMacroNode *N) {
1483  Out << FS << "type: ";
1484  auto Type = dwarf::MacinfoString(N->getMacinfoType());
1485  if (!Type.empty())
1486  Out << Type;
1487  else
1488  Out << N->getMacinfoType();
1489 }
1490 
1491 void MDFieldPrinter::printChecksumKind(const DIFile *N) {
1492  if (N->getChecksumKind() == DIFile::CSK_None)
1493  // Skip CSK_None checksum kind.
1494  return;
1495  Out << FS << "checksumkind: " << N->getChecksumKindAsString();
1496 }
1497 
1498 void MDFieldPrinter::printString(StringRef Name, StringRef Value,
1499  bool ShouldSkipEmpty) {
1500  if (ShouldSkipEmpty && Value.empty())
1501  return;
1502 
1503  Out << FS << Name << ": \"";
1504  PrintEscapedString(Value, Out);
1505  Out << "\"";
1506 }
1507 
1508 static void writeMetadataAsOperand(raw_ostream &Out, const Metadata *MD,
1509  TypePrinting *TypePrinter,
1510  SlotTracker *Machine,
1511  const Module *Context) {
1512  if (!MD) {
1513  Out << "null";
1514  return;
1515  }
1516  WriteAsOperandInternal(Out, MD, TypePrinter, Machine, Context);
1517 }
1518 
1519 void MDFieldPrinter::printMetadata(StringRef Name, const Metadata *MD,
1520  bool ShouldSkipNull) {
1521  if (ShouldSkipNull && !MD)
1522  return;
1523 
1524  Out << FS << Name << ": ";
1525  writeMetadataAsOperand(Out, MD, TypePrinter, Machine, Context);
1526 }
1527 
1528 template <class IntTy>
1529 void MDFieldPrinter::printInt(StringRef Name, IntTy Int, bool ShouldSkipZero) {
1530  if (ShouldSkipZero && !Int)
1531  return;
1532 
1533  Out << FS << Name << ": " << Int;
1534 }
1535 
1536 void MDFieldPrinter::printBool(StringRef Name, bool Value,
1537  Optional<bool> Default) {
1538  if (Default && Value == *Default)
1539  return;
1540  Out << FS << Name << ": " << (Value ? "true" : "false");
1541 }
1542 
1543 void MDFieldPrinter::printDIFlags(StringRef Name, DINode::DIFlags Flags) {
1544  if (!Flags)
1545  return;
1546 
1547  Out << FS << Name << ": ";
1548 
1549  SmallVector<DINode::DIFlags, 8> SplitFlags;
1550  auto Extra = DINode::splitFlags(Flags, SplitFlags);
1551 
1552  FieldSeparator FlagsFS(" | ");
1553  for (auto F : SplitFlags) {
1554  auto StringF = DINode::getFlagString(F);
1555  assert(!StringF.empty() && "Expected valid flag");
1556  Out << FlagsFS << StringF;
1557  }
1558  if (Extra || SplitFlags.empty())
1559  Out << FlagsFS << Extra;
1560 }
1561 
1562 void MDFieldPrinter::printEmissionKind(StringRef Name,
1563  DICompileUnit::DebugEmissionKind EK) {
1564  Out << FS << Name << ": " << DICompileUnit::EmissionKindString(EK);
1565 }
1566 
1567 template <class IntTy, class Stringifier>
1568 void MDFieldPrinter::printDwarfEnum(StringRef Name, IntTy Value,
1569  Stringifier toString, bool ShouldSkipZero) {
1570  if (!Value)
1571  return;
1572 
1573  Out << FS << Name << ": ";
1574  auto S = toString(Value);
1575  if (!S.empty())
1576  Out << S;
1577  else
1578  Out << Value;
1579 }
1580 
1581 static void writeGenericDINode(raw_ostream &Out, const GenericDINode *N,
1582  TypePrinting *TypePrinter, SlotTracker *Machine,
1583  const Module *Context) {
1584  Out << "!GenericDINode(";
1585  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1586  Printer.printTag(N);
1587  Printer.printString("header", N->getHeader());
1588  if (N->getNumDwarfOperands()) {
1589  Out << Printer.FS << "operands: {";
1590  FieldSeparator IFS;
1591  for (auto &I : N->dwarf_operands()) {
1592  Out << IFS;
1593  writeMetadataAsOperand(Out, I, TypePrinter, Machine, Context);
1594  }
1595  Out << "}";
1596  }
1597  Out << ")";
1598 }
1599 
1600 static void writeDILocation(raw_ostream &Out, const DILocation *DL,
1601  TypePrinting *TypePrinter, SlotTracker *Machine,
1602  const Module *Context) {
1603  Out << "!DILocation(";
1604  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1605  // Always output the line, since 0 is a relevant and important value for it.
1606  Printer.printInt("line", DL->getLine(), /* ShouldSkipZero */ false);
1607  Printer.printInt("column", DL->getColumn());
1608  Printer.printMetadata("scope", DL->getRawScope(), /* ShouldSkipNull */ false);
1609  Printer.printMetadata("inlinedAt", DL->getRawInlinedAt());
1610  Out << ")";
1611 }
1612 
1613 static void writeDISubrange(raw_ostream &Out, const DISubrange *N,
1614  TypePrinting *, SlotTracker *, const Module *) {
1615  Out << "!DISubrange(";
1616  MDFieldPrinter Printer(Out);
1617  Printer.printInt("count", N->getCount(), /* ShouldSkipZero */ false);
1618  Printer.printInt("lowerBound", N->getLowerBound());
1619  Out << ")";
1620 }
1621 
1622 static void writeDIEnumerator(raw_ostream &Out, const DIEnumerator *N,
1623  TypePrinting *, SlotTracker *, const Module *) {
1624  Out << "!DIEnumerator(";
1625  MDFieldPrinter Printer(Out);
1626  Printer.printString("name", N->getName(), /* ShouldSkipEmpty */ false);
1627  Printer.printInt("value", N->getValue(), /* ShouldSkipZero */ false);
1628  Out << ")";
1629 }
1630 
1631 static void writeDIBasicType(raw_ostream &Out, const DIBasicType *N,
1632  TypePrinting *, SlotTracker *, const Module *) {
1633  Out << "!DIBasicType(";
1634  MDFieldPrinter Printer(Out);
1635  if (N->getTag() != dwarf::DW_TAG_base_type)
1636  Printer.printTag(N);
1637  Printer.printString("name", N->getName());
1638  Printer.printInt("size", N->getSizeInBits());
1639  Printer.printInt("align", N->getAlignInBits());
1640  Printer.printDwarfEnum("encoding", N->getEncoding(),
1641  dwarf::AttributeEncodingString);
1642  Out << ")";
1643 }
1644 
1645 static void writeDIDerivedType(raw_ostream &Out, const DIDerivedType *N,
1646  TypePrinting *TypePrinter, SlotTracker *Machine,
1647  const Module *Context) {
1648  Out << "!DIDerivedType(";
1649  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1650  Printer.printTag(N);
1651  Printer.printString("name", N->getName());
1652  Printer.printMetadata("scope", N->getRawScope());
1653  Printer.printMetadata("file", N->getRawFile());
1654  Printer.printInt("line", N->getLine());
1655  Printer.printMetadata("baseType", N->getRawBaseType(),
1656  /* ShouldSkipNull */ false);
1657  Printer.printInt("size", N->getSizeInBits());
1658  Printer.printInt("align", N->getAlignInBits());
1659  Printer.printInt("offset", N->getOffsetInBits());
1660  Printer.printDIFlags("flags", N->getFlags());
1661  Printer.printMetadata("extraData", N->getRawExtraData());
1662  if (const auto &DWARFAddressSpace = N->getDWARFAddressSpace())
1663  Printer.printInt("dwarfAddressSpace", *DWARFAddressSpace,
1664  /* ShouldSkipZero */ false);
1665  Out << ")";
1666 }
1667 
1668 static void writeDICompositeType(raw_ostream &Out, const DICompositeType *N,
1669  TypePrinting *TypePrinter,
1670  SlotTracker *Machine, const Module *Context) {
1671  Out << "!DICompositeType(";
1672  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1673  Printer.printTag(N);
1674  Printer.printString("name", N->getName());
1675  Printer.printMetadata("scope", N->getRawScope());
1676  Printer.printMetadata("file", N->getRawFile());
1677  Printer.printInt("line", N->getLine());
1678  Printer.printMetadata("baseType", N->getRawBaseType());
1679  Printer.printInt("size", N->getSizeInBits());
1680  Printer.printInt("align", N->getAlignInBits());
1681  Printer.printInt("offset", N->getOffsetInBits());
1682  Printer.printDIFlags("flags", N->getFlags());
1683  Printer.printMetadata("elements", N->getRawElements());
1684  Printer.printDwarfEnum("runtimeLang", N->getRuntimeLang(),
1685  dwarf::LanguageString);
1686  Printer.printMetadata("vtableHolder", N->getRawVTableHolder());
1687  Printer.printMetadata("templateParams", N->getRawTemplateParams());
1688  Printer.printString("identifier", N->getIdentifier());
1689  Out << ")";
1690 }
1691 
1692 static void writeDISubroutineType(raw_ostream &Out, const DISubroutineType *N,
1693  TypePrinting *TypePrinter,
1694  SlotTracker *Machine, const Module *Context) {
1695  Out << "!DISubroutineType(";
1696  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1697  Printer.printDIFlags("flags", N->getFlags());
1698  Printer.printDwarfEnum("cc", N->getCC(), dwarf::ConventionString);
1699  Printer.printMetadata("types", N->getRawTypeArray(),
1700  /* ShouldSkipNull */ false);
1701  Out << ")";
1702 }
1703 
1704 static void writeDIFile(raw_ostream &Out, const DIFile *N, TypePrinting *,
1705  SlotTracker *, const Module *) {
1706  Out << "!DIFile(";
1707  MDFieldPrinter Printer(Out);
1708  Printer.printString("filename", N->getFilename(),
1709  /* ShouldSkipEmpty */ false);
1710  Printer.printString("directory", N->getDirectory(),
1711  /* ShouldSkipEmpty */ false);
1712  Printer.printChecksumKind(N);
1713  Printer.printString("checksum", N->getChecksum(), /* ShouldSkipEmpty */ true);
1714  Out << ")";
1715 }
1716 
1717 static void writeDICompileUnit(raw_ostream &Out, const DICompileUnit *N,
1718  TypePrinting *TypePrinter, SlotTracker *Machine,
1719  const Module *Context) {
1720  Out << "!DICompileUnit(";
1721  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1722  Printer.printDwarfEnum("language", N->getSourceLanguage(),
1723  dwarf::LanguageString, /* ShouldSkipZero */ false);
1724  Printer.printMetadata("file", N->getRawFile(), /* ShouldSkipNull */ false);
1725  Printer.printString("producer", N->getProducer());
1726  Printer.printBool("isOptimized", N->isOptimized());
1727  Printer.printString("flags", N->getFlags());
1728  Printer.printInt("runtimeVersion", N->getRuntimeVersion(),
1729  /* ShouldSkipZero */ false);
1730  Printer.printString("splitDebugFilename", N->getSplitDebugFilename());
1731  Printer.printEmissionKind("emissionKind", N->getEmissionKind());
1732  Printer.printMetadata("enums", N->getRawEnumTypes());
1733  Printer.printMetadata("retainedTypes", N->getRawRetainedTypes());
1734  Printer.printMetadata("globals", N->getRawGlobalVariables());
1735  Printer.printMetadata("imports", N->getRawImportedEntities());
1736  Printer.printMetadata("macros", N->getRawMacros());
1737  Printer.printInt("dwoId", N->getDWOId());
1738  Printer.printBool("splitDebugInlining", N->getSplitDebugInlining(), true);
1739  Printer.printBool("debugInfoForProfiling", N->getDebugInfoForProfiling(),
1740  false);
1741  Out << ")";
1742 }
1743 
1744 static void writeDISubprogram(raw_ostream &Out, const DISubprogram *N,
1745  TypePrinting *TypePrinter, SlotTracker *Machine,
1746  const Module *Context) {
1747  Out << "!DISubprogram(";
1748  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1749  Printer.printString("name", N->getName());
1750  Printer.printString("linkageName", N->getLinkageName());
1751  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1752  Printer.printMetadata("file", N->getRawFile());
1753  Printer.printInt("line", N->getLine());
1754  Printer.printMetadata("type", N->getRawType());
1755  Printer.printBool("isLocal", N->isLocalToUnit());
1756  Printer.printBool("isDefinition", N->isDefinition());
1757  Printer.printInt("scopeLine", N->getScopeLine());
1758  Printer.printMetadata("containingType", N->getRawContainingType());
1759  Printer.printDwarfEnum("virtuality", N->getVirtuality(),
1760  dwarf::VirtualityString);
1761  if (N->getVirtuality() != dwarf::DW_VIRTUALITY_none ||
1762  N->getVirtualIndex() != 0)
1763  Printer.printInt("virtualIndex", N->getVirtualIndex(), false);
1764  Printer.printInt("thisAdjustment", N->getThisAdjustment());
1765  Printer.printDIFlags("flags", N->getFlags());
1766  Printer.printBool("isOptimized", N->isOptimized());
1767  Printer.printMetadata("unit", N->getRawUnit());
1768  Printer.printMetadata("templateParams", N->getRawTemplateParams());
1769  Printer.printMetadata("declaration", N->getRawDeclaration());
1770  Printer.printMetadata("variables", N->getRawVariables());
1771  Printer.printMetadata("thrownTypes", N->getRawThrownTypes());
1772  Out << ")";
1773 }
1774 
1775 static void writeDILexicalBlock(raw_ostream &Out, const DILexicalBlock *N,
1776  TypePrinting *TypePrinter, SlotTracker *Machine,
1777  const Module *Context) {
1778  Out << "!DILexicalBlock(";
1779  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1780  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1781  Printer.printMetadata("file", N->getRawFile());
1782  Printer.printInt("line", N->getLine());
1783  Printer.printInt("column", N->getColumn());
1784  Out << ")";
1785 }
1786 
1787 static void writeDILexicalBlockFile(raw_ostream &Out,
1788  const DILexicalBlockFile *N,
1789  TypePrinting *TypePrinter,
1790  SlotTracker *Machine,
1791  const Module *Context) {
1792  Out << "!DILexicalBlockFile(";
1793  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1794  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1795  Printer.printMetadata("file", N->getRawFile());
1796  Printer.printInt("discriminator", N->getDiscriminator(),
1797  /* ShouldSkipZero */ false);
1798  Out << ")";
1799 }
1800 
1801 static void writeDINamespace(raw_ostream &Out, const DINamespace *N,
1802  TypePrinting *TypePrinter, SlotTracker *Machine,
1803  const Module *Context) {
1804  Out << "!DINamespace(";
1805  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1806  Printer.printString("name", N->getName());
1807  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1808  Printer.printBool("exportSymbols", N->getExportSymbols(), false);
1809  Out << ")";
1810 }
1811 
1812 static void writeDIMacro(raw_ostream &Out, const DIMacro *N,
1813  TypePrinting *TypePrinter, SlotTracker *Machine,
1814  const Module *Context) {
1815  Out << "!DIMacro(";
1816  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1817  Printer.printMacinfoType(N);
1818  Printer.printInt("line", N->getLine());
1819  Printer.printString("name", N->getName());
1820  Printer.printString("value", N->getValue());
1821  Out << ")";
1822 }
1823 
1824 static void writeDIMacroFile(raw_ostream &Out, const DIMacroFile *N,
1825  TypePrinting *TypePrinter, SlotTracker *Machine,
1826  const Module *Context) {
1827  Out << "!DIMacroFile(";
1828  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1829  Printer.printInt("line", N->getLine());
1830  Printer.printMetadata("file", N->getRawFile(), /* ShouldSkipNull */ false);
1831  Printer.printMetadata("nodes", N->getRawElements());
1832  Out << ")";
1833 }
1834 
1835 static void writeDIModule(raw_ostream &Out, const DIModule *N,
1836  TypePrinting *TypePrinter, SlotTracker *Machine,
1837  const Module *Context) {
1838  Out << "!DIModule(";
1839  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1840  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1841  Printer.printString("name", N->getName());
1842  Printer.printString("configMacros", N->getConfigurationMacros());
1843  Printer.printString("includePath", N->getIncludePath());
1844  Printer.printString("isysroot", N->getISysRoot());
1845  Out << ")";
1846 }
1847 
1848 
1849 static void writeDITemplateTypeParameter(raw_ostream &Out,
1850  const DITemplateTypeParameter *N,
1851  TypePrinting *TypePrinter,
1852  SlotTracker *Machine,
1853  const Module *Context) {
1854  Out << "!DITemplateTypeParameter(";
1855  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1856  Printer.printString("name", N->getName());
1857  Printer.printMetadata("type", N->getRawType(), /* ShouldSkipNull */ false);
1858  Out << ")";
1859 }
1860 
1861 static void writeDITemplateValueParameter(raw_ostream &Out,
1862  const DITemplateValueParameter *N,
1863  TypePrinting *TypePrinter,
1864  SlotTracker *Machine,
1865  const Module *Context) {
1866  Out << "!DITemplateValueParameter(";
1867  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1868  if (N->getTag() != dwarf::DW_TAG_template_value_parameter)
1869  Printer.printTag(N);
1870  Printer.printString("name", N->getName());
1871  Printer.printMetadata("type", N->getRawType());
1872  Printer.printMetadata("value", N->getValue(), /* ShouldSkipNull */ false);
1873  Out << ")";
1874 }
1875 
1876 static void writeDIGlobalVariable(raw_ostream &Out, const DIGlobalVariable *N,
1877  TypePrinting *TypePrinter,
1878  SlotTracker *Machine, const Module *Context) {
1879  Out << "!DIGlobalVariable(";
1880  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1881  Printer.printString("name", N->getName());
1882  Printer.printString("linkageName", N->getLinkageName());
1883  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1884  Printer.printMetadata("file", N->getRawFile());
1885  Printer.printInt("line", N->getLine());
1886  Printer.printMetadata("type", N->getRawType());
1887  Printer.printBool("isLocal", N->isLocalToUnit());
1888  Printer.printBool("isDefinition", N->isDefinition());
1889  Printer.printMetadata("declaration", N->getRawStaticDataMemberDeclaration());
1890  Printer.printInt("align", N->getAlignInBits());
1891  Out << ")";
1892 }
1893 
1894 static void writeDILocalVariable(raw_ostream &Out, const DILocalVariable *N,
1895  TypePrinting *TypePrinter,
1896  SlotTracker *Machine, const Module *Context) {
1897  Out << "!DILocalVariable(";
1898  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1899  Printer.printString("name", N->getName());
1900  Printer.printInt("arg", N->getArg());
1901  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1902  Printer.printMetadata("file", N->getRawFile());
1903  Printer.printInt("line", N->getLine());
1904  Printer.printMetadata("type", N->getRawType());
1905  Printer.printDIFlags("flags", N->getFlags());
1906  Printer.printInt("align", N->getAlignInBits());
1907  Out << ")";
1908 }
1909 
1910 static void writeDIExpression(raw_ostream &Out, const DIExpression *N,
1911  TypePrinting *TypePrinter, SlotTracker *Machine,
1912  const Module *Context) {
1913  Out << "!DIExpression(";
1914  FieldSeparator FS;
1915  if (N->isValid()) {
1916  for (auto I = N->expr_op_begin(), E = N->expr_op_end(); I != E; ++I) {
1917  auto OpStr = dwarf::OperationEncodingString(I->getOp());
1918  assert(!OpStr.empty() && "Expected valid opcode");
1919 
1920  Out << FS << OpStr;
1921  for (unsigned A = 0, AE = I->getNumArgs(); A != AE; ++A)
1922  Out << FS << I->getArg(A);
1923  }
1924  } else {
1925  for (const auto &I : N->getElements())
1926  Out << FS << I;
1927  }
1928  Out << ")";
1929 }
1930 
1931 static void writeDIGlobalVariableExpression(raw_ostream &Out,
1932  const DIGlobalVariableExpression *N,
1933  TypePrinting *TypePrinter,
1934  SlotTracker *Machine,
1935  const Module *Context) {
1936  Out << "!DIGlobalVariableExpression(";
1937  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1938  Printer.printMetadata("var", N->getVariable());
1939  Printer.printMetadata("expr", N->getExpression());
1940  Out << ")";
1941 }
1942 
1943 static void writeDIObjCProperty(raw_ostream &Out, const DIObjCProperty *N,
1944  TypePrinting *TypePrinter, SlotTracker *Machine,
1945  const Module *Context) {
1946  Out << "!DIObjCProperty(";
1947  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1948  Printer.printString("name", N->getName());
1949  Printer.printMetadata("file", N->getRawFile());
1950  Printer.printInt("line", N->getLine());
1951  Printer.printString("setter", N->getSetterName());
1952  Printer.printString("getter", N->getGetterName());
1953  Printer.printInt("attributes", N->getAttributes());
1954  Printer.printMetadata("type", N->getRawType());
1955  Out << ")";
1956 }
1957 
1958 static void writeDIImportedEntity(raw_ostream &Out, const DIImportedEntity *N,
1959  TypePrinting *TypePrinter,
1960  SlotTracker *Machine, const Module *Context) {
1961  Out << "!DIImportedEntity(";
1962  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1963  Printer.printTag(N);
1964  Printer.printString("name", N->getName());
1965  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1966  Printer.printMetadata("entity", N->getRawEntity());
1967  Printer.printMetadata("file", N->getRawFile());
1968  Printer.printInt("line", N->getLine());
1969  Out << ")";
1970 }
1971 
1972 static void WriteMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node,
1973  TypePrinting *TypePrinter,
1974  SlotTracker *Machine,
1975  const Module *Context) {
1976  if (Node->isDistinct())
1977  Out << "distinct ";
1978  else if (Node->isTemporary())
1979  Out << "<temporary!> "; // Handle broken code.
1980 
1981  switch (Node->getMetadataID()) {
1982  default:
1983  llvm_unreachable("Expected uniquable MDNode");
1984 #define HANDLE_MDNODE_LEAF(CLASS) \
1985  case Metadata::CLASS##Kind: \
1986  write##CLASS(Out, cast<CLASS>(Node), TypePrinter, Machine, Context); \
1987  break;
1988 #include "llvm/IR/Metadata.def"
1989  }
1990 }
1991 
1992 // Full implementation of printing a Value as an operand with support for
1993 // TypePrinting, etc.
1994 static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
1995  TypePrinting *TypePrinter,
1996  SlotTracker *Machine,
1997  const Module *Context) {
1998  if (V->hasName()) {
1999  PrintLLVMName(Out, V);
2000  return;
2001  }
2002 
2003  const Constant *CV = dyn_cast<Constant>(V);
2004  if (CV && !isa<GlobalValue>(CV)) {
2005  assert(TypePrinter && "Constants require TypePrinting!");
2006  WriteConstantInternal(Out, CV, *TypePrinter, Machine, Context);
2007  return;
2008  }
2009 
2010  if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
2011  Out << "asm ";
2012  if (IA->hasSideEffects())
2013  Out << "sideeffect ";
2014  if (IA->isAlignStack())
2015  Out << "alignstack ";
2016  // We don't emit the AD_ATT dialect as it's the assumed default.
2017  if (IA->getDialect() == InlineAsm::AD_Intel)
2018  Out << "inteldialect ";
2019  Out << '"';
2020  PrintEscapedString(IA->getAsmString(), Out);
2021  Out << "\", \"";
2022  PrintEscapedString(IA->getConstraintString(), Out);
2023  Out << '"';
2024  return;
2025  }
2026 
2027  if (auto *MD = dyn_cast<MetadataAsValue>(V)) {
2028  WriteAsOperandInternal(Out, MD->getMetadata(), TypePrinter, Machine,
2029  Context, /* FromValue */ true);
2030  return;
2031  }
2032 
2033  char Prefix = '%';
2034  int Slot;
2035  // If we have a SlotTracker, use it.
2036  if (Machine) {
2037  if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
2038  Slot = Machine->getGlobalSlot(GV);
2039  Prefix = '@';
2040  } else {
2041  Slot = Machine->getLocalSlot(V);
2042 
2043  // If the local value didn't succeed, then we may be referring to a value
2044  // from a different function. Translate it, as this can happen when using
2045  // address of blocks.
2046  if (Slot == -1)
2047  if ((Machine = createSlotTracker(V))) {
2048  Slot = Machine->getLocalSlot(V);
2049  delete Machine;
2050  }
2051  }
2052  } else if ((Machine = createSlotTracker(V))) {
2053  // Otherwise, create one to get the # and then destroy it.
2054  if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
2055  Slot = Machine->getGlobalSlot(GV);
2056  Prefix = '@';
2057  } else {
2058  Slot = Machine->getLocalSlot(V);
2059  }
2060  delete Machine;
2061  Machine = nullptr;
2062  } else {
2063  Slot = -1;
2064  }
2065 
2066  if (Slot != -1)
2067  Out << Prefix << Slot;
2068  else
2069  Out << "<badref>";
2070 }
2071 
2072 static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
2073  TypePrinting *TypePrinter,
2074  SlotTracker *Machine, const Module *Context,
2075  bool FromValue) {
2076  if (const MDNode *N = dyn_cast<MDNode>(MD)) {
2077  std::unique_ptr<SlotTracker> MachineStorage;
2078  if (!Machine) {
2079  MachineStorage = make_unique<SlotTracker>(Context);
2080  Machine = MachineStorage.get();
2081  }
2082  int Slot = Machine->getMetadataSlot(N);
2083  if (Slot == -1)
2084  // Give the pointer value instead of "badref", since this comes up all
2085  // the time when debugging.
2086  Out << "<" << N << ">";
2087  else
2088  Out << '!' << Slot;
2089  return;
2090  }
2091 
2092  if (const MDString *MDS = dyn_cast<MDString>(MD)) {
2093  Out << "!\"";
2094  PrintEscapedString(MDS->getString(), Out);
2095  Out << '"';
2096  return;
2097  }
2098 
2099  auto *V = cast<ValueAsMetadata>(MD);
2100  assert(TypePrinter && "TypePrinter required for metadata values");
2101  assert((FromValue || !isa<LocalAsMetadata>(V)) &&
2102  "Unexpected function-local metadata outside of value argument");
2103 
2104  TypePrinter->print(V->getValue()->getType(), Out);
2105  Out << ' ';
2106  WriteAsOperandInternal(Out, V->getValue(), TypePrinter, Machine, Context);
2107 }
2108 
2109 namespace {
2110 
2111 class AssemblyWriter {
2112  formatted_raw_ostream &Out;
2113  const Module *TheModule;
2114  std::unique_ptr<SlotTracker> SlotTrackerStorage;
2116  TypePrinting TypePrinter;
2117  AssemblyAnnotationWriter *AnnotationWriter;
2118  SetVector<const Comdat *> Comdats;
2119  bool IsForDebug;
2120  bool ShouldPreserveUseListOrder;
2121  UseListOrderStack UseListOrders;
2122  SmallVector<StringRef, 8> MDNames;
2123  /// Synchronization scope names registered with LLVMContext.
2125 
2126 public:
2127  /// Construct an AssemblyWriter with an external SlotTracker
2128  AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac, const Module *M,
2129  AssemblyAnnotationWriter *AAW, bool IsForDebug,
2130  bool ShouldPreserveUseListOrder = false);
2131 
2132  void printMDNodeBody(const MDNode *MD);
2133  void printNamedMDNode(const NamedMDNode *NMD);
2134 
2135  void printModule(const Module *M);
2136 
2137  void writeOperand(const Value *Op, bool PrintType);
2138  void writeParamOperand(const Value *Operand, AttributeSet Attrs);
2139  void writeOperandBundles(ImmutableCallSite CS);
2140  void writeSyncScope(const LLVMContext &Context,
2141  SyncScope::ID SSID);
2142  void writeAtomic(const LLVMContext &Context,
2143  AtomicOrdering Ordering,
2144  SyncScope::ID SSID);
2145  void writeAtomicCmpXchg(const LLVMContext &Context,
2146  AtomicOrdering SuccessOrdering,
2147  AtomicOrdering FailureOrdering,
2148  SyncScope::ID SSID);
2149 
2150  void writeAllMDNodes();
2151  void writeMDNode(unsigned Slot, const MDNode *Node);
2152  void writeAllAttributeGroups();
2153 
2154  void printTypeIdentities();
2155  void printGlobal(const GlobalVariable *GV);
2156  void printIndirectSymbol(const GlobalIndirectSymbol *GIS);
2157  void printComdat(const Comdat *C);
2158  void printFunction(const Function *F);
2159  void printArgument(const Argument *FA, AttributeSet Attrs);
2160  void printBasicBlock(const BasicBlock *BB);
2161  void printInstructionLine(const Instruction &I);
2162  void printInstruction(const Instruction &I);
2163 
2164  void printUseListOrder(const UseListOrder &Order);
2165  void printUseLists(const Function *F);
2166 
2167 private:
2168  /// \brief Print out metadata attachments.
2169  void printMetadataAttachments(
2170  const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
2172 
2173  // printInfoComment - Print a little comment after the instruction indicating
2174  // which slot it occupies.
2175  void printInfoComment(const Value &V);
2176 
2177  // printGCRelocateComment - print comment after call to the gc.relocate
2178  // intrinsic indicating base and derived pointer names.
2179  void printGCRelocateComment(const GCRelocateInst &Relocate);
2180 };
2181 
2182 } // end anonymous namespace
2183 
2184 AssemblyWriter::AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
2185  const Module *M, AssemblyAnnotationWriter *AAW,
2186  bool IsForDebug, bool ShouldPreserveUseListOrder)
2187  : Out(o), TheModule(M), Machine(Mac), AnnotationWriter(AAW),
2188  IsForDebug(IsForDebug),
2189  ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {
2190  if (!TheModule)
2191  return;
2192  TypePrinter.incorporateTypes(*TheModule);
2193  for (const GlobalObject &GO : TheModule->global_objects())
2194  if (const Comdat *C = GO.getComdat())
2195  Comdats.insert(C);
2196 }
2197 
2198 void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) {
2199  if (!Operand) {
2200  Out << "<null operand!>";
2201  return;
2202  }
2203  if (PrintType) {
2204  TypePrinter.print(Operand->getType(), Out);
2205  Out << ' ';
2206  }
2207  WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule);
2208 }
2209 
2210 void AssemblyWriter::writeSyncScope(const LLVMContext &Context,
2211  SyncScope::ID SSID) {
2212  switch (SSID) {
2213  case SyncScope::System: {
2214  break;
2215  }
2216  default: {
2217  if (SSNs.empty())
2218  Context.getSyncScopeNames(SSNs);
2219 
2220  Out << " syncscope(\"";
2221  PrintEscapedString(SSNs[SSID], Out);
2222  Out << "\")";
2223  break;
2224  }
2225  }
2226 }
2227 
2228 void AssemblyWriter::writeAtomic(const LLVMContext &Context,
2229  AtomicOrdering Ordering,
2230  SyncScope::ID SSID) {
2231  if (Ordering == AtomicOrdering::NotAtomic)
2232  return;
2233 
2234  writeSyncScope(Context, SSID);
2235  Out << " " << toIRString(Ordering);
2236 }
2237 
2238 void AssemblyWriter::writeAtomicCmpXchg(const LLVMContext &Context,
2239  AtomicOrdering SuccessOrdering,
2240  AtomicOrdering FailureOrdering,
2241  SyncScope::ID SSID) {
2242  assert(SuccessOrdering != AtomicOrdering::NotAtomic &&
2243  FailureOrdering != AtomicOrdering::NotAtomic);
2244 
2245  writeSyncScope(Context, SSID);
2246  Out << " " << toIRString(SuccessOrdering);
2247  Out << " " << toIRString(FailureOrdering);
2248 }
2249 
2250 void AssemblyWriter::writeParamOperand(const Value *Operand,
2251  AttributeSet Attrs) {
2252  if (!Operand) {
2253  Out << "<null operand!>";
2254  return;
2255  }
2256 
2257  // Print the type
2258  TypePrinter.print(Operand->getType(), Out);
2259  // Print parameter attributes list
2260  if (Attrs.hasAttributes())
2261  Out << ' ' << Attrs.getAsString();
2262  Out << ' ';
2263  // Print the operand
2264  WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule);
2265 }
2266 
2267 void AssemblyWriter::writeOperandBundles(ImmutableCallSite CS) {
2268  if (!CS.hasOperandBundles())
2269  return;
2270 
2271  Out << " [ ";
2272 
2273  bool FirstBundle = true;
2274  for (unsigned i = 0, e = CS.getNumOperandBundles(); i != e; ++i) {
2276 
2277  if (!FirstBundle)
2278  Out << ", ";
2279  FirstBundle = false;
2280 
2281  Out << '"';
2282  PrintEscapedString(BU.getTagName(), Out);
2283  Out << '"';
2284 
2285  Out << '(';
2286 
2287  bool FirstInput = true;
2288  for (const auto &Input : BU.Inputs) {
2289  if (!FirstInput)
2290  Out << ", ";
2291  FirstInput = false;
2292 
2293  TypePrinter.print(Input->getType(), Out);
2294  Out << " ";
2295  WriteAsOperandInternal(Out, Input, &TypePrinter, &Machine, TheModule);
2296  }
2297 
2298  Out << ')';
2299  }
2300 
2301  Out << " ]";
2302 }
2303 
2304 void AssemblyWriter::printModule(const Module *M) {
2305  Machine.initialize();
2306 
2307  if (ShouldPreserveUseListOrder)
2308  UseListOrders = predictUseListOrder(M);
2309 
2310  if (!M->getModuleIdentifier().empty() &&
2311  // Don't print the ID if it will start a new line (which would
2312  // require a comment char before it).
2313  M->getModuleIdentifier().find('\n') == std::string::npos)
2314  Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n";
2315 
2316  if (!M->getSourceFileName().empty()) {
2317  Out << "source_filename = \"";
2319  Out << "\"\n";
2320  }
2321 
2322  const std::string &DL = M->getDataLayoutStr();
2323  if (!DL.empty())
2324  Out << "target datalayout = \"" << DL << "\"\n";
2325  if (!M->getTargetTriple().empty())
2326  Out << "target triple = \"" << M->getTargetTriple() << "\"\n";
2327 
2328  if (!M->getModuleInlineAsm().empty()) {
2329  Out << '\n';
2330 
2331  // Split the string into lines, to make it easier to read the .ll file.
2333  do {
2334  StringRef Front;
2335  std::tie(Front, Asm) = Asm.split('\n');
2336 
2337  // We found a newline, print the portion of the asm string from the
2338  // last newline up to this newline.
2339  Out << "module asm \"";
2340  PrintEscapedString(Front, Out);
2341  Out << "\"\n";
2342  } while (!Asm.empty());
2343  }
2344 
2345  printTypeIdentities();
2346 
2347  // Output all comdats.
2348  if (!Comdats.empty())
2349  Out << '\n';
2350  for (const Comdat *C : Comdats) {
2351  printComdat(C);
2352  if (C != Comdats.back())
2353  Out << '\n';
2354  }
2355 
2356  // Output all globals.
2357  if (!M->global_empty()) Out << '\n';
2358  for (const GlobalVariable &GV : M->globals()) {
2359  printGlobal(&GV); Out << '\n';
2360  }
2361 
2362  // Output all aliases.
2363  if (!M->alias_empty()) Out << "\n";
2364  for (const GlobalAlias &GA : M->aliases())
2365  printIndirectSymbol(&GA);
2366 
2367  // Output all ifuncs.
2368  if (!M->ifunc_empty()) Out << "\n";
2369  for (const GlobalIFunc &GI : M->ifuncs())
2370  printIndirectSymbol(&GI);
2371 
2372  // Output global use-lists.
2373  printUseLists(nullptr);
2374 
2375  // Output all of the functions.
2376  for (const Function &F : *M)
2377  printFunction(&F);
2378  assert(UseListOrders.empty() && "All use-lists should have been consumed");
2379 
2380  // Output all attribute groups.
2381  if (!Machine.as_empty()) {
2382  Out << '\n';
2383  writeAllAttributeGroups();
2384  }
2385 
2386  // Output named metadata.
2387  if (!M->named_metadata_empty()) Out << '\n';
2388 
2389  for (const NamedMDNode &Node : M->named_metadata())
2390  printNamedMDNode(&Node);
2391 
2392  // Output metadata.
2393  if (!Machine.mdn_empty()) {
2394  Out << '\n';
2395  writeAllMDNodes();
2396  }
2397 }
2398 
2400  formatted_raw_ostream &Out) {
2401  if (Name.empty()) {
2402  Out << "<empty name> ";
2403  } else {
2404  if (isalpha(static_cast<unsigned char>(Name[0])) || Name[0] == '-' ||
2405  Name[0] == '$' || Name[0] == '.' || Name[0] == '_')
2406  Out << Name[0];
2407  else
2408  Out << '\\' << hexdigit(Name[0] >> 4) << hexdigit(Name[0] & 0x0F);
2409  for (unsigned i = 1, e = Name.size(); i != e; ++i) {
2410  unsigned char C = Name[i];
2411  if (isalnum(static_cast<unsigned char>(C)) || C == '-' || C == '$' ||
2412  C == '.' || C == '_')
2413  Out << C;
2414  else
2415  Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
2416  }
2417  }
2418 }
2419 
2420 void AssemblyWriter::printNamedMDNode(const NamedMDNode *NMD) {
2421  Out << '!';
2422  printMetadataIdentifier(NMD->getName(), Out);
2423  Out << " = !{";
2424  for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2425  if (i)
2426  Out << ", ";
2427  int Slot = Machine.getMetadataSlot(NMD->getOperand(i));
2428  if (Slot == -1)
2429  Out << "<badref>";
2430  else
2431  Out << '!' << Slot;
2432  }
2433  Out << "}\n";
2434 }
2435 
2437  switch (LT) {
2439  return "";
2441  return "private ";
2443  return "internal ";
2445  return "linkonce ";
2447  return "linkonce_odr ";
2449  return "weak ";
2451  return "weak_odr ";
2453  return "common ";
2455  return "appending ";
2457  return "extern_weak ";
2459  return "available_externally ";
2460  }
2461  llvm_unreachable("invalid linkage");
2462 }
2463 
2465  formatted_raw_ostream &Out) {
2466  switch (Vis) {
2467  case GlobalValue::DefaultVisibility: break;
2468  case GlobalValue::HiddenVisibility: Out << "hidden "; break;
2469  case GlobalValue::ProtectedVisibility: Out << "protected "; break;
2470  }
2471 }
2472 
2474  formatted_raw_ostream &Out) {
2475  switch (SCT) {
2477  case GlobalValue::DLLImportStorageClass: Out << "dllimport "; break;
2478  case GlobalValue::DLLExportStorageClass: Out << "dllexport "; break;
2479  }
2480 }
2481 
2483  formatted_raw_ostream &Out) {
2484  switch (TLM) {
2486  break;
2488  Out << "thread_local ";
2489  break;
2491  Out << "thread_local(localdynamic) ";
2492  break;
2494  Out << "thread_local(initialexec) ";
2495  break;
2497  Out << "thread_local(localexec) ";
2498  break;
2499  }
2500 }
2501 
2503  switch (UA) {
2505  return "";
2507  return "local_unnamed_addr";
2509  return "unnamed_addr";
2510  }
2511  llvm_unreachable("Unknown UnnamedAddr");
2512 }
2513 
2515  const GlobalObject &GO) {
2516  const Comdat *C = GO.getComdat();
2517  if (!C)
2518  return;
2519 
2520  if (isa<GlobalVariable>(GO))
2521  Out << ',';
2522  Out << " comdat";
2523 
2524  if (GO.getName() == C->getName())
2525  return;
2526 
2527  Out << '(';
2528  PrintLLVMName(Out, C->getName(), ComdatPrefix);
2529  Out << ')';
2530 }
2531 
2532 void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
2533  if (GV->isMaterializable())
2534  Out << "; Materializable\n";
2535 
2536  WriteAsOperandInternal(Out, GV, &TypePrinter, &Machine, GV->getParent());
2537  Out << " = ";
2538 
2539  if (!GV->hasInitializer() && GV->hasExternalLinkage())
2540  Out << "external ";
2541 
2542  Out << getLinkagePrintName(GV->getLinkage());
2543  PrintVisibility(GV->getVisibility(), Out);
2547  if (!UA.empty())
2548  Out << UA << ' ';
2549 
2550  if (unsigned AddressSpace = GV->getType()->getAddressSpace())
2551  Out << "addrspace(" << AddressSpace << ") ";
2552  if (GV->isExternallyInitialized()) Out << "externally_initialized ";
2553  Out << (GV->isConstant() ? "constant " : "global ");
2554  TypePrinter.print(GV->getValueType(), Out);
2555 
2556  if (GV->hasInitializer()) {
2557  Out << ' ';
2558  writeOperand(GV->getInitializer(), false);
2559  }
2560 
2561  if (GV->hasSection()) {
2562  Out << ", section \"";
2563  PrintEscapedString(GV->getSection(), Out);
2564  Out << '"';
2565  }
2566  maybePrintComdat(Out, *GV);
2567  if (GV->getAlignment())
2568  Out << ", align " << GV->getAlignment();
2569 
2571  GV->getAllMetadata(MDs);
2572  printMetadataAttachments(MDs, ", ");
2573 
2574  auto Attrs = GV->getAttributes();
2575  if (Attrs.hasAttributes())
2576  Out << " #" << Machine.getAttributeGroupSlot(Attrs);
2577 
2578  printInfoComment(*GV);
2579 }
2580 
2581 void AssemblyWriter::printIndirectSymbol(const GlobalIndirectSymbol *GIS) {
2582  if (GIS->isMaterializable())
2583  Out << "; Materializable\n";
2584 
2585  WriteAsOperandInternal(Out, GIS, &TypePrinter, &Machine, GIS->getParent());
2586  Out << " = ";
2587 
2588  Out << getLinkagePrintName(GIS->getLinkage());
2589  PrintVisibility(GIS->getVisibility(), Out);
2593  if (!UA.empty())
2594  Out << UA << ' ';
2595 
2596  if (isa<GlobalAlias>(GIS))
2597  Out << "alias ";
2598  else if (isa<GlobalIFunc>(GIS))
2599  Out << "ifunc ";
2600  else
2601  llvm_unreachable("Not an alias or ifunc!");
2602 
2603  TypePrinter.print(GIS->getValueType(), Out);
2604 
2605  Out << ", ";
2606 
2607  const Constant *IS = GIS->getIndirectSymbol();
2608 
2609  if (!IS) {
2610  TypePrinter.print(GIS->getType(), Out);
2611  Out << " <<NULL ALIASEE>>";
2612  } else {
2613  writeOperand(IS, !isa<ConstantExpr>(IS));
2614  }
2615 
2616  printInfoComment(*GIS);
2617  Out << '\n';
2618 }
2619 
2620 void AssemblyWriter::printComdat(const Comdat *C) {
2621  C->print(Out);
2622 }
2623 
2624 void AssemblyWriter::printTypeIdentities() {
2625  if (TypePrinter.NumberedTypes.empty() &&
2626  TypePrinter.NamedTypes.empty())
2627  return;
2628 
2629  Out << '\n';
2630 
2631  // We know all the numbers that each type is used and we know that it is a
2632  // dense assignment. Convert the map to an index table.
2633  std::vector<StructType*> NumberedTypes(TypePrinter.NumberedTypes.size());
2635  TypePrinter.NumberedTypes.begin(), E = TypePrinter.NumberedTypes.end();
2636  I != E; ++I) {
2637  assert(I->second < NumberedTypes.size() && "Didn't get a dense numbering?");
2638  NumberedTypes[I->second] = I->first;
2639  }
2640 
2641  // Emit all numbered types.
2642  for (unsigned i = 0, e = NumberedTypes.size(); i != e; ++i) {
2643  Out << '%' << i << " = type ";
2644 
2645  // Make sure we print out at least one level of the type structure, so
2646  // that we do not get %2 = type %2
2647  TypePrinter.printStructBody(NumberedTypes[i], Out);
2648  Out << '\n';
2649  }
2650 
2651  for (unsigned i = 0, e = TypePrinter.NamedTypes.size(); i != e; ++i) {
2652  PrintLLVMName(Out, TypePrinter.NamedTypes[i]->getName(), LocalPrefix);
2653  Out << " = type ";
2654 
2655  // Make sure we print out at least one level of the type structure, so
2656  // that we do not get %FILE = type %FILE
2657  TypePrinter.printStructBody(TypePrinter.NamedTypes[i], Out);
2658  Out << '\n';
2659  }
2660 }
2661 
2662 /// printFunction - Print all aspects of a function.
2663 void AssemblyWriter::printFunction(const Function *F) {
2664  // Print out the return type and name.
2665  Out << '\n';
2666 
2667  if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out);
2668 
2669  if (F->isMaterializable())
2670  Out << "; Materializable\n";
2671 
2672  const AttributeList &Attrs = F->getAttributes();
2674  AttributeSet AS = Attrs.getFnAttributes();
2675  std::string AttrStr;
2676 
2677  for (const Attribute &Attr : AS) {
2678  if (!Attr.isStringAttribute()) {
2679  if (!AttrStr.empty()) AttrStr += ' ';
2680  AttrStr += Attr.getAsString();
2681  }
2682  }
2683 
2684  if (!AttrStr.empty())
2685  Out << "; Function Attrs: " << AttrStr << '\n';
2686  }
2687 
2688  Machine.incorporateFunction(F);
2689 
2690  if (F->isDeclaration()) {
2691  Out << "declare";
2693  F->getAllMetadata(MDs);
2694  printMetadataAttachments(MDs, " ");
2695  Out << ' ';
2696  } else
2697  Out << "define ";
2698 
2699  Out << getLinkagePrintName(F->getLinkage());
2700  PrintVisibility(F->getVisibility(), Out);
2702 
2703  // Print the calling convention.
2704  if (F->getCallingConv() != CallingConv::C) {
2705  PrintCallingConv(F->getCallingConv(), Out);
2706  Out << " ";
2707  }
2708 
2709  FunctionType *FT = F->getFunctionType();
2711  Out << Attrs.getAsString(AttributeList::ReturnIndex) << ' ';
2712  TypePrinter.print(F->getReturnType(), Out);
2713  Out << ' ';
2714  WriteAsOperandInternal(Out, F, &TypePrinter, &Machine, F->getParent());
2715  Out << '(';
2716 
2717  // Loop over the arguments, printing them...
2718  if (F->isDeclaration() && !IsForDebug) {
2719  // We're only interested in the type here - don't print argument names.
2720  for (unsigned I = 0, E = FT->getNumParams(); I != E; ++I) {
2721  // Insert commas as we go... the first arg doesn't get a comma
2722  if (I)
2723  Out << ", ";
2724  // Output type...
2725  TypePrinter.print(FT->getParamType(I), Out);
2726 
2727  AttributeSet ArgAttrs = Attrs.getParamAttributes(I);
2728  if (ArgAttrs.hasAttributes())
2729  Out << ' ' << ArgAttrs.getAsString();
2730  }
2731  } else {
2732  // The arguments are meaningful here, print them in detail.
2733  for (const Argument &Arg : F->args()) {
2734  // Insert commas as we go... the first arg doesn't get a comma
2735  if (Arg.getArgNo() != 0)
2736  Out << ", ";
2737  printArgument(&Arg, Attrs.getParamAttributes(Arg.getArgNo()));
2738  }
2739  }
2740 
2741  // Finish printing arguments...
2742  if (FT->isVarArg()) {
2743  if (FT->getNumParams()) Out << ", ";
2744  Out << "..."; // Output varargs portion of signature!
2745  }
2746  Out << ')';
2748  if (!UA.empty())
2749  Out << ' ' << UA;
2751  Out << " #" << Machine.getAttributeGroupSlot(Attrs.getFnAttributes());
2752  if (F->hasSection()) {
2753  Out << " section \"";
2754  PrintEscapedString(F->getSection(), Out);
2755  Out << '"';
2756  }
2757  maybePrintComdat(Out, *F);
2758  if (F->getAlignment())
2759  Out << " align " << F->getAlignment();
2760  if (F->hasGC())
2761  Out << " gc \"" << F->getGC() << '"';
2762  if (F->hasPrefixData()) {
2763  Out << " prefix ";
2764  writeOperand(F->getPrefixData(), true);
2765  }
2766  if (F->hasPrologueData()) {
2767  Out << " prologue ";
2768  writeOperand(F->getPrologueData(), true);
2769  }
2770  if (F->hasPersonalityFn()) {
2771  Out << " personality ";
2772  writeOperand(F->getPersonalityFn(), /*PrintType=*/true);
2773  }
2774 
2775  if (F->isDeclaration()) {
2776  Out << '\n';
2777  } else {
2779  F->getAllMetadata(MDs);
2780  printMetadataAttachments(MDs, " ");
2781 
2782  Out << " {";
2783  // Output all of the function's basic blocks.
2784  for (const BasicBlock &BB : *F)
2785  printBasicBlock(&BB);
2786 
2787  // Output the function's use-lists.
2788  printUseLists(F);
2789 
2790  Out << "}\n";
2791  }
2792 
2793  Machine.purgeFunction();
2794 }
2795 
2796 /// printArgument - This member is called for every argument that is passed into
2797 /// the function. Simply print it out
2798 void AssemblyWriter::printArgument(const Argument *Arg, AttributeSet Attrs) {
2799  // Output type...
2800  TypePrinter.print(Arg->getType(), Out);
2801 
2802  // Output parameter attributes list
2803  if (Attrs.hasAttributes())
2804  Out << ' ' << Attrs.getAsString();
2805 
2806  // Output name, if available...
2807  if (Arg->hasName()) {
2808  Out << ' ';
2809  PrintLLVMName(Out, Arg);
2810  }
2811 }
2812 
2813 /// printBasicBlock - This member is called for each basic block in a method.
2814 void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
2815  if (BB->hasName()) { // Print out the label if it exists...
2816  Out << "\n";
2817  PrintLLVMName(Out, BB->getName(), LabelPrefix);
2818  Out << ':';
2819  } else if (!BB->use_empty()) { // Don't print block # of no uses...
2820  Out << "\n; <label>:";
2821  int Slot = Machine.getLocalSlot(BB);
2822  if (Slot != -1)
2823  Out << Slot << ":";
2824  else
2825  Out << "<badref>";
2826  }
2827 
2828  if (!BB->getParent()) {
2829  Out.PadToColumn(50);
2830  Out << "; Error: Block without parent!";
2831  } else if (BB != &BB->getParent()->getEntryBlock()) { // Not the entry block?
2832  // Output predecessors for the block.
2833  Out.PadToColumn(50);
2834  Out << ";";
2835  const_pred_iterator PI = pred_begin(BB), PE = pred_end(BB);
2836 
2837  if (PI == PE) {
2838  Out << " No predecessors!";
2839  } else {
2840  Out << " preds = ";
2841  writeOperand(*PI, false);
2842  for (++PI; PI != PE; ++PI) {
2843  Out << ", ";
2844  writeOperand(*PI, false);
2845  }
2846  }
2847  }
2848 
2849  Out << "\n";
2850 
2851  if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out);
2852 
2853  // Output all of the instructions in the basic block...
2854  for (const Instruction &I : *BB) {
2855  printInstructionLine(I);
2856  }
2857 
2858  if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out);
2859 }
2860 
2861 /// printInstructionLine - Print an instruction and a newline character.
2862 void AssemblyWriter::printInstructionLine(const Instruction &I) {
2863  printInstruction(I);
2864  Out << '\n';
2865 }
2866 
2867 /// printGCRelocateComment - print comment after call to the gc.relocate
2868 /// intrinsic indicating base and derived pointer names.
2869 void AssemblyWriter::printGCRelocateComment(const GCRelocateInst &Relocate) {
2870  Out << " ; (";
2871  writeOperand(Relocate.getBasePtr(), false);
2872  Out << ", ";
2873  writeOperand(Relocate.getDerivedPtr(), false);
2874  Out << ")";
2875 }
2876 
2877 /// printInfoComment - Print a little comment after the instruction indicating
2878 /// which slot it occupies.
2879 void AssemblyWriter::printInfoComment(const Value &V) {
2880  if (const auto *Relocate = dyn_cast<GCRelocateInst>(&V))
2881  printGCRelocateComment(*Relocate);
2882 
2883  if (AnnotationWriter)
2884  AnnotationWriter->printInfoComment(V, Out);
2885 }
2886 
2887 // This member is called for each Instruction in a function..
2888 void AssemblyWriter::printInstruction(const Instruction &I) {
2889  if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out);
2890 
2891  // Print out indentation for an instruction.
2892  Out << " ";
2893 
2894  // Print out name if it exists...
2895  if (I.hasName()) {
2896  PrintLLVMName(Out, &I);
2897  Out << " = ";
2898  } else if (!I.getType()->isVoidTy()) {
2899  // Print out the def slot taken.
2900  int SlotNum = Machine.getLocalSlot(&I);
2901  if (SlotNum == -1)
2902  Out << "<badref> = ";
2903  else
2904  Out << '%' << SlotNum << " = ";
2905  }
2906 
2907  if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
2908  if (CI->isMustTailCall())
2909  Out << "musttail ";
2910  else if (CI->isTailCall())
2911  Out << "tail ";
2912  else if (CI->isNoTailCall())
2913  Out << "notail ";
2914  }
2915 
2916  // Print out the opcode...
2917  Out << I.getOpcodeName();
2918 
2919  // If this is an atomic load or store, print out the atomic marker.
2920  if ((isa<LoadInst>(I) && cast<LoadInst>(I).isAtomic()) ||
2921  (isa<StoreInst>(I) && cast<StoreInst>(I).isAtomic()))
2922  Out << " atomic";
2923 
2924  if (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).isWeak())
2925  Out << " weak";
2926 
2927  // If this is a volatile operation, print out the volatile marker.
2928  if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) ||
2929  (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile()) ||
2930  (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).isVolatile()) ||
2931  (isa<AtomicRMWInst>(I) && cast<AtomicRMWInst>(I).isVolatile()))
2932  Out << " volatile";
2933 
2934  // Print out optimization information.
2935  WriteOptimizationInfo(Out, &I);
2936 
2937  // Print out the compare instruction predicates
2938  if (const CmpInst *CI = dyn_cast<CmpInst>(&I))
2939  Out << ' ' << CmpInst::getPredicateName(CI->getPredicate());
2940 
2941  // Print out the atomicrmw operation
2942  if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I))
2943  writeAtomicRMWOperation(Out, RMWI->getOperation());
2944 
2945  // Print out the type of the operands...
2946  const Value *Operand = I.getNumOperands() ? I.getOperand(0) : nullptr;
2947 
2948  // Special case conditional branches to swizzle the condition out to the front
2949  if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) {
2950  const BranchInst &BI(cast<BranchInst>(I));
2951  Out << ' ';
2952  writeOperand(BI.getCondition(), true);
2953  Out << ", ";
2954  writeOperand(BI.getSuccessor(0), true);
2955  Out << ", ";
2956  writeOperand(BI.getSuccessor(1), true);
2957 
2958  } else if (isa<SwitchInst>(I)) {
2959  const SwitchInst& SI(cast<SwitchInst>(I));
2960  // Special case switch instruction to get formatting nice and correct.
2961  Out << ' ';
2962  writeOperand(SI.getCondition(), true);
2963  Out << ", ";
2964  writeOperand(SI.getDefaultDest(), true);
2965  Out << " [";
2966  for (auto Case : SI.cases()) {
2967  Out << "\n ";
2968  writeOperand(Case.getCaseValue(), true);
2969  Out << ", ";
2970  writeOperand(Case.getCaseSuccessor(), true);
2971  }
2972  Out << "\n ]";
2973  } else if (isa<IndirectBrInst>(I)) {
2974  // Special case indirectbr instruction to get formatting nice and correct.
2975  Out << ' ';
2976  writeOperand(Operand, true);
2977  Out << ", [";
2978 
2979  for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) {
2980  if (i != 1)
2981  Out << ", ";
2982  writeOperand(I.getOperand(i), true);
2983  }
2984  Out << ']';
2985  } else if (const PHINode *PN = dyn_cast<PHINode>(&I)) {
2986  Out << ' ';
2987  TypePrinter.print(I.getType(), Out);
2988  Out << ' ';
2989 
2990  for (unsigned op = 0, Eop = PN->getNumIncomingValues(); op < Eop; ++op) {
2991  if (op) Out << ", ";
2992  Out << "[ ";
2993  writeOperand(PN->getIncomingValue(op), false); Out << ", ";
2994  writeOperand(PN->getIncomingBlock(op), false); Out << " ]";
2995  }
2996  } else if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(&I)) {
2997  Out << ' ';
2998  writeOperand(I.getOperand(0), true);
2999  for (const unsigned *i = EVI->idx_begin(), *e = EVI->idx_end(); i != e; ++i)
3000  Out << ", " << *i;
3001  } else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(&I)) {
3002  Out << ' ';
3003  writeOperand(I.getOperand(0), true); Out << ", ";
3004  writeOperand(I.getOperand(1), true);
3005  for (const unsigned *i = IVI->idx_begin(), *e = IVI->idx_end(); i != e; ++i)
3006  Out << ", " << *i;
3007  } else if (const LandingPadInst *LPI = dyn_cast<LandingPadInst>(&I)) {
3008  Out << ' ';
3009  TypePrinter.print(I.getType(), Out);
3010  if (LPI->isCleanup() || LPI->getNumClauses() != 0)
3011  Out << '\n';
3012 
3013  if (LPI->isCleanup())
3014  Out << " cleanup";
3015 
3016  for (unsigned i = 0, e = LPI->getNumClauses(); i != e; ++i) {
3017  if (i != 0 || LPI->isCleanup()) Out << "\n";
3018  if (LPI->isCatch(i))
3019  Out << " catch ";
3020  else
3021  Out << " filter ";
3022 
3023  writeOperand(LPI->getClause(i), true);
3024  }
3025  } else if (const auto *CatchSwitch = dyn_cast<CatchSwitchInst>(&I)) {
3026  Out << " within ";
3027  writeOperand(CatchSwitch->getParentPad(), /*PrintType=*/false);
3028  Out << " [";
3029  unsigned Op = 0;
3030  for (const BasicBlock *PadBB : CatchSwitch->handlers()) {
3031  if (Op > 0)
3032  Out << ", ";
3033  writeOperand(PadBB, /*PrintType=*/true);
3034  ++Op;
3035  }
3036  Out << "] unwind ";
3037  if (const BasicBlock *UnwindDest = CatchSwitch->getUnwindDest())
3038  writeOperand(UnwindDest, /*PrintType=*/true);
3039  else
3040  Out << "to caller";
3041  } else if (const auto *FPI = dyn_cast<FuncletPadInst>(&I)) {
3042  Out << " within ";
3043  writeOperand(FPI->getParentPad(), /*PrintType=*/false);
3044  Out << " [";
3045  for (unsigned Op = 0, NumOps = FPI->getNumArgOperands(); Op < NumOps;
3046  ++Op) {
3047  if (Op > 0)
3048  Out << ", ";
3049  writeOperand(FPI->getArgOperand(Op), /*PrintType=*/true);
3050  }
3051  Out << ']';
3052  } else if (isa<ReturnInst>(I) && !Operand) {
3053  Out << " void";
3054  } else if (const auto *CRI = dyn_cast<CatchReturnInst>(&I)) {
3055  Out << " from ";
3056  writeOperand(CRI->getOperand(0), /*PrintType=*/false);
3057 
3058  Out << " to ";
3059  writeOperand(CRI->getOperand(1), /*PrintType=*/true);
3060  } else if (const auto *CRI = dyn_cast<CleanupReturnInst>(&I)) {
3061  Out << " from ";
3062  writeOperand(CRI->getOperand(0), /*PrintType=*/false);
3063 
3064  Out << " unwind ";
3065  if (CRI->hasUnwindDest())
3066  writeOperand(CRI->getOperand(1), /*PrintType=*/true);
3067  else
3068  Out << "to caller";
3069  } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
3070  // Print the calling convention being used.
3071  if (CI->getCallingConv() != CallingConv::C) {
3072  Out << " ";
3073  PrintCallingConv(CI->getCallingConv(), Out);
3074  }
3075 
3076  Operand = CI->getCalledValue();
3077  FunctionType *FTy = CI->getFunctionType();
3078  Type *RetTy = FTy->getReturnType();
3079  const AttributeList &PAL = CI->getAttributes();
3080 
3082  Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
3083 
3084  // If possible, print out the short form of the call instruction. We can
3085  // only do this if the first argument is a pointer to a nonvararg function,
3086  // and if the return type is not a pointer to a function.
3087  //
3088  Out << ' ';
3089  TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
3090  Out << ' ';
3091  writeOperand(Operand, false);
3092  Out << '(';
3093  for (unsigned op = 0, Eop = CI->getNumArgOperands(); op < Eop; ++op) {
3094  if (op > 0)
3095  Out << ", ";
3096  writeParamOperand(CI->getArgOperand(op), PAL.getParamAttributes(op));
3097  }
3098 
3099  // Emit an ellipsis if this is a musttail call in a vararg function. This
3100  // is only to aid readability, musttail calls forward varargs by default.
3101  if (CI->isMustTailCall() && CI->getParent() &&
3102  CI->getParent()->getParent() &&
3103  CI->getParent()->getParent()->isVarArg())
3104  Out << ", ...";
3105 
3106  Out << ')';
3108  Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
3109 
3110  writeOperandBundles(CI);
3111  } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
3112  Operand = II->getCalledValue();
3113  FunctionType *FTy = II->getFunctionType();
3114  Type *RetTy = FTy->getReturnType();
3115  const AttributeList &PAL = II->getAttributes();
3116 
3117  // Print the calling convention being used.
3118  if (II->getCallingConv() != CallingConv::C) {
3119  Out << " ";
3120  PrintCallingConv(II->getCallingConv(), Out);
3121  }
3122 
3124  Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
3125 
3126  // If possible, print out the short form of the invoke instruction. We can
3127  // only do this if the first argument is a pointer to a nonvararg function,
3128  // and if the return type is not a pointer to a function.
3129  //
3130  Out << ' ';
3131  TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
3132  Out << ' ';
3133  writeOperand(Operand, false);
3134  Out << '(';
3135  for (unsigned op = 0, Eop = II->getNumArgOperands(); op < Eop; ++op) {
3136  if (op)
3137  Out << ", ";
3138  writeParamOperand(II->getArgOperand(op), PAL.getParamAttributes(op));
3139  }
3140 
3141  Out << ')';
3143  Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
3144 
3145  writeOperandBundles(II);
3146 
3147  Out << "\n to ";
3148  writeOperand(II->getNormalDest(), true);
3149  Out << " unwind ";
3150  writeOperand(II->getUnwindDest(), true);
3151  } else if (const AllocaInst *AI = dyn_cast<AllocaInst>(&I)) {
3152  Out << ' ';
3153  if (AI->isUsedWithInAlloca())
3154  Out << "inalloca ";
3155  if (AI->isSwiftError())
3156  Out << "swifterror ";
3157  TypePrinter.print(AI->getAllocatedType(), Out);
3158 
3159  // Explicitly write the array size if the code is broken, if it's an array
3160  // allocation, or if the type is not canonical for scalar allocations. The
3161  // latter case prevents the type from mutating when round-tripping through
3162  // assembly.
3163  if (!AI->getArraySize() || AI->isArrayAllocation() ||
3164  !AI->getArraySize()->getType()->isIntegerTy(32)) {
3165  Out << ", ";
3166  writeOperand(AI->getArraySize(), true);
3167  }
3168  if (AI->getAlignment()) {
3169  Out << ", align " << AI->getAlignment();
3170  }
3171 
3172  unsigned AddrSpace = AI->getType()->getAddressSpace();
3173  if (AddrSpace != 0) {
3174  Out << ", addrspace(" << AddrSpace << ')';
3175  }
3176  } else if (isa<CastInst>(I)) {
3177  if (Operand) {
3178  Out << ' ';
3179  writeOperand(Operand, true); // Work with broken code
3180  }
3181  Out << " to ";
3182  TypePrinter.print(I.getType(), Out);
3183  } else if (isa<VAArgInst>(I)) {
3184  if (Operand) {
3185  Out << ' ';
3186  writeOperand(Operand, true); // Work with broken code
3187  }
3188  Out << ", ";
3189  TypePrinter.print(I.getType(), Out);
3190  } else if (Operand) { // Print the normal way.
3191  if (const auto *GEP = dyn_cast<GetElementPtrInst>(&I)) {
3192  Out << ' ';
3193  TypePrinter.print(GEP->getSourceElementType(), Out);
3194  Out << ',';
3195  } else if (const auto *LI = dyn_cast<LoadInst>(&I)) {
3196  Out << ' ';
3197  TypePrinter.print(LI->getType(), Out);
3198  Out << ',';
3199  }
3200 
3201  // PrintAllTypes - Instructions who have operands of all the same type
3202  // omit the type from all but the first operand. If the instruction has
3203  // different type operands (for example br), then they are all printed.
3204  bool PrintAllTypes = false;
3205  Type *TheType = Operand->getType();
3206 
3207  // Select, Store and ShuffleVector always print all types.
3208  if (isa<SelectInst>(I) || isa<StoreInst>(I) || isa<ShuffleVectorInst>(I)
3209  || isa<ReturnInst>(I)) {
3210  PrintAllTypes = true;
3211  } else {
3212  for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) {
3213  Operand = I.getOperand(i);
3214  // note that Operand shouldn't be null, but the test helps make dump()
3215  // more tolerant of malformed IR
3216  if (Operand && Operand->getType() != TheType) {
3217  PrintAllTypes = true; // We have differing types! Print them all!
3218  break;
3219  }
3220  }
3221  }
3222 
3223  if (!PrintAllTypes) {
3224  Out << ' ';
3225  TypePrinter.print(TheType, Out);
3226  }
3227 
3228  Out << ' ';
3229  for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) {
3230  if (i) Out << ", ";
3231  writeOperand(I.getOperand(i), PrintAllTypes);
3232  }
3233  }
3234 
3235  // Print atomic ordering/alignment for memory operations
3236  if (const LoadInst *LI = dyn_cast<LoadInst>(&I)) {
3237  if (LI->isAtomic())
3238  writeAtomic(LI->getContext(), LI->getOrdering(), LI->getSyncScopeID());
3239  if (LI->getAlignment())
3240  Out << ", align " << LI->getAlignment();
3241  } else if (const StoreInst *SI = dyn_cast<StoreInst>(&I)) {
3242  if (SI->isAtomic())
3243  writeAtomic(SI->getContext(), SI->getOrdering(), SI->getSyncScopeID());
3244  if (SI->getAlignment())
3245  Out << ", align " << SI->getAlignment();
3246  } else if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(&I)) {
3247  writeAtomicCmpXchg(CXI->getContext(), CXI->getSuccessOrdering(),
3248  CXI->getFailureOrdering(), CXI->getSyncScopeID());
3249  } else if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I)) {
3250  writeAtomic(RMWI->getContext(), RMWI->getOrdering(),
3251  RMWI->getSyncScopeID());
3252  } else if (const FenceInst *FI = dyn_cast<FenceInst>(&I)) {
3253  writeAtomic(FI->getContext(), FI->getOrdering(), FI->getSyncScopeID());
3254  }
3255 
3256  // Print Metadata info.
3258  I.getAllMetadata(InstMD);
3259  printMetadataAttachments(InstMD, ", ");
3260 
3261  // Print a nice comment.
3262  printInfoComment(I);
3263 }
3264 
3265 void AssemblyWriter::printMetadataAttachments(
3266  const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
3267  StringRef Separator) {
3268  if (MDs.empty())
3269  return;
3270 
3271  if (MDNames.empty())
3272  MDs[0].second->getContext().getMDKindNames(MDNames);
3273 
3274  for (const auto &I : MDs) {
3275  unsigned Kind = I.first;
3276  Out << Separator;
3277  if (Kind < MDNames.size()) {
3278  Out << "!";
3279  printMetadataIdentifier(MDNames[Kind], Out);
3280  } else
3281  Out << "!<unknown kind #" << Kind << ">";
3282  Out << ' ';
3283  WriteAsOperandInternal(Out, I.second, &TypePrinter, &Machine, TheModule);
3284  }
3285 }
3286 
3287 void AssemblyWriter::writeMDNode(unsigned Slot, const MDNode *Node) {
3288  Out << '!' << Slot << " = ";
3289  printMDNodeBody(Node);
3290  Out << "\n";
3291 }
3292 
3293 void AssemblyWriter::writeAllMDNodes() {
3295  Nodes.resize(Machine.mdn_size());
3296  for (SlotTracker::mdn_iterator I = Machine.mdn_begin(), E = Machine.mdn_end();
3297  I != E; ++I)
3298  Nodes[I->second] = cast<MDNode>(I->first);
3299 
3300  for (unsigned i = 0, e = Nodes.size(); i != e; ++i) {
3301  writeMDNode(i, Nodes[i]);
3302  }
3303 }
3304 
3305 void AssemblyWriter::printMDNodeBody(const MDNode *Node) {
3306  WriteMDNodeBodyInternal(Out, Node, &TypePrinter, &Machine, TheModule);
3307 }
3308 
3309 void AssemblyWriter::writeAllAttributeGroups() {
3310  std::vector<std::pair<AttributeSet, unsigned>> asVec;
3311  asVec.resize(Machine.as_size());
3312 
3313  for (SlotTracker::as_iterator I = Machine.as_begin(), E = Machine.as_end();
3314  I != E; ++I)
3315  asVec[I->second] = *I;
3316 
3317  for (const auto &I : asVec)
3318  Out << "attributes #" << I.second << " = { "
3319  << I.first.getAsString(true) << " }\n";
3320 }
3321 
3322 void AssemblyWriter::printUseListOrder(const UseListOrder &Order) {
3323  bool IsInFunction = Machine.getFunction();
3324  if (IsInFunction)
3325  Out << " ";
3326 
3327  Out << "uselistorder";
3328  if (const BasicBlock *BB =
3329  IsInFunction ? nullptr : dyn_cast<BasicBlock>(Order.V)) {
3330  Out << "_bb ";
3331  writeOperand(BB->getParent(), false);
3332  Out << ", ";
3333  writeOperand(BB, false);
3334  } else {
3335  Out << " ";
3336  writeOperand(Order.V, true);
3337  }
3338  Out << ", { ";
3339 
3340  assert(Order.Shuffle.size() >= 2 && "Shuffle too small");
3341  Out << Order.Shuffle[0];
3342  for (unsigned I = 1, E = Order.Shuffle.size(); I != E; ++I)
3343  Out << ", " << Order.Shuffle[I];
3344  Out << " }\n";
3345 }
3346 
3347 void AssemblyWriter::printUseLists(const Function *F) {
3348  auto hasMore =
3349  [&]() { return !UseListOrders.empty() && UseListOrders.back().F == F; };
3350  if (!hasMore())
3351  // Nothing to do.
3352  return;
3353 
3354  Out << "\n; uselistorder directives\n";
3355  while (hasMore()) {
3356  printUseListOrder(UseListOrders.back());
3357  UseListOrders.pop_back();
3358  }
3359 }
3360 
3361 //===----------------------------------------------------------------------===//
3362 // External Interface declarations
3363 //===----------------------------------------------------------------------===//
3364 
3366  bool ShouldPreserveUseListOrder,
3367  bool IsForDebug) const {
3368  SlotTracker SlotTable(this->getParent());
3369  formatted_raw_ostream OS(ROS);
3370  AssemblyWriter W(OS, SlotTable, this->getParent(), AAW,
3371  IsForDebug,
3372  ShouldPreserveUseListOrder);
3373  W.printFunction(this);
3374 }
3375 
3377  bool ShouldPreserveUseListOrder, bool IsForDebug) const {
3378  SlotTracker SlotTable(this);
3379  formatted_raw_ostream OS(ROS);
3380  AssemblyWriter W(OS, SlotTable, this, AAW, IsForDebug,
3381  ShouldPreserveUseListOrder);
3382  W.printModule(this);
3383 }
3384 
3385 void NamedMDNode::print(raw_ostream &ROS, bool IsForDebug) const {
3386  SlotTracker SlotTable(getParent());
3387  formatted_raw_ostream OS(ROS);
3388  AssemblyWriter W(OS, SlotTable, getParent(), nullptr, IsForDebug);
3389  W.printNamedMDNode(this);
3390 }
3391 
3393  bool IsForDebug) const {
3394  Optional<SlotTracker> LocalST;
3395  SlotTracker *SlotTable;
3396  if (auto *ST = MST.getMachine())
3397  SlotTable = ST;
3398  else {
3399  LocalST.emplace(getParent());
3400  SlotTable = &*LocalST;
3401  }
3402 
3403  formatted_raw_ostream OS(ROS);
3404  AssemblyWriter W(OS, *SlotTable, getParent(), nullptr, IsForDebug);
3405  W.printNamedMDNode(this);
3406 }
3407 
3408 void Comdat::print(raw_ostream &ROS, bool /*IsForDebug*/) const {
3410  ROS << " = comdat ";
3411 
3412  switch (getSelectionKind()) {
3413  case Comdat::Any:
3414  ROS << "any";
3415  break;
3416  case Comdat::ExactMatch:
3417  ROS << "exactmatch";
3418  break;
3419  case Comdat::Largest:
3420  ROS << "largest";
3421  break;
3422  case Comdat::NoDuplicates:
3423  ROS << "noduplicates";
3424  break;
3425  case Comdat::SameSize:
3426  ROS << "samesize";
3427  break;
3428  }
3429 
3430  ROS << '\n';
3431 }
3432 
3433 void Type::print(raw_ostream &OS, bool /*IsForDebug*/, bool NoDetails) const {
3434  TypePrinting TP;
3435  TP.print(const_cast<Type*>(this), OS);
3436 
3437  if (NoDetails)
3438  return;
3439 
3440  // If the type is a named struct type, print the body as well.
3441  if (StructType *STy = dyn_cast<StructType>(const_cast<Type*>(this)))
3442  if (!STy->isLiteral()) {
3443  OS << " = type ";
3444  TP.printStructBody(STy, OS);
3445  }
3446 }
3447 
3448 static bool isReferencingMDNode(const Instruction &I) {
3449  if (const auto *CI = dyn_cast<CallInst>(&I))
3450  if (Function *F = CI->getCalledFunction())
3451  if (F->isIntrinsic())
3452  for (auto &Op : I.operands())
3453  if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op))
3454  if (isa<MDNode>(V->getMetadata()))
3455  return true;
3456  return false;
3457 }
3458 
3459 void Value::print(raw_ostream &ROS, bool IsForDebug) const {
3460  bool ShouldInitializeAllMetadata = false;
3461  if (auto *I = dyn_cast<Instruction>(this))
3462  ShouldInitializeAllMetadata = isReferencingMDNode(*I);
3463  else if (isa<Function>(this) || isa<MetadataAsValue>(this))
3464  ShouldInitializeAllMetadata = true;
3465 
3466  ModuleSlotTracker MST(getModuleFromVal(this), ShouldInitializeAllMetadata);
3467  print(ROS, MST, IsForDebug);
3468 }
3469 
3471  bool IsForDebug) const {
3472  formatted_raw_ostream OS(ROS);
3473  SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));
3474  SlotTracker &SlotTable =
3475  MST.getMachine() ? *MST.getMachine() : EmptySlotTable;
3476  auto incorporateFunction = [&](const Function *F) {
3477  if (F)
3478  MST.incorporateFunction(*F);
3479  };
3480 
3481  if (const Instruction *I = dyn_cast<Instruction>(this)) {
3482  incorporateFunction(I->getParent() ? I->getParent()->getParent() : nullptr);
3483  AssemblyWriter W(OS, SlotTable, getModuleFromVal(I), nullptr, IsForDebug);
3484  W.printInstruction(*I);
3485  } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(this)) {
3486  incorporateFunction(BB->getParent());
3487  AssemblyWriter W(OS, SlotTable, getModuleFromVal(BB), nullptr, IsForDebug);
3488  W.printBasicBlock(BB);
3489  } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(this)) {
3490  AssemblyWriter W(OS, SlotTable, GV->getParent(), nullptr, IsForDebug);
3491  if (const GlobalVariable *V = dyn_cast<GlobalVariable>(GV))
3492  W.printGlobal(V);
3493  else if (const Function *F = dyn_cast<Function>(GV))
3494  W.printFunction(F);
3495  else
3496  W.printIndirectSymbol(cast<GlobalIndirectSymbol>(GV));
3497  } else if (const MetadataAsValue *V = dyn_cast<MetadataAsValue>(this)) {
3498  V->getMetadata()->print(ROS, MST, getModuleFromVal(V));
3499  } else if (const Constant *C = dyn_cast<Constant>(this)) {
3500  TypePrinting TypePrinter;
3501  TypePrinter.print(C->getType(), OS);
3502  OS << ' ';
3503  WriteConstantInternal(OS, C, TypePrinter, MST.getMachine(), nullptr);
3504  } else if (isa<InlineAsm>(this) || isa<Argument>(this)) {
3505  this->printAsOperand(OS, /* PrintType */ true, MST);
3506  } else {
3507  llvm_unreachable("Unknown value to print out!");
3508  }
3509 }
3510 
3511 /// Print without a type, skipping the TypePrinting object.
3512 ///
3513 /// \return \c true iff printing was successful.
3514 static bool printWithoutType(const Value &V, raw_ostream &O,
3515  SlotTracker *Machine, const Module *M) {
3516  if (V.hasName() || isa<GlobalValue>(V) ||
3517  (!isa<Constant>(V) && !isa<MetadataAsValue>(V))) {
3518  WriteAsOperandInternal(O, &V, nullptr, Machine, M);
3519  return true;
3520  }
3521  return false;
3522 }
3523 
3524 static void printAsOperandImpl(const Value &V, raw_ostream &O, bool PrintType,
3525  ModuleSlotTracker &MST) {
3526  TypePrinting TypePrinter;
3527  if (const Module *M = MST.getModule())
3528  TypePrinter.incorporateTypes(*M);
3529  if (PrintType) {
3530  TypePrinter.print(V.getType(), O);
3531  O << ' ';
3532  }
3533 
3534  WriteAsOperandInternal(O, &V, &TypePrinter, MST.getMachine(),
3535  MST.getModule());
3536 }
3537 
3538 void Value::printAsOperand(raw_ostream &O, bool PrintType,
3539  const Module *M) const {
3540  if (!M)
3541  M = getModuleFromVal(this);
3542 
3543  if (!PrintType)
3544  if (printWithoutType(*this, O, nullptr, M))
3545  return;
3546 
3548  M, /* ShouldInitializeAllMetadata */ isa<MetadataAsValue>(this));
3549  ModuleSlotTracker MST(Machine, M);
3550  printAsOperandImpl(*this, O, PrintType, MST);
3551 }
3552 
3553 void Value::printAsOperand(raw_ostream &O, bool PrintType,
3554  ModuleSlotTracker &MST) const {
3555  if (!PrintType)
3556  if (printWithoutType(*this, O, MST.getMachine(), MST.getModule()))
3557  return;
3558 
3559  printAsOperandImpl(*this, O, PrintType, MST);
3560 }
3561 
3562 static void printMetadataImpl(raw_ostream &ROS, const Metadata &MD,
3563  ModuleSlotTracker &MST, const Module *M,
3564  bool OnlyAsOperand) {
3565  formatted_raw_ostream OS(ROS);
3566 
3567  TypePrinting TypePrinter;
3568  if (M)
3569  TypePrinter.incorporateTypes(*M);
3570 
3571  WriteAsOperandInternal(OS, &MD, &TypePrinter, MST.getMachine(), M,
3572  /* FromValue */ true);
3573 
3574  auto *N = dyn_cast<MDNode>(&MD);
3575  if (OnlyAsOperand || !N)
3576  return;
3577 
3578  OS << " = ";
3579  WriteMDNodeBodyInternal(OS, N, &TypePrinter, MST.getMachine(), M);
3580 }
3581 
3582 void Metadata::printAsOperand(raw_ostream &OS, const Module *M) const {
3583  ModuleSlotTracker MST(M, isa<MDNode>(this));
3584  printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ true);
3585 }
3586 
3588  const Module *M) const {
3589  printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ true);
3590 }
3591 
3593  bool /*IsForDebug*/) const {
3594  ModuleSlotTracker MST(M, isa<MDNode>(this));
3595  printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
3596 }
3597 
3599  const Module *M, bool /*IsForDebug*/) const {
3600  printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
3601 }
3602 
3603 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
3604 // Value::dump - allow easy printing of Values from the debugger.
3606 void Value::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
3607 
3608 // Type::dump - allow easy printing of Types from the debugger.
3610 void Type::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
3611 
3612 // Module::dump() - Allow printing of Modules from the debugger.
3614 void Module::dump() const {
3615  print(dbgs(), nullptr,
3616  /*ShouldPreserveUseListOrder=*/false, /*IsForDebug=*/true);
3617 }
3618 
3619 // \brief Allow printing of Comdats from the debugger.
3621 void Comdat::dump() const { print(dbgs(), /*IsForDebug=*/true); }
3622 
3623 // NamedMDNode::dump() - Allow printing of NamedMDNodes from the debugger.
3625 void NamedMDNode::dump() const { print(dbgs(), /*IsForDebug=*/true); }
3626 
3628 void Metadata::dump() const { dump(nullptr); }
3629 
3631 void Metadata::dump(const Module *M) const {
3632  print(dbgs(), M, /*IsForDebug=*/true);
3633  dbgs() << '\n';
3634 }
3635 #endif
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type.
Type * getVectorElementType() const
Definition: Type.h:368
AttributeSet getAttributes() const
Return the attribute set for this global.
uint64_t CallInst * C
static const fltSemantics & IEEEquad() LLVM_READNONE
Definition: APFloat.cpp:125
StringRef getSection() const
Get the custom section of this global if it has one.
Definition: GlobalObject.h:90
bool isIntrinsic() const
isIntrinsic - Returns true if the function&#39;s name starts with "llvm.".
Definition: Function.h:172
static SlotTracker * createSlotTracker(const Value *V)
Definition: AsmWriter.cpp:788
unsigned getAlignment() const
Definition: GlobalObject.h:59
use_iterator use_end()
Definition: Value.h:342
7: Labels
Definition: Type.h:64
const std::string & getTargetTriple() const
Get the target triple which is a string describing the target host.
Definition: Module.h:233
ThreadLocalMode getThreadLocalMode() const
Definition: GlobalValue.h:241
static void WriteOptimizationInfo(raw_ostream &Out, const User *U)
Definition: AsmWriter.cpp:1103
This class is the base class for the comparison instructions.
Definition: InstrTypes.h:850
iterator_range< use_iterator > uses()
Definition: Value.h:350
This instruction extracts a struct member or array element value from an aggregate value...
Special purpose, only applies to global arrays.
Definition: GlobalValue.h:55
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1542
*p = old <signed v ? old : v
Definition: Instructions.h:707
iterator_range< CaseIt > cases()
Iteration adapter for range-for loops.
Calling convention used for Mesa hull shaders.
Definition: CallingConv.h:206
This class represents an incoming formal argument to a Function.
Definition: Argument.h:30
void purgeFunction()
After calling incorporateFunction, use this method to remove the most recently incorporated function ...
Definition: AsmWriter.cpp:967
LLVMContext & Context
Synchronized with respect to all concurrently executing threads.
Definition: LLVMContext.h:58
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:3514
Atomic ordering constants.
MDNode * getOperand(unsigned i) const
Definition: Metadata.cpp:1073
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds...
Definition: Compiler.h:449
Type * getParamType(unsigned i) const
Parameter type accessors.
Definition: DerivedTypes.h:135
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:136
void PrintEscapedString(StringRef Name, raw_ostream &Out)
PrintEscapedString - Print each character of the specified string, escaping it if it is not printable...
Definition: AsmWriter.cpp:384
2: 32-bit floating point type
Definition: Type.h:59
An instruction for ordering other memory operations.
Definition: Instructions.h:440
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:54
static StringRef getUnnamedAddrEncoding(GlobalVariable::UnnamedAddr UA)
Definition: AsmWriter.cpp:2502
an instruction that atomically checks whether a specified value is in a memory location, and, if it is, stores a new value there.
Definition: Instructions.h:514
FormattedNumber format_hex(uint64_t N, unsigned Width, bool Upper=false)
format_hex - Output N as a fixed width hexadecimal.
Definition: Format.h:186
The C convention as specified in the x86-64 supplement to the System V ABI, used on most non-Windows ...
Definition: CallingConv.h:144
formatted_raw_ostream - A raw_ostream that wraps another one and keeps track of line and column posit...
bool isMaterializable() const
If this function&#39;s Module is being lazily streamed in functions from disk or some other source...
Definition: Globals.cpp:45
Calling convention for AMDGPU code object kernels.
Definition: CallingConv.h:199
Available for inspection, not emission.
Definition: GlobalValue.h:50
static void writeAtomicRMWOperation(raw_ostream &Out, AtomicRMWInst::BinOp Op)
Definition: AsmWriter.cpp:1085
PrefixType
Definition: AsmWriter.cpp:394
This provides a very simple, boring adaptor for a begin and end iterator into a range type...
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
MSVC calling convention that passes vectors and vector aggregates in SSE registers.
Definition: CallingConv.h:158
This class represents a function call, abstracting a target machine&#39;s calling convention.
This file contains the declarations for metadata subclasses.
Value * getCondition() const
*p = old <unsigned v ? old : v
Definition: Instructions.h:711
float convertToFloat() const
Definition: APFloat.h:1098
Like Internal, but omit from symbol table.
Definition: GlobalValue.h:57
static void PrintDLLStorageClass(GlobalValue::DLLStorageClassTypes SCT, formatted_raw_ostream &Out)
Definition: AsmWriter.cpp:2473
bool global_empty() const
Definition: Module.h:559
*p = old >unsigned v ? old : v
Definition: Instructions.h:709
Externally visible function.
Definition: GlobalValue.h:49
bool hasPrologueData() const
Check whether this function has prologue data.
Definition: Function.h:644
The data referenced by the COMDAT must be the same size.
Definition: Comdat.h:36
const std::string & getDataLayoutStr() const
Get the data layout string for the module&#39;s target platform.
Definition: Module.h:224
unsigned second
BasicBlock * getSuccessor(unsigned i) const
13: Structures
Definition: Type.h:73
Metadata node.
Definition: Metadata.h:862
int getGlobalSlot(const GlobalValue *V)
getGlobalSlot - Get the slot number of a global value.
Definition: AsmWriter.cpp:976
4: 80-bit floating point type (X87)
Definition: Type.h:61
const fltSemantics & getSemantics() const
Definition: APFloat.h:1140
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1067
param_iterator param_end() const
Definition: DerivedTypes.h:129
An instruction for reading from memory.
Definition: Instructions.h:164
Manage lifetime of a slot tracker for printing IR.
1: 16-bit floating point type
Definition: Type.h:58
an instruction that atomically reads a memory location, combines it with another value, and then stores the result back.
Definition: Instructions.h:677
Hexagon Common GEP
Value * getCondition() const
#define op(i)
15: Pointers
Definition: Type.h:75
This defines the Use class.
void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode *>> &MDs) const
Appends all attachments for the global to MDs, sorting by attachment ID.
Definition: Metadata.cpp:1404
SPIR_FUNC - Calling convention for SPIR non-kernel device functions.
Definition: CallingConv.h:129
12: Functions
Definition: Type.h:72
*p = old >signed v ? old : v
Definition: Instructions.h:705
int getMetadataSlot(const MDNode *N)
getMetadataSlot - Get the slot number of a MDNode.
Definition: AsmWriter.cpp:986
static void PrintCallingConv(unsigned cc, raw_ostream &Out)
Definition: AsmWriter.cpp:342
MSP430_INTR - Calling convention used for MSP430 interrupt routines.
Definition: CallingConv.h:106
Tentative definitions.
Definition: GlobalValue.h:59
HHVM calling convention for invoking C/C++ helpers.
Definition: CallingConv.h:167
Constant * getPrologueData() const
Get the prologue data associated with this function.
Definition: Function.cpp:1275
SlotTracker * getMachine()
Lazily creates a slot tracker.
Definition: AsmWriter.cpp:758
static void predictValueUseListOrder(const Value *V, const Function *F, OrderMap &OM, UseListOrderStack &Stack)
Definition: AsmWriter.cpp:242
static const char * getLinkagePrintName(GlobalValue::LinkageTypes LT)
Definition: AsmWriter.cpp:2436
void dump() const
Support for debugging, callable in GDB: V->dump()
Definition: AsmWriter.cpp:3606
The address of a basic block.
Definition: Constants.h:813
A tuple of MDNodes.
Definition: Metadata.h:1316
bool hasPrefixData() const
Check whether this function has prefix data.
Definition: Function.h:635
Calling convention used for Mesa pixel shaders.
Definition: CallingConv.h:193
APInt getLoBits(unsigned numBits) const
Compute an APInt containing numBits lowbits from this APInt.
Definition: APInt.cpp:515
std::vector< unsigned > Shuffle
Definition: UseListOrder.h:30
static OrderMap orderModule(const Module *M)
Definition: AsmWriter.cpp:132
static void printMetadataImpl(raw_ostream &ROS, const Metadata &MD, ModuleSlotTracker &MST, const Module *M, bool OnlyAsOperand)
Definition: AsmWriter.cpp:3562
const Value * V
Definition: UseListOrder.h:28
TypeID getTypeID() const
Return the type id for the type.
Definition: Type.h:138
static F t[256]
Class to represent struct types.
Definition: DerivedTypes.h:201
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
Value * getDerivedPtr() const
Definition: Statepoint.h:402
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:42
const Module * getModule() const
UnnamedAddr getUnnamedAddr() const
Definition: GlobalValue.h:200
ARM_APCS - ARM Procedure Calling Standard calling convention (obsolete, but still used on some target...
Definition: CallingConv.h:96
static StringRef getName(Value *V)
This file contains the simple types necessary to represent the attributes associated with functions a...
The linker may choose any COMDAT.
Definition: Comdat.h:32
unsigned getNumOperands() const
Definition: Metadata.cpp:1069
bool hasAttributes(unsigned Index) const
Return true if attribute exists at the given index.
APInt getHiBits(unsigned numBits) const
Compute an APInt containing numBits highbits from this APInt.
Definition: APInt.cpp:510
uint64_t getNumElements() const
Definition: DerivedTypes.h:359
static void printMetadataIdentifier(StringRef Name, formatted_raw_ostream &Out)
Definition: AsmWriter.cpp:2399
static const uint16_t * lookup(unsigned opcode, unsigned domain, ArrayRef< uint16_t[3]> Table)
This file implements a class to represent arbitrary precision integral constant values and operations...
Constant * getPrefixData() const
Get the prefix data associated with this function.
Definition: Function.cpp:1265
AtomicOrdering
Atomic ordering for LLVM&#39;s memory model.
void dump() const
Definition: AsmWriter.cpp:3621
bool hasExternalLinkage() const
Definition: GlobalValue.h:402
Class to represent function types.
Definition: DerivedTypes.h:103
bool isInfinity() const
Definition: APFloat.h:1129
#define F(x, y, z)
Definition: MD5.cpp:55
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
reverse_iterator rend()
Definition: Module.h:578
SPIR_KERNEL - Calling convention for SPIR kernel functions.
Definition: CallingConv.h:137
opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
Definition: APFloat.cpp:4441
void toString(SmallVectorImpl< char > &Str, unsigned FormatPrecision=0, unsigned FormatMaxPadding=3, bool TruncateZero=true) const
Definition: APFloat.h:1152
BinOp
This enumeration lists the possible modifications atomicrmw can make.
Definition: Instructions.h:689
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:3365
Class to represent array types.
Definition: DerivedTypes.h:369
AttributeSet getParamAttributes(unsigned ArgNo) const
The attributes for the argument or parameter at the given index are returned.
VisibilityTypes
An enumeration for the kinds of visibility of global values.
Definition: GlobalValue.h:63
bool isVarArg() const
Definition: DerivedTypes.h:123
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
const std::string & getGC() const
Definition: Function.cpp:444
AttributeList getAttributes() const
Return the attribute list for this Function.
Definition: Function.h:197
An instruction for storing to memory.
Definition: Instructions.h:306
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:626
COFF::MachineTypes Machine
Definition: COFFYAML.cpp:323
LinkageTypes getLinkage() const
Definition: GlobalValue.h:430
static const fltSemantics & IEEEdouble() LLVM_READNONE
Definition: APFloat.cpp:122
static void PrintVisibility(GlobalValue::VisibilityTypes Vis, formatted_raw_ostream &Out)
Definition: AsmWriter.cpp:2464
This file contains the declaration of the Comdat class, which represents a single COMDAT in LLVM...
Structure to hold a use-list order.
Definition: UseListOrder.h:27
C - The default llvm calling convention, compatible with C.
Definition: CallingConv.h:35
const char * Name
Value * getOperand(unsigned i) const
Definition: User.h:154
int getLocalSlot(const Value *V)
Return the slot number of the specified value in it&#39;s type plane.
Definition: AsmWriter.cpp:996
Class to represent pointers.
Definition: DerivedTypes.h:467
const std::string & getSourceFileName() const
Get the module&#39;s original source file name.
Definition: Module.h:214
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
Definition: Constants.cpp:277
AttributeSet getAttributes(unsigned Index) const
The attributes for the specified index are returned.
11: Arbitrary bit width integers
Definition: Type.h:71
bool alias_empty() const
Definition: Module.h:599
Calling convention used for Mesa vertex shaders.
Definition: CallingConv.h:187
bool isVoidTy() const
Return true if this is &#39;void&#39;.
Definition: Type.h:141
ExternalWeak linkage description.
Definition: GlobalValue.h:58
const BasicBlock & getEntryBlock() const
Definition: Function.h:564
constexpr char Attrs[]
Key for Kernel::Metadata::mAttrs.
This class provides computation of slot numbers for LLVM Assembly writing.
Definition: AsmWriter.cpp:624
0: type with no size
Definition: Type.h:57
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:52
Type * getReturnType() const
Returns the type of the ret val.
Definition: Function.h:142
No other Module may specify this COMDAT.
Definition: Comdat.h:35
StringRef getName() const
Definition: Comdat.cpp:24
The landingpad instruction holds all of the information necessary to generate correct exception handl...
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
void print(raw_ostream &OS, bool IsForDebug=false) const
Definition: AsmWriter.cpp:3408
DLLStorageClassTypes getDLLStorageClass() const
Definition: GlobalValue.h:245
VisibilityTypes getVisibility() const
Definition: GlobalValue.h:220
An array constant whose element type is a simple 1/2/4/8-byte integer or float/double, and whose elements are just simple data values (i.e.
Definition: Constants.h:681
static void predictValueUseListOrderImpl(const Value *V, const Function *F, unsigned ID, const OrderMap &OM, UseListOrderStack &Stack)
Definition: AsmWriter.cpp:179
bool hasName() const
Definition: Value.h:251
LLVM Basic Block Representation.
Definition: BasicBlock.h:59
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
Calling convention used by HipHop Virtual Machine (HHVM) to perform calls to and from translation cac...
Definition: CallingConv.h:164
Conditional or Unconditional Branch instruction.
const char * getOpcodeName() const
Definition: Instruction.h:123
bool isNaN() const
Definition: APFloat.h:1130
This is an important base class in LLVM.
Definition: Constant.h:42
ArrayRef< Use > Inputs
Definition: InstrTypes.h:1170
void dump() const
Dump the module to stderr (for debugging).
Definition: AsmWriter.cpp:3614
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:116
X86_INTR - x86 hardware interrupt context.
Definition: CallingConv.h:174
static StringRef getPredicateName(Predicate P)
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Register calling convention used for parameters transfer optimization.
Definition: CallingConv.h:202
ARM_AAPCS - ARM Architecture Procedure Calling Standard calling convention (aka EABI).
Definition: CallingConv.h:100
10: Tokens
Definition: Type.h:67
void getSyncScopeNames(SmallVectorImpl< StringRef > &SSNs) const
getSyncScopeNames - Populates client supplied SmallVector with synchronization scope names registered...
void print(raw_ostream &ROS, bool IsForDebug=false) const
Definition: AsmWriter.cpp:3385
std::vector< UseListOrder > UseListOrderStack
Definition: UseListOrder.h:40
unsigned getNumParams() const
Return the number of fixed parameters this function type requires.
Definition: DerivedTypes.h:139
#define A
Definition: LargeTest.cpp:12
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:264
double convertToDouble() const
Definition: APFloat.h:1097
Interval::pred_iterator pred_begin(Interval *I)
pred_begin/pred_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:113
BasicBlock * getDefaultDest() const
A udiv or sdiv instruction, which can be marked as "exact", indicating that no bits are destroyed...
Definition: Operator.h:120
The C convention as implemented on Windows/x86-64 and AArch64.
Definition: CallingConv.h:154
static void WriteAsOperandInternal(raw_ostream &Out, const Value *V, TypePrinting *TypePrinter, SlotTracker *Machine, const Module *Context)
Definition: AsmWriter.cpp:1994
param_iterator param_begin() const
Definition: DerivedTypes.h:128
This file declares a class to represent arbitrary precision floating point values and provide a varie...
bool hasOperandBundles() const
Definition: CallSite.h:509
Utility class for integer arithmetic operators which may exhibit overflow - Add, Sub, and Mul.
Definition: Operator.h:67
void print(raw_ostream &O, bool IsForDebug=false) const
Implement operator<< on Value.
Definition: AsmWriter.cpp:3459
StringRef getName() const
Return the name for this struct type if it has an identity.
Definition: Type.cpp:487
DLLStorageClassTypes
Storage classes of global values for PE targets.
Definition: GlobalValue.h:70
6: 128-bit floating point type (two 64-bits, PowerPC)
Definition: Type.h:63
ARM_AAPCS_VFP - Same as ARM_AAPCS, but uses hard floating point ABI.
Definition: CallingConv.h:103
static void printAsOperandImpl(const Value &V, raw_ostream &O, bool PrintType, ModuleSlotTracker &MST)
Definition: AsmWriter.cpp:3524
Interval::pred_iterator pred_end(Interval *I)
Definition: Interval.h:116
op_range operands()
Definition: User.h:222
unsigned getAddressSpace() const
Return the address space of the Pointer type.
Definition: DerivedTypes.h:495
static const fltSemantics & x87DoubleExtended() LLVM_READNONE
Definition: APFloat.cpp:128
X86_FastCall - &#39;fast&#39; analog of X86_StdCall.
Definition: CallingConv.h:92
bool isMaterializable() const
Definition: Function.h:152
static const Module * getModuleFromVal(const Value *V)
Definition: AsmWriter.cpp:316
The data referenced by the COMDAT must be the same.
Definition: Comdat.h:33
Calling convention used for Mesa geometry shaders.
Definition: CallingConv.h:190
Metadata wrapper in the Value hierarchy.
Definition: Metadata.h:172
const Function * getFunction() const
Return the function this instruction belongs to.
Definition: Instruction.cpp:61
std::string getAsString(unsigned Index, bool InAttrGrp=false) const
Return the attributes at the index as a string.
void incorporateFunction(const Function &F)
Incorporate the given function.
Definition: AsmWriter.cpp:769
const AMDGPUAS & AS
static bool isAtomic(Instruction *I)
static void PrintThreadLocalModel(GlobalVariable::ThreadLocalMode TLM, formatted_raw_ostream &Out)
Definition: AsmWriter.cpp:2482
const std::string & getModuleIdentifier() const
Get the module identifier which is, essentially, the name of the module.
Definition: Module.h:208
void printAsOperand(raw_ostream &O, bool PrintType=true, const Module *M=nullptr) const
Print the name of this Value out to the specified raw_ostream.
Definition: AsmWriter.cpp:3538
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
unsigned first
void dump() const
Definition: AsmWriter.cpp:3610
Used for AVR interrupt routines.
Definition: CallingConv.h:177
static void PrintLLVMName(raw_ostream &OS, StringRef Name, PrefixType Prefix)
Turn the specified name into an &#39;LLVM name&#39;, which is either prefixed with % (if the string only cont...
Definition: AsmWriter.cpp:438
reverse_iterator rbegin()
Definition: Module.h:576
void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW, bool ShouldPreserveUseListOrder=false, bool IsForDebug=false) const
Print the module to an output stream with an optional AssemblyAnnotationWriter.
Definition: AsmWriter.cpp:3376
14: Arrays
Definition: Type.h:74
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
void print(raw_ostream &OS, const Module *M=nullptr, bool IsForDebug=false) const
Print.
Definition: AsmWriter.cpp:3592
static const fltSemantics & IEEEsingle() LLVM_READNONE
Definition: APFloat.cpp:119
Intel_OCL_BI - Calling conventions for Intel OpenCL built-ins.
Definition: CallingConv.h:140
unsigned getNumOperands() const
Definition: User.h:176
std::string getAsString(bool InAttrGrp=false) const
Definition: Attributes.cpp:608
#define E
Definition: LargeTest.cpp:27
This is the shared class of boolean and integer constants.
Definition: Constants.h:84
static const fltSemantics & IEEEhalf() LLVM_READNONE
Definition: APFloat.cpp:116
OperandBundleUse getOperandBundleAt(unsigned Index) const
Definition: CallSite.h:525
16: SIMD &#39;packed&#39; format, or other vector type
Definition: Type.h:76
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:186
static const char * Separator
bool hasSection() const
Check if this global has a custom object file section.
Definition: GlobalObject.h:82
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:864
Keep one copy of function when linking (inline)
Definition: GlobalValue.h:51
Utility class for floating point operations which can have information about relaxed accuracy require...
Definition: Operator.h:220
Module.h This file contains the declarations for the Module class.
static void WriteConstantInternal(raw_ostream &Out, const Constant *CV, TypePrinting &TypePrinter, SlotTracker *Machine, const Module *Context)
Definition: AsmWriter.cpp:1138
LLVM_NODISCARD std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
Definition: StringRef.h:727
Type::subtype_iterator param_iterator
Definition: DerivedTypes.h:126
AddressSpace
Definition: NVPTXBaseInfo.h:22
const DataFlowGraph & G
Definition: RDFGraph.cpp:206
Type * getReturnType() const
Definition: DerivedTypes.h:124
const size_t N
void printLLVMNameWithoutPrefix(raw_ostream &OS, StringRef Name)
Print out a name of an LLVM value without any prefixes.
Definition: AsmWriter.cpp:402
The linker will choose the largest COMDAT.
Definition: Comdat.h:34
static bool isReferencingMDNode(const Instruction &I)
Definition: AsmWriter.cpp:3448
void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode *>> &MDs) const
Get all metadata attached to this Instruction.
Definition: Instruction.h:206
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
8: Metadata
Definition: Type.h:65
unsigned getVectorNumElements() const
Definition: DerivedTypes.h:462
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:137
bool isLiteral() const
Return true if this type is uniqued by structural equivalence, false if it is a struct definition...
Definition: DerivedTypes.h:265
Class to represent vector types.
Definition: DerivedTypes.h:393
ConstantArray - Constant Array Declarations.
Definition: Constants.h:405
Class for arbitrary precision integers.
Definition: APInt.h:69
static const char * toIRString(AtomicOrdering ao)
String used by LLVM IR to represent atomic ordering.
static bool isWeak(const MCSymbolELF &Sym)
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:48
StringRef getName() const
Definition: Metadata.cpp:1090
static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T, ArrayRef< StringRef > StandardNames)
initialize - Initialize the set of available library functions based on the specified target triple...
A lightweight accessor for an operand bundle meant to be passed around by value.
Definition: InstrTypes.h:1169
iterator_range< user_iterator > users()
Definition: Value.h:395
static char hexdigit(unsigned X, bool LowerCase=false)
hexdigit - Return the hexadecimal character for the given number X (which should be less than 16)...
Definition: StringExtras.h:36
const Comdat * getComdat() const
Definition: GlobalObject.h:101
Fast - This calling convention attempts to make calls as fast as possible (e.g.
Definition: CallingConv.h:43
static const fltSemantics & PPCDoubleDouble() LLVM_READNONE
Definition: APFloat.cpp:134
use_iterator use_begin()
Definition: Value.h:334
#define ST_DEBUG(X)
Definition: AsmWriter.cpp:817
Function to be accessible from DLL.
Definition: GlobalValue.h:73
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:120
bool hasGC() const
hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm to use during code generatio...
Definition: Function.h:278
unsigned getNumOperandBundles() const
Definition: CallSite.h:505
bool ifunc_empty() const
Definition: Module.h:617
void print(raw_ostream &O, bool IsForDebug=false, bool NoDetails=false) const
Print the current type.
Definition: AsmWriter.cpp:3433
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:61
static void orderValue(const Value *V, OrderMap &OM)
Definition: AsmWriter.cpp:117
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:218
Establish a view to a call site for examination.
Definition: CallSite.h:687
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:108
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
const NodeList & List
Definition: RDFGraph.cpp:205
#define I(x, y, z)
Definition: MD5.cpp:58
PTX_Kernel - Call to a PTX kernel.
Definition: CallingConv.h:115
void dump() const
User-friendly dump.
Definition: AsmWriter.cpp:3628
StringRef getTagName() const
Return the tag of this operand bundle as a string.
Definition: InstrTypes.h:1188
static void maybePrintComdat(formatted_raw_ostream &Out, const GlobalObject &GO)
Definition: AsmWriter.cpp:2514
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:323
Calling convention used for Mesa compute shaders.
Definition: CallingConv.h:196
Type * getValueType() const
Definition: GlobalValue.h:262
Keep one copy of named function when linking (weak)
Definition: GlobalValue.h:53
static void WriteMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node, TypePrinting *TypePrinter, SlotTracker *Machine, const Module *Context)
Definition: AsmWriter.cpp:1972
Rename collisions when linking (static functions).
Definition: GlobalValue.h:56
const Constant * getIndirectSymbol() const
iterator_range< ifunc_iterator > ifuncs()
Definition: Module.h:619
Function to be imported from DLL.
Definition: GlobalValue.h:72
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:166
const std::string & getModuleInlineAsm() const
Get any module-scope inline assembly blocks.
Definition: Module.h:241
This file defines passes to print out IR in various granularities.
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:200
const unsigned Kind
3: 64-bit floating point type
Definition: Type.h:60
Multiway switch.
void printAsOperand(raw_ostream &OS, const Module *M=nullptr) const
Print as operand.
Definition: AsmWriter.cpp:3582
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
bool hasAttributes() const
Return true if attributes exists in this set.
Definition: Attributes.h:261
Represents calls to the gc.relocate intrinsic.
Definition: Statepoint.h:374
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:545
LLVM Value Representation.
Definition: Value.h:73
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1255
X86_StdCall - stdcall is the calling conventions mostly used by the Win32 API.
Definition: CallingConv.h:87
A vector that has set insertion semantics.
Definition: SetVector.h:41
bool hasInitializer() const
Definitions have initializers, declarations don&#39;t.
static const Function * getParent(const Value *V)
AttributeSet getFnAttributes() const
The function attributes are returned.
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
Invoke instruction.
X86_ThisCall - Similar to X86_StdCall.
Definition: CallingConv.h:111
Type * getElementType() const
Definition: DerivedTypes.h:360
iterator_range< global_iterator > globals()
Definition: Module.h:561
IRTranslator LLVM IR MI
PTX_Device - Call to a PTX device function.
Definition: CallingConv.h:119
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
A single uniqued string.
Definition: Metadata.h:602
void dump() const
Definition: AsmWriter.cpp:3625
APInt bitcastToAPInt() const
Definition: APFloat.h:1094
void sort(Policy policy, RandomAccessIterator Start, RandomAccessIterator End, const Comparator &Comp=Comparator())
Definition: Parallel.h:201
Value * getBasePtr() const
Definition: Statepoint.h:397
static bool isVolatile(Instruction *Inst)
9: MMX vectors (64 bits, X86 specific)
Definition: Type.h:66
Calling convention used for AVR signal routines.
Definition: CallingConv.h:180
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1073
void emplace(ArgTypes &&...Args)
Create a new object by constructing it in place with the given arguments.
Definition: Optional.h:87
for(unsigned i=Desc.getNumOperands(), e=OldMI.getNumOperands();i !=e;++i)
TypeFinder - Walk over a module, identifying all of the types that are used by the module...
Definition: TypeFinder.h:31
Root of the metadata hierarchy.
Definition: Metadata.h:58
bool isExternallyInitialized() const
static UseListOrderStack predictUseListOrder(const Module *M)
Definition: AsmWriter.cpp:263
bool use_empty() const
Definition: Value.h:322
Type * getElementType() const
Definition: DerivedTypes.h:486
TLM
Definition: LLParser.cpp:1335
int getAttributeGroupSlot(AttributeSet AS)
Definition: AsmWriter.cpp:1006
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:260
iterator_range< arg_iterator > args()
Definition: Function.h:613
const BasicBlock * getParent() const
Definition: Instruction.h:66
an instruction to allocate memory on the stack
Definition: Instructions.h:60
This instruction inserts a struct field of array element value into an aggregate value.
5: 128-bit floating point type (112-bit mantissa)
Definition: Type.h:62
iterator_range< alias_iterator > aliases()
Definition: Module.h:601
void resize(size_type N)
Definition: SmallVector.h:355