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  // Don't make slots for DIExpressions. We just print them inline everywhere.
1050  if (isa<DIExpression>(N))
1051  return;
1052 
1053  unsigned DestSlot = mdnNext;
1054  if (!mdnMap.insert(std::make_pair(N, DestSlot)).second)
1055  return;
1056  ++mdnNext;
1057 
1058  // Recursively add any MDNodes referenced by operands.
1059  for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
1060  if (const MDNode *Op = dyn_cast_or_null<MDNode>(N->getOperand(i)))
1061  CreateMetadataSlot(Op);
1062 }
1063 
1064 void SlotTracker::CreateAttributeSetSlot(AttributeSet AS) {
1065  assert(AS.hasAttributes() && "Doesn't need a slot!");
1066 
1067  as_iterator I = asMap.find(AS);
1068  if (I != asMap.end())
1069  return;
1070 
1071  unsigned DestSlot = asNext++;
1072  asMap[AS] = DestSlot;
1073 }
1074 
1075 //===----------------------------------------------------------------------===//
1076 // AsmWriter Implementation
1077 //===----------------------------------------------------------------------===//
1078 
1079 static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
1080  TypePrinting *TypePrinter,
1082  const Module *Context);
1083 
1084 static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
1085  TypePrinting *TypePrinter,
1086  SlotTracker *Machine, const Module *Context,
1087  bool FromValue = false);
1088 
1091  switch (Op) {
1092  default: Out << " <unknown operation " << Op << ">"; break;
1093  case AtomicRMWInst::Xchg: Out << " xchg"; break;
1094  case AtomicRMWInst::Add: Out << " add"; break;
1095  case AtomicRMWInst::Sub: Out << " sub"; break;
1096  case AtomicRMWInst::And: Out << " and"; break;
1097  case AtomicRMWInst::Nand: Out << " nand"; break;
1098  case AtomicRMWInst::Or: Out << " or"; break;
1099  case AtomicRMWInst::Xor: Out << " xor"; break;
1100  case AtomicRMWInst::Max: Out << " max"; break;
1101  case AtomicRMWInst::Min: Out << " min"; break;
1102  case AtomicRMWInst::UMax: Out << " umax"; break;
1103  case AtomicRMWInst::UMin: Out << " umin"; break;
1104  }
1105 }
1106 
1107 static void WriteOptimizationInfo(raw_ostream &Out, const User *U) {
1108  if (const FPMathOperator *FPO = dyn_cast<const FPMathOperator>(U)) {
1109  // Unsafe algebra implies all the others, no need to write them all out
1110  if (FPO->hasUnsafeAlgebra())
1111  Out << " fast";
1112  else {
1113  if (FPO->hasNoNaNs())
1114  Out << " nnan";
1115  if (FPO->hasNoInfs())
1116  Out << " ninf";
1117  if (FPO->hasNoSignedZeros())
1118  Out << " nsz";
1119  if (FPO->hasAllowReciprocal())
1120  Out << " arcp";
1121  if (FPO->hasAllowContract())
1122  Out << " contract";
1123  }
1124  }
1125 
1126  if (const OverflowingBinaryOperator *OBO =
1127  dyn_cast<OverflowingBinaryOperator>(U)) {
1128  if (OBO->hasNoUnsignedWrap())
1129  Out << " nuw";
1130  if (OBO->hasNoSignedWrap())
1131  Out << " nsw";
1132  } else if (const PossiblyExactOperator *Div =
1133  dyn_cast<PossiblyExactOperator>(U)) {
1134  if (Div->isExact())
1135  Out << " exact";
1136  } else if (const GEPOperator *GEP = dyn_cast<GEPOperator>(U)) {
1137  if (GEP->isInBounds())
1138  Out << " inbounds";
1139  }
1140 }
1141 
1142 static void WriteConstantInternal(raw_ostream &Out, const Constant *CV,
1143  TypePrinting &TypePrinter,
1145  const Module *Context) {
1146  if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
1147  if (CI->getType()->isIntegerTy(1)) {
1148  Out << (CI->getZExtValue() ? "true" : "false");
1149  return;
1150  }
1151  Out << CI->getValue();
1152  return;
1153  }
1154 
1155  if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) {
1156  const APFloat &APF = CFP->getValueAPF();
1157  if (&APF.getSemantics() == &APFloat::IEEEsingle() ||
1158  &APF.getSemantics() == &APFloat::IEEEdouble()) {
1159  // We would like to output the FP constant value in exponential notation,
1160  // but we cannot do this if doing so will lose precision. Check here to
1161  // make sure that we only output it in exponential format if we can parse
1162  // the value back and get the same value.
1163  //
1164  bool ignored;
1165  bool isDouble = &APF.getSemantics() == &APFloat::IEEEdouble();
1166  bool isInf = APF.isInfinity();
1167  bool isNaN = APF.isNaN();
1168  if (!isInf && !isNaN) {
1169  double Val = isDouble ? APF.convertToDouble() : APF.convertToFloat();
1171  APF.toString(StrVal, 6, 0, false);
1172  // Check to make sure that the stringized number is not some string like
1173  // "Inf" or NaN, that atof will accept, but the lexer will not. Check
1174  // that the string matches the "[-+]?[0-9]" regex.
1175  //
1176  assert(((StrVal[0] >= '0' && StrVal[0] <= '9') ||
1177  ((StrVal[0] == '-' || StrVal[0] == '+') &&
1178  (StrVal[1] >= '0' && StrVal[1] <= '9'))) &&
1179  "[-+]?[0-9] regex does not match!");
1180  // Reparse stringized version!
1181  if (APFloat(APFloat::IEEEdouble(), StrVal).convertToDouble() == Val) {
1182  Out << StrVal;
1183  return;
1184  }
1185  }
1186  // Otherwise we could not reparse it to exactly the same value, so we must
1187  // output the string in hexadecimal format! Note that loading and storing
1188  // floating point types changes the bits of NaNs on some hosts, notably
1189  // x86, so we must not use these types.
1190  static_assert(sizeof(double) == sizeof(uint64_t),
1191  "assuming that double is 64 bits!");
1192  APFloat apf = APF;
1193  // Floats are represented in ASCII IR as double, convert.
1194  if (!isDouble)
1196  &ignored);
1197  Out << format_hex(apf.bitcastToAPInt().getZExtValue(), 0, /*Upper=*/true);
1198  return;
1199  }
1200 
1201  // Either half, or some form of long double.
1202  // These appear as a magic letter identifying the type, then a
1203  // fixed number of hex digits.
1204  Out << "0x";
1205  APInt API = APF.bitcastToAPInt();
1206  if (&APF.getSemantics() == &APFloat::x87DoubleExtended()) {
1207  Out << 'K';
1208  Out << format_hex_no_prefix(API.getHiBits(16).getZExtValue(), 4,
1209  /*Upper=*/true);
1210  Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
1211  /*Upper=*/true);
1212  return;
1213  } else if (&APF.getSemantics() == &APFloat::IEEEquad()) {
1214  Out << 'L';
1215  Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
1216  /*Upper=*/true);
1217  Out << format_hex_no_prefix(API.getHiBits(64).getZExtValue(), 16,
1218  /*Upper=*/true);
1219  } else if (&APF.getSemantics() == &APFloat::PPCDoubleDouble()) {
1220  Out << 'M';
1221  Out << format_hex_no_prefix(API.getLoBits(64).getZExtValue(), 16,
1222  /*Upper=*/true);
1223  Out << format_hex_no_prefix(API.getHiBits(64).getZExtValue(), 16,
1224  /*Upper=*/true);
1225  } else if (&APF.getSemantics() == &APFloat::IEEEhalf()) {
1226  Out << 'H';
1227  Out << format_hex_no_prefix(API.getZExtValue(), 4,
1228  /*Upper=*/true);
1229  } else
1230  llvm_unreachable("Unsupported floating point type");
1231  return;
1232  }
1233 
1234  if (isa<ConstantAggregateZero>(CV)) {
1235  Out << "zeroinitializer";
1236  return;
1237  }
1238 
1239  if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV)) {
1240  Out << "blockaddress(";
1241  WriteAsOperandInternal(Out, BA->getFunction(), &TypePrinter, Machine,
1242  Context);
1243  Out << ", ";
1244  WriteAsOperandInternal(Out, BA->getBasicBlock(), &TypePrinter, Machine,
1245  Context);
1246  Out << ")";
1247  return;
1248  }
1249 
1250  if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) {
1251  Type *ETy = CA->getType()->getElementType();
1252  Out << '[';
1253  TypePrinter.print(ETy, Out);
1254  Out << ' ';
1255  WriteAsOperandInternal(Out, CA->getOperand(0),
1256  &TypePrinter, Machine,
1257  Context);
1258  for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) {
1259  Out << ", ";
1260  TypePrinter.print(ETy, Out);
1261  Out << ' ';
1262  WriteAsOperandInternal(Out, CA->getOperand(i), &TypePrinter, Machine,
1263  Context);
1264  }
1265  Out << ']';
1266  return;
1267  }
1268 
1269  if (const ConstantDataArray *CA = dyn_cast<ConstantDataArray>(CV)) {
1270  // As a special case, print the array as a string if it is an array of
1271  // i8 with ConstantInt values.
1272  if (CA->isString()) {
1273  Out << "c\"";
1274  PrintEscapedString(CA->getAsString(), Out);
1275  Out << '"';
1276  return;
1277  }
1278 
1279  Type *ETy = CA->getType()->getElementType();
1280  Out << '[';
1281  TypePrinter.print(ETy, Out);
1282  Out << ' ';
1283  WriteAsOperandInternal(Out, CA->getElementAsConstant(0),
1284  &TypePrinter, Machine,
1285  Context);
1286  for (unsigned i = 1, e = CA->getNumElements(); i != e; ++i) {
1287  Out << ", ";
1288  TypePrinter.print(ETy, Out);
1289  Out << ' ';
1290  WriteAsOperandInternal(Out, CA->getElementAsConstant(i), &TypePrinter,
1291  Machine, Context);
1292  }
1293  Out << ']';
1294  return;
1295  }
1296 
1297  if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) {
1298  if (CS->getType()->isPacked())
1299  Out << '<';
1300  Out << '{';
1301  unsigned N = CS->getNumOperands();
1302  if (N) {
1303  Out << ' ';
1304  TypePrinter.print(CS->getOperand(0)->getType(), Out);
1305  Out << ' ';
1306 
1307  WriteAsOperandInternal(Out, CS->getOperand(0), &TypePrinter, Machine,
1308  Context);
1309 
1310  for (unsigned i = 1; i < N; i++) {
1311  Out << ", ";
1312  TypePrinter.print(CS->getOperand(i)->getType(), Out);
1313  Out << ' ';
1314 
1315  WriteAsOperandInternal(Out, CS->getOperand(i), &TypePrinter, Machine,
1316  Context);
1317  }
1318  Out << ' ';
1319  }
1320 
1321  Out << '}';
1322  if (CS->getType()->isPacked())
1323  Out << '>';
1324  return;
1325  }
1326 
1327  if (isa<ConstantVector>(CV) || isa<ConstantDataVector>(CV)) {
1328  Type *ETy = CV->getType()->getVectorElementType();
1329  Out << '<';
1330  TypePrinter.print(ETy, Out);
1331  Out << ' ';
1332  WriteAsOperandInternal(Out, CV->getAggregateElement(0U), &TypePrinter,
1333  Machine, Context);
1334  for (unsigned i = 1, e = CV->getType()->getVectorNumElements(); i != e;++i){
1335  Out << ", ";
1336  TypePrinter.print(ETy, Out);
1337  Out << ' ';
1338  WriteAsOperandInternal(Out, CV->getAggregateElement(i), &TypePrinter,
1339  Machine, Context);
1340  }
1341  Out << '>';
1342  return;
1343  }
1344 
1345  if (isa<ConstantPointerNull>(CV)) {
1346  Out << "null";
1347  return;
1348  }
1349 
1350  if (isa<ConstantTokenNone>(CV)) {
1351  Out << "none";
1352  return;
1353  }
1354 
1355  if (isa<UndefValue>(CV)) {
1356  Out << "undef";
1357  return;
1358  }
1359 
1360  if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
1361  Out << CE->getOpcodeName();
1362  WriteOptimizationInfo(Out, CE);
1363  if (CE->isCompare())
1364  Out << ' ' << CmpInst::getPredicateName(
1365  static_cast<CmpInst::Predicate>(CE->getPredicate()));
1366  Out << " (";
1367 
1368  Optional<unsigned> InRangeOp;
1369  if (const GEPOperator *GEP = dyn_cast<GEPOperator>(CE)) {
1370  TypePrinter.print(GEP->getSourceElementType(), Out);
1371  Out << ", ";
1372  InRangeOp = GEP->getInRangeIndex();
1373  if (InRangeOp)
1374  ++*InRangeOp;
1375  }
1376 
1377  for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) {
1378  if (InRangeOp && unsigned(OI - CE->op_begin()) == *InRangeOp)
1379  Out << "inrange ";
1380  TypePrinter.print((*OI)->getType(), Out);
1381  Out << ' ';
1382  WriteAsOperandInternal(Out, *OI, &TypePrinter, Machine, Context);
1383  if (OI+1 != CE->op_end())
1384  Out << ", ";
1385  }
1386 
1387  if (CE->hasIndices()) {
1388  ArrayRef<unsigned> Indices = CE->getIndices();
1389  for (unsigned i = 0, e = Indices.size(); i != e; ++i)
1390  Out << ", " << Indices[i];
1391  }
1392 
1393  if (CE->isCast()) {
1394  Out << " to ";
1395  TypePrinter.print(CE->getType(), Out);
1396  }
1397 
1398  Out << ')';
1399  return;
1400  }
1401 
1402  Out << "<placeholder or erroneous Constant>";
1403 }
1404 
1405 static void writeMDTuple(raw_ostream &Out, const MDTuple *Node,
1406  TypePrinting *TypePrinter, SlotTracker *Machine,
1407  const Module *Context) {
1408  Out << "!{";
1409  for (unsigned mi = 0, me = Node->getNumOperands(); mi != me; ++mi) {
1410  const Metadata *MD = Node->getOperand(mi);
1411  if (!MD)
1412  Out << "null";
1413  else if (auto *MDV = dyn_cast<ValueAsMetadata>(MD)) {
1414  Value *V = MDV->getValue();
1415  TypePrinter->print(V->getType(), Out);
1416  Out << ' ';
1417  WriteAsOperandInternal(Out, V, TypePrinter, Machine, Context);
1418  } else {
1419  WriteAsOperandInternal(Out, MD, TypePrinter, Machine, Context);
1420  }
1421  if (mi + 1 != me)
1422  Out << ", ";
1423  }
1424 
1425  Out << "}";
1426 }
1427 
1428 namespace {
1429 
1430 struct FieldSeparator {
1431  bool Skip = true;
1432  const char *Sep;
1433 
1434  FieldSeparator(const char *Sep = ", ") : Sep(Sep) {}
1435 };
1436 
1437 raw_ostream &operator<<(raw_ostream &OS, FieldSeparator &FS) {
1438  if (FS.Skip) {
1439  FS.Skip = false;
1440  return OS;
1441  }
1442  return OS << FS.Sep;
1443 }
1444 
1445 struct MDFieldPrinter {
1446  raw_ostream &Out;
1447  FieldSeparator FS;
1448  TypePrinting *TypePrinter = nullptr;
1449  SlotTracker *Machine = nullptr;
1450  const Module *Context = nullptr;
1451 
1452  explicit MDFieldPrinter(raw_ostream &Out) : Out(Out) {}
1453  MDFieldPrinter(raw_ostream &Out, TypePrinting *TypePrinter,
1454  SlotTracker *Machine, const Module *Context)
1455  : Out(Out), TypePrinter(TypePrinter), Machine(Machine), Context(Context) {
1456  }
1457 
1458  void printTag(const DINode *N);
1459  void printMacinfoType(const DIMacroNode *N);
1460  void printChecksumKind(const DIFile *N);
1461  void printString(StringRef Name, StringRef Value,
1462  bool ShouldSkipEmpty = true);
1463  void printMetadata(StringRef Name, const Metadata *MD,
1464  bool ShouldSkipNull = true);
1465  template <class IntTy>
1466  void printInt(StringRef Name, IntTy Int, bool ShouldSkipZero = true);
1467  void printBool(StringRef Name, bool Value, Optional<bool> Default = None);
1468  void printDIFlags(StringRef Name, DINode::DIFlags Flags);
1469  template <class IntTy, class Stringifier>
1470  void printDwarfEnum(StringRef Name, IntTy Value, Stringifier toString,
1471  bool ShouldSkipZero = true);
1472  void printEmissionKind(StringRef Name, DICompileUnit::DebugEmissionKind EK);
1473 };
1474 
1475 } // end anonymous namespace
1476 
1477 void MDFieldPrinter::printTag(const DINode *N) {
1478  Out << FS << "tag: ";
1479  auto Tag = dwarf::TagString(N->getTag());
1480  if (!Tag.empty())
1481  Out << Tag;
1482  else
1483  Out << N->getTag();
1484 }
1485 
1486 void MDFieldPrinter::printMacinfoType(const DIMacroNode *N) {
1487  Out << FS << "type: ";
1488  auto Type = dwarf::MacinfoString(N->getMacinfoType());
1489  if (!Type.empty())
1490  Out << Type;
1491  else
1492  Out << N->getMacinfoType();
1493 }
1494 
1495 void MDFieldPrinter::printChecksumKind(const DIFile *N) {
1496  if (N->getChecksumKind() == DIFile::CSK_None)
1497  // Skip CSK_None checksum kind.
1498  return;
1499  Out << FS << "checksumkind: " << N->getChecksumKindAsString();
1500 }
1501 
1502 void MDFieldPrinter::printString(StringRef Name, StringRef Value,
1503  bool ShouldSkipEmpty) {
1504  if (ShouldSkipEmpty && Value.empty())
1505  return;
1506 
1507  Out << FS << Name << ": \"";
1508  PrintEscapedString(Value, Out);
1509  Out << "\"";
1510 }
1511 
1512 static void writeMetadataAsOperand(raw_ostream &Out, const Metadata *MD,
1513  TypePrinting *TypePrinter,
1514  SlotTracker *Machine,
1515  const Module *Context) {
1516  if (!MD) {
1517  Out << "null";
1518  return;
1519  }
1520  WriteAsOperandInternal(Out, MD, TypePrinter, Machine, Context);
1521 }
1522 
1523 void MDFieldPrinter::printMetadata(StringRef Name, const Metadata *MD,
1524  bool ShouldSkipNull) {
1525  if (ShouldSkipNull && !MD)
1526  return;
1527 
1528  Out << FS << Name << ": ";
1529  writeMetadataAsOperand(Out, MD, TypePrinter, Machine, Context);
1530 }
1531 
1532 template <class IntTy>
1533 void MDFieldPrinter::printInt(StringRef Name, IntTy Int, bool ShouldSkipZero) {
1534  if (ShouldSkipZero && !Int)
1535  return;
1536 
1537  Out << FS << Name << ": " << Int;
1538 }
1539 
1540 void MDFieldPrinter::printBool(StringRef Name, bool Value,
1541  Optional<bool> Default) {
1542  if (Default && Value == *Default)
1543  return;
1544  Out << FS << Name << ": " << (Value ? "true" : "false");
1545 }
1546 
1547 void MDFieldPrinter::printDIFlags(StringRef Name, DINode::DIFlags Flags) {
1548  if (!Flags)
1549  return;
1550 
1551  Out << FS << Name << ": ";
1552 
1553  SmallVector<DINode::DIFlags, 8> SplitFlags;
1554  auto Extra = DINode::splitFlags(Flags, SplitFlags);
1555 
1556  FieldSeparator FlagsFS(" | ");
1557  for (auto F : SplitFlags) {
1558  auto StringF = DINode::getFlagString(F);
1559  assert(!StringF.empty() && "Expected valid flag");
1560  Out << FlagsFS << StringF;
1561  }
1562  if (Extra || SplitFlags.empty())
1563  Out << FlagsFS << Extra;
1564 }
1565 
1566 void MDFieldPrinter::printEmissionKind(StringRef Name,
1567  DICompileUnit::DebugEmissionKind EK) {
1568  Out << FS << Name << ": " << DICompileUnit::EmissionKindString(EK);
1569 }
1570 
1571 template <class IntTy, class Stringifier>
1572 void MDFieldPrinter::printDwarfEnum(StringRef Name, IntTy Value,
1573  Stringifier toString, bool ShouldSkipZero) {
1574  if (!Value)
1575  return;
1576 
1577  Out << FS << Name << ": ";
1578  auto S = toString(Value);
1579  if (!S.empty())
1580  Out << S;
1581  else
1582  Out << Value;
1583 }
1584 
1585 static void writeGenericDINode(raw_ostream &Out, const GenericDINode *N,
1586  TypePrinting *TypePrinter, SlotTracker *Machine,
1587  const Module *Context) {
1588  Out << "!GenericDINode(";
1589  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1590  Printer.printTag(N);
1591  Printer.printString("header", N->getHeader());
1592  if (N->getNumDwarfOperands()) {
1593  Out << Printer.FS << "operands: {";
1594  FieldSeparator IFS;
1595  for (auto &I : N->dwarf_operands()) {
1596  Out << IFS;
1597  writeMetadataAsOperand(Out, I, TypePrinter, Machine, Context);
1598  }
1599  Out << "}";
1600  }
1601  Out << ")";
1602 }
1603 
1604 static void writeDILocation(raw_ostream &Out, const DILocation *DL,
1605  TypePrinting *TypePrinter, SlotTracker *Machine,
1606  const Module *Context) {
1607  Out << "!DILocation(";
1608  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1609  // Always output the line, since 0 is a relevant and important value for it.
1610  Printer.printInt("line", DL->getLine(), /* ShouldSkipZero */ false);
1611  Printer.printInt("column", DL->getColumn());
1612  Printer.printMetadata("scope", DL->getRawScope(), /* ShouldSkipNull */ false);
1613  Printer.printMetadata("inlinedAt", DL->getRawInlinedAt());
1614  Out << ")";
1615 }
1616 
1617 static void writeDISubrange(raw_ostream &Out, const DISubrange *N,
1618  TypePrinting *, SlotTracker *, const Module *) {
1619  Out << "!DISubrange(";
1620  MDFieldPrinter Printer(Out);
1621  Printer.printInt("count", N->getCount(), /* ShouldSkipZero */ false);
1622  Printer.printInt("lowerBound", N->getLowerBound());
1623  Out << ")";
1624 }
1625 
1626 static void writeDIEnumerator(raw_ostream &Out, const DIEnumerator *N,
1627  TypePrinting *, SlotTracker *, const Module *) {
1628  Out << "!DIEnumerator(";
1629  MDFieldPrinter Printer(Out);
1630  Printer.printString("name", N->getName(), /* ShouldSkipEmpty */ false);
1631  Printer.printInt("value", N->getValue(), /* ShouldSkipZero */ false);
1632  Out << ")";
1633 }
1634 
1635 static void writeDIBasicType(raw_ostream &Out, const DIBasicType *N,
1636  TypePrinting *, SlotTracker *, const Module *) {
1637  Out << "!DIBasicType(";
1638  MDFieldPrinter Printer(Out);
1639  if (N->getTag() != dwarf::DW_TAG_base_type)
1640  Printer.printTag(N);
1641  Printer.printString("name", N->getName());
1642  Printer.printInt("size", N->getSizeInBits());
1643  Printer.printInt("align", N->getAlignInBits());
1644  Printer.printDwarfEnum("encoding", N->getEncoding(),
1645  dwarf::AttributeEncodingString);
1646  Out << ")";
1647 }
1648 
1649 static void writeDIDerivedType(raw_ostream &Out, const DIDerivedType *N,
1650  TypePrinting *TypePrinter, SlotTracker *Machine,
1651  const Module *Context) {
1652  Out << "!DIDerivedType(";
1653  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1654  Printer.printTag(N);
1655  Printer.printString("name", N->getName());
1656  Printer.printMetadata("scope", N->getRawScope());
1657  Printer.printMetadata("file", N->getRawFile());
1658  Printer.printInt("line", N->getLine());
1659  Printer.printMetadata("baseType", N->getRawBaseType(),
1660  /* ShouldSkipNull */ false);
1661  Printer.printInt("size", N->getSizeInBits());
1662  Printer.printInt("align", N->getAlignInBits());
1663  Printer.printInt("offset", N->getOffsetInBits());
1664  Printer.printDIFlags("flags", N->getFlags());
1665  Printer.printMetadata("extraData", N->getRawExtraData());
1666  if (const auto &DWARFAddressSpace = N->getDWARFAddressSpace())
1667  Printer.printInt("dwarfAddressSpace", *DWARFAddressSpace,
1668  /* ShouldSkipZero */ false);
1669  Out << ")";
1670 }
1671 
1672 static void writeDICompositeType(raw_ostream &Out, const DICompositeType *N,
1673  TypePrinting *TypePrinter,
1674  SlotTracker *Machine, const Module *Context) {
1675  Out << "!DICompositeType(";
1676  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1677  Printer.printTag(N);
1678  Printer.printString("name", N->getName());
1679  Printer.printMetadata("scope", N->getRawScope());
1680  Printer.printMetadata("file", N->getRawFile());
1681  Printer.printInt("line", N->getLine());
1682  Printer.printMetadata("baseType", N->getRawBaseType());
1683  Printer.printInt("size", N->getSizeInBits());
1684  Printer.printInt("align", N->getAlignInBits());
1685  Printer.printInt("offset", N->getOffsetInBits());
1686  Printer.printDIFlags("flags", N->getFlags());
1687  Printer.printMetadata("elements", N->getRawElements());
1688  Printer.printDwarfEnum("runtimeLang", N->getRuntimeLang(),
1689  dwarf::LanguageString);
1690  Printer.printMetadata("vtableHolder", N->getRawVTableHolder());
1691  Printer.printMetadata("templateParams", N->getRawTemplateParams());
1692  Printer.printString("identifier", N->getIdentifier());
1693  Out << ")";
1694 }
1695 
1696 static void writeDISubroutineType(raw_ostream &Out, const DISubroutineType *N,
1697  TypePrinting *TypePrinter,
1698  SlotTracker *Machine, const Module *Context) {
1699  Out << "!DISubroutineType(";
1700  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1701  Printer.printDIFlags("flags", N->getFlags());
1702  Printer.printDwarfEnum("cc", N->getCC(), dwarf::ConventionString);
1703  Printer.printMetadata("types", N->getRawTypeArray(),
1704  /* ShouldSkipNull */ false);
1705  Out << ")";
1706 }
1707 
1708 static void writeDIFile(raw_ostream &Out, const DIFile *N, TypePrinting *,
1709  SlotTracker *, const Module *) {
1710  Out << "!DIFile(";
1711  MDFieldPrinter Printer(Out);
1712  Printer.printString("filename", N->getFilename(),
1713  /* ShouldSkipEmpty */ false);
1714  Printer.printString("directory", N->getDirectory(),
1715  /* ShouldSkipEmpty */ false);
1716  Printer.printChecksumKind(N);
1717  Printer.printString("checksum", N->getChecksum(), /* ShouldSkipEmpty */ true);
1718  Out << ")";
1719 }
1720 
1721 static void writeDICompileUnit(raw_ostream &Out, const DICompileUnit *N,
1722  TypePrinting *TypePrinter, SlotTracker *Machine,
1723  const Module *Context) {
1724  Out << "!DICompileUnit(";
1725  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1726  Printer.printDwarfEnum("language", N->getSourceLanguage(),
1727  dwarf::LanguageString, /* ShouldSkipZero */ false);
1728  Printer.printMetadata("file", N->getRawFile(), /* ShouldSkipNull */ false);
1729  Printer.printString("producer", N->getProducer());
1730  Printer.printBool("isOptimized", N->isOptimized());
1731  Printer.printString("flags", N->getFlags());
1732  Printer.printInt("runtimeVersion", N->getRuntimeVersion(),
1733  /* ShouldSkipZero */ false);
1734  Printer.printString("splitDebugFilename", N->getSplitDebugFilename());
1735  Printer.printEmissionKind("emissionKind", N->getEmissionKind());
1736  Printer.printMetadata("enums", N->getRawEnumTypes());
1737  Printer.printMetadata("retainedTypes", N->getRawRetainedTypes());
1738  Printer.printMetadata("globals", N->getRawGlobalVariables());
1739  Printer.printMetadata("imports", N->getRawImportedEntities());
1740  Printer.printMetadata("macros", N->getRawMacros());
1741  Printer.printInt("dwoId", N->getDWOId());
1742  Printer.printBool("splitDebugInlining", N->getSplitDebugInlining(), true);
1743  Printer.printBool("debugInfoForProfiling", N->getDebugInfoForProfiling(),
1744  false);
1745  Printer.printBool("gnuPubnames", N->getGnuPubnames(), false);
1746  Out << ")";
1747 }
1748 
1749 static void writeDISubprogram(raw_ostream &Out, const DISubprogram *N,
1750  TypePrinting *TypePrinter, SlotTracker *Machine,
1751  const Module *Context) {
1752  Out << "!DISubprogram(";
1753  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1754  Printer.printString("name", N->getName());
1755  Printer.printString("linkageName", N->getLinkageName());
1756  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1757  Printer.printMetadata("file", N->getRawFile());
1758  Printer.printInt("line", N->getLine());
1759  Printer.printMetadata("type", N->getRawType());
1760  Printer.printBool("isLocal", N->isLocalToUnit());
1761  Printer.printBool("isDefinition", N->isDefinition());
1762  Printer.printInt("scopeLine", N->getScopeLine());
1763  Printer.printMetadata("containingType", N->getRawContainingType());
1764  Printer.printDwarfEnum("virtuality", N->getVirtuality(),
1765  dwarf::VirtualityString);
1766  if (N->getVirtuality() != dwarf::DW_VIRTUALITY_none ||
1767  N->getVirtualIndex() != 0)
1768  Printer.printInt("virtualIndex", N->getVirtualIndex(), false);
1769  Printer.printInt("thisAdjustment", N->getThisAdjustment());
1770  Printer.printDIFlags("flags", N->getFlags());
1771  Printer.printBool("isOptimized", N->isOptimized());
1772  Printer.printMetadata("unit", N->getRawUnit());
1773  Printer.printMetadata("templateParams", N->getRawTemplateParams());
1774  Printer.printMetadata("declaration", N->getRawDeclaration());
1775  Printer.printMetadata("variables", N->getRawVariables());
1776  Printer.printMetadata("thrownTypes", N->getRawThrownTypes());
1777  Out << ")";
1778 }
1779 
1780 static void writeDILexicalBlock(raw_ostream &Out, const DILexicalBlock *N,
1781  TypePrinting *TypePrinter, SlotTracker *Machine,
1782  const Module *Context) {
1783  Out << "!DILexicalBlock(";
1784  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1785  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1786  Printer.printMetadata("file", N->getRawFile());
1787  Printer.printInt("line", N->getLine());
1788  Printer.printInt("column", N->getColumn());
1789  Out << ")";
1790 }
1791 
1792 static void writeDILexicalBlockFile(raw_ostream &Out,
1793  const DILexicalBlockFile *N,
1794  TypePrinting *TypePrinter,
1795  SlotTracker *Machine,
1796  const Module *Context) {
1797  Out << "!DILexicalBlockFile(";
1798  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1799  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1800  Printer.printMetadata("file", N->getRawFile());
1801  Printer.printInt("discriminator", N->getDiscriminator(),
1802  /* ShouldSkipZero */ false);
1803  Out << ")";
1804 }
1805 
1806 static void writeDINamespace(raw_ostream &Out, const DINamespace *N,
1807  TypePrinting *TypePrinter, SlotTracker *Machine,
1808  const Module *Context) {
1809  Out << "!DINamespace(";
1810  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1811  Printer.printString("name", N->getName());
1812  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1813  Printer.printBool("exportSymbols", N->getExportSymbols(), false);
1814  Out << ")";
1815 }
1816 
1817 static void writeDIMacro(raw_ostream &Out, const DIMacro *N,
1818  TypePrinting *TypePrinter, SlotTracker *Machine,
1819  const Module *Context) {
1820  Out << "!DIMacro(";
1821  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1822  Printer.printMacinfoType(N);
1823  Printer.printInt("line", N->getLine());
1824  Printer.printString("name", N->getName());
1825  Printer.printString("value", N->getValue());
1826  Out << ")";
1827 }
1828 
1829 static void writeDIMacroFile(raw_ostream &Out, const DIMacroFile *N,
1830  TypePrinting *TypePrinter, SlotTracker *Machine,
1831  const Module *Context) {
1832  Out << "!DIMacroFile(";
1833  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1834  Printer.printInt("line", N->getLine());
1835  Printer.printMetadata("file", N->getRawFile(), /* ShouldSkipNull */ false);
1836  Printer.printMetadata("nodes", N->getRawElements());
1837  Out << ")";
1838 }
1839 
1840 static void writeDIModule(raw_ostream &Out, const DIModule *N,
1841  TypePrinting *TypePrinter, SlotTracker *Machine,
1842  const Module *Context) {
1843  Out << "!DIModule(";
1844  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1845  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1846  Printer.printString("name", N->getName());
1847  Printer.printString("configMacros", N->getConfigurationMacros());
1848  Printer.printString("includePath", N->getIncludePath());
1849  Printer.printString("isysroot", N->getISysRoot());
1850  Out << ")";
1851 }
1852 
1853 
1854 static void writeDITemplateTypeParameter(raw_ostream &Out,
1855  const DITemplateTypeParameter *N,
1856  TypePrinting *TypePrinter,
1857  SlotTracker *Machine,
1858  const Module *Context) {
1859  Out << "!DITemplateTypeParameter(";
1860  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1861  Printer.printString("name", N->getName());
1862  Printer.printMetadata("type", N->getRawType(), /* ShouldSkipNull */ false);
1863  Out << ")";
1864 }
1865 
1866 static void writeDITemplateValueParameter(raw_ostream &Out,
1867  const DITemplateValueParameter *N,
1868  TypePrinting *TypePrinter,
1869  SlotTracker *Machine,
1870  const Module *Context) {
1871  Out << "!DITemplateValueParameter(";
1872  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1873  if (N->getTag() != dwarf::DW_TAG_template_value_parameter)
1874  Printer.printTag(N);
1875  Printer.printString("name", N->getName());
1876  Printer.printMetadata("type", N->getRawType());
1877  Printer.printMetadata("value", N->getValue(), /* ShouldSkipNull */ false);
1878  Out << ")";
1879 }
1880 
1881 static void writeDIGlobalVariable(raw_ostream &Out, const DIGlobalVariable *N,
1882  TypePrinting *TypePrinter,
1883  SlotTracker *Machine, const Module *Context) {
1884  Out << "!DIGlobalVariable(";
1885  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1886  Printer.printString("name", N->getName());
1887  Printer.printString("linkageName", N->getLinkageName());
1888  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1889  Printer.printMetadata("file", N->getRawFile());
1890  Printer.printInt("line", N->getLine());
1891  Printer.printMetadata("type", N->getRawType());
1892  Printer.printBool("isLocal", N->isLocalToUnit());
1893  Printer.printBool("isDefinition", N->isDefinition());
1894  Printer.printMetadata("declaration", N->getRawStaticDataMemberDeclaration());
1895  Printer.printInt("align", N->getAlignInBits());
1896  Out << ")";
1897 }
1898 
1899 static void writeDILocalVariable(raw_ostream &Out, const DILocalVariable *N,
1900  TypePrinting *TypePrinter,
1901  SlotTracker *Machine, const Module *Context) {
1902  Out << "!DILocalVariable(";
1903  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1904  Printer.printString("name", N->getName());
1905  Printer.printInt("arg", N->getArg());
1906  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1907  Printer.printMetadata("file", N->getRawFile());
1908  Printer.printInt("line", N->getLine());
1909  Printer.printMetadata("type", N->getRawType());
1910  Printer.printDIFlags("flags", N->getFlags());
1911  Printer.printInt("align", N->getAlignInBits());
1912  Out << ")";
1913 }
1914 
1915 static void writeDIExpression(raw_ostream &Out, const DIExpression *N,
1916  TypePrinting *TypePrinter, SlotTracker *Machine,
1917  const Module *Context) {
1918  Out << "!DIExpression(";
1919  FieldSeparator FS;
1920  if (N->isValid()) {
1921  for (auto I = N->expr_op_begin(), E = N->expr_op_end(); I != E; ++I) {
1922  auto OpStr = dwarf::OperationEncodingString(I->getOp());
1923  assert(!OpStr.empty() && "Expected valid opcode");
1924 
1925  Out << FS << OpStr;
1926  for (unsigned A = 0, AE = I->getNumArgs(); A != AE; ++A)
1927  Out << FS << I->getArg(A);
1928  }
1929  } else {
1930  for (const auto &I : N->getElements())
1931  Out << FS << I;
1932  }
1933  Out << ")";
1934 }
1935 
1936 static void writeDIGlobalVariableExpression(raw_ostream &Out,
1937  const DIGlobalVariableExpression *N,
1938  TypePrinting *TypePrinter,
1939  SlotTracker *Machine,
1940  const Module *Context) {
1941  Out << "!DIGlobalVariableExpression(";
1942  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1943  Printer.printMetadata("var", N->getVariable());
1944  Printer.printMetadata("expr", N->getExpression());
1945  Out << ")";
1946 }
1947 
1948 static void writeDIObjCProperty(raw_ostream &Out, const DIObjCProperty *N,
1949  TypePrinting *TypePrinter, SlotTracker *Machine,
1950  const Module *Context) {
1951  Out << "!DIObjCProperty(";
1952  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1953  Printer.printString("name", N->getName());
1954  Printer.printMetadata("file", N->getRawFile());
1955  Printer.printInt("line", N->getLine());
1956  Printer.printString("setter", N->getSetterName());
1957  Printer.printString("getter", N->getGetterName());
1958  Printer.printInt("attributes", N->getAttributes());
1959  Printer.printMetadata("type", N->getRawType());
1960  Out << ")";
1961 }
1962 
1963 static void writeDIImportedEntity(raw_ostream &Out, const DIImportedEntity *N,
1964  TypePrinting *TypePrinter,
1965  SlotTracker *Machine, const Module *Context) {
1966  Out << "!DIImportedEntity(";
1967  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
1968  Printer.printTag(N);
1969  Printer.printString("name", N->getName());
1970  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
1971  Printer.printMetadata("entity", N->getRawEntity());
1972  Printer.printMetadata("file", N->getRawFile());
1973  Printer.printInt("line", N->getLine());
1974  Out << ")";
1975 }
1976 
1977 static void WriteMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node,
1978  TypePrinting *TypePrinter,
1979  SlotTracker *Machine,
1980  const Module *Context) {
1981  if (Node->isDistinct())
1982  Out << "distinct ";
1983  else if (Node->isTemporary())
1984  Out << "<temporary!> "; // Handle broken code.
1985 
1986  switch (Node->getMetadataID()) {
1987  default:
1988  llvm_unreachable("Expected uniquable MDNode");
1989 #define HANDLE_MDNODE_LEAF(CLASS) \
1990  case Metadata::CLASS##Kind: \
1991  write##CLASS(Out, cast<CLASS>(Node), TypePrinter, Machine, Context); \
1992  break;
1993 #include "llvm/IR/Metadata.def"
1994  }
1995 }
1996 
1997 // Full implementation of printing a Value as an operand with support for
1998 // TypePrinting, etc.
1999 static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
2000  TypePrinting *TypePrinter,
2001  SlotTracker *Machine,
2002  const Module *Context) {
2003  if (V->hasName()) {
2004  PrintLLVMName(Out, V);
2005  return;
2006  }
2007 
2008  const Constant *CV = dyn_cast<Constant>(V);
2009  if (CV && !isa<GlobalValue>(CV)) {
2010  assert(TypePrinter && "Constants require TypePrinting!");
2011  WriteConstantInternal(Out, CV, *TypePrinter, Machine, Context);
2012  return;
2013  }
2014 
2015  if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
2016  Out << "asm ";
2017  if (IA->hasSideEffects())
2018  Out << "sideeffect ";
2019  if (IA->isAlignStack())
2020  Out << "alignstack ";
2021  // We don't emit the AD_ATT dialect as it's the assumed default.
2022  if (IA->getDialect() == InlineAsm::AD_Intel)
2023  Out << "inteldialect ";
2024  Out << '"';
2025  PrintEscapedString(IA->getAsmString(), Out);
2026  Out << "\", \"";
2027  PrintEscapedString(IA->getConstraintString(), Out);
2028  Out << '"';
2029  return;
2030  }
2031 
2032  if (auto *MD = dyn_cast<MetadataAsValue>(V)) {
2033  WriteAsOperandInternal(Out, MD->getMetadata(), TypePrinter, Machine,
2034  Context, /* FromValue */ true);
2035  return;
2036  }
2037 
2038  char Prefix = '%';
2039  int Slot;
2040  // If we have a SlotTracker, use it.
2041  if (Machine) {
2042  if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
2043  Slot = Machine->getGlobalSlot(GV);
2044  Prefix = '@';
2045  } else {
2046  Slot = Machine->getLocalSlot(V);
2047 
2048  // If the local value didn't succeed, then we may be referring to a value
2049  // from a different function. Translate it, as this can happen when using
2050  // address of blocks.
2051  if (Slot == -1)
2052  if ((Machine = createSlotTracker(V))) {
2053  Slot = Machine->getLocalSlot(V);
2054  delete Machine;
2055  }
2056  }
2057  } else if ((Machine = createSlotTracker(V))) {
2058  // Otherwise, create one to get the # and then destroy it.
2059  if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
2060  Slot = Machine->getGlobalSlot(GV);
2061  Prefix = '@';
2062  } else {
2063  Slot = Machine->getLocalSlot(V);
2064  }
2065  delete Machine;
2066  Machine = nullptr;
2067  } else {
2068  Slot = -1;
2069  }
2070 
2071  if (Slot != -1)
2072  Out << Prefix << Slot;
2073  else
2074  Out << "<badref>";
2075 }
2076 
2077 static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
2078  TypePrinting *TypePrinter,
2079  SlotTracker *Machine, const Module *Context,
2080  bool FromValue) {
2081  // Write DIExpressions inline when used as a value. Improves readability of
2082  // debug info intrinsics.
2083  if (const DIExpression *Expr = dyn_cast<DIExpression>(MD)) {
2084  writeDIExpression(Out, Expr, TypePrinter, Machine, Context);
2085  return;
2086  }
2087 
2088  if (const MDNode *N = dyn_cast<MDNode>(MD)) {
2089  std::unique_ptr<SlotTracker> MachineStorage;
2090  if (!Machine) {
2091  MachineStorage = make_unique<SlotTracker>(Context);
2092  Machine = MachineStorage.get();
2093  }
2094  int Slot = Machine->getMetadataSlot(N);
2095  if (Slot == -1)
2096  // Give the pointer value instead of "badref", since this comes up all
2097  // the time when debugging.
2098  Out << "<" << N << ">";
2099  else
2100  Out << '!' << Slot;
2101  return;
2102  }
2103 
2104  if (const MDString *MDS = dyn_cast<MDString>(MD)) {
2105  Out << "!\"";
2106  PrintEscapedString(MDS->getString(), Out);
2107  Out << '"';
2108  return;
2109  }
2110 
2111  auto *V = cast<ValueAsMetadata>(MD);
2112  assert(TypePrinter && "TypePrinter required for metadata values");
2113  assert((FromValue || !isa<LocalAsMetadata>(V)) &&
2114  "Unexpected function-local metadata outside of value argument");
2115 
2116  TypePrinter->print(V->getValue()->getType(), Out);
2117  Out << ' ';
2118  WriteAsOperandInternal(Out, V->getValue(), TypePrinter, Machine, Context);
2119 }
2120 
2121 namespace {
2122 
2123 class AssemblyWriter {
2124  formatted_raw_ostream &Out;
2125  const Module *TheModule;
2126  std::unique_ptr<SlotTracker> SlotTrackerStorage;
2128  TypePrinting TypePrinter;
2129  AssemblyAnnotationWriter *AnnotationWriter;
2130  SetVector<const Comdat *> Comdats;
2131  bool IsForDebug;
2132  bool ShouldPreserveUseListOrder;
2133  UseListOrderStack UseListOrders;
2134  SmallVector<StringRef, 8> MDNames;
2135  /// Synchronization scope names registered with LLVMContext.
2137 
2138 public:
2139  /// Construct an AssemblyWriter with an external SlotTracker
2140  AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac, const Module *M,
2141  AssemblyAnnotationWriter *AAW, bool IsForDebug,
2142  bool ShouldPreserveUseListOrder = false);
2143 
2144  void printMDNodeBody(const MDNode *MD);
2145  void printNamedMDNode(const NamedMDNode *NMD);
2146 
2147  void printModule(const Module *M);
2148 
2149  void writeOperand(const Value *Op, bool PrintType);
2150  void writeParamOperand(const Value *Operand, AttributeSet Attrs);
2151  void writeOperandBundles(ImmutableCallSite CS);
2152  void writeSyncScope(const LLVMContext &Context,
2153  SyncScope::ID SSID);
2154  void writeAtomic(const LLVMContext &Context,
2155  AtomicOrdering Ordering,
2156  SyncScope::ID SSID);
2157  void writeAtomicCmpXchg(const LLVMContext &Context,
2158  AtomicOrdering SuccessOrdering,
2159  AtomicOrdering FailureOrdering,
2160  SyncScope::ID SSID);
2161 
2162  void writeAllMDNodes();
2163  void writeMDNode(unsigned Slot, const MDNode *Node);
2164  void writeAllAttributeGroups();
2165 
2166  void printTypeIdentities();
2167  void printGlobal(const GlobalVariable *GV);
2168  void printIndirectSymbol(const GlobalIndirectSymbol *GIS);
2169  void printComdat(const Comdat *C);
2170  void printFunction(const Function *F);
2171  void printArgument(const Argument *FA, AttributeSet Attrs);
2172  void printBasicBlock(const BasicBlock *BB);
2173  void printInstructionLine(const Instruction &I);
2174  void printInstruction(const Instruction &I);
2175 
2176  void printUseListOrder(const UseListOrder &Order);
2177  void printUseLists(const Function *F);
2178 
2179 private:
2180  /// \brief Print out metadata attachments.
2181  void printMetadataAttachments(
2182  const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
2183  StringRef Separator);
2184 
2185  // printInfoComment - Print a little comment after the instruction indicating
2186  // which slot it occupies.
2187  void printInfoComment(const Value &V);
2188 
2189  // printGCRelocateComment - print comment after call to the gc.relocate
2190  // intrinsic indicating base and derived pointer names.
2191  void printGCRelocateComment(const GCRelocateInst &Relocate);
2192 };
2193 
2194 } // end anonymous namespace
2195 
2196 AssemblyWriter::AssemblyWriter(formatted_raw_ostream &o, SlotTracker &Mac,
2197  const Module *M, AssemblyAnnotationWriter *AAW,
2198  bool IsForDebug, bool ShouldPreserveUseListOrder)
2199  : Out(o), TheModule(M), Machine(Mac), AnnotationWriter(AAW),
2200  IsForDebug(IsForDebug),
2201  ShouldPreserveUseListOrder(ShouldPreserveUseListOrder) {
2202  if (!TheModule)
2203  return;
2204  TypePrinter.incorporateTypes(*TheModule);
2205  for (const GlobalObject &GO : TheModule->global_objects())
2206  if (const Comdat *C = GO.getComdat())
2207  Comdats.insert(C);
2208 }
2209 
2210 void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) {
2211  if (!Operand) {
2212  Out << "<null operand!>";
2213  return;
2214  }
2215  if (PrintType) {
2216  TypePrinter.print(Operand->getType(), Out);
2217  Out << ' ';
2218  }
2219  WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule);
2220 }
2221 
2222 void AssemblyWriter::writeSyncScope(const LLVMContext &Context,
2223  SyncScope::ID SSID) {
2224  switch (SSID) {
2225  case SyncScope::System: {
2226  break;
2227  }
2228  default: {
2229  if (SSNs.empty())
2230  Context.getSyncScopeNames(SSNs);
2231 
2232  Out << " syncscope(\"";
2233  PrintEscapedString(SSNs[SSID], Out);
2234  Out << "\")";
2235  break;
2236  }
2237  }
2238 }
2239 
2240 void AssemblyWriter::writeAtomic(const LLVMContext &Context,
2241  AtomicOrdering Ordering,
2242  SyncScope::ID SSID) {
2243  if (Ordering == AtomicOrdering::NotAtomic)
2244  return;
2245 
2246  writeSyncScope(Context, SSID);
2247  Out << " " << toIRString(Ordering);
2248 }
2249 
2250 void AssemblyWriter::writeAtomicCmpXchg(const LLVMContext &Context,
2251  AtomicOrdering SuccessOrdering,
2252  AtomicOrdering FailureOrdering,
2253  SyncScope::ID SSID) {
2254  assert(SuccessOrdering != AtomicOrdering::NotAtomic &&
2255  FailureOrdering != AtomicOrdering::NotAtomic);
2256 
2257  writeSyncScope(Context, SSID);
2258  Out << " " << toIRString(SuccessOrdering);
2259  Out << " " << toIRString(FailureOrdering);
2260 }
2261 
2262 void AssemblyWriter::writeParamOperand(const Value *Operand,
2263  AttributeSet Attrs) {
2264  if (!Operand) {
2265  Out << "<null operand!>";
2266  return;
2267  }
2268 
2269  // Print the type
2270  TypePrinter.print(Operand->getType(), Out);
2271  // Print parameter attributes list
2272  if (Attrs.hasAttributes())
2273  Out << ' ' << Attrs.getAsString();
2274  Out << ' ';
2275  // Print the operand
2276  WriteAsOperandInternal(Out, Operand, &TypePrinter, &Machine, TheModule);
2277 }
2278 
2279 void AssemblyWriter::writeOperandBundles(ImmutableCallSite CS) {
2280  if (!CS.hasOperandBundles())
2281  return;
2282 
2283  Out << " [ ";
2284 
2285  bool FirstBundle = true;
2286  for (unsigned i = 0, e = CS.getNumOperandBundles(); i != e; ++i) {
2288 
2289  if (!FirstBundle)
2290  Out << ", ";
2291  FirstBundle = false;
2292 
2293  Out << '"';
2294  PrintEscapedString(BU.getTagName(), Out);
2295  Out << '"';
2296 
2297  Out << '(';
2298 
2299  bool FirstInput = true;
2300  for (const auto &Input : BU.Inputs) {
2301  if (!FirstInput)
2302  Out << ", ";
2303  FirstInput = false;
2304 
2305  TypePrinter.print(Input->getType(), Out);
2306  Out << " ";
2307  WriteAsOperandInternal(Out, Input, &TypePrinter, &Machine, TheModule);
2308  }
2309 
2310  Out << ')';
2311  }
2312 
2313  Out << " ]";
2314 }
2315 
2316 void AssemblyWriter::printModule(const Module *M) {
2317  Machine.initialize();
2318 
2319  if (ShouldPreserveUseListOrder)
2320  UseListOrders = predictUseListOrder(M);
2321 
2322  if (!M->getModuleIdentifier().empty() &&
2323  // Don't print the ID if it will start a new line (which would
2324  // require a comment char before it).
2325  M->getModuleIdentifier().find('\n') == std::string::npos)
2326  Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n";
2327 
2328  if (!M->getSourceFileName().empty()) {
2329  Out << "source_filename = \"";
2331  Out << "\"\n";
2332  }
2333 
2334  const std::string &DL = M->getDataLayoutStr();
2335  if (!DL.empty())
2336  Out << "target datalayout = \"" << DL << "\"\n";
2337  if (!M->getTargetTriple().empty())
2338  Out << "target triple = \"" << M->getTargetTriple() << "\"\n";
2339 
2340  if (!M->getModuleInlineAsm().empty()) {
2341  Out << '\n';
2342 
2343  // Split the string into lines, to make it easier to read the .ll file.
2345  do {
2346  StringRef Front;
2347  std::tie(Front, Asm) = Asm.split('\n');
2348 
2349  // We found a newline, print the portion of the asm string from the
2350  // last newline up to this newline.
2351  Out << "module asm \"";
2352  PrintEscapedString(Front, Out);
2353  Out << "\"\n";
2354  } while (!Asm.empty());
2355  }
2356 
2357  printTypeIdentities();
2358 
2359  // Output all comdats.
2360  if (!Comdats.empty())
2361  Out << '\n';
2362  for (const Comdat *C : Comdats) {
2363  printComdat(C);
2364  if (C != Comdats.back())
2365  Out << '\n';
2366  }
2367 
2368  // Output all globals.
2369  if (!M->global_empty()) Out << '\n';
2370  for (const GlobalVariable &GV : M->globals()) {
2371  printGlobal(&GV); Out << '\n';
2372  }
2373 
2374  // Output all aliases.
2375  if (!M->alias_empty()) Out << "\n";
2376  for (const GlobalAlias &GA : M->aliases())
2377  printIndirectSymbol(&GA);
2378 
2379  // Output all ifuncs.
2380  if (!M->ifunc_empty()) Out << "\n";
2381  for (const GlobalIFunc &GI : M->ifuncs())
2382  printIndirectSymbol(&GI);
2383 
2384  // Output global use-lists.
2385  printUseLists(nullptr);
2386 
2387  // Output all of the functions.
2388  for (const Function &F : *M)
2389  printFunction(&F);
2390  assert(UseListOrders.empty() && "All use-lists should have been consumed");
2391 
2392  // Output all attribute groups.
2393  if (!Machine.as_empty()) {
2394  Out << '\n';
2395  writeAllAttributeGroups();
2396  }
2397 
2398  // Output named metadata.
2399  if (!M->named_metadata_empty()) Out << '\n';
2400 
2401  for (const NamedMDNode &Node : M->named_metadata())
2402  printNamedMDNode(&Node);
2403 
2404  // Output metadata.
2405  if (!Machine.mdn_empty()) {
2406  Out << '\n';
2407  writeAllMDNodes();
2408  }
2409 }
2410 
2412  formatted_raw_ostream &Out) {
2413  if (Name.empty()) {
2414  Out << "<empty name> ";
2415  } else {
2416  if (isalpha(static_cast<unsigned char>(Name[0])) || Name[0] == '-' ||
2417  Name[0] == '$' || Name[0] == '.' || Name[0] == '_')
2418  Out << Name[0];
2419  else
2420  Out << '\\' << hexdigit(Name[0] >> 4) << hexdigit(Name[0] & 0x0F);
2421  for (unsigned i = 1, e = Name.size(); i != e; ++i) {
2422  unsigned char C = Name[i];
2423  if (isalnum(static_cast<unsigned char>(C)) || C == '-' || C == '$' ||
2424  C == '.' || C == '_')
2425  Out << C;
2426  else
2427  Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
2428  }
2429  }
2430 }
2431 
2432 void AssemblyWriter::printNamedMDNode(const NamedMDNode *NMD) {
2433  Out << '!';
2434  printMetadataIdentifier(NMD->getName(), Out);
2435  Out << " = !{";
2436  for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
2437  if (i)
2438  Out << ", ";
2439 
2440  // Write DIExpressions inline.
2441  // FIXME: Ban DIExpressions in NamedMDNodes, they will serve no purpose.
2442  MDNode *Op = NMD->getOperand(i);
2443  if (auto *Expr = dyn_cast<DIExpression>(Op)) {
2444  writeDIExpression(Out, Expr, nullptr, nullptr, nullptr);
2445  continue;
2446  }
2447 
2448  int Slot = Machine.getMetadataSlot(Op);
2449  if (Slot == -1)
2450  Out << "<badref>";
2451  else
2452  Out << '!' << Slot;
2453  }
2454  Out << "}\n";
2455 }
2456 
2458  switch (LT) {
2460  return "";
2462  return "private ";
2464  return "internal ";
2466  return "linkonce ";
2468  return "linkonce_odr ";
2470  return "weak ";
2472  return "weak_odr ";
2474  return "common ";
2476  return "appending ";
2478  return "extern_weak ";
2480  return "available_externally ";
2481  }
2482  llvm_unreachable("invalid linkage");
2483 }
2484 
2486  formatted_raw_ostream &Out) {
2487  switch (Vis) {
2488  case GlobalValue::DefaultVisibility: break;
2489  case GlobalValue::HiddenVisibility: Out << "hidden "; break;
2490  case GlobalValue::ProtectedVisibility: Out << "protected "; break;
2491  }
2492 }
2493 
2495  formatted_raw_ostream &Out) {
2496  switch (SCT) {
2498  case GlobalValue::DLLImportStorageClass: Out << "dllimport "; break;
2499  case GlobalValue::DLLExportStorageClass: Out << "dllexport "; break;
2500  }
2501 }
2502 
2504  formatted_raw_ostream &Out) {
2505  switch (TLM) {
2507  break;
2509  Out << "thread_local ";
2510  break;
2512  Out << "thread_local(localdynamic) ";
2513  break;
2515  Out << "thread_local(initialexec) ";
2516  break;
2518  Out << "thread_local(localexec) ";
2519  break;
2520  }
2521 }
2522 
2524  switch (UA) {
2526  return "";
2528  return "local_unnamed_addr";
2530  return "unnamed_addr";
2531  }
2532  llvm_unreachable("Unknown UnnamedAddr");
2533 }
2534 
2536  const GlobalObject &GO) {
2537  const Comdat *C = GO.getComdat();
2538  if (!C)
2539  return;
2540 
2541  if (isa<GlobalVariable>(GO))
2542  Out << ',';
2543  Out << " comdat";
2544 
2545  if (GO.getName() == C->getName())
2546  return;
2547 
2548  Out << '(';
2549  PrintLLVMName(Out, C->getName(), ComdatPrefix);
2550  Out << ')';
2551 }
2552 
2553 void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
2554  if (GV->isMaterializable())
2555  Out << "; Materializable\n";
2556 
2557  WriteAsOperandInternal(Out, GV, &TypePrinter, &Machine, GV->getParent());
2558  Out << " = ";
2559 
2560  if (!GV->hasInitializer() && GV->hasExternalLinkage())
2561  Out << "external ";
2562 
2563  Out << getLinkagePrintName(GV->getLinkage());
2564  PrintVisibility(GV->getVisibility(), Out);
2568  if (!UA.empty())
2569  Out << UA << ' ';
2570 
2571  if (unsigned AddressSpace = GV->getType()->getAddressSpace())
2572  Out << "addrspace(" << AddressSpace << ") ";
2573  if (GV->isExternallyInitialized()) Out << "externally_initialized ";
2574  Out << (GV->isConstant() ? "constant " : "global ");
2575  TypePrinter.print(GV->getValueType(), Out);
2576 
2577  if (GV->hasInitializer()) {
2578  Out << ' ';
2579  writeOperand(GV->getInitializer(), false);
2580  }
2581 
2582  if (GV->hasSection()) {
2583  Out << ", section \"";
2584  PrintEscapedString(GV->getSection(), Out);
2585  Out << '"';
2586  }
2587  maybePrintComdat(Out, *GV);
2588  if (GV->getAlignment())
2589  Out << ", align " << GV->getAlignment();
2590 
2592  GV->getAllMetadata(MDs);
2593  printMetadataAttachments(MDs, ", ");
2594 
2595  auto Attrs = GV->getAttributes();
2596  if (Attrs.hasAttributes())
2597  Out << " #" << Machine.getAttributeGroupSlot(Attrs);
2598 
2599  printInfoComment(*GV);
2600 }
2601 
2602 void AssemblyWriter::printIndirectSymbol(const GlobalIndirectSymbol *GIS) {
2603  if (GIS->isMaterializable())
2604  Out << "; Materializable\n";
2605 
2606  WriteAsOperandInternal(Out, GIS, &TypePrinter, &Machine, GIS->getParent());
2607  Out << " = ";
2608 
2609  Out << getLinkagePrintName(GIS->getLinkage());
2610  PrintVisibility(GIS->getVisibility(), Out);
2614  if (!UA.empty())
2615  Out << UA << ' ';
2616 
2617  if (isa<GlobalAlias>(GIS))
2618  Out << "alias ";
2619  else if (isa<GlobalIFunc>(GIS))
2620  Out << "ifunc ";
2621  else
2622  llvm_unreachable("Not an alias or ifunc!");
2623 
2624  TypePrinter.print(GIS->getValueType(), Out);
2625 
2626  Out << ", ";
2627 
2628  const Constant *IS = GIS->getIndirectSymbol();
2629 
2630  if (!IS) {
2631  TypePrinter.print(GIS->getType(), Out);
2632  Out << " <<NULL ALIASEE>>";
2633  } else {
2634  writeOperand(IS, !isa<ConstantExpr>(IS));
2635  }
2636 
2637  printInfoComment(*GIS);
2638  Out << '\n';
2639 }
2640 
2641 void AssemblyWriter::printComdat(const Comdat *C) {
2642  C->print(Out);
2643 }
2644 
2645 void AssemblyWriter::printTypeIdentities() {
2646  if (TypePrinter.NumberedTypes.empty() &&
2647  TypePrinter.NamedTypes.empty())
2648  return;
2649 
2650  Out << '\n';
2651 
2652  // We know all the numbers that each type is used and we know that it is a
2653  // dense assignment. Convert the map to an index table.
2654  std::vector<StructType*> NumberedTypes(TypePrinter.NumberedTypes.size());
2656  TypePrinter.NumberedTypes.begin(), E = TypePrinter.NumberedTypes.end();
2657  I != E; ++I) {
2658  assert(I->second < NumberedTypes.size() && "Didn't get a dense numbering?");
2659  NumberedTypes[I->second] = I->first;
2660  }
2661 
2662  // Emit all numbered types.
2663  for (unsigned i = 0, e = NumberedTypes.size(); i != e; ++i) {
2664  Out << '%' << i << " = type ";
2665 
2666  // Make sure we print out at least one level of the type structure, so
2667  // that we do not get %2 = type %2
2668  TypePrinter.printStructBody(NumberedTypes[i], Out);
2669  Out << '\n';
2670  }
2671 
2672  for (unsigned i = 0, e = TypePrinter.NamedTypes.size(); i != e; ++i) {
2673  PrintLLVMName(Out, TypePrinter.NamedTypes[i]->getName(), LocalPrefix);
2674  Out << " = type ";
2675 
2676  // Make sure we print out at least one level of the type structure, so
2677  // that we do not get %FILE = type %FILE
2678  TypePrinter.printStructBody(TypePrinter.NamedTypes[i], Out);
2679  Out << '\n';
2680  }
2681 }
2682 
2683 /// printFunction - Print all aspects of a function.
2684 void AssemblyWriter::printFunction(const Function *F) {
2685  // Print out the return type and name.
2686  Out << '\n';
2687 
2688  if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out);
2689 
2690  if (F->isMaterializable())
2691  Out << "; Materializable\n";
2692 
2693  const AttributeList &Attrs = F->getAttributes();
2695  AttributeSet AS = Attrs.getFnAttributes();
2696  std::string AttrStr;
2697 
2698  for (const Attribute &Attr : AS) {
2699  if (!Attr.isStringAttribute()) {
2700  if (!AttrStr.empty()) AttrStr += ' ';
2701  AttrStr += Attr.getAsString();
2702  }
2703  }
2704 
2705  if (!AttrStr.empty())
2706  Out << "; Function Attrs: " << AttrStr << '\n';
2707  }
2708 
2709  Machine.incorporateFunction(F);
2710 
2711  if (F->isDeclaration()) {
2712  Out << "declare";
2714  F->getAllMetadata(MDs);
2715  printMetadataAttachments(MDs, " ");
2716  Out << ' ';
2717  } else
2718  Out << "define ";
2719 
2720  Out << getLinkagePrintName(F->getLinkage());
2721  PrintVisibility(F->getVisibility(), Out);
2723 
2724  // Print the calling convention.
2725  if (F->getCallingConv() != CallingConv::C) {
2726  PrintCallingConv(F->getCallingConv(), Out);
2727  Out << " ";
2728  }
2729 
2730  FunctionType *FT = F->getFunctionType();
2732  Out << Attrs.getAsString(AttributeList::ReturnIndex) << ' ';
2733  TypePrinter.print(F->getReturnType(), Out);
2734  Out << ' ';
2735  WriteAsOperandInternal(Out, F, &TypePrinter, &Machine, F->getParent());
2736  Out << '(';
2737 
2738  // Loop over the arguments, printing them...
2739  if (F->isDeclaration() && !IsForDebug) {
2740  // We're only interested in the type here - don't print argument names.
2741  for (unsigned I = 0, E = FT->getNumParams(); I != E; ++I) {
2742  // Insert commas as we go... the first arg doesn't get a comma
2743  if (I)
2744  Out << ", ";
2745  // Output type...
2746  TypePrinter.print(FT->getParamType(I), Out);
2747 
2748  AttributeSet ArgAttrs = Attrs.getParamAttributes(I);
2749  if (ArgAttrs.hasAttributes())
2750  Out << ' ' << ArgAttrs.getAsString();
2751  }
2752  } else {
2753  // The arguments are meaningful here, print them in detail.
2754  for (const Argument &Arg : F->args()) {
2755  // Insert commas as we go... the first arg doesn't get a comma
2756  if (Arg.getArgNo() != 0)
2757  Out << ", ";
2758  printArgument(&Arg, Attrs.getParamAttributes(Arg.getArgNo()));
2759  }
2760  }
2761 
2762  // Finish printing arguments...
2763  if (FT->isVarArg()) {
2764  if (FT->getNumParams()) Out << ", ";
2765  Out << "..."; // Output varargs portion of signature!
2766  }
2767  Out << ')';
2769  if (!UA.empty())
2770  Out << ' ' << UA;
2772  Out << " #" << Machine.getAttributeGroupSlot(Attrs.getFnAttributes());
2773  if (F->hasSection()) {
2774  Out << " section \"";
2775  PrintEscapedString(F->getSection(), Out);
2776  Out << '"';
2777  }
2778  maybePrintComdat(Out, *F);
2779  if (F->getAlignment())
2780  Out << " align " << F->getAlignment();
2781  if (F->hasGC())
2782  Out << " gc \"" << F->getGC() << '"';
2783  if (F->hasPrefixData()) {
2784  Out << " prefix ";
2785  writeOperand(F->getPrefixData(), true);
2786  }
2787  if (F->hasPrologueData()) {
2788  Out << " prologue ";
2789  writeOperand(F->getPrologueData(), true);
2790  }
2791  if (F->hasPersonalityFn()) {
2792  Out << " personality ";
2793  writeOperand(F->getPersonalityFn(), /*PrintType=*/true);
2794  }
2795 
2796  if (F->isDeclaration()) {
2797  Out << '\n';
2798  } else {
2800  F->getAllMetadata(MDs);
2801  printMetadataAttachments(MDs, " ");
2802 
2803  Out << " {";
2804  // Output all of the function's basic blocks.
2805  for (const BasicBlock &BB : *F)
2806  printBasicBlock(&BB);
2807 
2808  // Output the function's use-lists.
2809  printUseLists(F);
2810 
2811  Out << "}\n";
2812  }
2813 
2814  Machine.purgeFunction();
2815 }
2816 
2817 /// printArgument - This member is called for every argument that is passed into
2818 /// the function. Simply print it out
2819 void AssemblyWriter::printArgument(const Argument *Arg, AttributeSet Attrs) {
2820  // Output type...
2821  TypePrinter.print(Arg->getType(), Out);
2822 
2823  // Output parameter attributes list
2824  if (Attrs.hasAttributes())
2825  Out << ' ' << Attrs.getAsString();
2826 
2827  // Output name, if available...
2828  if (Arg->hasName()) {
2829  Out << ' ';
2830  PrintLLVMName(Out, Arg);
2831  }
2832 }
2833 
2834 /// printBasicBlock - This member is called for each basic block in a method.
2835 void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
2836  if (BB->hasName()) { // Print out the label if it exists...
2837  Out << "\n";
2838  PrintLLVMName(Out, BB->getName(), LabelPrefix);
2839  Out << ':';
2840  } else if (!BB->use_empty()) { // Don't print block # of no uses...
2841  Out << "\n; <label>:";
2842  int Slot = Machine.getLocalSlot(BB);
2843  if (Slot != -1)
2844  Out << Slot << ":";
2845  else
2846  Out << "<badref>";
2847  }
2848 
2849  if (!BB->getParent()) {
2850  Out.PadToColumn(50);
2851  Out << "; Error: Block without parent!";
2852  } else if (BB != &BB->getParent()->getEntryBlock()) { // Not the entry block?
2853  // Output predecessors for the block.
2854  Out.PadToColumn(50);
2855  Out << ";";
2856  const_pred_iterator PI = pred_begin(BB), PE = pred_end(BB);
2857 
2858  if (PI == PE) {
2859  Out << " No predecessors!";
2860  } else {
2861  Out << " preds = ";
2862  writeOperand(*PI, false);
2863  for (++PI; PI != PE; ++PI) {
2864  Out << ", ";
2865  writeOperand(*PI, false);
2866  }
2867  }
2868  }
2869 
2870  Out << "\n";
2871 
2872  if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out);
2873 
2874  // Output all of the instructions in the basic block...
2875  for (const Instruction &I : *BB) {
2876  printInstructionLine(I);
2877  }
2878 
2879  if (AnnotationWriter) AnnotationWriter->emitBasicBlockEndAnnot(BB, Out);
2880 }
2881 
2882 /// printInstructionLine - Print an instruction and a newline character.
2883 void AssemblyWriter::printInstructionLine(const Instruction &I) {
2884  printInstruction(I);
2885  Out << '\n';
2886 }
2887 
2888 /// printGCRelocateComment - print comment after call to the gc.relocate
2889 /// intrinsic indicating base and derived pointer names.
2890 void AssemblyWriter::printGCRelocateComment(const GCRelocateInst &Relocate) {
2891  Out << " ; (";
2892  writeOperand(Relocate.getBasePtr(), false);
2893  Out << ", ";
2894  writeOperand(Relocate.getDerivedPtr(), false);
2895  Out << ")";
2896 }
2897 
2898 /// printInfoComment - Print a little comment after the instruction indicating
2899 /// which slot it occupies.
2900 void AssemblyWriter::printInfoComment(const Value &V) {
2901  if (const auto *Relocate = dyn_cast<GCRelocateInst>(&V))
2902  printGCRelocateComment(*Relocate);
2903 
2904  if (AnnotationWriter)
2905  AnnotationWriter->printInfoComment(V, Out);
2906 }
2907 
2908 // This member is called for each Instruction in a function..
2909 void AssemblyWriter::printInstruction(const Instruction &I) {
2910  if (AnnotationWriter) AnnotationWriter->emitInstructionAnnot(&I, Out);
2911 
2912  // Print out indentation for an instruction.
2913  Out << " ";
2914 
2915  // Print out name if it exists...
2916  if (I.hasName()) {
2917  PrintLLVMName(Out, &I);
2918  Out << " = ";
2919  } else if (!I.getType()->isVoidTy()) {
2920  // Print out the def slot taken.
2921  int SlotNum = Machine.getLocalSlot(&I);
2922  if (SlotNum == -1)
2923  Out << "<badref> = ";
2924  else
2925  Out << '%' << SlotNum << " = ";
2926  }
2927 
2928  if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
2929  if (CI->isMustTailCall())
2930  Out << "musttail ";
2931  else if (CI->isTailCall())
2932  Out << "tail ";
2933  else if (CI->isNoTailCall())
2934  Out << "notail ";
2935  }
2936 
2937  // Print out the opcode...
2938  Out << I.getOpcodeName();
2939 
2940  // If this is an atomic load or store, print out the atomic marker.
2941  if ((isa<LoadInst>(I) && cast<LoadInst>(I).isAtomic()) ||
2942  (isa<StoreInst>(I) && cast<StoreInst>(I).isAtomic()))
2943  Out << " atomic";
2944 
2945  if (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).isWeak())
2946  Out << " weak";
2947 
2948  // If this is a volatile operation, print out the volatile marker.
2949  if ((isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) ||
2950  (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile()) ||
2951  (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).isVolatile()) ||
2952  (isa<AtomicRMWInst>(I) && cast<AtomicRMWInst>(I).isVolatile()))
2953  Out << " volatile";
2954 
2955  // Print out optimization information.
2956  WriteOptimizationInfo(Out, &I);
2957 
2958  // Print out the compare instruction predicates
2959  if (const CmpInst *CI = dyn_cast<CmpInst>(&I))
2960  Out << ' ' << CmpInst::getPredicateName(CI->getPredicate());
2961 
2962  // Print out the atomicrmw operation
2963  if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I))
2964  writeAtomicRMWOperation(Out, RMWI->getOperation());
2965 
2966  // Print out the type of the operands...
2967  const Value *Operand = I.getNumOperands() ? I.getOperand(0) : nullptr;
2968 
2969  // Special case conditional branches to swizzle the condition out to the front
2970  if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) {
2971  const BranchInst &BI(cast<BranchInst>(I));
2972  Out << ' ';
2973  writeOperand(BI.getCondition(), true);
2974  Out << ", ";
2975  writeOperand(BI.getSuccessor(0), true);
2976  Out << ", ";
2977  writeOperand(BI.getSuccessor(1), true);
2978 
2979  } else if (isa<SwitchInst>(I)) {
2980  const SwitchInst& SI(cast<SwitchInst>(I));
2981  // Special case switch instruction to get formatting nice and correct.
2982  Out << ' ';
2983  writeOperand(SI.getCondition(), true);
2984  Out << ", ";
2985  writeOperand(SI.getDefaultDest(), true);
2986  Out << " [";
2987  for (auto Case : SI.cases()) {
2988  Out << "\n ";
2989  writeOperand(Case.getCaseValue(), true);
2990  Out << ", ";
2991  writeOperand(Case.getCaseSuccessor(), true);
2992  }
2993  Out << "\n ]";
2994  } else if (isa<IndirectBrInst>(I)) {
2995  // Special case indirectbr instruction to get formatting nice and correct.
2996  Out << ' ';
2997  writeOperand(Operand, true);
2998  Out << ", [";
2999 
3000  for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i) {
3001  if (i != 1)
3002  Out << ", ";
3003  writeOperand(I.getOperand(i), true);
3004  }
3005  Out << ']';
3006  } else if (const PHINode *PN = dyn_cast<PHINode>(&I)) {
3007  Out << ' ';
3008  TypePrinter.print(I.getType(), Out);
3009  Out << ' ';
3010 
3011  for (unsigned op = 0, Eop = PN->getNumIncomingValues(); op < Eop; ++op) {
3012  if (op) Out << ", ";
3013  Out << "[ ";
3014  writeOperand(PN->getIncomingValue(op), false); Out << ", ";
3015  writeOperand(PN->getIncomingBlock(op), false); Out << " ]";
3016  }
3017  } else if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(&I)) {
3018  Out << ' ';
3019  writeOperand(I.getOperand(0), true);
3020  for (const unsigned *i = EVI->idx_begin(), *e = EVI->idx_end(); i != e; ++i)
3021  Out << ", " << *i;
3022  } else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(&I)) {
3023  Out << ' ';
3024  writeOperand(I.getOperand(0), true); Out << ", ";
3025  writeOperand(I.getOperand(1), true);
3026  for (const unsigned *i = IVI->idx_begin(), *e = IVI->idx_end(); i != e; ++i)
3027  Out << ", " << *i;
3028  } else if (const LandingPadInst *LPI = dyn_cast<LandingPadInst>(&I)) {
3029  Out << ' ';
3030  TypePrinter.print(I.getType(), Out);
3031  if (LPI->isCleanup() || LPI->getNumClauses() != 0)
3032  Out << '\n';
3033 
3034  if (LPI->isCleanup())
3035  Out << " cleanup";
3036 
3037  for (unsigned i = 0, e = LPI->getNumClauses(); i != e; ++i) {
3038  if (i != 0 || LPI->isCleanup()) Out << "\n";
3039  if (LPI->isCatch(i))
3040  Out << " catch ";
3041  else
3042  Out << " filter ";
3043 
3044  writeOperand(LPI->getClause(i), true);
3045  }
3046  } else if (const auto *CatchSwitch = dyn_cast<CatchSwitchInst>(&I)) {
3047  Out << " within ";
3048  writeOperand(CatchSwitch->getParentPad(), /*PrintType=*/false);
3049  Out << " [";
3050  unsigned Op = 0;
3051  for (const BasicBlock *PadBB : CatchSwitch->handlers()) {
3052  if (Op > 0)
3053  Out << ", ";
3054  writeOperand(PadBB, /*PrintType=*/true);
3055  ++Op;
3056  }
3057  Out << "] unwind ";
3058  if (const BasicBlock *UnwindDest = CatchSwitch->getUnwindDest())
3059  writeOperand(UnwindDest, /*PrintType=*/true);
3060  else
3061  Out << "to caller";
3062  } else if (const auto *FPI = dyn_cast<FuncletPadInst>(&I)) {
3063  Out << " within ";
3064  writeOperand(FPI->getParentPad(), /*PrintType=*/false);
3065  Out << " [";
3066  for (unsigned Op = 0, NumOps = FPI->getNumArgOperands(); Op < NumOps;
3067  ++Op) {
3068  if (Op > 0)
3069  Out << ", ";
3070  writeOperand(FPI->getArgOperand(Op), /*PrintType=*/true);
3071  }
3072  Out << ']';
3073  } else if (isa<ReturnInst>(I) && !Operand) {
3074  Out << " void";
3075  } else if (const auto *CRI = dyn_cast<CatchReturnInst>(&I)) {
3076  Out << " from ";
3077  writeOperand(CRI->getOperand(0), /*PrintType=*/false);
3078 
3079  Out << " to ";
3080  writeOperand(CRI->getOperand(1), /*PrintType=*/true);
3081  } else if (const auto *CRI = dyn_cast<CleanupReturnInst>(&I)) {
3082  Out << " from ";
3083  writeOperand(CRI->getOperand(0), /*PrintType=*/false);
3084 
3085  Out << " unwind ";
3086  if (CRI->hasUnwindDest())
3087  writeOperand(CRI->getOperand(1), /*PrintType=*/true);
3088  else
3089  Out << "to caller";
3090  } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
3091  // Print the calling convention being used.
3092  if (CI->getCallingConv() != CallingConv::C) {
3093  Out << " ";
3094  PrintCallingConv(CI->getCallingConv(), Out);
3095  }
3096 
3097  Operand = CI->getCalledValue();
3098  FunctionType *FTy = CI->getFunctionType();
3099  Type *RetTy = FTy->getReturnType();
3100  const AttributeList &PAL = CI->getAttributes();
3101 
3103  Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
3104 
3105  // If possible, print out the short form of the call instruction. We can
3106  // only do this if the first argument is a pointer to a nonvararg function,
3107  // and if the return type is not a pointer to a function.
3108  //
3109  Out << ' ';
3110  TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
3111  Out << ' ';
3112  writeOperand(Operand, false);
3113  Out << '(';
3114  for (unsigned op = 0, Eop = CI->getNumArgOperands(); op < Eop; ++op) {
3115  if (op > 0)
3116  Out << ", ";
3117  writeParamOperand(CI->getArgOperand(op), PAL.getParamAttributes(op));
3118  }
3119 
3120  // Emit an ellipsis if this is a musttail call in a vararg function. This
3121  // is only to aid readability, musttail calls forward varargs by default.
3122  if (CI->isMustTailCall() && CI->getParent() &&
3123  CI->getParent()->getParent() &&
3124  CI->getParent()->getParent()->isVarArg())
3125  Out << ", ...";
3126 
3127  Out << ')';
3129  Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
3130 
3131  writeOperandBundles(CI);
3132  } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
3133  Operand = II->getCalledValue();
3134  FunctionType *FTy = II->getFunctionType();
3135  Type *RetTy = FTy->getReturnType();
3136  const AttributeList &PAL = II->getAttributes();
3137 
3138  // Print the calling convention being used.
3139  if (II->getCallingConv() != CallingConv::C) {
3140  Out << " ";
3141  PrintCallingConv(II->getCallingConv(), Out);
3142  }
3143 
3145  Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
3146 
3147  // If possible, print out the short form of the invoke instruction. We can
3148  // only do this if the first argument is a pointer to a nonvararg function,
3149  // and if the return type is not a pointer to a function.
3150  //
3151  Out << ' ';
3152  TypePrinter.print(FTy->isVarArg() ? FTy : RetTy, Out);
3153  Out << ' ';
3154  writeOperand(Operand, false);
3155  Out << '(';
3156  for (unsigned op = 0, Eop = II->getNumArgOperands(); op < Eop; ++op) {
3157  if (op)
3158  Out << ", ";
3159  writeParamOperand(II->getArgOperand(op), PAL.getParamAttributes(op));
3160  }
3161 
3162  Out << ')';
3164  Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
3165 
3166  writeOperandBundles(II);
3167 
3168  Out << "\n to ";
3169  writeOperand(II->getNormalDest(), true);
3170  Out << " unwind ";
3171  writeOperand(II->getUnwindDest(), true);
3172  } else if (const AllocaInst *AI = dyn_cast<AllocaInst>(&I)) {
3173  Out << ' ';
3174  if (AI->isUsedWithInAlloca())
3175  Out << "inalloca ";
3176  if (AI->isSwiftError())
3177  Out << "swifterror ";
3178  TypePrinter.print(AI->getAllocatedType(), Out);
3179 
3180  // Explicitly write the array size if the code is broken, if it's an array
3181  // allocation, or if the type is not canonical for scalar allocations. The
3182  // latter case prevents the type from mutating when round-tripping through
3183  // assembly.
3184  if (!AI->getArraySize() || AI->isArrayAllocation() ||
3185  !AI->getArraySize()->getType()->isIntegerTy(32)) {
3186  Out << ", ";
3187  writeOperand(AI->getArraySize(), true);
3188  }
3189  if (AI->getAlignment()) {
3190  Out << ", align " << AI->getAlignment();
3191  }
3192 
3193  unsigned AddrSpace = AI->getType()->getAddressSpace();
3194  if (AddrSpace != 0) {
3195  Out << ", addrspace(" << AddrSpace << ')';
3196  }
3197  } else if (isa<CastInst>(I)) {
3198  if (Operand) {
3199  Out << ' ';
3200  writeOperand(Operand, true); // Work with broken code
3201  }
3202  Out << " to ";
3203  TypePrinter.print(I.getType(), Out);
3204  } else if (isa<VAArgInst>(I)) {
3205  if (Operand) {
3206  Out << ' ';
3207  writeOperand(Operand, true); // Work with broken code
3208  }
3209  Out << ", ";
3210  TypePrinter.print(I.getType(), Out);
3211  } else if (Operand) { // Print the normal way.
3212  if (const auto *GEP = dyn_cast<GetElementPtrInst>(&I)) {
3213  Out << ' ';
3214  TypePrinter.print(GEP->getSourceElementType(), Out);
3215  Out << ',';
3216  } else if (const auto *LI = dyn_cast<LoadInst>(&I)) {
3217  Out << ' ';
3218  TypePrinter.print(LI->getType(), Out);
3219  Out << ',';
3220  }
3221 
3222  // PrintAllTypes - Instructions who have operands of all the same type
3223  // omit the type from all but the first operand. If the instruction has
3224  // different type operands (for example br), then they are all printed.
3225  bool PrintAllTypes = false;
3226  Type *TheType = Operand->getType();
3227 
3228  // Select, Store and ShuffleVector always print all types.
3229  if (isa<SelectInst>(I) || isa<StoreInst>(I) || isa<ShuffleVectorInst>(I)
3230  || isa<ReturnInst>(I)) {
3231  PrintAllTypes = true;
3232  } else {
3233  for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) {
3234  Operand = I.getOperand(i);
3235  // note that Operand shouldn't be null, but the test helps make dump()
3236  // more tolerant of malformed IR
3237  if (Operand && Operand->getType() != TheType) {
3238  PrintAllTypes = true; // We have differing types! Print them all!
3239  break;
3240  }
3241  }
3242  }
3243 
3244  if (!PrintAllTypes) {
3245  Out << ' ';
3246  TypePrinter.print(TheType, Out);
3247  }
3248 
3249  Out << ' ';
3250  for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) {
3251  if (i) Out << ", ";
3252  writeOperand(I.getOperand(i), PrintAllTypes);
3253  }
3254  }
3255 
3256  // Print atomic ordering/alignment for memory operations
3257  if (const LoadInst *LI = dyn_cast<LoadInst>(&I)) {
3258  if (LI->isAtomic())
3259  writeAtomic(LI->getContext(), LI->getOrdering(), LI->getSyncScopeID());
3260  if (LI->getAlignment())
3261  Out << ", align " << LI->getAlignment();
3262  } else if (const StoreInst *SI = dyn_cast<StoreInst>(&I)) {
3263  if (SI->isAtomic())
3264  writeAtomic(SI->getContext(), SI->getOrdering(), SI->getSyncScopeID());
3265  if (SI->getAlignment())
3266  Out << ", align " << SI->getAlignment();
3267  } else if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(&I)) {
3268  writeAtomicCmpXchg(CXI->getContext(), CXI->getSuccessOrdering(),
3269  CXI->getFailureOrdering(), CXI->getSyncScopeID());
3270  } else if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(&I)) {
3271  writeAtomic(RMWI->getContext(), RMWI->getOrdering(),
3272  RMWI->getSyncScopeID());
3273  } else if (const FenceInst *FI = dyn_cast<FenceInst>(&I)) {
3274  writeAtomic(FI->getContext(), FI->getOrdering(), FI->getSyncScopeID());
3275  }
3276 
3277  // Print Metadata info.
3279  I.getAllMetadata(InstMD);
3280  printMetadataAttachments(InstMD, ", ");
3281 
3282  // Print a nice comment.
3283  printInfoComment(I);
3284 }
3285 
3286 void AssemblyWriter::printMetadataAttachments(
3287  const SmallVectorImpl<std::pair<unsigned, MDNode *>> &MDs,
3288  StringRef Separator) {
3289  if (MDs.empty())
3290  return;
3291 
3292  if (MDNames.empty())
3293  MDs[0].second->getContext().getMDKindNames(MDNames);
3294 
3295  for (const auto &I : MDs) {
3296  unsigned Kind = I.first;
3297  Out << Separator;
3298  if (Kind < MDNames.size()) {
3299  Out << "!";
3300  printMetadataIdentifier(MDNames[Kind], Out);
3301  } else
3302  Out << "!<unknown kind #" << Kind << ">";
3303  Out << ' ';
3304  WriteAsOperandInternal(Out, I.second, &TypePrinter, &Machine, TheModule);
3305  }
3306 }
3307 
3308 void AssemblyWriter::writeMDNode(unsigned Slot, const MDNode *Node) {
3309  Out << '!' << Slot << " = ";
3310  printMDNodeBody(Node);
3311  Out << "\n";
3312 }
3313 
3314 void AssemblyWriter::writeAllMDNodes() {
3316  Nodes.resize(Machine.mdn_size());
3317  for (SlotTracker::mdn_iterator I = Machine.mdn_begin(), E = Machine.mdn_end();
3318  I != E; ++I)
3319  Nodes[I->second] = cast<MDNode>(I->first);
3320 
3321  for (unsigned i = 0, e = Nodes.size(); i != e; ++i) {
3322  writeMDNode(i, Nodes[i]);
3323  }
3324 }
3325 
3326 void AssemblyWriter::printMDNodeBody(const MDNode *Node) {
3327  WriteMDNodeBodyInternal(Out, Node, &TypePrinter, &Machine, TheModule);
3328 }
3329 
3330 void AssemblyWriter::writeAllAttributeGroups() {
3331  std::vector<std::pair<AttributeSet, unsigned>> asVec;
3332  asVec.resize(Machine.as_size());
3333 
3334  for (SlotTracker::as_iterator I = Machine.as_begin(), E = Machine.as_end();
3335  I != E; ++I)
3336  asVec[I->second] = *I;
3337 
3338  for (const auto &I : asVec)
3339  Out << "attributes #" << I.second << " = { "
3340  << I.first.getAsString(true) << " }\n";
3341 }
3342 
3343 void AssemblyWriter::printUseListOrder(const UseListOrder &Order) {
3344  bool IsInFunction = Machine.getFunction();
3345  if (IsInFunction)
3346  Out << " ";
3347 
3348  Out << "uselistorder";
3349  if (const BasicBlock *BB =
3350  IsInFunction ? nullptr : dyn_cast<BasicBlock>(Order.V)) {
3351  Out << "_bb ";
3352  writeOperand(BB->getParent(), false);
3353  Out << ", ";
3354  writeOperand(BB, false);
3355  } else {
3356  Out << " ";
3357  writeOperand(Order.V, true);
3358  }
3359  Out << ", { ";
3360 
3361  assert(Order.Shuffle.size() >= 2 && "Shuffle too small");
3362  Out << Order.Shuffle[0];
3363  for (unsigned I = 1, E = Order.Shuffle.size(); I != E; ++I)
3364  Out << ", " << Order.Shuffle[I];
3365  Out << " }\n";
3366 }
3367 
3368 void AssemblyWriter::printUseLists(const Function *F) {
3369  auto hasMore =
3370  [&]() { return !UseListOrders.empty() && UseListOrders.back().F == F; };
3371  if (!hasMore())
3372  // Nothing to do.
3373  return;
3374 
3375  Out << "\n; uselistorder directives\n";
3376  while (hasMore()) {
3377  printUseListOrder(UseListOrders.back());
3378  UseListOrders.pop_back();
3379  }
3380 }
3381 
3382 //===----------------------------------------------------------------------===//
3383 // External Interface declarations
3384 //===----------------------------------------------------------------------===//
3385 
3387  bool ShouldPreserveUseListOrder,
3388  bool IsForDebug) const {
3389  SlotTracker SlotTable(this->getParent());
3390  formatted_raw_ostream OS(ROS);
3391  AssemblyWriter W(OS, SlotTable, this->getParent(), AAW,
3392  IsForDebug,
3393  ShouldPreserveUseListOrder);
3394  W.printFunction(this);
3395 }
3396 
3398  bool ShouldPreserveUseListOrder, bool IsForDebug) const {
3399  SlotTracker SlotTable(this);
3400  formatted_raw_ostream OS(ROS);
3401  AssemblyWriter W(OS, SlotTable, this, AAW, IsForDebug,
3402  ShouldPreserveUseListOrder);
3403  W.printModule(this);
3404 }
3405 
3406 void NamedMDNode::print(raw_ostream &ROS, bool IsForDebug) const {
3407  SlotTracker SlotTable(getParent());
3408  formatted_raw_ostream OS(ROS);
3409  AssemblyWriter W(OS, SlotTable, getParent(), nullptr, IsForDebug);
3410  W.printNamedMDNode(this);
3411 }
3412 
3414  bool IsForDebug) const {
3415  Optional<SlotTracker> LocalST;
3416  SlotTracker *SlotTable;
3417  if (auto *ST = MST.getMachine())
3418  SlotTable = ST;
3419  else {
3420  LocalST.emplace(getParent());
3421  SlotTable = &*LocalST;
3422  }
3423 
3424  formatted_raw_ostream OS(ROS);
3425  AssemblyWriter W(OS, *SlotTable, getParent(), nullptr, IsForDebug);
3426  W.printNamedMDNode(this);
3427 }
3428 
3429 void Comdat::print(raw_ostream &ROS, bool /*IsForDebug*/) const {
3431  ROS << " = comdat ";
3432 
3433  switch (getSelectionKind()) {
3434  case Comdat::Any:
3435  ROS << "any";
3436  break;
3437  case Comdat::ExactMatch:
3438  ROS << "exactmatch";
3439  break;
3440  case Comdat::Largest:
3441  ROS << "largest";
3442  break;
3443  case Comdat::NoDuplicates:
3444  ROS << "noduplicates";
3445  break;
3446  case Comdat::SameSize:
3447  ROS << "samesize";
3448  break;
3449  }
3450 
3451  ROS << '\n';
3452 }
3453 
3454 void Type::print(raw_ostream &OS, bool /*IsForDebug*/, bool NoDetails) const {
3455  TypePrinting TP;
3456  TP.print(const_cast<Type*>(this), OS);
3457 
3458  if (NoDetails)
3459  return;
3460 
3461  // If the type is a named struct type, print the body as well.
3462  if (StructType *STy = dyn_cast<StructType>(const_cast<Type*>(this)))
3463  if (!STy->isLiteral()) {
3464  OS << " = type ";
3465  TP.printStructBody(STy, OS);
3466  }
3467 }
3468 
3469 static bool isReferencingMDNode(const Instruction &I) {
3470  if (const auto *CI = dyn_cast<CallInst>(&I))
3471  if (Function *F = CI->getCalledFunction())
3472  if (F->isIntrinsic())
3473  for (auto &Op : I.operands())
3474  if (auto *V = dyn_cast_or_null<MetadataAsValue>(Op))
3475  if (isa<MDNode>(V->getMetadata()))
3476  return true;
3477  return false;
3478 }
3479 
3480 void Value::print(raw_ostream &ROS, bool IsForDebug) const {
3481  bool ShouldInitializeAllMetadata = false;
3482  if (auto *I = dyn_cast<Instruction>(this))
3483  ShouldInitializeAllMetadata = isReferencingMDNode(*I);
3484  else if (isa<Function>(this) || isa<MetadataAsValue>(this))
3485  ShouldInitializeAllMetadata = true;
3486 
3487  ModuleSlotTracker MST(getModuleFromVal(this), ShouldInitializeAllMetadata);
3488  print(ROS, MST, IsForDebug);
3489 }
3490 
3492  bool IsForDebug) const {
3493  formatted_raw_ostream OS(ROS);
3494  SlotTracker EmptySlotTable(static_cast<const Module *>(nullptr));
3495  SlotTracker &SlotTable =
3496  MST.getMachine() ? *MST.getMachine() : EmptySlotTable;
3497  auto incorporateFunction = [&](const Function *F) {
3498  if (F)
3499  MST.incorporateFunction(*F);
3500  };
3501 
3502  if (const Instruction *I = dyn_cast<Instruction>(this)) {
3503  incorporateFunction(I->getParent() ? I->getParent()->getParent() : nullptr);
3504  AssemblyWriter W(OS, SlotTable, getModuleFromVal(I), nullptr, IsForDebug);
3505  W.printInstruction(*I);
3506  } else if (const BasicBlock *BB = dyn_cast<BasicBlock>(this)) {
3507  incorporateFunction(BB->getParent());
3508  AssemblyWriter W(OS, SlotTable, getModuleFromVal(BB), nullptr, IsForDebug);
3509  W.printBasicBlock(BB);
3510  } else if (const GlobalValue *GV = dyn_cast<GlobalValue>(this)) {
3511  AssemblyWriter W(OS, SlotTable, GV->getParent(), nullptr, IsForDebug);
3512  if (const GlobalVariable *V = dyn_cast<GlobalVariable>(GV))
3513  W.printGlobal(V);
3514  else if (const Function *F = dyn_cast<Function>(GV))
3515  W.printFunction(F);
3516  else
3517  W.printIndirectSymbol(cast<GlobalIndirectSymbol>(GV));
3518  } else if (const MetadataAsValue *V = dyn_cast<MetadataAsValue>(this)) {
3519  V->getMetadata()->print(ROS, MST, getModuleFromVal(V));
3520  } else if (const Constant *C = dyn_cast<Constant>(this)) {
3521  TypePrinting TypePrinter;
3522  TypePrinter.print(C->getType(), OS);
3523  OS << ' ';
3524  WriteConstantInternal(OS, C, TypePrinter, MST.getMachine(), nullptr);
3525  } else if (isa<InlineAsm>(this) || isa<Argument>(this)) {
3526  this->printAsOperand(OS, /* PrintType */ true, MST);
3527  } else {
3528  llvm_unreachable("Unknown value to print out!");
3529  }
3530 }
3531 
3532 /// Print without a type, skipping the TypePrinting object.
3533 ///
3534 /// \return \c true iff printing was successful.
3535 static bool printWithoutType(const Value &V, raw_ostream &O,
3536  SlotTracker *Machine, const Module *M) {
3537  if (V.hasName() || isa<GlobalValue>(V) ||
3538  (!isa<Constant>(V) && !isa<MetadataAsValue>(V))) {
3539  WriteAsOperandInternal(O, &V, nullptr, Machine, M);
3540  return true;
3541  }
3542  return false;
3543 }
3544 
3545 static void printAsOperandImpl(const Value &V, raw_ostream &O, bool PrintType,
3546  ModuleSlotTracker &MST) {
3547  TypePrinting TypePrinter;
3548  if (const Module *M = MST.getModule())
3549  TypePrinter.incorporateTypes(*M);
3550  if (PrintType) {
3551  TypePrinter.print(V.getType(), O);
3552  O << ' ';
3553  }
3554 
3555  WriteAsOperandInternal(O, &V, &TypePrinter, MST.getMachine(),
3556  MST.getModule());
3557 }
3558 
3559 void Value::printAsOperand(raw_ostream &O, bool PrintType,
3560  const Module *M) const {
3561  if (!M)
3562  M = getModuleFromVal(this);
3563 
3564  if (!PrintType)
3565  if (printWithoutType(*this, O, nullptr, M))
3566  return;
3567 
3569  M, /* ShouldInitializeAllMetadata */ isa<MetadataAsValue>(this));
3570  ModuleSlotTracker MST(Machine, M);
3571  printAsOperandImpl(*this, O, PrintType, MST);
3572 }
3573 
3574 void Value::printAsOperand(raw_ostream &O, bool PrintType,
3575  ModuleSlotTracker &MST) const {
3576  if (!PrintType)
3577  if (printWithoutType(*this, O, MST.getMachine(), MST.getModule()))
3578  return;
3579 
3580  printAsOperandImpl(*this, O, PrintType, MST);
3581 }
3582 
3583 static void printMetadataImpl(raw_ostream &ROS, const Metadata &MD,
3584  ModuleSlotTracker &MST, const Module *M,
3585  bool OnlyAsOperand) {
3586  formatted_raw_ostream OS(ROS);
3587 
3588  TypePrinting TypePrinter;
3589  if (M)
3590  TypePrinter.incorporateTypes(*M);
3591 
3592  WriteAsOperandInternal(OS, &MD, &TypePrinter, MST.getMachine(), M,
3593  /* FromValue */ true);
3594 
3595  auto *N = dyn_cast<MDNode>(&MD);
3596  if (OnlyAsOperand || !N || isa<DIExpression>(MD))
3597  return;
3598 
3599  OS << " = ";
3600  WriteMDNodeBodyInternal(OS, N, &TypePrinter, MST.getMachine(), M);
3601 }
3602 
3603 void Metadata::printAsOperand(raw_ostream &OS, const Module *M) const {
3604  ModuleSlotTracker MST(M, isa<MDNode>(this));
3605  printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ true);
3606 }
3607 
3609  const Module *M) const {
3610  printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ true);
3611 }
3612 
3614  bool /*IsForDebug*/) const {
3615  ModuleSlotTracker MST(M, isa<MDNode>(this));
3616  printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
3617 }
3618 
3620  const Module *M, bool /*IsForDebug*/) const {
3621  printMetadataImpl(OS, *this, MST, M, /* OnlyAsOperand */ false);
3622 }
3623 
3624 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
3625 // Value::dump - allow easy printing of Values from the debugger.
3627 void Value::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
3628 
3629 // Type::dump - allow easy printing of Types from the debugger.
3631 void Type::dump() const { print(dbgs(), /*IsForDebug=*/true); dbgs() << '\n'; }
3632 
3633 // Module::dump() - Allow printing of Modules from the debugger.
3635 void Module::dump() const {
3636  print(dbgs(), nullptr,
3637  /*ShouldPreserveUseListOrder=*/false, /*IsForDebug=*/true);
3638 }
3639 
3640 // \brief Allow printing of Comdats from the debugger.
3642 void Comdat::dump() const { print(dbgs(), /*IsForDebug=*/true); }
3643 
3644 // NamedMDNode::dump() - Allow printing of NamedMDNodes from the debugger.
3646 void NamedMDNode::dump() const { print(dbgs(), /*IsForDebug=*/true); }
3647 
3649 void Metadata::dump() const { dump(nullptr); }
3650 
3652 void Metadata::dump(const Module *M) const {
3653  print(dbgs(), M, /*IsForDebug=*/true);
3654  dbgs() << '\n';
3655 }
3656 #endif
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type.
Calling convention used for Mesa hull shaders.
Definition: CallingConv.h:206
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:180
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:1107
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.
This class represents an incoming formal argument to a Function.
Definition: Argument.h:30
Calling convention used by HipHop Virtual Machine (HHVM) to perform calls to and from translation cac...
Definition: CallingConv.h:164
void purgeFunction()
After calling incorporateFunction, use this method to remove the most recently incorporated function ...
Definition: AsmWriter.cpp:967
LLVMContext & Context
static bool printWithoutType(const Value &V, raw_ostream &O, SlotTracker *Machine, const Module *M)
Print without a type, skipping the TypePrinting object.
Definition: AsmWriter.cpp:3535
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
X86_ThisCall - Similar to X86_StdCall.
Definition: CallingConv.h:111
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:2523
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
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
Available for inspection, not emission.
Definition: GlobalValue.h:50
Register calling convention used for parameters transfer optimization.
Definition: CallingConv.h:202
static void writeAtomicRMWOperation(raw_ostream &Out, AtomicRMWInst::BinOp Op)
Definition: AsmWriter.cpp:1089
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
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
MSVC calling convention that passes vectors and vector aggregates in SSE registers.
Definition: CallingConv.h:158
static void PrintDLLStorageClass(GlobalValue::DLLStorageClassTypes SCT, formatted_raw_ostream &Out)
Definition: AsmWriter.cpp:2494
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:652
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
F(f)
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
12: Functions
Definition: Type.h:72
*p = old >signed v ? old : v
Definition: Instructions.h:705
Calling convention used for Mesa compute shaders.
Definition: CallingConv.h:196
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
Tentative definitions.
Definition: GlobalValue.h:59
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:2457
C - The default llvm calling convention, compatible with C.
Definition: CallingConv.h:35
void dump() const
Support for debugging, callable in GDB: V->dump()
Definition: AsmWriter.cpp:3627
The address of a basic block.
Definition: Constants.h:813
A tuple of MDNodes.
Definition: Metadata.h:1323
bool hasPrefixData() const
Check whether this function has prefix data.
Definition: Function.h:643
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
The C convention as specified in the x86-64 supplement to the System V ABI, used on most non-Windows ...
Definition: CallingConv.h:144
static void printMetadataImpl(raw_ostream &ROS, const Metadata &MD, ModuleSlotTracker &MST, const Module *M, bool OnlyAsOperand)
Definition: AsmWriter.cpp:3583
const Value * V
Definition: UseListOrder.h:28
TypeID getTypeID() const
Return the type id for the type.
Definition: Type.h:138
ARM_APCS - ARM Procedure Calling Standard calling convention (obsolete, but still used on some target...
Definition: CallingConv.h:96
MSP430_INTR - Calling convention used for MSP430 interrupt routines.
Definition: CallingConv.h:106
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_AAPCS - ARM Architecture Procedure Calling Standard calling convention (aka EABI).
Definition: CallingConv.h:100
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:2411
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.
X86_INTR - x86 hardware interrupt context.
Definition: CallingConv.h:174
void dump() const
Definition: AsmWriter.cpp:3642
bool hasExternalLinkage() const
Definition: GlobalValue.h:402
Class to represent function types.
Definition: DerivedTypes.h:103
bool isInfinity() const
Definition: APFloat.h:1129
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
reverse_iterator rend()
Definition: Module.h:578
opStatus convert(const fltSemantics &ToSemantics, roundingMode RM, bool *losesInfo)
Definition: APFloat.cpp:4438
X86_FastCall - &#39;fast&#39; analog of X86_StdCall.
Definition: CallingConv.h:92
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:3386
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:205
An instruction for storing to memory.
Definition: Instructions.h:306
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:634
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:2485
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
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
Calling convention used for Mesa vertex shaders.
Definition: CallingConv.h:187
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
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:572
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:150
No other Module may specify this COMDAT.
Definition: Comdat.h:35
Synchronized with respect to all concurrently executing threads.
Definition: LLVMContext.h:59
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:3429
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:69
Conditional or Unconditional Branch instruction.
const char * getOpcodeName() const
Definition: Instruction.h:127
bool isNaN() const
Definition: APFloat.h:1130
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:42
Calling convention used for AVR signal routines.
Definition: CallingConv.h:180
ArrayRef< Use > Inputs
Definition: InstrTypes.h:1170
void dump() const
Dump the module to stderr (for debugging).
Definition: AsmWriter.cpp:3635
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:116
static StringRef getPredicateName(Predicate P)
This file contains the declarations for the subclasses of Constant, which represent the different fla...
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:3406
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
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
static void WriteAsOperandInternal(raw_ostream &Out, const Value *V, TypePrinting *TypePrinter, SlotTracker *Machine, const Module *Context)
Definition: AsmWriter.cpp:1999
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:517
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:3480
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
static void printAsOperandImpl(const Value &V, raw_ostream &O, bool PrintType, ModuleSlotTracker &MST)
Definition: AsmWriter.cpp:3545
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
bool isMaterializable() const
Definition: Function.h:160
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
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
Calling convention used for Mesa geometry shaders.
Definition: CallingConv.h:190
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:2503
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:3559
PTX_Device - Call to a PTX device function.
Definition: CallingConv.h:119
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
SPIR_KERNEL - Calling convention for SPIR kernel functions.
Definition: CallingConv.h:137
unsigned first
void dump() const
Definition: AsmWriter.cpp:3631
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:3397
PTX_Kernel - Call to a PTX kernel.
Definition: CallingConv.h:115
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:3613
static const fltSemantics & IEEEsingle() LLVM_READNONE
Definition: APFloat.cpp:119
unsigned getNumOperands() const
Definition: User.h:176
std::string getAsString(bool InAttrGrp=false) const
Definition: Attributes.cpp:610
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:533
16: SIMD &#39;packed&#39; format, or other vector type
Definition: Type.h:76
Intel_OCL_BI - Calling conventions for Intel OpenCL built-ins.
Definition: CallingConv.h:140
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:194
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
HHVM calling convention for invoking C/C++ helpers.
Definition: CallingConv.h:167
SPIR_FUNC - Calling convention for SPIR non-kernel device functions.
Definition: CallingConv.h:129
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:1142
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:211
X86_StdCall - stdcall is the calling conventions mostly used by the Win32 API.
Definition: CallingConv.h:87
Type * getReturnType() const
Definition: DerivedTypes.h:124
The C convention as implemented on Windows/x86-64 and AArch64.
Definition: CallingConv.h:154
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:3469
DWARF expression.
void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode *>> &MDs) const
Get all metadata attached to this Instruction.
Definition: Instruction.h:210
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:145
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
This file contains constants used for implementing Dwarf debug support.
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
amdgpu Simplify well known AMD library false Value Value * Arg
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
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:286
unsigned getNumOperandBundles() const
Definition: CallSite.h:513
Fast - This calling convention attempts to make calls as fast as possible (e.g.
Definition: CallingConv.h:43
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:3454
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:61
Used for AVR interrupt routines.
Definition: CallingConv.h:177
static void writeDIExpression(raw_ostream &Out, const DIExpression *N, TypePrinting *TypePrinter, SlotTracker *Machine, const Module *Context)
Definition: AsmWriter.cpp:1915
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:695
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:210
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
void dump() const
User-friendly dump.
Definition: AsmWriter.cpp:3649
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:2535
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
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:1977
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:181
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
Calling convention for AMDGPU code object kernels.
Definition: CallingConv.h:199
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:3603
Calling convention used for Mesa pixel shaders.
Definition: CallingConv.h:193
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
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.
Type * getElementType() const
Definition: DerivedTypes.h:360
iterator_range< global_iterator > globals()
Definition: Module.h:561
IRTranslator LLVM IR MI
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
ARM_AAPCS_VFP - Same as ARM_AAPCS, but uses hard floating point ABI.
Definition: CallingConv.h:103
A single uniqued string.
Definition: Metadata.h:602
void dump() const
Definition: AsmWriter.cpp:3646
APInt bitcastToAPInt() const
Definition: APFloat.h:1094
void sort(Policy policy, RandomAccessIterator Start, RandomAccessIterator End, const Comparator &Comp=Comparator())
Definition: Parallel.h:199
Value * getBasePtr() const
Definition: Statepoint.h:397
static bool isVolatile(Instruction *Inst)
9: MMX vectors (64 bits, X86 specific)
Definition: Type.h:66
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:1343
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:621
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