LLVM  14.0.0git
LLVMContextImpl.h
Go to the documentation of this file.
1 //===- LLVMContextImpl.h - The LLVMContextImpl opaque class -----*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file declares LLVMContextImpl, the opaque implementation
10 // of LLVMContext.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_LIB_IR_LLVMCONTEXTIMPL_H
15 #define LLVM_LIB_IR_LLVMCONTEXTIMPL_H
16 
17 #include "AttributeImpl.h"
18 #include "ConstantsContext.h"
19 #include "llvm/ADT/APFloat.h"
20 #include "llvm/ADT/APInt.h"
21 #include "llvm/ADT/ArrayRef.h"
22 #include "llvm/ADT/DenseMap.h"
23 #include "llvm/ADT/DenseMapInfo.h"
24 #include "llvm/ADT/DenseSet.h"
25 #include "llvm/ADT/FoldingSet.h"
26 #include "llvm/ADT/Hashing.h"
27 #include "llvm/ADT/Optional.h"
28 #include "llvm/ADT/STLExtras.h"
29 #include "llvm/ADT/SmallPtrSet.h"
30 #include "llvm/ADT/SmallVector.h"
31 #include "llvm/ADT/StringMap.h"
33 #include "llvm/IR/Constants.h"
35 #include "llvm/IR/DerivedTypes.h"
36 #include "llvm/IR/LLVMContext.h"
38 #include "llvm/IR/Metadata.h"
39 #include "llvm/IR/TrackingMDRef.h"
40 #include "llvm/Support/Allocator.h"
41 #include "llvm/Support/Casting.h"
44 #include <algorithm>
45 #include <cassert>
46 #include <cstddef>
47 #include <cstdint>
48 #include <memory>
49 #include <string>
50 #include <utility>
51 #include <vector>
52 
53 namespace llvm {
54 
55 class StringRef;
56 class Type;
57 class Value;
58 class ValueHandleBase;
59 
61 
63  static inline APFloat getEmptyKey() { return APFloat(APFloat::Bogus(), 1); }
64  static inline APFloat getTombstoneKey() { return APFloat(APFloat::Bogus(), 2); }
65 
66  static unsigned getHashValue(const APFloat &Key) {
67  return static_cast<unsigned>(hash_value(Key));
68  }
69 
70  static bool isEqual(const APFloat &LHS, const APFloat &RHS) {
71  return LHS.bitwiseIsEqual(RHS);
72  }
73 };
74 
76  struct KeyTy {
78  bool isPacked;
79 
80  KeyTy(const ArrayRef<Type*>& E, bool P) :
81  ETypes(E), isPacked(P) {}
82 
84  : ETypes(ST->elements()), isPacked(ST->isPacked()) {}
85 
86  bool operator==(const KeyTy& that) const {
87  if (isPacked != that.isPacked)
88  return false;
89  if (ETypes != that.ETypes)
90  return false;
91  return true;
92  }
93  bool operator!=(const KeyTy& that) const {
94  return !this->operator==(that);
95  }
96  };
97 
98  static inline StructType* getEmptyKey() {
100  }
101 
102  static inline StructType* getTombstoneKey() {
104  }
105 
106  static unsigned getHashValue(const KeyTy& Key) {
107  return hash_combine(hash_combine_range(Key.ETypes.begin(),
108  Key.ETypes.end()),
109  Key.isPacked);
110  }
111 
112  static unsigned getHashValue(const StructType *ST) {
113  return getHashValue(KeyTy(ST));
114  }
115 
116  static bool isEqual(const KeyTy& LHS, const StructType *RHS) {
117  if (RHS == getEmptyKey() || RHS == getTombstoneKey())
118  return false;
119  return LHS == KeyTy(RHS);
120  }
121 
122  static bool isEqual(const StructType *LHS, const StructType *RHS) {
123  return LHS == RHS;
124  }
125 };
126 
128  struct KeyTy {
129  const Type *ReturnType;
131  bool isVarArg;
132 
133  KeyTy(const Type* R, const ArrayRef<Type*>& P, bool V) :
134  ReturnType(R), Params(P), isVarArg(V) {}
135  KeyTy(const FunctionType *FT)
136  : ReturnType(FT->getReturnType()), Params(FT->params()),
137  isVarArg(FT->isVarArg()) {}
138 
139  bool operator==(const KeyTy& that) const {
140  if (ReturnType != that.ReturnType)
141  return false;
142  if (isVarArg != that.isVarArg)
143  return false;
144  if (Params != that.Params)
145  return false;
146  return true;
147  }
148  bool operator!=(const KeyTy& that) const {
149  return !this->operator==(that);
150  }
151  };
152 
153  static inline FunctionType* getEmptyKey() {
155  }
156 
157  static inline FunctionType* getTombstoneKey() {
159  }
160 
161  static unsigned getHashValue(const KeyTy& Key) {
162  return hash_combine(Key.ReturnType,
163  hash_combine_range(Key.Params.begin(),
164  Key.Params.end()),
165  Key.isVarArg);
166  }
167 
168  static unsigned getHashValue(const FunctionType *FT) {
169  return getHashValue(KeyTy(FT));
170  }
171 
172  static bool isEqual(const KeyTy& LHS, const FunctionType *RHS) {
173  if (RHS == getEmptyKey() || RHS == getTombstoneKey())
174  return false;
175  return LHS == KeyTy(RHS);
176  }
177 
178  static bool isEqual(const FunctionType *LHS, const FunctionType *RHS) {
179  return LHS == RHS;
180  }
181 };
182 
183 /// Structure for hashing arbitrary MDNode operands.
185  ArrayRef<Metadata *> RawOps;
187  unsigned Hash;
188 
189 protected:
191  : RawOps(Ops), Hash(calculateHash(Ops)) {}
192 
193  template <class NodeTy>
194  MDNodeOpsKey(const NodeTy *N, unsigned Offset = 0)
195  : Ops(N->op_begin() + Offset, N->op_end()), Hash(N->getHash()) {}
196 
197  template <class NodeTy>
198  bool compareOps(const NodeTy *RHS, unsigned Offset = 0) const {
199  if (getHash() != RHS->getHash())
200  return false;
201 
202  assert((RawOps.empty() || Ops.empty()) && "Two sets of operands?");
203  return RawOps.empty() ? compareOps(Ops, RHS, Offset)
204  : compareOps(RawOps, RHS, Offset);
205  }
206 
207  static unsigned calculateHash(MDNode *N, unsigned Offset = 0);
208 
209 private:
210  template <class T>
211  static bool compareOps(ArrayRef<T> Ops, const MDNode *RHS, unsigned Offset) {
212  if (Ops.size() != RHS->getNumOperands() - Offset)
213  return false;
214  return std::equal(Ops.begin(), Ops.end(), RHS->op_begin() + Offset);
215  }
216 
217  static unsigned calculateHash(ArrayRef<Metadata *> Ops);
218 
219 public:
220  unsigned getHash() const { return Hash; }
221 };
222 
223 template <class NodeTy> struct MDNodeKeyImpl;
224 
225 /// Configuration point for MDNodeInfo::isEqual().
226 template <class NodeTy> struct MDNodeSubsetEqualImpl {
228 
229  static bool isSubsetEqual(const KeyTy &LHS, const NodeTy *RHS) {
230  return false;
231  }
232 
233  static bool isSubsetEqual(const NodeTy *LHS, const NodeTy *RHS) {
234  return false;
235  }
236 };
237 
238 /// DenseMapInfo for MDTuple.
239 ///
240 /// Note that we don't need the is-function-local bit, since that's implicit in
241 /// the operands.
242 template <> struct MDNodeKeyImpl<MDTuple> : MDNodeOpsKey {
245 
246  bool isKeyOf(const MDTuple *RHS) const { return compareOps(RHS); }
247 
248  unsigned getHashValue() const { return getHash(); }
249 
250  static unsigned calculateHash(MDTuple *N) {
252  }
253 };
254 
255 /// DenseMapInfo for DILocation.
256 template <> struct MDNodeKeyImpl<DILocation> {
257  unsigned Line;
258  unsigned Column;
262 
263  MDNodeKeyImpl(unsigned Line, unsigned Column, Metadata *Scope,
264  Metadata *InlinedAt, bool ImplicitCode)
265  : Line(Line), Column(Column), Scope(Scope), InlinedAt(InlinedAt),
266  ImplicitCode(ImplicitCode) {}
268  : Line(L->getLine()), Column(L->getColumn()), Scope(L->getRawScope()),
269  InlinedAt(L->getRawInlinedAt()), ImplicitCode(L->isImplicitCode()) {}
270 
271  bool isKeyOf(const DILocation *RHS) const {
272  return Line == RHS->getLine() && Column == RHS->getColumn() &&
273  Scope == RHS->getRawScope() && InlinedAt == RHS->getRawInlinedAt() &&
274  ImplicitCode == RHS->isImplicitCode();
275  }
276 
277  unsigned getHashValue() const {
278  return hash_combine(Line, Column, Scope, InlinedAt, ImplicitCode);
279  }
280 };
281 
282 /// DenseMapInfo for GenericDINode.
283 template <> struct MDNodeKeyImpl<GenericDINode> : MDNodeOpsKey {
284  unsigned Tag;
286 
287  MDNodeKeyImpl(unsigned Tag, MDString *Header, ArrayRef<Metadata *> DwarfOps)
288  : MDNodeOpsKey(DwarfOps), Tag(Tag), Header(Header) {}
290  : MDNodeOpsKey(N, 1), Tag(N->getTag()), Header(N->getRawHeader()) {}
291 
292  bool isKeyOf(const GenericDINode *RHS) const {
293  return Tag == RHS->getTag() && Header == RHS->getRawHeader() &&
294  compareOps(RHS, 1);
295  }
296 
297  unsigned getHashValue() const { return hash_combine(getHash(), Tag, Header); }
298 
299  static unsigned calculateHash(GenericDINode *N) {
300  return MDNodeOpsKey::calculateHash(N, 1);
301  }
302 };
303 
304 template <> struct MDNodeKeyImpl<DISubrange> {
309 
310  MDNodeKeyImpl(Metadata *CountNode, Metadata *LowerBound, Metadata *UpperBound,
311  Metadata *Stride)
312  : CountNode(CountNode), LowerBound(LowerBound), UpperBound(UpperBound),
313  Stride(Stride) {}
315  : CountNode(N->getRawCountNode()), LowerBound(N->getRawLowerBound()),
316  UpperBound(N->getRawUpperBound()), Stride(N->getRawStride()) {}
317 
318  bool isKeyOf(const DISubrange *RHS) const {
319  auto BoundsEqual = [=](Metadata *Node1, Metadata *Node2) -> bool {
320  if (Node1 == Node2)
321  return true;
322 
323  ConstantAsMetadata *MD1 = dyn_cast_or_null<ConstantAsMetadata>(Node1);
324  ConstantAsMetadata *MD2 = dyn_cast_or_null<ConstantAsMetadata>(Node2);
325  if (MD1 && MD2) {
326  ConstantInt *CV1 = cast<ConstantInt>(MD1->getValue());
327  ConstantInt *CV2 = cast<ConstantInt>(MD2->getValue());
328  if (CV1->getSExtValue() == CV2->getSExtValue())
329  return true;
330  }
331  return false;
332  };
333 
334  return BoundsEqual(CountNode, RHS->getRawCountNode()) &&
335  BoundsEqual(LowerBound, RHS->getRawLowerBound()) &&
336  BoundsEqual(UpperBound, RHS->getRawUpperBound()) &&
337  BoundsEqual(Stride, RHS->getRawStride());
338  }
339 
340  unsigned getHashValue() const {
341  if (CountNode)
342  if (auto *MD = dyn_cast<ConstantAsMetadata>(CountNode))
343  return hash_combine(cast<ConstantInt>(MD->getValue())->getSExtValue(),
344  LowerBound, UpperBound, Stride);
345  return hash_combine(CountNode, LowerBound, UpperBound, Stride);
346  }
347 };
348 
349 template <> struct MDNodeKeyImpl<DIGenericSubrange> {
354 
355  MDNodeKeyImpl(Metadata *CountNode, Metadata *LowerBound, Metadata *UpperBound,
356  Metadata *Stride)
357  : CountNode(CountNode), LowerBound(LowerBound), UpperBound(UpperBound),
358  Stride(Stride) {}
360  : CountNode(N->getRawCountNode()), LowerBound(N->getRawLowerBound()),
361  UpperBound(N->getRawUpperBound()), Stride(N->getRawStride()) {}
362 
363  bool isKeyOf(const DIGenericSubrange *RHS) const {
364  return (CountNode == RHS->getRawCountNode()) &&
365  (LowerBound == RHS->getRawLowerBound()) &&
366  (UpperBound == RHS->getRawUpperBound()) &&
367  (Stride == RHS->getRawStride());
368  }
369 
370  unsigned getHashValue() const {
371  auto *MD = dyn_cast_or_null<ConstantAsMetadata>(CountNode);
372  if (CountNode && MD)
373  return hash_combine(cast<ConstantInt>(MD->getValue())->getSExtValue(),
374  LowerBound, UpperBound, Stride);
375  return hash_combine(CountNode, LowerBound, UpperBound, Stride);
376  }
377 };
378 
379 template <> struct MDNodeKeyImpl<DIEnumerator> {
383 
384  MDNodeKeyImpl(APInt Value, bool IsUnsigned, MDString *Name)
385  : Value(Value), Name(Name), IsUnsigned(IsUnsigned) {}
386  MDNodeKeyImpl(int64_t Value, bool IsUnsigned, MDString *Name)
387  : Value(APInt(64, Value, !IsUnsigned)), Name(Name),
388  IsUnsigned(IsUnsigned) {}
390  : Value(N->getValue()), Name(N->getRawName()),
391  IsUnsigned(N->isUnsigned()) {}
392 
393  bool isKeyOf(const DIEnumerator *RHS) const {
394  return APInt::isSameValue(Value, RHS->getValue()) &&
395  IsUnsigned == RHS->isUnsigned() && Name == RHS->getRawName();
396  }
397 
398  unsigned getHashValue() const { return hash_combine(Value, Name); }
399 };
400 
401 template <> struct MDNodeKeyImpl<DIBasicType> {
402  unsigned Tag;
404  uint64_t SizeInBits;
406  unsigned Encoding;
407  unsigned Flags;
408 
409  MDNodeKeyImpl(unsigned Tag, MDString *Name, uint64_t SizeInBits,
410  uint32_t AlignInBits, unsigned Encoding, unsigned Flags)
411  : Tag(Tag), Name(Name), SizeInBits(SizeInBits), AlignInBits(AlignInBits),
412  Encoding(Encoding), Flags(Flags) {}
414  : Tag(N->getTag()), Name(N->getRawName()), SizeInBits(N->getSizeInBits()),
415  AlignInBits(N->getAlignInBits()), Encoding(N->getEncoding()), Flags(N->getFlags()) {}
416 
417  bool isKeyOf(const DIBasicType *RHS) const {
418  return Tag == RHS->getTag() && Name == RHS->getRawName() &&
419  SizeInBits == RHS->getSizeInBits() &&
420  AlignInBits == RHS->getAlignInBits() &&
421  Encoding == RHS->getEncoding() &&
422  Flags == RHS->getFlags();
423  }
424 
425  unsigned getHashValue() const {
426  return hash_combine(Tag, Name, SizeInBits, AlignInBits, Encoding);
427  }
428 };
429 
430 template <> struct MDNodeKeyImpl<DIStringType> {
431  unsigned Tag;
435  uint64_t SizeInBits;
437  unsigned Encoding;
438 
439  MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *StringLength,
440  Metadata *StringLengthExp, uint64_t SizeInBits,
441  uint32_t AlignInBits, unsigned Encoding)
442  : Tag(Tag), Name(Name), StringLength(StringLength),
443  StringLengthExp(StringLengthExp), SizeInBits(SizeInBits),
444  AlignInBits(AlignInBits), Encoding(Encoding) {}
446  : Tag(N->getTag()), Name(N->getRawName()),
447  StringLength(N->getRawStringLength()),
448  StringLengthExp(N->getRawStringLengthExp()),
449  SizeInBits(N->getSizeInBits()), AlignInBits(N->getAlignInBits()),
450  Encoding(N->getEncoding()) {}
451 
452  bool isKeyOf(const DIStringType *RHS) const {
453  return Tag == RHS->getTag() && Name == RHS->getRawName() &&
454  SizeInBits == RHS->getSizeInBits() &&
455  AlignInBits == RHS->getAlignInBits() &&
456  Encoding == RHS->getEncoding();
457  }
458  unsigned getHashValue() const { return hash_combine(Tag, Name, Encoding); }
459 };
460 
461 template <> struct MDNodeKeyImpl<DIDerivedType> {
462  unsigned Tag;
465  unsigned Line;
468  uint64_t SizeInBits;
469  uint64_t OffsetInBits;
472  unsigned Flags;
474 
475  MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *File, unsigned Line,
476  Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
477  uint32_t AlignInBits, uint64_t OffsetInBits,
478  Optional<unsigned> DWARFAddressSpace, unsigned Flags,
479  Metadata *ExtraData)
480  : Tag(Tag), Name(Name), File(File), Line(Line), Scope(Scope),
481  BaseType(BaseType), SizeInBits(SizeInBits), OffsetInBits(OffsetInBits),
482  AlignInBits(AlignInBits), DWARFAddressSpace(DWARFAddressSpace),
483  Flags(Flags), ExtraData(ExtraData) {}
485  : Tag(N->getTag()), Name(N->getRawName()), File(N->getRawFile()),
486  Line(N->getLine()), Scope(N->getRawScope()),
487  BaseType(N->getRawBaseType()), SizeInBits(N->getSizeInBits()),
488  OffsetInBits(N->getOffsetInBits()), AlignInBits(N->getAlignInBits()),
489  DWARFAddressSpace(N->getDWARFAddressSpace()), Flags(N->getFlags()),
490  ExtraData(N->getRawExtraData()) {}
491 
492  bool isKeyOf(const DIDerivedType *RHS) const {
493  return Tag == RHS->getTag() && Name == RHS->getRawName() &&
494  File == RHS->getRawFile() && Line == RHS->getLine() &&
495  Scope == RHS->getRawScope() && BaseType == RHS->getRawBaseType() &&
496  SizeInBits == RHS->getSizeInBits() &&
497  AlignInBits == RHS->getAlignInBits() &&
498  OffsetInBits == RHS->getOffsetInBits() &&
499  DWARFAddressSpace == RHS->getDWARFAddressSpace() &&
500  Flags == RHS->getFlags() &&
501  ExtraData == RHS->getRawExtraData();
502  }
503 
504  unsigned getHashValue() const {
505  // If this is a member inside an ODR type, only hash the type and the name.
506  // Otherwise the hash will be stronger than
507  // MDNodeSubsetEqualImpl::isODRMember().
508  if (Tag == dwarf::DW_TAG_member && Name)
509  if (auto *CT = dyn_cast_or_null<DICompositeType>(Scope))
510  if (CT->getRawIdentifier())
511  return hash_combine(Name, Scope);
512 
513  // Intentionally computes the hash on a subset of the operands for
514  // performance reason. The subset has to be significant enough to avoid
515  // collision "most of the time". There is no correctness issue in case of
516  // collision because of the full check above.
517  return hash_combine(Tag, Name, File, Line, Scope, BaseType, Flags);
518  }
519 };
520 
523 
524  static bool isSubsetEqual(const KeyTy &LHS, const DIDerivedType *RHS) {
525  return isODRMember(LHS.Tag, LHS.Scope, LHS.Name, RHS);
526  }
527 
528  static bool isSubsetEqual(const DIDerivedType *LHS, const DIDerivedType *RHS) {
529  return isODRMember(LHS->getTag(), LHS->getRawScope(), LHS->getRawName(),
530  RHS);
531  }
532 
533  /// Subprograms compare equal if they declare the same function in an ODR
534  /// type.
535  static bool isODRMember(unsigned Tag, const Metadata *Scope,
536  const MDString *Name, const DIDerivedType *RHS) {
537  // Check whether the LHS is eligible.
538  if (Tag != dwarf::DW_TAG_member || !Name)
539  return false;
540 
541  auto *CT = dyn_cast_or_null<DICompositeType>(Scope);
542  if (!CT || !CT->getRawIdentifier())
543  return false;
544 
545  // Compare to the RHS.
546  return Tag == RHS->getTag() && Name == RHS->getRawName() &&
547  Scope == RHS->getRawScope();
548  }
549 };
550 
551 template <> struct MDNodeKeyImpl<DICompositeType> {
552  unsigned Tag;
555  unsigned Line;
558  uint64_t SizeInBits;
559  uint64_t OffsetInBits;
561  unsigned Flags;
563  unsigned RuntimeLang;
572 
573  MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *File, unsigned Line,
574  Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
575  uint32_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
576  Metadata *Elements, unsigned RuntimeLang,
577  Metadata *VTableHolder, Metadata *TemplateParams,
578  MDString *Identifier, Metadata *Discriminator,
579  Metadata *DataLocation, Metadata *Associated,
580  Metadata *Allocated, Metadata *Rank)
581  : Tag(Tag), Name(Name), File(File), Line(Line), Scope(Scope),
582  BaseType(BaseType), SizeInBits(SizeInBits), OffsetInBits(OffsetInBits),
583  AlignInBits(AlignInBits), Flags(Flags), Elements(Elements),
584  RuntimeLang(RuntimeLang), VTableHolder(VTableHolder),
585  TemplateParams(TemplateParams), Identifier(Identifier),
586  Discriminator(Discriminator), DataLocation(DataLocation),
587  Associated(Associated), Allocated(Allocated), Rank(Rank) {}
589  : Tag(N->getTag()), Name(N->getRawName()), File(N->getRawFile()),
590  Line(N->getLine()), Scope(N->getRawScope()),
591  BaseType(N->getRawBaseType()), SizeInBits(N->getSizeInBits()),
592  OffsetInBits(N->getOffsetInBits()), AlignInBits(N->getAlignInBits()),
593  Flags(N->getFlags()), Elements(N->getRawElements()),
594  RuntimeLang(N->getRuntimeLang()), VTableHolder(N->getRawVTableHolder()),
595  TemplateParams(N->getRawTemplateParams()),
596  Identifier(N->getRawIdentifier()),
597  Discriminator(N->getRawDiscriminator()),
598  DataLocation(N->getRawDataLocation()),
599  Associated(N->getRawAssociated()), Allocated(N->getRawAllocated()),
600  Rank(N->getRawRank()) {}
601 
602  bool isKeyOf(const DICompositeType *RHS) const {
603  return Tag == RHS->getTag() && Name == RHS->getRawName() &&
604  File == RHS->getRawFile() && Line == RHS->getLine() &&
605  Scope == RHS->getRawScope() && BaseType == RHS->getRawBaseType() &&
606  SizeInBits == RHS->getSizeInBits() &&
607  AlignInBits == RHS->getAlignInBits() &&
608  OffsetInBits == RHS->getOffsetInBits() && Flags == RHS->getFlags() &&
609  Elements == RHS->getRawElements() &&
610  RuntimeLang == RHS->getRuntimeLang() &&
611  VTableHolder == RHS->getRawVTableHolder() &&
612  TemplateParams == RHS->getRawTemplateParams() &&
613  Identifier == RHS->getRawIdentifier() &&
614  Discriminator == RHS->getRawDiscriminator() &&
615  DataLocation == RHS->getRawDataLocation() &&
616  Associated == RHS->getRawAssociated() &&
617  Allocated == RHS->getRawAllocated() && Rank == RHS->getRawRank();
618  }
619 
620  unsigned getHashValue() const {
621  // Intentionally computes the hash on a subset of the operands for
622  // performance reason. The subset has to be significant enough to avoid
623  // collision "most of the time". There is no correctness issue in case of
624  // collision because of the full check above.
625  return hash_combine(Name, File, Line, BaseType, Scope, Elements,
626  TemplateParams);
627  }
628 };
629 
630 template <> struct MDNodeKeyImpl<DISubroutineType> {
631  unsigned Flags;
632  uint8_t CC;
634 
635  MDNodeKeyImpl(unsigned Flags, uint8_t CC, Metadata *TypeArray)
636  : Flags(Flags), CC(CC), TypeArray(TypeArray) {}
638  : Flags(N->getFlags()), CC(N->getCC()), TypeArray(N->getRawTypeArray()) {}
639 
640  bool isKeyOf(const DISubroutineType *RHS) const {
641  return Flags == RHS->getFlags() && CC == RHS->getCC() &&
642  TypeArray == RHS->getRawTypeArray();
643  }
644 
645  unsigned getHashValue() const { return hash_combine(Flags, CC, TypeArray); }
646 };
647 
648 template <> struct MDNodeKeyImpl<DIFile> {
653 
654  MDNodeKeyImpl(MDString *Filename, MDString *Directory,
657  : Filename(Filename), Directory(Directory), Checksum(Checksum),
658  Source(Source) {}
660  : Filename(N->getRawFilename()), Directory(N->getRawDirectory()),
661  Checksum(N->getRawChecksum()), Source(N->getRawSource()) {}
662 
663  bool isKeyOf(const DIFile *RHS) const {
664  return Filename == RHS->getRawFilename() &&
665  Directory == RHS->getRawDirectory() &&
666  Checksum == RHS->getRawChecksum() &&
667  Source == RHS->getRawSource();
668  }
669 
670  unsigned getHashValue() const {
671  return hash_combine(
672  Filename, Directory, Checksum ? Checksum->Kind : 0,
673  Checksum ? Checksum->Value : nullptr, Source.getValueOr(nullptr));
674  }
675 };
676 
677 template <> struct MDNodeKeyImpl<DISubprogram> {
682  unsigned Line;
684  unsigned ScopeLine;
686  unsigned VirtualIndex;
688  unsigned Flags;
689  unsigned SPFlags;
695 
697  Metadata *File, unsigned Line, Metadata *Type,
698  unsigned ScopeLine, Metadata *ContainingType,
699  unsigned VirtualIndex, int ThisAdjustment, unsigned Flags,
700  unsigned SPFlags, Metadata *Unit, Metadata *TemplateParams,
701  Metadata *Declaration, Metadata *RetainedNodes,
702  Metadata *ThrownTypes)
704  Line(Line), Type(Type), ScopeLine(ScopeLine),
705  ContainingType(ContainingType), VirtualIndex(VirtualIndex),
706  ThisAdjustment(ThisAdjustment), Flags(Flags), SPFlags(SPFlags),
707  Unit(Unit), TemplateParams(TemplateParams), Declaration(Declaration),
708  RetainedNodes(RetainedNodes), ThrownTypes(ThrownTypes) {}
710  : Scope(N->getRawScope()), Name(N->getRawName()),
711  LinkageName(N->getRawLinkageName()), File(N->getRawFile()),
712  Line(N->getLine()), Type(N->getRawType()), ScopeLine(N->getScopeLine()),
713  ContainingType(N->getRawContainingType()),
714  VirtualIndex(N->getVirtualIndex()),
715  ThisAdjustment(N->getThisAdjustment()), Flags(N->getFlags()),
716  SPFlags(N->getSPFlags()), Unit(N->getRawUnit()),
717  TemplateParams(N->getRawTemplateParams()),
718  Declaration(N->getRawDeclaration()),
719  RetainedNodes(N->getRawRetainedNodes()),
720  ThrownTypes(N->getRawThrownTypes()) {}
721 
722  bool isKeyOf(const DISubprogram *RHS) const {
723  return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
724  LinkageName == RHS->getRawLinkageName() &&
725  File == RHS->getRawFile() && Line == RHS->getLine() &&
726  Type == RHS->getRawType() && ScopeLine == RHS->getScopeLine() &&
727  ContainingType == RHS->getRawContainingType() &&
728  VirtualIndex == RHS->getVirtualIndex() &&
729  ThisAdjustment == RHS->getThisAdjustment() &&
730  Flags == RHS->getFlags() && SPFlags == RHS->getSPFlags() &&
731  Unit == RHS->getUnit() &&
732  TemplateParams == RHS->getRawTemplateParams() &&
733  Declaration == RHS->getRawDeclaration() &&
734  RetainedNodes == RHS->getRawRetainedNodes() &&
735  ThrownTypes == RHS->getRawThrownTypes();
736  }
737 
738  bool isDefinition() const { return SPFlags & DISubprogram::SPFlagDefinition; }
739 
740  unsigned getHashValue() const {
741  // If this is a declaration inside an ODR type, only hash the type and the
742  // name. Otherwise the hash will be stronger than
743  // MDNodeSubsetEqualImpl::isDeclarationOfODRMember().
744  if (!isDefinition() && LinkageName)
745  if (auto *CT = dyn_cast_or_null<DICompositeType>(Scope))
746  if (CT->getRawIdentifier())
747  return hash_combine(LinkageName, Scope);
748 
749  // Intentionally computes the hash on a subset of the operands for
750  // performance reason. The subset has to be significant enough to avoid
751  // collision "most of the time". There is no correctness issue in case of
752  // collision because of the full check above.
753  return hash_combine(Name, Scope, File, Type, Line);
754  }
755 };
756 
757 template <> struct MDNodeSubsetEqualImpl<DISubprogram> {
759 
760  static bool isSubsetEqual(const KeyTy &LHS, const DISubprogram *RHS) {
761  return isDeclarationOfODRMember(LHS.isDefinition(), LHS.Scope,
762  LHS.LinkageName, LHS.TemplateParams, RHS);
763  }
764 
765  static bool isSubsetEqual(const DISubprogram *LHS, const DISubprogram *RHS) {
766  return isDeclarationOfODRMember(LHS->isDefinition(), LHS->getRawScope(),
767  LHS->getRawLinkageName(),
768  LHS->getRawTemplateParams(), RHS);
769  }
770 
771  /// Subprograms compare equal if they declare the same function in an ODR
772  /// type.
773  static bool isDeclarationOfODRMember(bool IsDefinition, const Metadata *Scope,
774  const MDString *LinkageName,
775  const Metadata *TemplateParams,
776  const DISubprogram *RHS) {
777  // Check whether the LHS is eligible.
778  if (IsDefinition || !Scope || !LinkageName)
779  return false;
780 
781  auto *CT = dyn_cast_or_null<DICompositeType>(Scope);
782  if (!CT || !CT->getRawIdentifier())
783  return false;
784 
785  // Compare to the RHS.
786  // FIXME: We need to compare template parameters here to avoid incorrect
787  // collisions in mapMetadata when RF_ReuseAndMutateDistinctMDs and a
788  // ODR-DISubprogram has a non-ODR template parameter (i.e., a
789  // DICompositeType that does not have an identifier). Eventually we should
790  // decouple ODR logic from uniquing logic.
791  return IsDefinition == RHS->isDefinition() && Scope == RHS->getRawScope() &&
792  LinkageName == RHS->getRawLinkageName() &&
793  TemplateParams == RHS->getRawTemplateParams();
794  }
795 };
796 
797 template <> struct MDNodeKeyImpl<DILexicalBlock> {
800  unsigned Line;
801  unsigned Column;
802 
803  MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Line, unsigned Column)
804  : Scope(Scope), File(File), Line(Line), Column(Column) {}
806  : Scope(N->getRawScope()), File(N->getRawFile()), Line(N->getLine()),
807  Column(N->getColumn()) {}
808 
809  bool isKeyOf(const DILexicalBlock *RHS) const {
810  return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
811  Line == RHS->getLine() && Column == RHS->getColumn();
812  }
813 
814  unsigned getHashValue() const {
815  return hash_combine(Scope, File, Line, Column);
816  }
817 };
818 
819 template <> struct MDNodeKeyImpl<DILexicalBlockFile> {
822  unsigned Discriminator;
823 
824  MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Discriminator)
825  : Scope(Scope), File(File), Discriminator(Discriminator) {}
827  : Scope(N->getRawScope()), File(N->getRawFile()),
828  Discriminator(N->getDiscriminator()) {}
829 
830  bool isKeyOf(const DILexicalBlockFile *RHS) const {
831  return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
832  Discriminator == RHS->getDiscriminator();
833  }
834 
835  unsigned getHashValue() const {
836  return hash_combine(Scope, File, Discriminator);
837  }
838 };
839 
840 template <> struct MDNodeKeyImpl<DINamespace> {
844 
845  MDNodeKeyImpl(Metadata *Scope, MDString *Name, bool ExportSymbols)
846  : Scope(Scope), Name(Name), ExportSymbols(ExportSymbols) {}
848  : Scope(N->getRawScope()), Name(N->getRawName()),
849  ExportSymbols(N->getExportSymbols()) {}
850 
851  bool isKeyOf(const DINamespace *RHS) const {
852  return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
853  ExportSymbols == RHS->getExportSymbols();
854  }
855 
856  unsigned getHashValue() const {
857  return hash_combine(Scope, Name);
858  }
859 };
860 
861 template <> struct MDNodeKeyImpl<DICommonBlock> {
866  unsigned LineNo;
867 
869  Metadata *File, unsigned LineNo)
870  : Scope(Scope), Decl(Decl), Name(Name), File(File), LineNo(LineNo) {}
872  : Scope(N->getRawScope()), Decl(N->getRawDecl()), Name(N->getRawName()),
873  File(N->getRawFile()), LineNo(N->getLineNo()) {}
874 
875  bool isKeyOf(const DICommonBlock *RHS) const {
876  return Scope == RHS->getRawScope() && Decl == RHS->getRawDecl() &&
877  Name == RHS->getRawName() && File == RHS->getRawFile() &&
878  LineNo == RHS->getLineNo();
879  }
880 
881  unsigned getHashValue() const {
882  return hash_combine(Scope, Decl, Name, File, LineNo);
883  }
884 };
885 
886 template <> struct MDNodeKeyImpl<DIModule> {
893  unsigned LineNo;
894  bool IsDecl;
895 
897  MDString *ConfigurationMacros, MDString *IncludePath,
898  MDString *APINotesFile, unsigned LineNo, bool IsDecl)
899  : File(File), Scope(Scope), Name(Name),
900  ConfigurationMacros(ConfigurationMacros), IncludePath(IncludePath),
901  APINotesFile(APINotesFile), LineNo(LineNo), IsDecl(IsDecl) {}
903  : File(N->getRawFile()), Scope(N->getRawScope()), Name(N->getRawName()),
904  ConfigurationMacros(N->getRawConfigurationMacros()),
905  IncludePath(N->getRawIncludePath()),
906  APINotesFile(N->getRawAPINotesFile()), LineNo(N->getLineNo()),
907  IsDecl(N->getIsDecl()) {}
908 
909  bool isKeyOf(const DIModule *RHS) const {
910  return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
911  ConfigurationMacros == RHS->getRawConfigurationMacros() &&
912  IncludePath == RHS->getRawIncludePath() &&
913  APINotesFile == RHS->getRawAPINotesFile() &&
914  File == RHS->getRawFile() && LineNo == RHS->getLineNo() &&
915  IsDecl == RHS->getIsDecl();
916  }
917 
918  unsigned getHashValue() const {
919  return hash_combine(Scope, Name, ConfigurationMacros, IncludePath);
920  }
921 };
922 
926  bool IsDefault;
927 
929  : Name(Name), Type(Type), IsDefault(IsDefault) {}
931  : Name(N->getRawName()), Type(N->getRawType()),
932  IsDefault(N->isDefault()) {}
933 
934  bool isKeyOf(const DITemplateTypeParameter *RHS) const {
935  return Name == RHS->getRawName() && Type == RHS->getRawType() &&
936  IsDefault == RHS->isDefault();
937  }
938 
939  unsigned getHashValue() const { return hash_combine(Name, Type, IsDefault); }
940 };
941 
943  unsigned Tag;
946  bool IsDefault;
948 
949  MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *Type, bool IsDefault,
950  Metadata *Value)
951  : Tag(Tag), Name(Name), Type(Type), IsDefault(IsDefault), Value(Value) {}
953  : Tag(N->getTag()), Name(N->getRawName()), Type(N->getRawType()),
954  IsDefault(N->isDefault()), Value(N->getValue()) {}
955 
956  bool isKeyOf(const DITemplateValueParameter *RHS) const {
957  return Tag == RHS->getTag() && Name == RHS->getRawName() &&
958  Type == RHS->getRawType() && IsDefault == RHS->isDefault() &&
959  Value == RHS->getValue();
960  }
961 
962  unsigned getHashValue() const {
963  return hash_combine(Tag, Name, Type, IsDefault, Value);
964  }
965 };
966 
967 template <> struct MDNodeKeyImpl<DIGlobalVariable> {
972  unsigned Line;
979 
981  Metadata *File, unsigned Line, Metadata *Type,
982  bool IsLocalToUnit, bool IsDefinition,
983  Metadata *StaticDataMemberDeclaration, Metadata *TemplateParams,
984  uint32_t AlignInBits)
986  Line(Line), Type(Type), IsLocalToUnit(IsLocalToUnit),
987  IsDefinition(IsDefinition),
988  StaticDataMemberDeclaration(StaticDataMemberDeclaration),
989  TemplateParams(TemplateParams), AlignInBits(AlignInBits) {}
991  : Scope(N->getRawScope()), Name(N->getRawName()),
992  LinkageName(N->getRawLinkageName()), File(N->getRawFile()),
993  Line(N->getLine()), Type(N->getRawType()),
994  IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()),
995  StaticDataMemberDeclaration(N->getRawStaticDataMemberDeclaration()),
996  TemplateParams(N->getRawTemplateParams()),
997  AlignInBits(N->getAlignInBits()) {}
998 
999  bool isKeyOf(const DIGlobalVariable *RHS) const {
1000  return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
1001  LinkageName == RHS->getRawLinkageName() &&
1002  File == RHS->getRawFile() && Line == RHS->getLine() &&
1003  Type == RHS->getRawType() && IsLocalToUnit == RHS->isLocalToUnit() &&
1004  IsDefinition == RHS->isDefinition() &&
1005  StaticDataMemberDeclaration ==
1007  TemplateParams == RHS->getRawTemplateParams() &&
1008  AlignInBits == RHS->getAlignInBits();
1009  }
1010 
1011  unsigned getHashValue() const {
1012  // We do not use AlignInBits in hashing function here on purpose:
1013  // in most cases this param for local variable is zero (for function param
1014  // it is always zero). This leads to lots of hash collisions and errors on
1015  // cases with lots of similar variables.
1016  // clang/test/CodeGen/debug-info-257-args.c is an example of this problem,
1017  // generated IR is random for each run and test fails with Align included.
1018  // TODO: make hashing work fine with such situations
1019  return hash_combine(Scope, Name, LinkageName, File, Line, Type,
1020  IsLocalToUnit, IsDefinition, /* AlignInBits, */
1021  StaticDataMemberDeclaration);
1022  }
1023 };
1024 
1025 template <> struct MDNodeKeyImpl<DILocalVariable> {
1029  unsigned Line;
1031  unsigned Arg;
1032  unsigned Flags;
1034 
1036  Metadata *Type, unsigned Arg, unsigned Flags,
1037  uint32_t AlignInBits)
1038  : Scope(Scope), Name(Name), File(File), Line(Line), Type(Type), Arg(Arg),
1039  Flags(Flags), AlignInBits(AlignInBits) {}
1041  : Scope(N->getRawScope()), Name(N->getRawName()), File(N->getRawFile()),
1042  Line(N->getLine()), Type(N->getRawType()), Arg(N->getArg()),
1043  Flags(N->getFlags()), AlignInBits(N->getAlignInBits()) {}
1044 
1045  bool isKeyOf(const DILocalVariable *RHS) const {
1046  return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
1047  File == RHS->getRawFile() && Line == RHS->getLine() &&
1048  Type == RHS->getRawType() && Arg == RHS->getArg() &&
1049  Flags == RHS->getFlags() && AlignInBits == RHS->getAlignInBits();
1050  }
1051 
1052  unsigned getHashValue() const {
1053  // We do not use AlignInBits in hashing function here on purpose:
1054  // in most cases this param for local variable is zero (for function param
1055  // it is always zero). This leads to lots of hash collisions and errors on
1056  // cases with lots of similar variables.
1057  // clang/test/CodeGen/debug-info-257-args.c is an example of this problem,
1058  // generated IR is random for each run and test fails with Align included.
1059  // TODO: make hashing work fine with such situations
1060  return hash_combine(Scope, Name, File, Line, Type, Arg, Flags);
1061  }
1062 };
1063 
1064 template <> struct MDNodeKeyImpl<DILabel> {
1068  unsigned Line;
1069 
1071  : Scope(Scope), Name(Name), File(File), Line(Line) {}
1073  : Scope(N->getRawScope()), Name(N->getRawName()), File(N->getRawFile()),
1074  Line(N->getLine()) {}
1075 
1076  bool isKeyOf(const DILabel *RHS) const {
1077  return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
1078  File == RHS->getRawFile() && Line == RHS->getLine();
1079  }
1080 
1081  /// Using name and line to get hash value. It should already be mostly unique.
1082  unsigned getHashValue() const {
1083  return hash_combine(Scope, Name, Line);
1084  }
1085 };
1086 
1087 template <> struct MDNodeKeyImpl<DIExpression> {
1089 
1090  MDNodeKeyImpl(ArrayRef<uint64_t> Elements) : Elements(Elements) {}
1091  MDNodeKeyImpl(const DIExpression *N) : Elements(N->getElements()) {}
1092 
1093  bool isKeyOf(const DIExpression *RHS) const {
1094  return Elements == RHS->getElements();
1095  }
1096 
1097  unsigned getHashValue() const {
1098  return hash_combine_range(Elements.begin(), Elements.end());
1099  }
1100 };
1101 
1105 
1107  : Variable(Variable), Expression(Expression) {}
1109  : Variable(N->getRawVariable()), Expression(N->getRawExpression()) {}
1110 
1111  bool isKeyOf(const DIGlobalVariableExpression *RHS) const {
1112  return Variable == RHS->getRawVariable() &&
1113  Expression == RHS->getRawExpression();
1114  }
1115 
1116  unsigned getHashValue() const { return hash_combine(Variable, Expression); }
1117 };
1118 
1119 template <> struct MDNodeKeyImpl<DIObjCProperty> {
1122  unsigned Line;
1125  unsigned Attributes;
1127 
1129  MDString *GetterName, MDString *SetterName, unsigned Attributes,
1130  Metadata *Type)
1131  : Name(Name), File(File), Line(Line), GetterName(GetterName),
1132  SetterName(SetterName), Attributes(Attributes), Type(Type) {}
1134  : Name(N->getRawName()), File(N->getRawFile()), Line(N->getLine()),
1135  GetterName(N->getRawGetterName()), SetterName(N->getRawSetterName()),
1136  Attributes(N->getAttributes()), Type(N->getRawType()) {}
1137 
1138  bool isKeyOf(const DIObjCProperty *RHS) const {
1139  return Name == RHS->getRawName() && File == RHS->getRawFile() &&
1140  Line == RHS->getLine() && GetterName == RHS->getRawGetterName() &&
1141  SetterName == RHS->getRawSetterName() &&
1142  Attributes == RHS->getAttributes() && Type == RHS->getRawType();
1143  }
1144 
1145  unsigned getHashValue() const {
1146  return hash_combine(Name, File, Line, GetterName, SetterName, Attributes,
1147  Type);
1148  }
1149 };
1150 
1151 template <> struct MDNodeKeyImpl<DIImportedEntity> {
1152  unsigned Tag;
1156  unsigned Line;
1158 
1159  MDNodeKeyImpl(unsigned Tag, Metadata *Scope, Metadata *Entity, Metadata *File,
1160  unsigned Line, MDString *Name)
1161  : Tag(Tag), Scope(Scope), Entity(Entity), File(File), Line(Line),
1162  Name(Name) {}
1164  : Tag(N->getTag()), Scope(N->getRawScope()), Entity(N->getRawEntity()),
1165  File(N->getRawFile()), Line(N->getLine()), Name(N->getRawName()) {}
1166 
1167  bool isKeyOf(const DIImportedEntity *RHS) const {
1168  return Tag == RHS->getTag() && Scope == RHS->getRawScope() &&
1169  Entity == RHS->getRawEntity() && File == RHS->getFile() &&
1170  Line == RHS->getLine() && Name == RHS->getRawName();
1171  }
1172 
1173  unsigned getHashValue() const {
1174  return hash_combine(Tag, Scope, Entity, File, Line, Name);
1175  }
1176 };
1177 
1178 template <> struct MDNodeKeyImpl<DIMacro> {
1179  unsigned MIType;
1180  unsigned Line;
1183 
1184  MDNodeKeyImpl(unsigned MIType, unsigned Line, MDString *Name, MDString *Value)
1185  : MIType(MIType), Line(Line), Name(Name), Value(Value) {}
1187  : MIType(N->getMacinfoType()), Line(N->getLine()), Name(N->getRawName()),
1188  Value(N->getRawValue()) {}
1189 
1190  bool isKeyOf(const DIMacro *RHS) const {
1191  return MIType == RHS->getMacinfoType() && Line == RHS->getLine() &&
1192  Name == RHS->getRawName() && Value == RHS->getRawValue();
1193  }
1194 
1195  unsigned getHashValue() const {
1196  return hash_combine(MIType, Line, Name, Value);
1197  }
1198 };
1199 
1200 template <> struct MDNodeKeyImpl<DIMacroFile> {
1201  unsigned MIType;
1202  unsigned Line;
1205 
1206  MDNodeKeyImpl(unsigned MIType, unsigned Line, Metadata *File,
1207  Metadata *Elements)
1208  : MIType(MIType), Line(Line), File(File), Elements(Elements) {}
1210  : MIType(N->getMacinfoType()), Line(N->getLine()), File(N->getRawFile()),
1211  Elements(N->getRawElements()) {}
1212 
1213  bool isKeyOf(const DIMacroFile *RHS) const {
1214  return MIType == RHS->getMacinfoType() && Line == RHS->getLine() &&
1215  File == RHS->getRawFile() && Elements == RHS->getRawElements();
1216  }
1217 
1218  unsigned getHashValue() const {
1219  return hash_combine(MIType, Line, File, Elements);
1220  }
1221 };
1222 
1223 template <> struct MDNodeKeyImpl<DIArgList> {
1225 
1227  MDNodeKeyImpl(const DIArgList *N) : Args(N->getArgs()) {}
1228 
1229  bool isKeyOf(const DIArgList *RHS) const { return Args == RHS->getArgs(); }
1230 
1231  unsigned getHashValue() const {
1232  return hash_combine_range(Args.begin(), Args.end());
1233  }
1234 };
1235 
1236 /// DenseMapInfo for MDNode subclasses.
1237 template <class NodeTy> struct MDNodeInfo {
1240 
1241  static inline NodeTy *getEmptyKey() {
1243  }
1244 
1245  static inline NodeTy *getTombstoneKey() {
1247  }
1248 
1249  static unsigned getHashValue(const KeyTy &Key) { return Key.getHashValue(); }
1250 
1251  static unsigned getHashValue(const NodeTy *N) {
1252  return KeyTy(N).getHashValue();
1253  }
1254 
1255  static bool isEqual(const KeyTy &LHS, const NodeTy *RHS) {
1256  if (RHS == getEmptyKey() || RHS == getTombstoneKey())
1257  return false;
1258  return SubsetEqualTy::isSubsetEqual(LHS, RHS) || LHS.isKeyOf(RHS);
1259  }
1260 
1261  static bool isEqual(const NodeTy *LHS, const NodeTy *RHS) {
1262  if (LHS == RHS)
1263  return true;
1264  if (RHS == getEmptyKey() || RHS == getTombstoneKey())
1265  return false;
1266  return SubsetEqualTy::isSubsetEqual(LHS, RHS);
1267  }
1268 };
1269 
1270 #define HANDLE_MDNODE_LEAF(CLASS) using CLASS##Info = MDNodeInfo<CLASS>;
1271 #include "llvm/IR/Metadata.def"
1272 
1273 /// Multimap-like storage for metadata attachments.
1275 public:
1276  struct Attachment {
1277  unsigned MDKind;
1279  };
1280 
1281 private:
1282  SmallVector<Attachment, 1> Attachments;
1283 
1284 public:
1285  bool empty() const { return Attachments.empty(); }
1286  size_t size() const { return Attachments.size(); }
1287 
1288  /// Returns the first attachment with the given ID or nullptr if no such
1289  /// attachment exists.
1290  MDNode *lookup(unsigned ID) const;
1291 
1292  /// Appends all attachments with the given ID to \c Result in insertion order.
1293  /// If the global has no attachments with the given ID, or if ID is invalid,
1294  /// leaves Result unchanged.
1295  void get(unsigned ID, SmallVectorImpl<MDNode *> &Result) const;
1296 
1297  /// Appends all attachments for the global to \c Result, sorting by attachment
1298  /// ID. Attachments with the same ID appear in insertion order. This function
1299  /// does \em not clear \c Result.
1300  void getAll(SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const;
1301 
1302  /// Set an attachment to a particular node.
1303  ///
1304  /// Set the \c ID attachment to \c MD, replacing the current attachments at \c
1305  /// ID (if anyway).
1306  void set(unsigned ID, MDNode *MD);
1307 
1308  /// Adds an attachment to a particular node.
1309  void insert(unsigned ID, MDNode &MD);
1310 
1311  /// Remove attachments with the given ID.
1312  ///
1313  /// Remove the attachments at \c ID, if any.
1314  bool erase(unsigned ID);
1315 
1316  /// Erase matching attachments.
1317  ///
1318  /// Erases all attachments matching the \c shouldRemove predicate.
1319  template <class PredTy> void remove_if(PredTy shouldRemove) {
1320  llvm::erase_if(Attachments, shouldRemove);
1321  }
1322 };
1323 
1325 public:
1326  /// OwnedModules - The set of modules instantiated in this context, and which
1327  /// will be automatically deleted if this context is deleted.
1329 
1330  /// The main remark streamer used by all the other streamers (e.g. IR, MIR,
1331  /// frontends, etc.). This should only be used by the specific streamers, and
1332  /// never directly.
1333  std::unique_ptr<remarks::RemarkStreamer> MainRemarkStreamer;
1334 
1335  std::unique_ptr<DiagnosticHandler> DiagHandler;
1338  /// The minimum hotness value a diagnostic needs in order to be included in
1339  /// optimization diagnostics.
1340  ///
1341  /// The threshold is an Optional value, which maps to one of the 3 states:
1342  /// 1). 0 => threshold disabled. All emarks will be printed.
1343  /// 2). positive int => manual threshold by user. Remarks with hotness exceed
1344  /// threshold will be printed.
1345  /// 3). None => 'auto' threshold by user. The actual value is not
1346  /// available at command line, but will be synced with
1347  /// hotness threhold from profile summary during
1348  /// compilation.
1349  ///
1350  /// State 1 and 2 are considered as terminal states. State transition is
1351  /// only allowed from 3 to 2, when the threshold is first synced with profile
1352  /// summary. This ensures that the threshold is set only once and stays
1353  /// constant.
1354  ///
1355  /// If threshold option is not specified, it is disabled (0) by default.
1357 
1358  /// The specialized remark streamer used by LLVM's OptimizationRemarkEmitter.
1359  std::unique_ptr<LLVMRemarkStreamer> LLVMRS;
1360 
1362  void *YieldOpaqueHandle = nullptr;
1363 
1364  using IntMapTy =
1367 
1368  using FPMapTy =
1371 
1375 
1379 
1381 
1382 #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
1383  DenseSet<CLASS *, CLASS##Info> CLASS##s;
1384 #include "llvm/IR/Metadata.def"
1385 
1386  // Optional map for looking up composite types by identifier.
1388 
1389  // MDNodes may be uniqued or not uniqued. When they're not uniqued, they
1390  // aren't in the MDNodeSet, but they're still shared between objects, so no
1391  // one object can destroy them. Keep track of them here so we can delete
1392  // them on context teardown.
1393  std::vector<MDNode *> DistinctMDNodes;
1394 
1396 
1399 
1402 
1405 
1407 
1409 
1411 
1413 
1416 
1418 
1420 
1422 
1425 
1426  std::unique_ptr<ConstantTokenNone> TheNoneToken;
1427 
1428  // Basic type instances.
1433 
1436 
1438 
1445 
1448  // TODO: clean up the following after we no longer support non-opaque pointer
1449  // types.
1451  DenseMap<Type*, PointerType*> PointerTypes; // Pointers in AddrSpace = 0
1453 
1454  /// ValueHandles - This map keeps track of all of the value handles that are
1455  /// watching a Value*. The Value::HasValueHandle bit is used to know
1456  /// whether or not a value has an entry in this map.
1459 
1460  /// CustomMDKindNames - Map to hold the metadata string to ID mapping.
1462 
1463  /// Collection of metadata used in this context.
1465 
1466  /// Collection of per-GlobalObject sections used in this context.
1468 
1469  /// Collection of per-GlobalValue partitions used in this context.
1471 
1472  /// DiscriminatorTable - This table maps file:line locations to an
1473  /// integer representing the next DWARF path discriminator to assign to
1474  /// instructions in different blocks at the same location.
1476 
1477  /// A set of interned tags for operand bundles. The StringMap maps
1478  /// bundle tags to their IDs.
1479  ///
1480  /// \see LLVMContext::getOperandBundleTagID
1482 
1486 
1487  /// A set of interned synchronization scopes. The StringMap maps
1488  /// synchronization scope names to their respective synchronization scope IDs.
1490 
1491  /// getOrInsertSyncScopeID - Maps synchronization scope name to
1492  /// synchronization scope ID. Every synchronization scope registered with
1493  /// LLVMContext has unique ID except pre-defined ones.
1495 
1496  /// getSyncScopeNames - Populates client supplied SmallVector with
1497  /// synchronization scope names registered with LLVMContext. Synchronization
1498  /// scope names are ordered by increasing synchronization scope IDs.
1500 
1501  /// Maintain the GC name for each function.
1502  ///
1503  /// This saves allocating an additional word in Function for programs which
1504  /// do not use GC (i.e., most programs) at the cost of increased overhead for
1505  /// clients which do use GC.
1507 
1508  /// Flag to indicate if Value (other than GlobalValue) retains their name or
1509  /// not.
1510  bool DiscardValueNames = false;
1511 
1513  ~LLVMContextImpl();
1514 
1515  /// Destroy the ConstantArrays if they are not used.
1517 
1518  mutable OptPassGate *OPG = nullptr;
1519 
1520  /// Access the object which can disable optional passes and individual
1521  /// optimizations at compile time.
1522  OptPassGate &getOptPassGate() const;
1523 
1524  /// Set the object which can disable optional passes and individual
1525  /// optimizations at compile time.
1526  ///
1527  /// The lifetime of the object must be guaranteed to extend as long as the
1528  /// LLVMContext is used by compilation.
1529  void setOptPassGate(OptPassGate&);
1530 };
1531 
1532 } // end namespace llvm
1533 
1534 #endif // LLVM_LIB_IR_LLVMCONTEXTIMPL_H
llvm::MDNodeKeyImpl< DIGlobalVariable >::IsDefinition
bool IsDefinition
Definition: LLVMContextImpl.h:975
llvm::MDNodeKeyImpl< DISubprogram >::isDefinition
bool isDefinition() const
Definition: LLVMContextImpl.h:738
llvm::MDNodeKeyImpl< DILocalVariable >::MDNodeKeyImpl
MDNodeKeyImpl(Metadata *Scope, MDString *Name, Metadata *File, unsigned Line, Metadata *Type, unsigned Arg, unsigned Flags, uint32_t AlignInBits)
Definition: LLVMContextImpl.h:1035
llvm::MDNodeKeyImpl< MDTuple >::MDNodeKeyImpl
MDNodeKeyImpl(ArrayRef< Metadata * > Ops)
Definition: LLVMContextImpl.h:243
llvm::MDNodeKeyImpl< DITemplateValueParameter >::isKeyOf
bool isKeyOf(const DITemplateValueParameter *RHS) const
Definition: LLVMContextImpl.h:956
llvm::MDNodeKeyImpl< DIGlobalVariableExpression >::Variable
Metadata * Variable
Definition: LLVMContextImpl.h:1103
llvm::FunctionTypeKeyInfo::getTombstoneKey
static FunctionType * getTombstoneKey()
Definition: LLVMContextImpl.h:157
llvm::LLVMContextImpl::Alloc
BumpPtrAllocator Alloc
Definition: LLVMContextImpl.h:1434
llvm::lltok::APFloat
@ APFloat
Definition: LLToken.h:491
llvm::LLVMContextImpl::OwnedModules
SmallPtrSet< Module *, 4 > OwnedModules
OwnedModules - The set of modules instantiated in this context, and which will be automatically delet...
Definition: LLVMContextImpl.h:1328
llvm::AnonStructTypeKeyInfo::KeyTy::ETypes
ArrayRef< Type * > ETypes
Definition: LLVMContextImpl.h:77
llvm::MDNodeKeyImpl< DICompositeType >::TemplateParams
Metadata * TemplateParams
Definition: LLVMContextImpl.h:565
llvm::MDNodeKeyImpl< DISubrange >::CountNode
Metadata * CountNode
Definition: LLVMContextImpl.h:305
llvm::MDAttachments::Attachment::MDKind
unsigned MDKind
Definition: LLVMContextImpl.h:1277
llvm::DenseMapAPFloatKeyInfo::getHashValue
static unsigned getHashValue(const APFloat &Key)
Definition: LLVMContextImpl.h:66
llvm::LLVMContextImpl::InlineAsms
ConstantUniqueMap< InlineAsm > InlineAsms
Definition: LLVMContextImpl.h:1421
llvm::MDNodeKeyImpl< DIImportedEntity >::Entity
Metadata * Entity
Definition: LLVMContextImpl.h:1154
llvm::MDNodeKeyImpl< DIExpression >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:1097
llvm::DILabel::getLine
unsigned getLine() const
Definition: DebugInfoMetadata.h:3179
llvm::AnonStructTypeKeyInfo::isEqual
static bool isEqual(const StructType *LHS, const StructType *RHS)
Definition: LLVMContextImpl.h:122
llvm::MDNodeKeyImpl< DICommonBlock >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:881
llvm::DIGenericSubrange::getRawLowerBound
Metadata * getRawLowerBound() const
Definition: DebugInfoMetadata.h:392
llvm::DIArgList
List of ValueAsMetadata, to be used as an argument to a dbg.value intrinsic.
Definition: DebugInfoMetadata.h:3546
llvm::MDNodeKeyImpl< GenericDINode >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:297
llvm::MDNodeKeyImpl< DISubprogram >::LinkageName
MDString * LinkageName
Definition: LLVMContextImpl.h:680
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::MDNodeKeyImpl< DILexicalBlockFile >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:820
llvm::DICompositeType::getRawDataLocation
Metadata * getRawDataLocation() const
Definition: DebugInfoMetadata.h:1200
llvm::MDNodeKeyImpl< DIStringType >::StringLengthExp
Metadata * StringLengthExp
Definition: LLVMContextImpl.h:434
llvm::LLVMContextImpl::BlockAddresses
DenseMap< std::pair< const Function *, const BasicBlock * >, BlockAddress * > BlockAddresses
Definition: LLVMContextImpl.h:1415
llvm::StringMapEntry< uint32_t >
Optional.h
llvm::MDNodeKeyImpl< DISubroutineType >::isKeyOf
bool isKeyOf(const DISubroutineType *RHS) const
Definition: LLVMContextImpl.h:640
llvm::MDNodeKeyImpl< DITemplateTypeParameter >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:939
llvm::MDNodeKeyImpl< DIDerivedType >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:504
llvm::DIGenericSubrange::getRawCountNode
Metadata * getRawCountNode() const
Definition: DebugInfoMetadata.h:391
llvm::DIMacroNode::getMacinfoType
unsigned getMacinfoType() const
Definition: DebugInfoMetadata.h:3420
llvm::MDNodeKeyImpl< DIImportedEntity >::MDNodeKeyImpl
MDNodeKeyImpl(unsigned Tag, Metadata *Scope, Metadata *Entity, Metadata *File, unsigned Line, MDString *Name)
Definition: LLVMContextImpl.h:1159
llvm::MDNodeKeyImpl< DIModule >::IsDecl
bool IsDecl
Definition: LLVMContextImpl.h:894
llvm::MDNodeKeyImpl< DIObjCProperty >::Line
unsigned Line
Definition: LLVMContextImpl.h:1122
Metadata.h
llvm::FunctionTypeKeyInfo::getHashValue
static unsigned getHashValue(const FunctionType *FT)
Definition: LLVMContextImpl.h:168
llvm::MDNodeKeyImpl< DILexicalBlock >::MDNodeKeyImpl
MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Line, unsigned Column)
Definition: LLVMContextImpl.h:803
llvm::MDNodeKeyImpl< DISubprogram >::MDNodeKeyImpl
MDNodeKeyImpl(const DISubprogram *N)
Definition: LLVMContextImpl.h:709
llvm::DIType::getSizeInBits
uint64_t getSizeInBits() const
Definition: DebugInfoMetadata.h:701
llvm::MDNodeKeyImpl< DINamespace >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:841
llvm::DIObjCProperty::getRawGetterName
MDString * getRawGetterName() const
Definition: DebugInfoMetadata.h:3274
DebugInfoMetadata.h
llvm::LLVMContextImpl::FPConstants
FPMapTy FPConstants
Definition: LLVMContextImpl.h:1370
llvm::MDNodeKeyImpl< DIArgList >::MDNodeKeyImpl
MDNodeKeyImpl(const DIArgList *N)
Definition: LLVMContextImpl.h:1227
llvm::LLVMContextImpl::DiscardValueNames
bool DiscardValueNames
Flag to indicate if Value (other than GlobalValue) retains their name or not.
Definition: LLVMContextImpl.h:1510
llvm::MDNodeKeyImpl< MDTuple >::calculateHash
static unsigned calculateHash(MDTuple *N)
Definition: LLVMContextImpl.h:250
llvm::MDNodeKeyImpl< DIImportedEntity >::Tag
unsigned Tag
Definition: LLVMContextImpl.h:1152
llvm::DIGenericSubrange
Definition: DebugInfoMetadata.h:362
llvm::MDNodeKeyImpl< DICommonBlock >::File
Metadata * File
Definition: LLVMContextImpl.h:865
llvm::LLVMContextImpl::IntegerTypes
DenseMap< unsigned, IntegerType * > IntegerTypes
Definition: LLVMContextImpl.h:1437
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::LLVMContextImpl::Int64Ty
IntegerType Int64Ty
Definition: LLVMContextImpl.h:1432
llvm::LLVMContextImpl::UVConstants
DenseMap< Type *, std::unique_ptr< UndefValue > > UVConstants
Definition: LLVMContextImpl.h:1408
llvm::MDNodeKeyImpl< DITemplateTypeParameter >::MDNodeKeyImpl
MDNodeKeyImpl(MDString *Name, Metadata *Type, bool IsDefault)
Definition: LLVMContextImpl.h:928
llvm::MDNodeKeyImpl< DIDerivedType >::Flags
unsigned Flags
Definition: LLVMContextImpl.h:472
llvm::MDNodeKeyImpl< DINamespace >::Name
MDString * Name
Definition: LLVMContextImpl.h:842
llvm::LLVMContextImpl::FloatTy
Type FloatTy
Definition: LLVMContextImpl.h:1429
llvm::DICommonBlock::getRawDecl
Metadata * getRawDecl() const
Definition: DebugInfoMetadata.h:3041
llvm::MDNodeKeyImpl< DICompositeType >::Discriminator
Metadata * Discriminator
Definition: LLVMContextImpl.h:567
llvm::MDNodeKeyImpl< DIImportedEntity >::isKeyOf
bool isKeyOf(const DIImportedEntity *RHS) const
Definition: LLVMContextImpl.h:1167
llvm::MDNodeInfo::isEqual
static bool isEqual(const NodeTy *LHS, const NodeTy *RHS)
Definition: LLVMContextImpl.h:1261
llvm::DIObjCProperty::getRawSetterName
MDString * getRawSetterName() const
Definition: DebugInfoMetadata.h:3275
llvm::MDNodeKeyImpl< DIFile >::Filename
MDString * Filename
Definition: LLVMContextImpl.h:649
llvm::DILexicalBlockFile
Definition: DebugInfoMetadata.h:2132
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
llvm::MDNodeKeyImpl< DIEnumerator >::MDNodeKeyImpl
MDNodeKeyImpl(const DIEnumerator *N)
Definition: LLVMContextImpl.h:389
llvm::MDAttachments::set
void set(unsigned ID, MDNode *MD)
Set an attachment to a particular node.
Definition: Metadata.cpp:1171
llvm::DenseMapAPFloatKeyInfo
Definition: LLVMContextImpl.h:62
llvm::DIStringType
String type, Fortran CHARACTER(n)
Definition: DebugInfoMetadata.h:837
llvm::MDAttachments::size
size_t size() const
Definition: LLVMContextImpl.h:1286
llvm::MDNodeInfo::getEmptyKey
static NodeTy * getEmptyKey()
Definition: LLVMContextImpl.h:1241
llvm::DITemplateParameter::isDefault
bool isDefault() const
Definition: DebugInfoMetadata.h:2389
llvm::DIFile::ChecksumInfo
A single checksum, represented by a Kind and a Value (a string).
Definition: DebugInfoMetadata.h:552
llvm::MDNodeKeyImpl< DINamespace >::MDNodeKeyImpl
MDNodeKeyImpl(const DINamespace *N)
Definition: LLVMContextImpl.h:847
llvm::MDNodeKeyImpl< DISubprogram >::Declaration
Metadata * Declaration
Definition: LLVMContextImpl.h:692
Allocator.h
llvm::erase_if
void erase_if(Container &C, UnaryPredicate P)
Provide a container algorithm similar to C++ Library Fundamentals v2's erase_if which is equivalent t...
Definition: STLExtras.h:1728
llvm::LLVMContextImpl::ExprConstants
ConstantUniqueMap< ConstantExpr > ExprConstants
Definition: LLVMContextImpl.h:1419
llvm::DIObjCProperty::getRawName
MDString * getRawName() const
Definition: DebugInfoMetadata.h:3272
llvm::DIEnumerator::isUnsigned
bool isUnsigned() const
Definition: DebugInfoMetadata.h:460
llvm::LLVMContextImpl::setOptPassGate
void setOptPassGate(OptPassGate &)
Set the object which can disable optional passes and individual optimizations at compile time.
Definition: LLVMContextImpl.cpp:227
llvm::MDNodeKeyImpl< DILocation >::Column
unsigned Column
Definition: LLVMContextImpl.h:258
llvm::MDNodeInfo::getHashValue
static unsigned getHashValue(const KeyTy &Key)
Definition: LLVMContextImpl.h:1249
llvm::MDNodeSubsetEqualImpl
Configuration point for MDNodeInfo::isEqual().
Definition: LLVMContextImpl.h:226
llvm::MDAttachments::erase
bool erase(unsigned ID)
Remove attachments with the given ID.
Definition: Metadata.cpp:1181
llvm::MDNodeKeyImpl< DISubroutineType >::MDNodeKeyImpl
MDNodeKeyImpl(unsigned Flags, uint8_t CC, Metadata *TypeArray)
Definition: LLVMContextImpl.h:635
llvm::MDNodeKeyImpl< DIGenericSubrange >::Stride
Metadata * Stride
Definition: LLVMContextImpl.h:353
llvm::MDNodeKeyImpl< DIGlobalVariableExpression >::isKeyOf
bool isKeyOf(const DIGlobalVariableExpression *RHS) const
Definition: LLVMContextImpl.h:1111
llvm::MDNodeKeyImpl< DILocalVariable >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:1052
APInt.h
llvm::MDNodeKeyImpl< DIFile >::MDNodeKeyImpl
MDNodeKeyImpl(MDString *Filename, MDString *Directory, Optional< DIFile::ChecksumInfo< MDString * >> Checksum, Optional< MDString * > Source)
Definition: LLVMContextImpl.h:654
llvm::MDNodeKeyImpl< GenericDINode >::MDNodeKeyImpl
MDNodeKeyImpl(unsigned Tag, MDString *Header, ArrayRef< Metadata * > DwarfOps)
Definition: LLVMContextImpl.h:287
llvm::MDNodeKeyImpl< DICompositeType >::OffsetInBits
uint64_t OffsetInBits
Definition: LLVMContextImpl.h:559
llvm::MDNodeKeyImpl< DIBasicType >::isKeyOf
bool isKeyOf(const DIBasicType *RHS) const
Definition: LLVMContextImpl.h:417
llvm::DILocation
Debug location.
Definition: DebugInfoMetadata.h:1562
llvm::DIType::getAlignInBits
uint32_t getAlignInBits() const
Definition: DebugInfoMetadata.h:702
llvm::MDNodeKeyImpl< DILabel >::MDNodeKeyImpl
MDNodeKeyImpl(const DILabel *N)
Definition: LLVMContextImpl.h:1072
llvm::MDNodeKeyImpl< DILexicalBlock >::MDNodeKeyImpl
MDNodeKeyImpl(const DILexicalBlock *N)
Definition: LLVMContextImpl.h:805
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::DIEnumerator::getRawName
MDString * getRawName() const
Definition: DebugInfoMetadata.h:463
DenseMap.h
llvm::MDNodeInfo::KeyTy
MDNodeKeyImpl< NodeTy > KeyTy
Definition: LLVMContextImpl.h:1238
llvm::MDNodeKeyImpl< DIStringType >::MDNodeKeyImpl
MDNodeKeyImpl(const DIStringType *N)
Definition: LLVMContextImpl.h:445
llvm::LLVMContextImpl::MainRemarkStreamer
std::unique_ptr< remarks::RemarkStreamer > MainRemarkStreamer
The main remark streamer used by all the other streamers (e.g.
Definition: LLVMContextImpl.h:1333
llvm::DICompositeType::getRawVTableHolder
Metadata * getRawVTableHolder() const
Definition: DebugInfoMetadata.h:1195
llvm::GenericDINode::getRawHeader
MDString * getRawHeader() const
Definition: DebugInfoMetadata.h:271
llvm::MDNodeKeyImpl< DIImportedEntity >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:1173
llvm::MDNodeKeyImpl< DIFile >::Directory
MDString * Directory
Definition: LLVMContextImpl.h:650
llvm::MDNodeKeyImpl< DIMacro >::MDNodeKeyImpl
MDNodeKeyImpl(unsigned MIType, unsigned Line, MDString *Name, MDString *Value)
Definition: LLVMContextImpl.h:1184
llvm::MDNodeKeyImpl< DILexicalBlockFile >::isKeyOf
bool isKeyOf(const DILexicalBlockFile *RHS) const
Definition: LLVMContextImpl.h:830
llvm::MDNodeKeyImpl< DIGlobalVariableExpression >::MDNodeKeyImpl
MDNodeKeyImpl(Metadata *Variable, Metadata *Expression)
Definition: LLVMContextImpl.h:1106
llvm::LLVMContextImpl::DiagnosticsHotnessRequested
bool DiagnosticsHotnessRequested
Definition: LLVMContextImpl.h:1337
llvm::MDNodeKeyImpl< DIGlobalVariable >::File
Metadata * File
Definition: LLVMContextImpl.h:971
llvm::LLVMContextImpl::X86_AMXTy
Type X86_AMXTy
Definition: LLVMContextImpl.h:1431
llvm::DIScope::getRawFile
Metadata * getRawFile() const
Return the raw underlying file.
Definition: DebugInfoMetadata.h:499
llvm::Optional< unsigned >
llvm::MDNodeKeyImpl< DISubprogram >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:740
llvm::MDNodeKeyImpl< DISubprogram >::ContainingType
Metadata * ContainingType
Definition: LLVMContextImpl.h:685
llvm::MDNodeKeyImpl< DIDerivedType >::Tag
unsigned Tag
Definition: LLVMContextImpl.h:462
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::SmallPtrSet< Module *, 4 >
llvm::Intrinsic::getAttributes
AttributeList getAttributes(LLVMContext &C, ID id)
Return the attributes for an intrinsic.
llvm::MDNodeKeyImpl< DIObjCProperty >::Name
MDString * Name
Definition: LLVMContextImpl.h:1120
llvm::MDNodeKeyImpl< DIMacro >::MDNodeKeyImpl
MDNodeKeyImpl(const DIMacro *N)
Definition: LLVMContextImpl.h:1186
Hashing.h
llvm::MDNodeKeyImpl< DISubrange >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:340
STLExtras.h
llvm::LLVMContextImpl::ValuesAsMetadata
DenseMap< Value *, ValueAsMetadata * > ValuesAsMetadata
Definition: LLVMContextImpl.h:1377
llvm::MDNodeKeyImpl< DIDerivedType >::File
Metadata * File
Definition: LLVMContextImpl.h:464
llvm::DIExpression
DWARF expression.
Definition: DebugInfoMetadata.h:2557
llvm::ArrayType
Class to represent array types.
Definition: DerivedTypes.h:356
llvm::MDNodeKeyImpl< DITemplateTypeParameter >::MDNodeKeyImpl
MDNodeKeyImpl(const DITemplateTypeParameter *N)
Definition: LLVMContextImpl.h:930
that
we should consider alternate ways to model stack dependencies Lots of things could be done in WebAssemblyTargetTransformInfo cpp there are numerous optimization related hooks that can be overridden in WebAssemblyTargetLowering Instead of the OptimizeReturned which should consider preserving the returned attribute through to MachineInstrs and extending the MemIntrinsicResults pass to do this optimization on calls too That would also let the WebAssemblyPeephole pass clean up dead defs for such as it does for stores Consider implementing and or getMachineCombinerPatterns Find a clean way to fix the problem which leads to the Shrink Wrapping pass being run after the WebAssembly PEI pass When setting multiple variables to the same we currently get code like const It could be done with a smaller encoding like local tee $pop5 local $pop6 WebAssembly registers are implicitly initialized to zero Explicit zeroing is therefore often redundant and could be optimized away Small indices may use smaller encodings than large indices WebAssemblyRegColoring and or WebAssemblyRegRenumbering should sort registers according to their usage frequency to maximize the usage of smaller encodings Many cases of irreducible control flow could be transformed more optimally than via the transform in WebAssemblyFixIrreducibleControlFlow cpp It may also be worthwhile to do transforms before register particularly when duplicating to allow register coloring to be aware of the duplication WebAssemblyRegStackify could use AliasAnalysis to reorder loads and stores more aggressively WebAssemblyRegStackify is currently a greedy algorithm This means that
Definition: README.txt:130
llvm::MDNodeKeyImpl< DIMacroFile >::Line
unsigned Line
Definition: LLVMContextImpl.h:1202
llvm::DINameKind::LinkageName
@ LinkageName
BaseType
llvm::LLVMContextImpl::ValueNames
DenseMap< const Value *, ValueName * > ValueNames
Definition: LLVMContextImpl.h:1380
llvm::LLVMContextImpl::~LLVMContextImpl
~LLVMContextImpl()
Definition: LLVMContextImpl.cpp:42
llvm::hash_value
hash_code hash_value(const APFloat &Arg)
See friend declarations above.
Definition: APFloat.cpp:4810
llvm::MDNodeInfo
DenseMapInfo for MDNode subclasses.
Definition: LLVMContextImpl.h:1237
getTag
static Optional< unsigned > getTag(const TargetRegisterInfo *TRI, const MachineInstr &MI, const LoadInfo &LI)
Definition: AArch64FalkorHWPFFix.cpp:659
llvm::LLVMContextImpl::DSOLocalEquivalents
DenseMap< const GlobalValue *, DSOLocalEquivalent * > DSOLocalEquivalents
Definition: LLVMContextImpl.h:1417
llvm::MDNodeKeyImpl< DIEnumerator >::Value
APInt Value
Definition: LLVMContextImpl.h:380
llvm::LLVMContextImpl::AnonStructTypes
StructTypeSet AnonStructTypes
Definition: LLVMContextImpl.h:1442
llvm::MDNodeKeyImpl< DIMacroFile >::File
Metadata * File
Definition: LLVMContextImpl.h:1203
llvm::MDNodeKeyImpl< DILabel >::MDNodeKeyImpl
MDNodeKeyImpl(Metadata *Scope, MDString *Name, Metadata *File, unsigned Line)
Definition: LLVMContextImpl.h:1070
llvm::MDNodeKeyImpl< DICompositeType >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:556
llvm::MDNodeKeyImpl< DILexicalBlock >::Column
unsigned Column
Definition: LLVMContextImpl.h:801
llvm::DINamespace
Definition: DebugInfoMetadata.h:2247
llvm::LLVMContextImpl::GlobalValuePartitions
DenseMap< const GlobalValue *, StringRef > GlobalValuePartitions
Collection of per-GlobalValue partitions used in this context.
Definition: LLVMContextImpl.h:1470
llvm::LLVMContextImpl::AttrsSet
FoldingSet< AttributeImpl > AttrsSet
Definition: LLVMContextImpl.h:1372
llvm::AnonStructTypeKeyInfo
Definition: LLVMContextImpl.h:75
llvm::DILexicalBlock
Definition: DebugInfoMetadata.h:2081
llvm::ArrayRef::empty
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:160
llvm::MDNodeKeyImpl< DILexicalBlock >::Line
unsigned Line
Definition: LLVMContextImpl.h:800
llvm::MDNodeKeyImpl< DIGenericSubrange >::MDNodeKeyImpl
MDNodeKeyImpl(const DIGenericSubrange *N)
Definition: LLVMContextImpl.h:359
llvm::MDNodeKeyImpl< DILocation >::Line
unsigned Line
Definition: LLVMContextImpl.h:257
llvm::MDNodeKeyImpl< DIMacro >::Value
MDString * Value
Definition: LLVMContextImpl.h:1182
llvm::MDNodeKeyImpl< DIDerivedType >
Definition: LLVMContextImpl.h:461
llvm::LLVMContextImpl::getSyncScopeNames
void getSyncScopeNames(SmallVectorImpl< StringRef > &SSNs) const
getSyncScopeNames - Populates client supplied SmallVector with synchronization scope names registered...
Definition: LLVMContextImpl.cpp:212
llvm::DIVariable::getRawFile
Metadata * getRawFile() const
Definition: DebugInfoMetadata.h:2539
llvm::LLVMContextImpl::TheNoneToken
std::unique_ptr< ConstantTokenNone > TheNoneToken
Definition: LLVMContextImpl.h:1426
llvm::lltok::equal
@ equal
Definition: LLToken.h:25
llvm::LLVMContextImpl::ArrayConstants
ArrayConstantsTy ArrayConstants
Definition: LLVMContextImpl.h:1398
llvm::MDNodeKeyImpl< DIModule >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:888
llvm::ConstantAsMetadata::getValue
Constant * getValue() const
Definition: Metadata.h:427
llvm::MDNode::getNumOperands
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1108
llvm::MDNodeKeyImpl< MDTuple >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:248
llvm::MDNodeKeyImpl< DICompositeType >::Allocated
Metadata * Allocated
Definition: LLVMContextImpl.h:570
llvm::LLVMContextImpl::X86_MMXTy
Type X86_MMXTy
Definition: LLVMContextImpl.h:1431
llvm::DIImportedEntity::getRawEntity
Metadata * getRawEntity() const
Definition: DebugInfoMetadata.h:3333
llvm::FunctionTypeKeyInfo::getEmptyKey
static FunctionType * getEmptyKey()
Definition: LLVMContextImpl.h:153
llvm::MDNodeKeyImpl< DILocalVariable >::Type
Metadata * Type
Definition: LLVMContextImpl.h:1030
llvm::LLVMContextImpl::MetadataTy
Type MetadataTy
Definition: LLVMContextImpl.h:1429
llvm::MDAttachments::Attachment
Definition: LLVMContextImpl.h:1276
llvm::UniqueStringSaver
Saves strings in the provided stable storage and returns a StringRef with a stable character pointer.
Definition: StringSaver.h:42
llvm::MDNodeSubsetEqualImpl< DIDerivedType >::isSubsetEqual
static bool isSubsetEqual(const DIDerivedType *LHS, const DIDerivedType *RHS)
Definition: LLVMContextImpl.h:528
Arg
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Definition: AMDGPULibCalls.cpp:206
llvm::LLVMContextImpl::TokenTy
Type TokenTy
Definition: LLVMContextImpl.h:1430
llvm::MDNodeKeyImpl< DISubrange >::UpperBound
Metadata * UpperBound
Definition: LLVMContextImpl.h:307
llvm::MDNodeKeyImpl< DITemplateValueParameter >::IsDefault
bool IsDefault
Definition: LLVMContextImpl.h:946
llvm::ConstantInt
This is the shared class of boolean and integer constants.
Definition: Constants.h:79
llvm::DIObjCProperty
Definition: DebugInfoMetadata.h:3201
llvm::MDNodeKeyImpl< DILabel >::File
Metadata * File
Definition: LLVMContextImpl.h:1067
llvm::DenseMapInfo
Definition: APInt.h:34
llvm::MDNodeKeyImpl< DIGenericSubrange >::isKeyOf
bool isKeyOf(const DIGenericSubrange *RHS) const
Definition: LLVMContextImpl.h:363
llvm::LLVMContextImpl::Int16Ty
IntegerType Int16Ty
Definition: LLVMContextImpl.h:1432
llvm::MDNodeKeyImpl< DIArgList >::Args
ArrayRef< ValueAsMetadata * > Args
Definition: LLVMContextImpl.h:1224
llvm::MDNodeKeyImpl< DIGlobalVariable >::StaticDataMemberDeclaration
Metadata * StaticDataMemberDeclaration
Definition: LLVMContextImpl.h:976
llvm::LLVMContextImpl::dropTriviallyDeadConstantArrays
void dropTriviallyDeadConstantArrays()
Destroy the ConstantArrays if they are not used.
Definition: LLVMContextImpl.cpp:125
llvm::DIType::getFlags
DIFlags getFlags() const
Definition: DebugInfoMetadata.h:705
llvm::DILocalVariable::getFlags
DIFlags getFlags() const
Definition: DebugInfoMetadata.h:3112
llvm::MDNodeKeyImpl< DICompositeType >::Elements
Metadata * Elements
Definition: LLVMContextImpl.h:562
llvm::LLVMContextImpl::DiscriminatorTable
DenseMap< std::pair< const char *, unsigned >, unsigned > DiscriminatorTable
DiscriminatorTable - This table maps file:line locations to an integer representing the next DWARF pa...
Definition: LLVMContextImpl.h:1475
llvm::LLVMContextImpl::VectorTypes
DenseMap< std::pair< Type *, ElementCount >, VectorType * > VectorTypes
Definition: LLVMContextImpl.h:1447
llvm::LLVMContextImpl::NamedStructTypes
StringMap< StructType * > NamedStructTypes
Definition: LLVMContextImpl.h:1443
llvm::MDNodeKeyImpl< DICompositeType >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:620
llvm::MDNodeKeyImpl< DIGlobalVariable >::isKeyOf
bool isKeyOf(const DIGlobalVariable *RHS) const
Definition: LLVMContextImpl.h:999
Constants.h
llvm::DIImportedEntity::getLine
unsigned getLine() const
Definition: DebugInfoMetadata.h:3326
llvm::MDNodeKeyImpl< DILexicalBlock >::isKeyOf
bool isKeyOf(const DILexicalBlock *RHS) const
Definition: LLVMContextImpl.h:809
llvm::AnonStructTypeKeyInfo::KeyTy::KeyTy
KeyTy(const ArrayRef< Type * > &E, bool P)
Definition: LLVMContextImpl.h:80
llvm::MDNodeKeyImpl< DIObjCProperty >::File
Metadata * File
Definition: LLVMContextImpl.h:1121
llvm::DIImportedEntity::getRawName
MDString * getRawName() const
Definition: DebugInfoMetadata.h:3334
llvm::MDNodeKeyImpl< DILexicalBlock >::File
Metadata * File
Definition: LLVMContextImpl.h:799
llvm::LLVMContextImpl::ValueHandles
ValueHandlesTy ValueHandles
Definition: LLVMContextImpl.h:1458
llvm::DILocalVariable
Local variable.
Definition: DebugInfoMetadata.h:3053
llvm::MDNodeKeyImpl< DIGlobalVariable >::AlignInBits
uint32_t AlignInBits
Definition: LLVMContextImpl.h:978
llvm::LLVMContextImpl::X86_FP80Ty
Type X86_FP80Ty
Definition: LLVMContextImpl.h:1431
llvm::MDNodeKeyImpl< DICompositeType >::RuntimeLang
unsigned RuntimeLang
Definition: LLVMContextImpl.h:563
llvm::FunctionTypeKeyInfo::isEqual
static bool isEqual(const FunctionType *LHS, const FunctionType *RHS)
Definition: LLVMContextImpl.h:178
llvm::DIMacro
Definition: DebugInfoMetadata.h:3433
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::FunctionTypeKeyInfo::KeyTy::ReturnType
const Type * ReturnType
Definition: LLVMContextImpl.h:129
llvm::DIGlobalVariable::isLocalToUnit
bool isLocalToUnit() const
Definition: DebugInfoMetadata.h:2973
llvm::LLVMContextImpl::getOperandBundleTagID
uint32_t getOperandBundleTagID(StringRef Tag) const
Definition: LLVMContextImpl.cpp:199
llvm::MDNodeKeyImpl< DIExpression >::isKeyOf
bool isKeyOf(const DIExpression *RHS) const
Definition: LLVMContextImpl.h:1093
llvm::MDNodeInfo::isEqual
static bool isEqual(const KeyTy &LHS, const NodeTy *RHS)
Definition: LLVMContextImpl.h:1255
llvm::MDNodeKeyImpl< DISubrange >::MDNodeKeyImpl
MDNodeKeyImpl(Metadata *CountNode, Metadata *LowerBound, Metadata *UpperBound, Metadata *Stride)
Definition: LLVMContextImpl.h:310
llvm::MDNodeKeyImpl< DIEnumerator >::MDNodeKeyImpl
MDNodeKeyImpl(APInt Value, bool IsUnsigned, MDString *Name)
Definition: LLVMContextImpl.h:384
llvm::MDNodeInfo::getTombstoneKey
static NodeTy * getTombstoneKey()
Definition: LLVMContextImpl.h:1245
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::MDNodeKeyImpl< DITemplateTypeParameter >::Type
Metadata * Type
Definition: LLVMContextImpl.h:925
llvm::MDNodeKeyImpl< DILocation >::InlinedAt
Metadata * InlinedAt
Definition: LLVMContextImpl.h:260
llvm::LLVMContextImpl
Definition: LLVMContextImpl.h:1324
llvm::DILexicalBlockBase::getRawScope
Metadata * getRawScope() const
Definition: DebugInfoMetadata.h:2073
llvm::DIMacroFile::getRawFile
Metadata * getRawFile() const
Definition: DebugInfoMetadata.h:3536
llvm::MDNodeKeyImpl< DISubprogram >::Name
MDString * Name
Definition: LLVMContextImpl.h:679
llvm::LLVMContextImpl::CAZConstants
DenseMap< Type *, std::unique_ptr< ConstantAggregateZero > > CAZConstants
Definition: LLVMContextImpl.h:1395
llvm::MDNodeKeyImpl< DILabel >::getHashValue
unsigned getHashValue() const
Using name and line to get hash value. It should already be mostly unique.
Definition: LLVMContextImpl.h:1082
llvm::MDNodeSubsetEqualImpl< DISubprogram >::isSubsetEqual
static bool isSubsetEqual(const KeyTy &LHS, const DISubprogram *RHS)
Definition: LLVMContextImpl.h:760
llvm::MDNodeKeyImpl< DIEnumerator >::IsUnsigned
bool IsUnsigned
Definition: LLVMContextImpl.h:382
llvm::DIType::getLine
unsigned getLine() const
Definition: DebugInfoMetadata.h:700
llvm::OptPassGate
Extensions to this class implement mechanisms to disable passes and individual optimizations at compi...
Definition: OptBisect.h:26
llvm::MDNodeKeyImpl< DIObjCProperty >::MDNodeKeyImpl
MDNodeKeyImpl(const DIObjCProperty *N)
Definition: LLVMContextImpl.h:1133
llvm::MDNodeKeyImpl< GenericDINode >::Header
MDString * Header
Definition: LLVMContextImpl.h:285
llvm::MDNodeKeyImpl< DISubrange >::LowerBound
Metadata * LowerBound
Definition: LLVMContextImpl.h:306
llvm::MDTuple
Tuple of metadata.
Definition: Metadata.h:1139
llvm::MDNodeKeyImpl< DICompositeType >::DataLocation
Metadata * DataLocation
Definition: LLVMContextImpl.h:568
llvm::LLVMContextImpl::getOrInsertBundleTag
StringMapEntry< uint32_t > * getOrInsertBundleTag(StringRef Tag)
Definition: LLVMContextImpl.cpp:188
llvm::AMDGPU::PALMD::Key
Key
PAL metadata keys.
Definition: AMDGPUMetadata.h:481
llvm::APFloatBase::Bogus
static const fltSemantics & Bogus() LLVM_READNONE
A Pseudo fltsemantic used to construct APFloats that cannot conflict with anything real.
Definition: APFloat.cpp:182
llvm::DISubrange
Array subrange.
Definition: DebugInfoMetadata.h:296
DenseSet.h
llvm::MDNodeKeyImpl< DIModule >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:918
llvm::MDNodeKeyImpl< DIGlobalVariable >::LinkageName
MDString * LinkageName
Definition: LLVMContextImpl.h:970
llvm::MDAttachments::lookup
MDNode * lookup(unsigned ID) const
Returns the first attachment with the given ID or nullptr if no such attachment exists.
Definition: Metadata.cpp:1147
llvm::DICompositeType::getRuntimeLang
unsigned getRuntimeLang() const
Definition: DebugInfoMetadata.h:1191
llvm::MDNodeKeyImpl< DIObjCProperty >::Attributes
unsigned Attributes
Definition: LLVMContextImpl.h:1125
llvm::DITemplateTypeParameter
Definition: DebugInfoMetadata.h:2397
llvm::MDNodeKeyImpl< DIGenericSubrange >::MDNodeKeyImpl
MDNodeKeyImpl(Metadata *CountNode, Metadata *LowerBound, Metadata *UpperBound, Metadata *Stride)
Definition: LLVMContextImpl.h:355
llvm::IntegerType
Class to represent integer types.
Definition: DerivedTypes.h:40
llvm::DIBasicType::getEncoding
unsigned getEncoding() const
Definition: DebugInfoMetadata.h:823
llvm::DIMacro::getRawValue
MDString * getRawValue() const
Definition: DebugInfoMetadata.h:3475
llvm::MDNodeKeyImpl< DILabel >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:1065
llvm::DIMacro::getRawName
MDString * getRawName() const
Definition: DebugInfoMetadata.h:3474
llvm::MDNodeKeyImpl< DIGlobalVariableExpression >::MDNodeKeyImpl
MDNodeKeyImpl(const DIGlobalVariableExpression *N)
Definition: LLVMContextImpl.h:1108
llvm::MDNodeKeyImpl< GenericDINode >::isKeyOf
bool isKeyOf(const GenericDINode *RHS) const
Definition: LLVMContextImpl.h:292
llvm::DIObjCProperty::getAttributes
unsigned getAttributes() const
Definition: DebugInfoMetadata.h:3253
llvm::MDNodeKeyImpl< DIFile >::isKeyOf
bool isKeyOf(const DIFile *RHS) const
Definition: LLVMContextImpl.h:663
llvm::APFloat::bitwiseIsEqual
bool bitwiseIsEqual(const APFloat &RHS) const
Definition: APFloat.h:1182
llvm::MDNodeKeyImpl< DIDerivedType >::Line
unsigned Line
Definition: LLVMContextImpl.h:465
llvm::MDNodeKeyImpl< DIGlobalVariable >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:1011
llvm::DICompositeType::getRawElements
Metadata * getRawElements() const
Definition: DebugInfoMetadata.h:1194
llvm::MDNodeKeyImpl< DIDerivedType >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:466
llvm::MDNodeKeyImpl< DISubprogram >::Unit
Metadata * Unit
Definition: LLVMContextImpl.h:690
llvm::ConstantUniqueMap< ConstantArray >
llvm::MDNodeKeyImpl< DILocation >::MDNodeKeyImpl
MDNodeKeyImpl(const DILocation *L)
Definition: LLVMContextImpl.h:267
llvm::MDNodeKeyImpl< DICommonBlock >::MDNodeKeyImpl
MDNodeKeyImpl(const DICommonBlock *N)
Definition: LLVMContextImpl.h:871
APFloat.h
This file declares a class to represent arbitrary precision floating point values and provide a varie...
llvm::MDNodeKeyImpl< DIObjCProperty >::Type
Metadata * Type
Definition: LLVMContextImpl.h:1126
llvm::MDNodeKeyImpl< DICompositeType >::Associated
Metadata * Associated
Definition: LLVMContextImpl.h:569
llvm::MDNodeSubsetEqualImpl::isSubsetEqual
static bool isSubsetEqual(const NodeTy *LHS, const NodeTy *RHS)
Definition: LLVMContextImpl.h:233
llvm::LLVMContextImpl::Int1Ty
IntegerType Int1Ty
Definition: LLVMContextImpl.h:1432
llvm::MDNodeKeyImpl< DINamespace >::MDNodeKeyImpl
MDNodeKeyImpl(Metadata *Scope, MDString *Name, bool ExportSymbols)
Definition: LLVMContextImpl.h:845
llvm::LLVMContextImpl::LabelTy
Type LabelTy
Definition: LLVMContextImpl.h:1429
SmallPtrSet.h
llvm::MDNodeKeyImpl< DIFile >::MDNodeKeyImpl
MDNodeKeyImpl(const DIFile *N)
Definition: LLVMContextImpl.h:659
llvm::MDNodeKeyImpl< DIBasicType >::MDNodeKeyImpl
MDNodeKeyImpl(const DIBasicType *N)
Definition: LLVMContextImpl.h:413
StringMap.h
llvm::MDNodeKeyImpl< DIModule >::LineNo
unsigned LineNo
Definition: LLVMContextImpl.h:893
llvm::DILabel::getRawScope
Metadata * getRawScope() const
Definition: DebugInfoMetadata.h:3183
llvm::MDNodeKeyImpl< DICompositeType >::File
Metadata * File
Definition: LLVMContextImpl.h:554
llvm::MDNodeKeyImpl< DIDerivedType >::isKeyOf
bool isKeyOf(const DIDerivedType *RHS) const
Definition: LLVMContextImpl.h:492
llvm::MDNodeKeyImpl< DIGenericSubrange >::LowerBound
Metadata * LowerBound
Definition: LLVMContextImpl.h:351
llvm::MDNodeKeyImpl< DIStringType >::AlignInBits
uint32_t AlignInBits
Definition: LLVMContextImpl.h:436
llvm::DIGenericSubrange::getRawUpperBound
Metadata * getRawUpperBound() const
Definition: DebugInfoMetadata.h:393
llvm::MDNodeKeyImpl< DIMacro >::isKeyOf
bool isKeyOf(const DIMacro *RHS) const
Definition: LLVMContextImpl.h:1190
llvm::Metadata
Root of the metadata hierarchy.
Definition: Metadata.h:62
llvm::MDNodeKeyImpl< DILocalVariable >::Name
MDString * Name
Definition: LLVMContextImpl.h:1027
llvm::DICompositeType::getRawTemplateParams
Metadata * getRawTemplateParams() const
Definition: DebugInfoMetadata.h:1196
llvm::DINamespace::getRawScope
Metadata * getRawScope() const
Definition: DebugInfoMetadata.h:2289
llvm::MDNodeKeyImpl< DISubprogram >::ThisAdjustment
int ThisAdjustment
Definition: LLVMContextImpl.h:687
llvm::MDNodeKeyImpl< DICommonBlock >::LineNo
unsigned LineNo
Definition: LLVMContextImpl.h:866
llvm::MDNodeKeyImpl< DIExpression >::MDNodeKeyImpl
MDNodeKeyImpl(const DIExpression *N)
Definition: LLVMContextImpl.h:1091
llvm::MDNodeKeyImpl< DISubprogram >::SPFlags
unsigned SPFlags
Definition: LLVMContextImpl.h:689
llvm::MDNodeKeyImpl< DISubprogram >::TemplateParams
Metadata * TemplateParams
Definition: LLVMContextImpl.h:691
llvm::LLVMContextImpl::CDSConstants
StringMap< std::unique_ptr< ConstantDataSequential > > CDSConstants
Definition: LLVMContextImpl.h:1412
llvm::DIVariable::getRawName
MDString * getRawName() const
Definition: DebugInfoMetadata.h:2538
llvm::MDNodeKeyImpl< DISubprogram >::File
Metadata * File
Definition: LLVMContextImpl.h:681
llvm::LLVMContextImpl::DoubleTy
Type DoubleTy
Definition: LLVMContextImpl.h:1429
llvm::MDNodeKeyImpl< DICommonBlock >::Decl
Metadata * Decl
Definition: LLVMContextImpl.h:863
llvm::MDNodeKeyImpl< MDTuple >::isKeyOf
bool isKeyOf(const MDTuple *RHS) const
Definition: LLVMContextImpl.h:246
llvm::MDNodeKeyImpl< DIMacroFile >::MDNodeKeyImpl
MDNodeKeyImpl(unsigned MIType, unsigned Line, Metadata *File, Metadata *Elements)
Definition: LLVMContextImpl.h:1206
llvm::DIMacroFile::getLine
unsigned getLine() const
Definition: DebugInfoMetadata.h:3529
llvm::LLVMContextImpl::RespectDiagnosticFilters
bool RespectDiagnosticFilters
Definition: LLVMContextImpl.h:1336
llvm::StringMap
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:108
llvm::MDNodeKeyImpl< DISubrange >::MDNodeKeyImpl
MDNodeKeyImpl(const DISubrange *N)
Definition: LLVMContextImpl.h:314
llvm::MDNodeKeyImpl< DIImportedEntity >::Name
MDString * Name
Definition: LLVMContextImpl.h:1157
llvm::MDNodeKeyImpl< DIEnumerator >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:398
StringSaver.h
llvm::DICommonBlock
Definition: DebugInfoMetadata.h:2991
llvm::MDNodeKeyImpl< DISubprogram >::Flags
unsigned Flags
Definition: LLVMContextImpl.h:688
llvm::LLVMContextImpl::BundleTagCache
StringMap< uint32_t > BundleTagCache
A set of interned tags for operand bundles.
Definition: LLVMContextImpl.h:1481
llvm::VectorType
Base class of all SIMD vector types.
Definition: DerivedTypes.h:388
llvm::LLVMContextImpl::ValueMetadata
DenseMap< const Value *, MDAttachments > ValueMetadata
Collection of metadata used in this context.
Definition: LLVMContextImpl.h:1464
llvm::DenseSet< FunctionType *, FunctionTypeKeyInfo >
llvm::MDNodeKeyImpl< DITemplateTypeParameter >::Name
MDString * Name
Definition: LLVMContextImpl.h:924
llvm::DIGlobalVariable::isDefinition
bool isDefinition() const
Definition: DebugInfoMetadata.h:2974
llvm::APFloat
Definition: APFloat.h:701
llvm::MDNodeInfo::getHashValue
static unsigned getHashValue(const NodeTy *N)
Definition: LLVMContextImpl.h:1251
llvm::MDNodeKeyImpl< DILocation >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:277
llvm::AnonStructTypeKeyInfo::getEmptyKey
static StructType * getEmptyKey()
Definition: LLVMContextImpl.h:98
llvm::MDNodeKeyImpl< DIStringType >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:458
llvm::MDNodeKeyImpl< DIMacro >::Line
unsigned Line
Definition: LLVMContextImpl.h:1180
llvm::DITemplateValueParameter::getValue
Metadata * getValue() const
Definition: DebugInfoMetadata.h:2481
llvm::LLVMContext::YieldCallbackTy
void(*)(LLVMContext *Context, void *OpaqueHandle) YieldCallbackTy
Defines the type of a yield callback.
Definition: LLVMContext.h:158
llvm::MDNodeKeyImpl< DIGlobalVariable >::TemplateParams
Metadata * TemplateParams
Definition: LLVMContextImpl.h:977
llvm::LLVMContextImpl::Int32Ty
IntegerType Int32Ty
Definition: LLVMContextImpl.h:1432
llvm::DILocalVariable::getArg
unsigned getArg() const
Definition: DebugInfoMetadata.h:3111
llvm::MDNodeKeyImpl< GenericDINode >::Tag
unsigned Tag
Definition: LLVMContextImpl.h:284
llvm::MDNodeKeyImpl< DIDerivedType >::ExtraData
Metadata * ExtraData
Definition: LLVMContextImpl.h:473
llvm::LLVMContextImpl::ForceOpaquePointers
bool ForceOpaquePointers
Definition: LLVMContextImpl.h:1450
llvm::LLVMContextImpl::HalfTy
Type HalfTy
Definition: LLVMContextImpl.h:1429
llvm::MDNodeKeyImpl< DITemplateValueParameter >::Value
Metadata * Value
Definition: LLVMContextImpl.h:947
llvm::MDNodeKeyImpl< DITemplateValueParameter >::Type
Metadata * Type
Definition: LLVMContextImpl.h:945
llvm::LLVMContextImpl::CPNConstants
DenseMap< PointerType *, std::unique_ptr< ConstantPointerNull > > CPNConstants
Definition: LLVMContextImpl.h:1406
llvm::DIEnumerator
Enumeration value.
Definition: DebugInfoMetadata.h:412
llvm::MDNodeKeyImpl< DIStringType >::MDNodeKeyImpl
MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *StringLength, Metadata *StringLengthExp, uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding)
Definition: LLVMContextImpl.h:439
llvm::DIVariable::getRawType
Metadata * getRawType() const
Definition: DebugInfoMetadata.h:2540
llvm::MDNodeKeyImpl< DIDerivedType >::AlignInBits
uint32_t AlignInBits
Definition: LLVMContextImpl.h:470
llvm::FunctionTypeKeyInfo::KeyTy
Definition: LLVMContextImpl.h:128
llvm::DIEnumerator::getValue
const APInt & getValue() const
Definition: DebugInfoMetadata.h:459
llvm::ARM_MB::ST
@ ST
Definition: ARMBaseInfo.h:73
llvm::LLVMContextImpl::TheFalseVal
ConstantInt * TheFalseVal
Definition: LLVMContextImpl.h:1424
llvm::MDNodeKeyImpl< DILocation >::MDNodeKeyImpl
MDNodeKeyImpl(unsigned Line, unsigned Column, Metadata *Scope, Metadata *InlinedAt, bool ImplicitCode)
Definition: LLVMContextImpl.h:263
llvm::MDNodeKeyImpl< DIObjCProperty >::GetterName
MDString * GetterName
Definition: LLVMContextImpl.h:1123
llvm::MDNodeKeyImpl< DILexicalBlockFile >::MDNodeKeyImpl
MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Discriminator)
Definition: LLVMContextImpl.h:824
llvm::LLVMContextImpl::Int128Ty
IntegerType Int128Ty
Definition: LLVMContextImpl.h:1432
llvm::BumpPtrAllocatorImpl
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:67
llvm::MDNodeKeyImpl< DICompositeType >::Rank
Metadata * Rank
Definition: LLVMContextImpl.h:571
llvm::DIGlobalVariable
Global variables.
Definition: DebugInfoMetadata.h:2911
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
llvm::FunctionTypeKeyInfo::isEqual
static bool isEqual(const KeyTy &LHS, const FunctionType *RHS)
Definition: LLVMContextImpl.h:172
llvm::MDNodeKeyImpl< DIBasicType >::MDNodeKeyImpl
MDNodeKeyImpl(unsigned Tag, MDString *Name, uint64_t SizeInBits, uint32_t AlignInBits, unsigned Encoding, unsigned Flags)
Definition: LLVMContextImpl.h:409
llvm::FunctionTypeKeyInfo::KeyTy::isVarArg
bool isVarArg
Definition: LLVMContextImpl.h:131
llvm::MDNodeKeyImpl< DISubroutineType >::CC
uint8_t CC
Definition: LLVMContextImpl.h:632
llvm::DenseMap< APInt, std::unique_ptr< ConstantInt >, DenseMapAPIntKeyInfo >
llvm::SyncScope::ID
uint8_t ID
Definition: LLVMContext.h:47
llvm::LLVMContextImpl::NamedStructTypesUniqueID
unsigned NamedStructTypesUniqueID
Definition: LLVMContextImpl.h:1444
llvm::MDNodeKeyImpl< DICommonBlock >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:862
llvm::MDAttachments
Multimap-like storage for metadata attachments.
Definition: LLVMContextImpl.h:1274
llvm::MDNodeKeyImpl< DIFile >::Source
Optional< MDString * > Source
Definition: LLVMContextImpl.h:652
llvm::LLVMContextImpl::GlobalObjectSections
DenseMap< const GlobalObject *, StringRef > GlobalObjectSections
Collection of per-GlobalObject sections used in this context.
Definition: LLVMContextImpl.h:1467
llvm::DIGlobalVariable::getRawStaticDataMemberDeclaration
Metadata * getRawStaticDataMemberDeclaration() const
Definition: DebugInfoMetadata.h:2982
llvm::DIGlobalVariableExpression::getRawExpression
Metadata * getRawExpression() const
Definition: DebugInfoMetadata.h:3373
llvm::MDNodeKeyImpl< DICompositeType >::Line
unsigned Line
Definition: LLVMContextImpl.h:555
llvm::LLVMContextImpl::ASPointerTypes
DenseMap< std::pair< Type *, unsigned >, PointerType * > ASPointerTypes
Definition: LLVMContextImpl.h:1452
llvm::LLVMContextImpl::getOperandBundleTags
void getOperandBundleTags(SmallVectorImpl< StringRef > &Tags) const
Definition: LLVMContextImpl.cpp:193
Attributes
AMDGPU Kernel Attributes
Definition: AMDGPULowerKernelAttributes.cpp:254
llvm::MDNodeKeyImpl< DITemplateValueParameter >::MDNodeKeyImpl
MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *Type, bool IsDefault, Metadata *Value)
Definition: LLVMContextImpl.h:949
llvm::DIImportedEntity
An imported module (C++ using directive or similar).
Definition: DebugInfoMetadata.h:3284
llvm::MDNodeKeyImpl< DIModule >::File
Metadata * File
Definition: LLVMContextImpl.h:887
llvm::MDAttachments::empty
bool empty() const
Definition: LLVMContextImpl.h:1285
llvm::PointerType
Class to represent pointers.
Definition: DerivedTypes.h:631
llvm::DenseMapInfo< APInt >
Provide DenseMapInfo for APInt.
Definition: APInt.h:2295
llvm::MDNodeKeyImpl< DICompositeType >::VTableHolder
Metadata * VTableHolder
Definition: LLVMContextImpl.h:564
llvm::DIGlobalVariable::getRawLinkageName
MDString * getRawLinkageName() const
Definition: DebugInfoMetadata.h:2981
ArrayRef.h
llvm::LLVMContextImpl::BFloatTy
Type BFloatTy
Definition: LLVMContextImpl.h:1429
llvm::MDNodeKeyImpl< DIModule >::MDNodeKeyImpl
MDNodeKeyImpl(const DIModule *N)
Definition: LLVMContextImpl.h:902
TemplateParamKind::Type
@ Type
llvm::MDNodeKeyImpl< DIMacro >::Name
MDString * Name
Definition: LLVMContextImpl.h:1181
llvm::LLVMContextImpl::OPG
OptPassGate * OPG
Definition: LLVMContextImpl.h:1518
llvm::MDNodeKeyImpl< DILexicalBlock >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:814
llvm::AnonStructTypeKeyInfo::getTombstoneKey
static StructType * getTombstoneKey()
Definition: LLVMContextImpl.h:102
llvm::MDNodeKeyImpl< DIFile >::Checksum
Optional< DIFile::ChecksumInfo< MDString * > > Checksum
Definition: LLVMContextImpl.h:651
llvm::DINamespace::getExportSymbols
bool getExportSymbols() const
Definition: DebugInfoMetadata.h:2285
llvm::MDNodeKeyImpl< DITemplateValueParameter >::Tag
unsigned Tag
Definition: LLVMContextImpl.h:943
llvm::DIMacroFile
Definition: DebugInfoMetadata.h:3482
llvm::MDNodeOpsKey
Structure for hashing arbitrary MDNode operands.
Definition: LLVMContextImpl.h:184
llvm::MDNodeKeyImpl< DILexicalBlockFile >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:835
llvm::AnonStructTypeKeyInfo::isEqual
static bool isEqual(const KeyTy &LHS, const StructType *RHS)
Definition: LLVMContextImpl.h:116
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::LLVMContextImpl::ArrayTypes
DenseMap< std::pair< Type *, uint64_t >, ArrayType * > ArrayTypes
Definition: LLVMContextImpl.h:1446
llvm::LLVMContextImpl::DiagHandler
std::unique_ptr< DiagnosticHandler > DiagHandler
Definition: LLVMContextImpl.h:1335
llvm::MDNodeKeyImpl< DICompositeType >::MDNodeKeyImpl
MDNodeKeyImpl(const DICompositeType *N)
Definition: LLVMContextImpl.h:588
llvm::MDNodeKeyImpl< DILabel >::Line
unsigned Line
Definition: LLVMContextImpl.h:1068
llvm::LLVMContextImpl::TheTrueVal
ConstantInt * TheTrueVal
Definition: LLVMContextImpl.h:1423
llvm::DIArgList::getArgs
ArrayRef< ValueAsMetadata * > getArgs() const
Definition: DebugInfoMetadata.h:3578
llvm::MDNodeKeyImpl< DIBasicType >::Encoding
unsigned Encoding
Definition: LLVMContextImpl.h:406
ConstantsContext.h
llvm::LLVMContextImpl::AttrsLists
FoldingSet< AttributeListImpl > AttrsLists
Definition: LLVMContextImpl.h:1373
llvm::MDNodeKeyImpl< DISubroutineType >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:645
llvm::DIGlobalVariable::getRawTemplateParams
Metadata * getRawTemplateParams() const
Definition: DebugInfoMetadata.h:2983
llvm::DISubroutineType::getRawTypeArray
Metadata * getRawTypeArray() const
Definition: DebugInfoMetadata.h:1309
llvm::MDNode
Metadata node.
Definition: Metadata.h:897
llvm::LLVMContextImpl::YieldCallback
LLVMContext::YieldCallbackTy YieldCallback
Definition: LLVMContextImpl.h:1361
llvm::MDNodeKeyImpl< DISubprogram >
Definition: LLVMContextImpl.h:677
llvm::FunctionTypeKeyInfo::KeyTy::KeyTy
KeyTy(const FunctionType *FT)
Definition: LLVMContextImpl.h:135
llvm::DICompositeType::getRawRank
Metadata * getRawRank() const
Definition: DebugInfoMetadata.h:1221
llvm::MDNodeKeyImpl< DIDerivedType >::OffsetInBits
uint64_t OffsetInBits
Definition: LLVMContextImpl.h:469
llvm::DIBasicType
Basic type, like 'int' or 'float'.
Definition: DebugInfoMetadata.h:769
llvm::MDNodeSubsetEqualImpl< DIDerivedType >::isODRMember
static bool isODRMember(unsigned Tag, const Metadata *Scope, const MDString *Name, const DIDerivedType *RHS)
Subprograms compare equal if they declare the same function in an ODR type.
Definition: LLVMContextImpl.h:535
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:70
llvm::DIType::getRawScope
Metadata * getRawScope() const
Definition: DebugInfoMetadata.h:711
llvm::MDNodeKeyImpl< DIObjCProperty >::SetterName
MDString * SetterName
Definition: LLVMContextImpl.h:1124
llvm::MDNodeKeyImpl< DISubprogram >::RetainedNodes
Metadata * RetainedNodes
Definition: LLVMContextImpl.h:693
llvm::DINode::getTag
dwarf::Tag getTag() const
Definition: DebugInfoMetadata.h:160
YAMLTraits.h
llvm::MDNodeKeyImpl< DIModule >::IncludePath
MDString * IncludePath
Definition: LLVMContextImpl.h:891
llvm::DISubroutineType::getCC
uint8_t getCC() const
Definition: DebugInfoMetadata.h:1303
llvm::LLVMContextImpl::IntConstants
IntMapTy IntConstants
Definition: LLVMContextImpl.h:1366
llvm::DISubroutineType
Type array for a subprogram.
Definition: DebugInfoMetadata.h:1263
llvm::MDNodeKeyImpl< DISubprogram >::ThrownTypes
Metadata * ThrownTypes
Definition: LLVMContextImpl.h:694
llvm::MDAttachments::insert
void insert(unsigned ID, MDNode &MD)
Adds an attachment to a particular node.
Definition: Metadata.cpp:1177
llvm::MDNodeKeyImpl< DIMacro >::MIType
unsigned MIType
Definition: LLVMContextImpl.h:1179
llvm::Expression
Class representing an expression and its matching format.
Definition: FileCheckImpl.h:237
llvm::DICompositeType
Composite types.
Definition: DebugInfoMetadata.h:1051
AttributeImpl.h
llvm::BlockAddress
The address of a basic block.
Definition: Constants.h:848
llvm::MDNodeKeyImpl< DISubprogram >::Line
unsigned Line
Definition: LLVMContextImpl.h:682
llvm::FoldingSet
FoldingSet - This template class is used to instantiate a specialized implementation of the folding s...
Definition: FoldingSet.h:493
llvm::Sched::Source
@ Source
Definition: TargetLowering.h:99
llvm::MDAttachments::remove_if
void remove_if(PredTy shouldRemove)
Erase matching attachments.
Definition: LLVMContextImpl.h:1319
llvm::MDNodeKeyImpl< DIImportedEntity >::MDNodeKeyImpl
MDNodeKeyImpl(const DIImportedEntity *N)
Definition: LLVMContextImpl.h:1163
llvm::MDNodeKeyImpl< DIStringType >::Name
MDString * Name
Definition: LLVMContextImpl.h:432
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::LLVMContextImpl::getOptPassGate
OptPassGate & getOptPassGate() const
Access the object which can disable optional passes and individual optimizations at compile time.
Definition: LLVMContextImpl.cpp:221
llvm::LLVMContextImpl::MDStringCache
StringMap< MDString, BumpPtrAllocator > MDStringCache
Definition: LLVMContextImpl.h:1376
elements
This compiles xmm1 mulss xmm1 xorps xmm0 movss xmm0 ret Because mulss doesn t modify the top elements
Definition: README-SSE.txt:221
llvm::MDNodeKeyImpl< DICompositeType >::isKeyOf
bool isKeyOf(const DICompositeType *RHS) const
Definition: LLVMContextImpl.h:602
llvm::MDNodeKeyImpl< DIGenericSubrange >::UpperBound
Metadata * UpperBound
Definition: LLVMContextImpl.h:352
llvm::DIImportedEntity::getRawScope
Metadata * getRawScope() const
Definition: DebugInfoMetadata.h:3332
llvm::StructType
Class to represent struct types.
Definition: DerivedTypes.h:212
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
Dwarf.h
llvm::MDNodeKeyImpl< DISubroutineType >::MDNodeKeyImpl
MDNodeKeyImpl(const DISubroutineType *N)
Definition: LLVMContextImpl.h:637
llvm::MDNodeKeyImpl< DIMacroFile >::isKeyOf
bool isKeyOf(const DIMacroFile *RHS) const
Definition: LLVMContextImpl.h:1213
llvm::MDNodeKeyImpl< DIExpression >::MDNodeKeyImpl
MDNodeKeyImpl(ArrayRef< uint64_t > Elements)
Definition: LLVMContextImpl.h:1090
llvm::MDNodeKeyImpl< DISubprogram >::Type
Metadata * Type
Definition: LLVMContextImpl.h:683
llvm::FunctionTypeKeyInfo::KeyTy::operator==
bool operator==(const KeyTy &that) const
Definition: LLVMContextImpl.h:139
llvm::DIVariable::getLine
unsigned getLine() const
Definition: DebugInfoMetadata.h:2501
llvm::DILabel::getRawFile
Metadata * getRawFile() const
Definition: DebugInfoMetadata.h:3185
llvm::MDNodeKeyImpl< DISubprogram >::VirtualIndex
unsigned VirtualIndex
Definition: LLVMContextImpl.h:686
uint32_t
llvm::DIStringType::getEncoding
unsigned getEncoding() const
Definition: DebugInfoMetadata.h:904
llvm::MDNodeKeyImpl< DISubprogram >::ScopeLine
unsigned ScopeLine
Definition: LLVMContextImpl.h:684
llvm::LLVMContextImpl::StructConstants
StructConstantsTy StructConstants
Definition: LLVMContextImpl.h:1401
llvm::MDNodeKeyImpl< DISubroutineType >::Flags
unsigned Flags
Definition: LLVMContextImpl.h:631
llvm::LLVMContextImpl::getOrInsertSyncScopeID
SyncScope::ID getOrInsertSyncScopeID(StringRef SSN)
getOrInsertSyncScopeID - Maps synchronization scope name to synchronization scope ID.
Definition: LLVMContextImpl.cpp:205
llvm::MDNodeKeyImpl< DILabel >::isKeyOf
bool isKeyOf(const DILabel *RHS) const
Definition: LLVMContextImpl.h:1076
llvm::MDNodeOpsKey::MDNodeOpsKey
MDNodeOpsKey(ArrayRef< Metadata * > Ops)
Definition: LLVMContextImpl.h:190
llvm::MDNodeKeyImpl< DIDerivedType >::MDNodeKeyImpl
MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, Optional< unsigned > DWARFAddressSpace, unsigned Flags, Metadata *ExtraData)
Definition: LLVMContextImpl.h:475
llvm::LLVMContextImpl::PVConstants
DenseMap< Type *, std::unique_ptr< PoisonValue > > PVConstants
Definition: LLVMContextImpl.h:1410
llvm::MDNodeKeyImpl< DICompositeType >::AlignInBits
uint32_t AlignInBits
Definition: LLVMContextImpl.h:560
llvm::GenericDINode
Generic tagged DWARF-like metadata node.
Definition: DebugInfoMetadata.h:225
llvm::MDNodeKeyImpl< DIDerivedType >::SizeInBits
uint64_t SizeInBits
Definition: LLVMContextImpl.h:468
llvm::MDNodeKeyImpl< DIDerivedType >::MDNodeKeyImpl
MDNodeKeyImpl(const DIDerivedType *N)
Definition: LLVMContextImpl.h:484
llvm::ConstantInt::getSExtValue
int64_t getSExtValue() const
Return the constant as a 64-bit integer value after it has been sign extended as appropriate for the ...
Definition: Constants.h:148
llvm::MDNodeKeyImpl< DIGlobalVariable >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:968
llvm::MDNodeKeyImpl< DIFile >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:670
llvm::DITemplateParameter::getRawName
MDString * getRawName() const
Definition: DebugInfoMetadata.h:2387
llvm::FunctionTypeKeyInfo::KeyTy::operator!=
bool operator!=(const KeyTy &that) const
Definition: LLVMContextImpl.h:148
llvm::MDNodeKeyImpl< DILexicalBlockFile >::MDNodeKeyImpl
MDNodeKeyImpl(const DILexicalBlockFile *N)
Definition: LLVMContextImpl.h:826
llvm::MDNodeKeyImpl< DILocalVariable >::Arg
unsigned Arg
Definition: LLVMContextImpl.h:1031
llvm::DIType::getRawName
MDString * getRawName() const
Definition: DebugInfoMetadata.h:712
llvm::MDNodeKeyImpl< DIStringType >::Tag
unsigned Tag
Definition: LLVMContextImpl.h:431
llvm::AnonStructTypeKeyInfo::KeyTy::isPacked
bool isPacked
Definition: LLVMContextImpl.h:78
llvm::MDNodeKeyImpl< DILocation >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:259
llvm::LLVMContextImpl::GCNames
DenseMap< const Function *, std::string > GCNames
Maintain the GC name for each function.
Definition: LLVMContextImpl.h:1506
llvm::MDNodeOpsKey::MDNodeOpsKey
MDNodeOpsKey(const NodeTy *N, unsigned Offset=0)
Definition: LLVMContextImpl.h:194
FoldingSet.h
llvm::MDNodeKeyImpl< DITemplateValueParameter >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:962
llvm::DILexicalBlock::getLine
unsigned getLine() const
Definition: DebugInfoMetadata.h:2124
llvm::MDNodeKeyImpl< DIGenericSubrange >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:370
llvm::MDNodeKeyImpl< DIStringType >::StringLength
Metadata * StringLength
Definition: LLVMContextImpl.h:433
llvm::MDNodeKeyImpl< DILabel >::Name
MDString * Name
Definition: LLVMContextImpl.h:1066
llvm::ConstantAsMetadata
Definition: Metadata.h:412
llvm::MDNodeKeyImpl< DIMacroFile >::MDNodeKeyImpl
MDNodeKeyImpl(const DIMacroFile *N)
Definition: LLVMContextImpl.h:1209
llvm::MDNodeKeyImpl< DILocalVariable >::Line
unsigned Line
Definition: LLVMContextImpl.h:1029
llvm::DIObjCProperty::getRawFile
Metadata * getRawFile() const
Definition: DebugInfoMetadata.h:3273
llvm::MDNodeKeyImpl< DIBasicType >::Name
MDString * Name
Definition: LLVMContextImpl.h:403
llvm::MDNodeKeyImpl< DICompositeType >::Tag
unsigned Tag
Definition: LLVMContextImpl.h:552
llvm::DICompositeType::getRawAssociated
Metadata * getRawAssociated() const
Definition: DebugInfoMetadata.h:1207
llvm::DIType::getOffsetInBits
uint64_t getOffsetInBits() const
Definition: DebugInfoMetadata.h:704
llvm::DIImportedEntity::getFile
DIFile * getFile() const
Definition: DebugInfoMetadata.h:3330
llvm::MDNodeKeyImpl< DIStringType >::Encoding
unsigned Encoding
Definition: LLVMContextImpl.h:437
llvm::LLVMContextImpl::CustomMDKindNames
StringMap< unsigned > CustomMDKindNames
CustomMDKindNames - Map to hold the metadata string to ID mapping.
Definition: LLVMContextImpl.h:1461
llvm::MDNodeKeyImpl< DIObjCProperty >::isKeyOf
bool isKeyOf(const DIObjCProperty *RHS) const
Definition: LLVMContextImpl.h:1138
llvm::MDNodeKeyImpl< DITemplateValueParameter >::MDNodeKeyImpl
MDNodeKeyImpl(const DITemplateValueParameter *N)
Definition: LLVMContextImpl.h:952
llvm::DILocation::getRawScope
Metadata * getRawScope() const
Definition: DebugInfoMetadata.h:1789
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::MDNodeKeyImpl< DICommonBlock >::isKeyOf
bool isKeyOf(const DICommonBlock *RHS) const
Definition: LLVMContextImpl.h:875
LLVMRemarkStreamer.h
llvm::DICompositeType::getRawDiscriminator
Metadata * getRawDiscriminator() const
Definition: DebugInfoMetadata.h:1198
llvm::DIMacroFile::getRawElements
Metadata * getRawElements() const
Definition: DebugInfoMetadata.h:3537
llvm::MDNodeKeyImpl< DITemplateValueParameter >::Name
MDString * Name
Definition: LLVMContextImpl.h:944
llvm::DITemplateParameter::getRawType
Metadata * getRawType() const
Definition: DebugInfoMetadata.h:2388
getFlags
static uint32_t getFlags(const Symbol *Sym)
Definition: TapiFile.cpp:23
llvm::MDNodeKeyImpl< DICompositeType >::SizeInBits
uint64_t SizeInBits
Definition: LLVMContextImpl.h:558
llvm::ArrayRef::begin
iterator begin() const
Definition: ArrayRef.h:153
llvm::AnonStructTypeKeyInfo::KeyTy::KeyTy
KeyTy(const StructType *ST)
Definition: LLVMContextImpl.h:83
llvm::GenericDINode::getTag
dwarf::Tag getTag() const
Definition: DebugInfoMetadata.h:269
llvm::MDNodeKeyImpl< DILocalVariable >::Flags
unsigned Flags
Definition: LLVMContextImpl.h:1032
llvm::MDNodeKeyImpl< DILocalVariable >::MDNodeKeyImpl
MDNodeKeyImpl(const DILocalVariable *N)
Definition: LLVMContextImpl.h:1040
llvm::DICompositeType::getRawAllocated
Metadata * getRawAllocated() const
Definition: DebugInfoMetadata.h:1214
llvm::DILocation::getRawInlinedAt
Metadata * getRawInlinedAt() const
Definition: DebugInfoMetadata.h:1790
llvm::MDNodeKeyImpl< DIGlobalVariable >::Line
unsigned Line
Definition: LLVMContextImpl.h:972
llvm::AnonStructTypeKeyInfo::KeyTy::operator==
bool operator==(const KeyTy &that) const
Definition: LLVMContextImpl.h:86
Casting.h
llvm::APInt::isSameValue
static bool isSameValue(const APInt &I1, const APInt &I2)
Determine if two APInts have the same value, after zero-extending one of them (if needed!...
Definition: APInt.h:678
llvm::AnonStructTypeKeyInfo::KeyTy
Definition: LLVMContextImpl.h:76
llvm::MDNodeKeyImpl< DIArgList >::isKeyOf
bool isKeyOf(const DIArgList *RHS) const
Definition: LLVMContextImpl.h:1229
TrackingMDRef.h
llvm::FunctionTypeKeyInfo
Definition: LLVMContextImpl.h:127
llvm::DenseMapAPFloatKeyInfo::getEmptyKey
static APFloat getEmptyKey()
Definition: LLVMContextImpl.h:63
llvm::LLVMContextImpl::VoidTy
Type VoidTy
Definition: LLVMContextImpl.h:1429
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::DICommonBlock::getRawFile
Metadata * getRawFile() const
Definition: DebugInfoMetadata.h:3043
llvm::MDNodeKeyImpl< DIGlobalVariableExpression >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:1116
llvm::MDNodeKeyImpl< DIBasicType >::AlignInBits
uint32_t AlignInBits
Definition: LLVMContextImpl.h:405
llvm::DenseMapAPFloatKeyInfo::getTombstoneKey
static APFloat getTombstoneKey()
Definition: LLVMContextImpl.h:64
llvm::DIExpression::getElements
ArrayRef< uint64_t > getElements() const
Definition: DebugInfoMetadata.h:2581
llvm::AnonStructTypeKeyInfo::KeyTy::operator!=
bool operator!=(const KeyTy &that) const
Definition: LLVMContextImpl.h:93
llvm::LLVMContextImpl::DiagnosticsHotnessThreshold
Optional< uint64_t > DiagnosticsHotnessThreshold
The minimum hotness value a diagnostic needs in order to be included in optimization diagnostics.
Definition: LLVMContextImpl.h:1356
llvm::LLVMContextImpl::AttrsSetNodes
FoldingSet< AttributeSetNode > AttrsSetNodes
Definition: LLVMContextImpl.h:1374
llvm::MDNodeKeyImpl< DIBasicType >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:425
llvm::MDNodeKeyImpl< DIStringType >::SizeInBits
uint64_t SizeInBits
Definition: LLVMContextImpl.h:435
llvm::MDNodeKeyImpl< GenericDINode >::calculateHash
static unsigned calculateHash(GenericDINode *N)
Definition: LLVMContextImpl.h:299
llvm::MDNodeKeyImpl< DICommonBlock >::Name
MDString * Name
Definition: LLVMContextImpl.h:864
llvm::FunctionTypeKeyInfo::getHashValue
static unsigned getHashValue(const KeyTy &Key)
Definition: LLVMContextImpl.h:161
llvm::LLVMContextImpl::Int8Ty
IntegerType Int8Ty
Definition: LLVMContextImpl.h:1432
llvm::MDNodeKeyImpl< DIModule >::MDNodeKeyImpl
MDNodeKeyImpl(Metadata *File, Metadata *Scope, MDString *Name, MDString *ConfigurationMacros, MDString *IncludePath, MDString *APINotesFile, unsigned LineNo, bool IsDecl)
Definition: LLVMContextImpl.h:896
llvm::MDNodeKeyImpl< DILexicalBlock >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:798
llvm::MDNodeKeyImpl< DISubprogram >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:678
llvm::MDNodeKeyImpl< DILocation >::isKeyOf
bool isKeyOf(const DILocation *RHS) const
Definition: LLVMContextImpl.h:271
llvm::MDNodeKeyImpl< DISubprogram >::MDNodeKeyImpl
MDNodeKeyImpl(Metadata *Scope, MDString *Name, MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type, unsigned ScopeLine, Metadata *ContainingType, unsigned VirtualIndex, int ThisAdjustment, unsigned Flags, unsigned SPFlags, Metadata *Unit, Metadata *TemplateParams, Metadata *Declaration, Metadata *RetainedNodes, Metadata *ThrownTypes)
Definition: LLVMContextImpl.h:696
llvm::DIDerivedType
Derived types.
Definition: DebugInfoMetadata.h:917
llvm::MDNodeKeyImpl< DILocalVariable >::AlignInBits
uint32_t AlignInBits
Definition: LLVMContextImpl.h:1033
llvm::DIGlobalVariableExpression
A pair of DIGlobalVariable and DIExpression.
Definition: DebugInfoMetadata.h:3343
llvm::MDNodeKeyImpl< DIBasicType >::Flags
unsigned Flags
Definition: LLVMContextImpl.h:407
llvm::AnonStructTypeKeyInfo::getHashValue
static unsigned getHashValue(const StructType *ST)
Definition: LLVMContextImpl.h:112
llvm::MDNodeKeyImpl< DIDerivedType >::Name
MDString * Name
Definition: LLVMContextImpl.h:463
llvm::LLVMContextImpl::MetadataAsValues
DenseMap< Metadata *, MetadataAsValue * > MetadataAsValues
Definition: LLVMContextImpl.h:1378
llvm::MDNodeKeyImpl< DICompositeType >::Name
MDString * Name
Definition: LLVMContextImpl.h:553
llvm::MDNodeSubsetEqualImpl::isSubsetEqual
static bool isSubsetEqual(const KeyTy &LHS, const NodeTy *RHS)
Definition: LLVMContextImpl.h:229
llvm::MDNodeKeyImpl< DIBasicType >::Tag
unsigned Tag
Definition: LLVMContextImpl.h:402
llvm::DIVariable::getRawScope
Metadata * getRawScope() const
Definition: DebugInfoMetadata.h:2537
llvm::MDNodeKeyImpl< DILocation >::ImplicitCode
bool ImplicitCode
Definition: LLVMContextImpl.h:261
llvm::MDNodeKeyImpl< DIDerivedType >::DWARFAddressSpace
Optional< unsigned > DWARFAddressSpace
Definition: LLVMContextImpl.h:471
llvm::DITemplateValueParameter
Definition: DebugInfoMetadata.h:2439
llvm::FunctionTypeKeyInfo::KeyTy::KeyTy
KeyTy(const Type *R, const ArrayRef< Type * > &P, bool V)
Definition: LLVMContextImpl.h:133
llvm::MDAttachments::getAll
void getAll(SmallVectorImpl< std::pair< unsigned, MDNode * >> &Result) const
Appends all attachments for the global to Result, sorting by attachment ID.
Definition: Metadata.cpp:1160
llvm::TypedTrackingMDRef< MDNode >
llvm::FunctionTypeKeyInfo::KeyTy::Params
ArrayRef< Type * > Params
Definition: LLVMContextImpl.h:130
SmallVector.h
llvm::DICommonBlock::getRawName
MDString * getRawName() const
Definition: DebugInfoMetadata.h:3042
llvm::LLVMContextImpl::Saver
UniqueStringSaver Saver
Definition: LLVMContextImpl.h:1435
llvm::LLVMContextImpl::PPC_FP128Ty
Type PPC_FP128Ty
Definition: LLVMContextImpl.h:1431
llvm::MDNodeSubsetEqualImpl< DISubprogram >::isSubsetEqual
static bool isSubsetEqual(const DISubprogram *LHS, const DISubprogram *RHS)
Definition: LLVMContextImpl.h:765
llvm::DILexicalBlock::getColumn
unsigned getColumn() const
Definition: DebugInfoMetadata.h:2125
llvm::hash_combine
hash_code hash_combine(const Ts &...args)
Combine values into a single hash_code.
Definition: Hashing.h:604
llvm::MDNodeKeyImpl< DIStringType >::isKeyOf
bool isKeyOf(const DIStringType *RHS) const
Definition: LLVMContextImpl.h:452
llvm::DICompositeType::getRawBaseType
Metadata * getRawBaseType() const
Definition: DebugInfoMetadata.h:1193
llvm::MDNodeKeyImpl< GenericDINode >::MDNodeKeyImpl
MDNodeKeyImpl(const GenericDINode *N)
Definition: LLVMContextImpl.h:289
llvm::MDNodeKeyImpl< DISubrange >::isKeyOf
bool isKeyOf(const DISubrange *RHS) const
Definition: LLVMContextImpl.h:318
llvm::MDNodeKeyImpl< DITemplateTypeParameter >::isKeyOf
bool isKeyOf(const DITemplateTypeParameter *RHS) const
Definition: LLVMContextImpl.h:934
llvm::MDNodeKeyImpl< DIMacroFile >::MIType
unsigned MIType
Definition: LLVMContextImpl.h:1201
llvm::MDNodeOpsKey::getHash
unsigned getHash() const
Definition: LLVMContextImpl.h:220
llvm::MDNodeSubsetEqualImpl< DIDerivedType >::isSubsetEqual
static bool isSubsetEqual(const KeyTy &LHS, const DIDerivedType *RHS)
Definition: LLVMContextImpl.h:524
N
#define N
llvm::MDNodeKeyImpl< DILocalVariable >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:1026
llvm::MDNodeKeyImpl< DIGlobalVariable >::MDNodeKeyImpl
MDNodeKeyImpl(const DIGlobalVariable *N)
Definition: LLVMContextImpl.h:990
llvm::hash_combine_range
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last)
Compute a hash_code for a sequence of values.
Definition: Hashing.h:482
llvm::MDNodeKeyImpl< DISubrange >::Stride
Metadata * Stride
Definition: LLVMContextImpl.h:308
llvm::MDNodeSubsetEqualImpl< DISubprogram >::isDeclarationOfODRMember
static bool isDeclarationOfODRMember(bool IsDefinition, const Metadata *Scope, const MDString *LinkageName, const Metadata *TemplateParams, const DISubprogram *RHS)
Subprograms compare equal if they declare the same function in an ODR type.
Definition: LLVMContextImpl.h:773
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
llvm::DICommonBlock::getLineNo
unsigned getLineNo() const
Definition: DebugInfoMetadata.h:3038
llvm::MDNodeKeyImpl< DIArgList >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:1231
llvm::MDNodeKeyImpl< DINamespace >::ExportSymbols
bool ExportSymbols
Definition: LLVMContextImpl.h:843
llvm::MDNodeKeyImpl< DISubroutineType >::TypeArray
Metadata * TypeArray
Definition: LLVMContextImpl.h:633
llvm::MDNodeKeyImpl
Definition: LLVMContextImpl.h:223
llvm::DINamespace::getRawName
MDString * getRawName() const
Definition: DebugInfoMetadata.h:2290
llvm::MDNodeKeyImpl< DICompositeType >::BaseType
Metadata * BaseType
Definition: LLVMContextImpl.h:557
llvm::LLVMContextImpl::DITypeMap
Optional< DenseMap< const MDString *, DICompositeType * > > DITypeMap
Definition: LLVMContextImpl.h:1387
llvm::MDNodeKeyImpl< DIImportedEntity >::Line
unsigned Line
Definition: LLVMContextImpl.h:1156
llvm::LLVMContextImpl::SSC
StringMap< SyncScope::ID > SSC
A set of interned synchronization scopes.
Definition: LLVMContextImpl.h:1489
llvm::MDNodeKeyImpl< DIGenericSubrange >::CountNode
Metadata * CountNode
Definition: LLVMContextImpl.h:350
llvm::MDNodeKeyImpl< DINamespace >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:856
llvm::MDNodeKeyImpl< DILocalVariable >::isKeyOf
bool isKeyOf(const DILocalVariable *RHS) const
Definition: LLVMContextImpl.h:1045
llvm::DISubprogram
Subprogram description.
Definition: DebugInfoMetadata.h:1802
llvm::LLVMContextImpl::VectorConstants
VectorConstantsTy VectorConstants
Definition: LLVMContextImpl.h:1404
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:43
llvm::DIVariable::getAlignInBits
uint32_t getAlignInBits() const
Definition: DebugInfoMetadata.h:2506
llvm::MDNodeOpsKey::compareOps
bool compareOps(const NodeTy *RHS, unsigned Offset=0) const
Definition: LLVMContextImpl.h:198
DenseMapInfo.h
llvm::DIModule
Represents a module in the programming language, for example, a Clang module, or a Fortran module.
Definition: DebugInfoMetadata.h:2299
llvm::MDNodeKeyImpl< DICompositeType >::Flags
unsigned Flags
Definition: LLVMContextImpl.h:561
llvm::MDNodeKeyImpl< DILexicalBlockFile >::File
Metadata * File
Definition: LLVMContextImpl.h:821
DerivedTypes.h
llvm::MDNodeKeyImpl< DIExpression >::Elements
ArrayRef< uint64_t > Elements
Definition: LLVMContextImpl.h:1088
llvm::MDNodeKeyImpl< DIDerivedType >::BaseType
Metadata * BaseType
Definition: LLVMContextImpl.h:467
llvm::DIObjCProperty::getRawType
Metadata * getRawType() const
Definition: DebugInfoMetadata.h:3276
llvm::MDNodeKeyImpl< DIGlobalVariable >::Type
Metadata * Type
Definition: LLVMContextImpl.h:973
llvm::LLVMContextImpl::PointerTypes
DenseMap< Type *, PointerType * > PointerTypes
Definition: LLVMContextImpl.h:1451
llvm::MDNodeOpsKey::calculateHash
static unsigned calculateHash(MDNode *N, unsigned Offset=0)
Definition: LLVMContextImpl.cpp:171
llvm::MDNodeKeyImpl< DIMacro >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:1195
llvm::MDNodeKeyImpl< DIEnumerator >::MDNodeKeyImpl
MDNodeKeyImpl(int64_t Value, bool IsUnsigned, MDString *Name)
Definition: LLVMContextImpl.h:386
llvm::MDNodeKeyImpl< DIModule >::Name
MDString * Name
Definition: LLVMContextImpl.h:889
llvm::MDNodeKeyImpl< DIArgList >::MDNodeKeyImpl
MDNodeKeyImpl(ArrayRef< ValueAsMetadata * > Args)
Definition: LLVMContextImpl.h:1226
llvm::LLVMContextImpl::YieldOpaqueHandle
void * YieldOpaqueHandle
Definition: LLVMContextImpl.h:1362
llvm::DIMacro::getLine
unsigned getLine() const
Definition: DebugInfoMetadata.h:3469
llvm::MDNodeKeyImpl< DISubprogram >::isKeyOf
bool isKeyOf(const DISubprogram *RHS) const
Definition: LLVMContextImpl.h:722
llvm::LLVMContextImpl::DistinctMDNodes
std::vector< MDNode * > DistinctMDNodes
Definition: LLVMContextImpl.h:1393
llvm::MDNodeKeyImpl< DIImportedEntity >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:1153
llvm::DILabel
Label.
Definition: DebugInfoMetadata.h:3133
llvm::DIGenericSubrange::getRawStride
Metadata * getRawStride() const
Definition: DebugInfoMetadata.h:394
llvm::MDNodeKeyImpl< DINamespace >::isKeyOf
bool isKeyOf(const DINamespace *RHS) const
Definition: LLVMContextImpl.h:851
LLVMContext.h
llvm::MDNodeKeyImpl< MDTuple >::MDNodeKeyImpl
MDNodeKeyImpl(const MDTuple *N)
Definition: LLVMContextImpl.h:244
llvm::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: AMDGPUMetadata.h:389
llvm::MDNodeKeyImpl< DIImportedEntity >::File
Metadata * File
Definition: LLVMContextImpl.h:1155
llvm::MDNodeKeyImpl< DIObjCProperty >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:1145
llvm::MDNodeKeyImpl< DILexicalBlockFile >::Discriminator
unsigned Discriminator
Definition: LLVMContextImpl.h:822
llvm::MDNodeKeyImpl< DIGlobalVariableExpression >::Expression
Metadata * Expression
Definition: LLVMContextImpl.h:1104
llvm::LLVMContextImpl::LLVMRS
std::unique_ptr< LLVMRemarkStreamer > LLVMRS
The specialized remark streamer used by LLVM's OptimizationRemarkEmitter.
Definition: LLVMContextImpl.h:1359
llvm::LLVMContextImpl::FP128Ty
Type FP128Ty
Definition: LLVMContextImpl.h:1431
llvm::MDNodeKeyImpl< DIEnumerator >::Name
MDString * Name
Definition: LLVMContextImpl.h:381
llvm::MDNodeKeyImpl< DICompositeType >::Identifier
MDString * Identifier
Definition: LLVMContextImpl.h:566
llvm::MDNodeKeyImpl< DITemplateTypeParameter >::IsDefault
bool IsDefault
Definition: LLVMContextImpl.h:926
llvm::AnonStructTypeKeyInfo::getHashValue
static unsigned getHashValue(const KeyTy &Key)
Definition: LLVMContextImpl.h:106
llvm::MDAttachments::Attachment::Node
TrackingMDNodeRef Node
Definition: LLVMContextImpl.h:1278
llvm::MDNodeKeyImpl< DIGlobalVariable >::Name
MDString * Name
Definition: LLVMContextImpl.h:969
llvm::MDNodeKeyImpl< DICommonBlock >::MDNodeKeyImpl
MDNodeKeyImpl(Metadata *Scope, Metadata *Decl, MDString *Name, Metadata *File, unsigned LineNo)
Definition: LLVMContextImpl.h:868
llvm::MDString
A single uniqued string.
Definition: Metadata.h:611
llvm::DIGlobalVariableExpression::getRawVariable
Metadata * getRawVariable() const
Definition: DebugInfoMetadata.h:3367
llvm::MDNodeKeyImpl< DIEnumerator >::isKeyOf
bool isKeyOf(const DIEnumerator *RHS) const
Definition: LLVMContextImpl.h:393
llvm::MDNodeKeyImpl< DIBasicType >::SizeInBits
uint64_t SizeInBits
Definition: LLVMContextImpl.h:404
llvm::DILexicalBlockFile::getDiscriminator
unsigned getDiscriminator() const
Definition: DebugInfoMetadata.h:2172
llvm::MDNodeKeyImpl< DIModule >::ConfigurationMacros
MDString * ConfigurationMacros
Definition: LLVMContextImpl.h:890
llvm::MDNodeKeyImpl< DICompositeType >::MDNodeKeyImpl
MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, unsigned Flags, Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder, Metadata *TemplateParams, MDString *Identifier, Metadata *Discriminator, Metadata *DataLocation, Metadata *Associated, Metadata *Allocated, Metadata *Rank)
Definition: LLVMContextImpl.h:573
llvm::MDNode::op_begin
op_iterator op_begin() const
Definition: Metadata.h:1092
llvm::MDNodeKeyImpl< DIMacroFile >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:1218
llvm::MDAttachments::get
void get(unsigned ID, SmallVectorImpl< MDNode * > &Result) const
Appends all attachments with the given ID to Result in insertion order.
Definition: Metadata.cpp:1154
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::DILabel::getRawName
MDString * getRawName() const
Definition: DebugInfoMetadata.h:3184
llvm::MDNodeKeyImpl< DILocalVariable >::File
Metadata * File
Definition: LLVMContextImpl.h:1028
llvm::MDNodeKeyImpl< DIModule >::isKeyOf
bool isKeyOf(const DIModule *RHS) const
Definition: LLVMContextImpl.h:909
llvm::LLVMContextImpl::LLVMContextImpl
LLVMContextImpl(LLVMContext &C)
Definition: LLVMContextImpl.cpp:30
File
Instrumentation for Order File
Definition: InstrOrderFile.cpp:206
llvm::MDNodeKeyImpl< DIGlobalVariable >::MDNodeKeyImpl
MDNodeKeyImpl(Metadata *Scope, MDString *Name, MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type, bool IsLocalToUnit, bool IsDefinition, Metadata *StaticDataMemberDeclaration, Metadata *TemplateParams, uint32_t AlignInBits)
Definition: LLVMContextImpl.h:980
llvm::DIObjCProperty::getLine
unsigned getLine() const
Definition: DebugInfoMetadata.h:3252
llvm::ArrayRef::end
iterator end() const
Definition: ArrayRef.h:154
llvm::DICompositeType::getRawIdentifier
MDString * getRawIdentifier() const
Definition: DebugInfoMetadata.h:1197
llvm::LLVMContextImpl::FunctionTypes
FunctionTypeSet FunctionTypes
Definition: LLVMContextImpl.h:1440
llvm::DICommonBlock::getRawScope
Metadata * getRawScope() const
Definition: DebugInfoMetadata.h:3040
llvm::DIFile
File.
Definition: DebugInfoMetadata.h:530
llvm::MDNodeKeyImpl< DIObjCProperty >::MDNodeKeyImpl
MDNodeKeyImpl(MDString *Name, Metadata *File, unsigned Line, MDString *GetterName, MDString *SetterName, unsigned Attributes, Metadata *Type)
Definition: LLVMContextImpl.h:1128
llvm::MDNodeKeyImpl< DIModule >::APINotesFile
MDString * APINotesFile
Definition: LLVMContextImpl.h:892
llvm::FunctionType
Class to represent function types.
Definition: DerivedTypes.h:102
llvm::MDNodeKeyImpl< DIGlobalVariable >::IsLocalToUnit
bool IsLocalToUnit
Definition: LLVMContextImpl.h:974
llvm::DenseMapAPFloatKeyInfo::isEqual
static bool isEqual(const APFloat &LHS, const APFloat &RHS)
Definition: LLVMContextImpl.h:70
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:38
llvm::MDNodeKeyImpl< DIMacroFile >::Elements
Metadata * Elements
Definition: LLVMContextImpl.h:1204