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;
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;
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;
472  unsigned Flags;
475 
476  MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *File, unsigned Line,
477  Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
478  uint32_t AlignInBits, uint64_t OffsetInBits,
479  Optional<unsigned> DWARFAddressSpace, unsigned Flags,
480  Metadata *ExtraData, Metadata *Annotations)
481  : Tag(Tag), Name(Name), File(File), Line(Line), Scope(Scope),
482  BaseType(BaseType), SizeInBits(SizeInBits), OffsetInBits(OffsetInBits),
483  AlignInBits(AlignInBits), DWARFAddressSpace(DWARFAddressSpace),
484  Flags(Flags), ExtraData(ExtraData), Annotations(Annotations) {}
486  : Tag(N->getTag()), Name(N->getRawName()), File(N->getRawFile()),
487  Line(N->getLine()), Scope(N->getRawScope()),
488  BaseType(N->getRawBaseType()), SizeInBits(N->getSizeInBits()),
489  OffsetInBits(N->getOffsetInBits()), AlignInBits(N->getAlignInBits()),
490  DWARFAddressSpace(N->getDWARFAddressSpace()), Flags(N->getFlags()),
491  ExtraData(N->getRawExtraData()), Annotations(N->getRawAnnotations()) {}
492 
493  bool isKeyOf(const DIDerivedType *RHS) const {
494  return Tag == RHS->getTag() && Name == RHS->getRawName() &&
495  File == RHS->getRawFile() && Line == RHS->getLine() &&
496  Scope == RHS->getRawScope() && BaseType == RHS->getRawBaseType() &&
497  SizeInBits == RHS->getSizeInBits() &&
498  AlignInBits == RHS->getAlignInBits() &&
499  OffsetInBits == RHS->getOffsetInBits() &&
500  DWARFAddressSpace == RHS->getDWARFAddressSpace() &&
501  Flags == RHS->getFlags() && ExtraData == RHS->getRawExtraData() &&
502  Annotations == RHS->getRawAnnotations();
503  }
504 
505  unsigned getHashValue() const {
506  // If this is a member inside an ODR type, only hash the type and the name.
507  // Otherwise the hash will be stronger than
508  // MDNodeSubsetEqualImpl::isODRMember().
509  if (Tag == dwarf::DW_TAG_member && Name)
510  if (auto *CT = dyn_cast_or_null<DICompositeType>(Scope))
511  if (CT->getRawIdentifier())
512  return hash_combine(Name, Scope);
513 
514  // Intentionally computes the hash on a subset of the operands for
515  // performance reason. The subset has to be significant enough to avoid
516  // collision "most of the time". There is no correctness issue in case of
517  // collision because of the full check above.
518  return hash_combine(Tag, Name, File, Line, Scope, BaseType, Flags);
519  }
520 };
521 
524 
525  static bool isSubsetEqual(const KeyTy &LHS, const DIDerivedType *RHS) {
526  return isODRMember(LHS.Tag, LHS.Scope, LHS.Name, RHS);
527  }
528 
529  static bool isSubsetEqual(const DIDerivedType *LHS, const DIDerivedType *RHS) {
530  return isODRMember(LHS->getTag(), LHS->getRawScope(), LHS->getRawName(),
531  RHS);
532  }
533 
534  /// Subprograms compare equal if they declare the same function in an ODR
535  /// type.
536  static bool isODRMember(unsigned Tag, const Metadata *Scope,
537  const MDString *Name, const DIDerivedType *RHS) {
538  // Check whether the LHS is eligible.
539  if (Tag != dwarf::DW_TAG_member || !Name)
540  return false;
541 
542  auto *CT = dyn_cast_or_null<DICompositeType>(Scope);
543  if (!CT || !CT->getRawIdentifier())
544  return false;
545 
546  // Compare to the RHS.
547  return Tag == RHS->getTag() && Name == RHS->getRawName() &&
548  Scope == RHS->getRawScope();
549  }
550 };
551 
552 template <> struct MDNodeKeyImpl<DICompositeType> {
553  unsigned Tag;
556  unsigned Line;
562  unsigned Flags;
564  unsigned RuntimeLang;
574 
575  MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *File, unsigned Line,
576  Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
577  uint32_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
578  Metadata *Elements, unsigned RuntimeLang,
579  Metadata *VTableHolder, Metadata *TemplateParams,
580  MDString *Identifier, Metadata *Discriminator,
581  Metadata *DataLocation, Metadata *Associated,
582  Metadata *Allocated, Metadata *Rank, Metadata *Annotations)
583  : Tag(Tag), Name(Name), File(File), Line(Line), Scope(Scope),
584  BaseType(BaseType), SizeInBits(SizeInBits), OffsetInBits(OffsetInBits),
585  AlignInBits(AlignInBits), Flags(Flags), Elements(Elements),
586  RuntimeLang(RuntimeLang), VTableHolder(VTableHolder),
587  TemplateParams(TemplateParams), Identifier(Identifier),
588  Discriminator(Discriminator), DataLocation(DataLocation),
589  Associated(Associated), Allocated(Allocated), Rank(Rank),
592  : Tag(N->getTag()), Name(N->getRawName()), File(N->getRawFile()),
593  Line(N->getLine()), Scope(N->getRawScope()),
594  BaseType(N->getRawBaseType()), SizeInBits(N->getSizeInBits()),
595  OffsetInBits(N->getOffsetInBits()), AlignInBits(N->getAlignInBits()),
596  Flags(N->getFlags()), Elements(N->getRawElements()),
597  RuntimeLang(N->getRuntimeLang()), VTableHolder(N->getRawVTableHolder()),
598  TemplateParams(N->getRawTemplateParams()),
599  Identifier(N->getRawIdentifier()),
600  Discriminator(N->getRawDiscriminator()),
601  DataLocation(N->getRawDataLocation()),
602  Associated(N->getRawAssociated()), Allocated(N->getRawAllocated()),
603  Rank(N->getRawRank()), Annotations(N->getRawAnnotations()) {}
604 
605  bool isKeyOf(const DICompositeType *RHS) const {
606  return Tag == RHS->getTag() && Name == RHS->getRawName() &&
607  File == RHS->getRawFile() && Line == RHS->getLine() &&
608  Scope == RHS->getRawScope() && BaseType == RHS->getRawBaseType() &&
609  SizeInBits == RHS->getSizeInBits() &&
610  AlignInBits == RHS->getAlignInBits() &&
611  OffsetInBits == RHS->getOffsetInBits() && Flags == RHS->getFlags() &&
612  Elements == RHS->getRawElements() &&
613  RuntimeLang == RHS->getRuntimeLang() &&
614  VTableHolder == RHS->getRawVTableHolder() &&
615  TemplateParams == RHS->getRawTemplateParams() &&
616  Identifier == RHS->getRawIdentifier() &&
617  Discriminator == RHS->getRawDiscriminator() &&
618  DataLocation == RHS->getRawDataLocation() &&
619  Associated == RHS->getRawAssociated() &&
620  Allocated == RHS->getRawAllocated() && Rank == RHS->getRawRank() &&
621  Annotations == RHS->getRawAnnotations();
622  }
623 
624  unsigned getHashValue() const {
625  // Intentionally computes the hash on a subset of the operands for
626  // performance reason. The subset has to be significant enough to avoid
627  // collision "most of the time". There is no correctness issue in case of
628  // collision because of the full check above.
629  return hash_combine(Name, File, Line, BaseType, Scope, Elements,
630  TemplateParams, Annotations);
631  }
632 };
633 
634 template <> struct MDNodeKeyImpl<DISubroutineType> {
635  unsigned Flags;
636  uint8_t CC;
638 
639  MDNodeKeyImpl(unsigned Flags, uint8_t CC, Metadata *TypeArray)
640  : Flags(Flags), CC(CC), TypeArray(TypeArray) {}
642  : Flags(N->getFlags()), CC(N->getCC()), TypeArray(N->getRawTypeArray()) {}
643 
644  bool isKeyOf(const DISubroutineType *RHS) const {
645  return Flags == RHS->getFlags() && CC == RHS->getCC() &&
646  TypeArray == RHS->getRawTypeArray();
647  }
648 
649  unsigned getHashValue() const { return hash_combine(Flags, CC, TypeArray); }
650 };
651 
652 template <> struct MDNodeKeyImpl<DIFile> {
657 
658  MDNodeKeyImpl(MDString *Filename, MDString *Directory,
661  : Filename(Filename), Directory(Directory), Checksum(Checksum),
662  Source(Source) {}
664  : Filename(N->getRawFilename()), Directory(N->getRawDirectory()),
665  Checksum(N->getRawChecksum()), Source(N->getRawSource()) {}
666 
667  bool isKeyOf(const DIFile *RHS) const {
668  return Filename == RHS->getRawFilename() &&
669  Directory == RHS->getRawDirectory() &&
670  Checksum == RHS->getRawChecksum() &&
671  Source == RHS->getRawSource();
672  }
673 
674  unsigned getHashValue() const {
675  return hash_combine(
676  Filename, Directory, Checksum ? Checksum->Kind : 0,
677  Checksum ? Checksum->Value : nullptr, Source.getValueOr(nullptr));
678  }
679 };
680 
681 template <> struct MDNodeKeyImpl<DISubprogram> {
686  unsigned Line;
688  unsigned ScopeLine;
690  unsigned VirtualIndex;
692  unsigned Flags;
693  unsigned SPFlags;
700 
702  Metadata *File, unsigned Line, Metadata *Type,
703  unsigned ScopeLine, Metadata *ContainingType,
704  unsigned VirtualIndex, int ThisAdjustment, unsigned Flags,
705  unsigned SPFlags, Metadata *Unit, Metadata *TemplateParams,
706  Metadata *Declaration, Metadata *RetainedNodes,
707  Metadata *ThrownTypes, Metadata *Annotations)
709  Line(Line), Type(Type), ScopeLine(ScopeLine),
710  ContainingType(ContainingType), VirtualIndex(VirtualIndex),
711  ThisAdjustment(ThisAdjustment), Flags(Flags), SPFlags(SPFlags),
712  Unit(Unit), TemplateParams(TemplateParams), Declaration(Declaration),
713  RetainedNodes(RetainedNodes), ThrownTypes(ThrownTypes),
716  : Scope(N->getRawScope()), Name(N->getRawName()),
717  LinkageName(N->getRawLinkageName()), File(N->getRawFile()),
718  Line(N->getLine()), Type(N->getRawType()), ScopeLine(N->getScopeLine()),
719  ContainingType(N->getRawContainingType()),
720  VirtualIndex(N->getVirtualIndex()),
721  ThisAdjustment(N->getThisAdjustment()), Flags(N->getFlags()),
722  SPFlags(N->getSPFlags()), Unit(N->getRawUnit()),
723  TemplateParams(N->getRawTemplateParams()),
724  Declaration(N->getRawDeclaration()),
725  RetainedNodes(N->getRawRetainedNodes()),
726  ThrownTypes(N->getRawThrownTypes()), Annotations(N->getRawAnnotations())
727  {}
728 
729  bool isKeyOf(const DISubprogram *RHS) const {
730  return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
731  LinkageName == RHS->getRawLinkageName() &&
732  File == RHS->getRawFile() && Line == RHS->getLine() &&
733  Type == RHS->getRawType() && ScopeLine == RHS->getScopeLine() &&
734  ContainingType == RHS->getRawContainingType() &&
735  VirtualIndex == RHS->getVirtualIndex() &&
736  ThisAdjustment == RHS->getThisAdjustment() &&
737  Flags == RHS->getFlags() && SPFlags == RHS->getSPFlags() &&
738  Unit == RHS->getUnit() &&
739  TemplateParams == RHS->getRawTemplateParams() &&
740  Declaration == RHS->getRawDeclaration() &&
741  RetainedNodes == RHS->getRawRetainedNodes() &&
742  ThrownTypes == RHS->getRawThrownTypes() &&
743  Annotations == RHS->getRawAnnotations();
744  }
745 
746  bool isDefinition() const { return SPFlags & DISubprogram::SPFlagDefinition; }
747 
748  unsigned getHashValue() const {
749  // If this is a declaration inside an ODR type, only hash the type and the
750  // name. Otherwise the hash will be stronger than
751  // MDNodeSubsetEqualImpl::isDeclarationOfODRMember().
752  if (!isDefinition() && LinkageName)
753  if (auto *CT = dyn_cast_or_null<DICompositeType>(Scope))
754  if (CT->getRawIdentifier())
755  return hash_combine(LinkageName, Scope);
756 
757  // Intentionally computes the hash on a subset of the operands for
758  // performance reason. The subset has to be significant enough to avoid
759  // collision "most of the time". There is no correctness issue in case of
760  // collision because of the full check above.
761  return hash_combine(Name, Scope, File, Type, Line);
762  }
763 };
764 
765 template <> struct MDNodeSubsetEqualImpl<DISubprogram> {
767 
768  static bool isSubsetEqual(const KeyTy &LHS, const DISubprogram *RHS) {
769  return isDeclarationOfODRMember(LHS.isDefinition(), LHS.Scope,
770  LHS.LinkageName, LHS.TemplateParams, RHS);
771  }
772 
773  static bool isSubsetEqual(const DISubprogram *LHS, const DISubprogram *RHS) {
774  return isDeclarationOfODRMember(LHS->isDefinition(), LHS->getRawScope(),
775  LHS->getRawLinkageName(),
776  LHS->getRawTemplateParams(), RHS);
777  }
778 
779  /// Subprograms compare equal if they declare the same function in an ODR
780  /// type.
781  static bool isDeclarationOfODRMember(bool IsDefinition, const Metadata *Scope,
782  const MDString *LinkageName,
783  const Metadata *TemplateParams,
784  const DISubprogram *RHS) {
785  // Check whether the LHS is eligible.
786  if (IsDefinition || !Scope || !LinkageName)
787  return false;
788 
789  auto *CT = dyn_cast_or_null<DICompositeType>(Scope);
790  if (!CT || !CT->getRawIdentifier())
791  return false;
792 
793  // Compare to the RHS.
794  // FIXME: We need to compare template parameters here to avoid incorrect
795  // collisions in mapMetadata when RF_ReuseAndMutateDistinctMDs and a
796  // ODR-DISubprogram has a non-ODR template parameter (i.e., a
797  // DICompositeType that does not have an identifier). Eventually we should
798  // decouple ODR logic from uniquing logic.
799  return IsDefinition == RHS->isDefinition() && Scope == RHS->getRawScope() &&
800  LinkageName == RHS->getRawLinkageName() &&
801  TemplateParams == RHS->getRawTemplateParams();
802  }
803 };
804 
805 template <> struct MDNodeKeyImpl<DILexicalBlock> {
808  unsigned Line;
809  unsigned Column;
810 
811  MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Line, unsigned Column)
812  : Scope(Scope), File(File), Line(Line), Column(Column) {}
814  : Scope(N->getRawScope()), File(N->getRawFile()), Line(N->getLine()),
815  Column(N->getColumn()) {}
816 
817  bool isKeyOf(const DILexicalBlock *RHS) const {
818  return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
819  Line == RHS->getLine() && Column == RHS->getColumn();
820  }
821 
822  unsigned getHashValue() const {
823  return hash_combine(Scope, File, Line, Column);
824  }
825 };
826 
827 template <> struct MDNodeKeyImpl<DILexicalBlockFile> {
830  unsigned Discriminator;
831 
832  MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Discriminator)
833  : Scope(Scope), File(File), Discriminator(Discriminator) {}
835  : Scope(N->getRawScope()), File(N->getRawFile()),
836  Discriminator(N->getDiscriminator()) {}
837 
838  bool isKeyOf(const DILexicalBlockFile *RHS) const {
839  return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
840  Discriminator == RHS->getDiscriminator();
841  }
842 
843  unsigned getHashValue() const {
844  return hash_combine(Scope, File, Discriminator);
845  }
846 };
847 
848 template <> struct MDNodeKeyImpl<DINamespace> {
852 
853  MDNodeKeyImpl(Metadata *Scope, MDString *Name, bool ExportSymbols)
854  : Scope(Scope), Name(Name), ExportSymbols(ExportSymbols) {}
856  : Scope(N->getRawScope()), Name(N->getRawName()),
857  ExportSymbols(N->getExportSymbols()) {}
858 
859  bool isKeyOf(const DINamespace *RHS) const {
860  return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
861  ExportSymbols == RHS->getExportSymbols();
862  }
863 
864  unsigned getHashValue() const {
865  return hash_combine(Scope, Name);
866  }
867 };
868 
869 template <> struct MDNodeKeyImpl<DICommonBlock> {
874  unsigned LineNo;
875 
877  Metadata *File, unsigned LineNo)
878  : Scope(Scope), Decl(Decl), Name(Name), File(File), LineNo(LineNo) {}
880  : Scope(N->getRawScope()), Decl(N->getRawDecl()), Name(N->getRawName()),
881  File(N->getRawFile()), LineNo(N->getLineNo()) {}
882 
883  bool isKeyOf(const DICommonBlock *RHS) const {
884  return Scope == RHS->getRawScope() && Decl == RHS->getRawDecl() &&
885  Name == RHS->getRawName() && File == RHS->getRawFile() &&
886  LineNo == RHS->getLineNo();
887  }
888 
889  unsigned getHashValue() const {
890  return hash_combine(Scope, Decl, Name, File, LineNo);
891  }
892 };
893 
894 template <> struct MDNodeKeyImpl<DIModule> {
901  unsigned LineNo;
902  bool IsDecl;
903 
905  MDString *ConfigurationMacros, MDString *IncludePath,
906  MDString *APINotesFile, unsigned LineNo, bool IsDecl)
907  : File(File), Scope(Scope), Name(Name),
908  ConfigurationMacros(ConfigurationMacros), IncludePath(IncludePath),
909  APINotesFile(APINotesFile), LineNo(LineNo), IsDecl(IsDecl) {}
911  : File(N->getRawFile()), Scope(N->getRawScope()), Name(N->getRawName()),
912  ConfigurationMacros(N->getRawConfigurationMacros()),
913  IncludePath(N->getRawIncludePath()),
914  APINotesFile(N->getRawAPINotesFile()), LineNo(N->getLineNo()),
915  IsDecl(N->getIsDecl()) {}
916 
917  bool isKeyOf(const DIModule *RHS) const {
918  return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
919  ConfigurationMacros == RHS->getRawConfigurationMacros() &&
920  IncludePath == RHS->getRawIncludePath() &&
921  APINotesFile == RHS->getRawAPINotesFile() &&
922  File == RHS->getRawFile() && LineNo == RHS->getLineNo() &&
923  IsDecl == RHS->getIsDecl();
924  }
925 
926  unsigned getHashValue() const {
927  return hash_combine(Scope, Name, ConfigurationMacros, IncludePath);
928  }
929 };
930 
934  bool IsDefault;
935 
937  : Name(Name), Type(Type), IsDefault(IsDefault) {}
939  : Name(N->getRawName()), Type(N->getRawType()),
940  IsDefault(N->isDefault()) {}
941 
942  bool isKeyOf(const DITemplateTypeParameter *RHS) const {
943  return Name == RHS->getRawName() && Type == RHS->getRawType() &&
944  IsDefault == RHS->isDefault();
945  }
946 
947  unsigned getHashValue() const { return hash_combine(Name, Type, IsDefault); }
948 };
949 
951  unsigned Tag;
954  bool IsDefault;
956 
957  MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *Type, bool IsDefault,
958  Metadata *Value)
959  : Tag(Tag), Name(Name), Type(Type), IsDefault(IsDefault), Value(Value) {}
961  : Tag(N->getTag()), Name(N->getRawName()), Type(N->getRawType()),
962  IsDefault(N->isDefault()), Value(N->getValue()) {}
963 
964  bool isKeyOf(const DITemplateValueParameter *RHS) const {
965  return Tag == RHS->getTag() && Name == RHS->getRawName() &&
966  Type == RHS->getRawType() && IsDefault == RHS->isDefault() &&
967  Value == RHS->getValue();
968  }
969 
970  unsigned getHashValue() const {
971  return hash_combine(Tag, Name, Type, IsDefault, Value);
972  }
973 };
974 
975 template <> struct MDNodeKeyImpl<DIGlobalVariable> {
980  unsigned Line;
988 
990  Metadata *File, unsigned Line, Metadata *Type,
991  bool IsLocalToUnit, bool IsDefinition,
992  Metadata *StaticDataMemberDeclaration, Metadata *TemplateParams,
993  uint32_t AlignInBits, Metadata *Annotations)
995  Line(Line), Type(Type), IsLocalToUnit(IsLocalToUnit),
996  IsDefinition(IsDefinition),
997  StaticDataMemberDeclaration(StaticDataMemberDeclaration),
998  TemplateParams(TemplateParams), AlignInBits(AlignInBits),
1001  : Scope(N->getRawScope()), Name(N->getRawName()),
1002  LinkageName(N->getRawLinkageName()), File(N->getRawFile()),
1003  Line(N->getLine()), Type(N->getRawType()),
1004  IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()),
1005  StaticDataMemberDeclaration(N->getRawStaticDataMemberDeclaration()),
1006  TemplateParams(N->getRawTemplateParams()),
1007  AlignInBits(N->getAlignInBits()), Annotations(N->getRawAnnotations()) {}
1008 
1009  bool isKeyOf(const DIGlobalVariable *RHS) const {
1010  return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
1011  LinkageName == RHS->getRawLinkageName() &&
1012  File == RHS->getRawFile() && Line == RHS->getLine() &&
1013  Type == RHS->getRawType() && IsLocalToUnit == RHS->isLocalToUnit() &&
1014  IsDefinition == RHS->isDefinition() &&
1015  StaticDataMemberDeclaration ==
1017  TemplateParams == RHS->getRawTemplateParams() &&
1018  AlignInBits == RHS->getAlignInBits() &&
1019  Annotations == RHS->getRawAnnotations();
1020  }
1021 
1022  unsigned getHashValue() const {
1023  // We do not use AlignInBits in hashing function here on purpose:
1024  // in most cases this param for local variable is zero (for function param
1025  // it is always zero). This leads to lots of hash collisions and errors on
1026  // cases with lots of similar variables.
1027  // clang/test/CodeGen/debug-info-257-args.c is an example of this problem,
1028  // generated IR is random for each run and test fails with Align included.
1029  // TODO: make hashing work fine with such situations
1030  return hash_combine(Scope, Name, LinkageName, File, Line, Type,
1031  IsLocalToUnit, IsDefinition, /* AlignInBits, */
1032  StaticDataMemberDeclaration, Annotations);
1033  }
1034 };
1035 
1036 template <> struct MDNodeKeyImpl<DILocalVariable> {
1040  unsigned Line;
1042  unsigned Arg;
1043  unsigned Flags;
1046 
1048  Metadata *Type, unsigned Arg, unsigned Flags,
1049  uint32_t AlignInBits, Metadata *Annotations)
1050  : Scope(Scope), Name(Name), File(File), Line(Line), Type(Type), Arg(Arg),
1051  Flags(Flags), AlignInBits(AlignInBits), Annotations(Annotations) {}
1053  : Scope(N->getRawScope()), Name(N->getRawName()), File(N->getRawFile()),
1054  Line(N->getLine()), Type(N->getRawType()), Arg(N->getArg()),
1055  Flags(N->getFlags()), AlignInBits(N->getAlignInBits()),
1056  Annotations(N->getRawAnnotations()) {}
1057 
1058  bool isKeyOf(const DILocalVariable *RHS) const {
1059  return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
1060  File == RHS->getRawFile() && Line == RHS->getLine() &&
1061  Type == RHS->getRawType() && Arg == RHS->getArg() &&
1062  Flags == RHS->getFlags() && AlignInBits == RHS->getAlignInBits() &&
1063  Annotations == RHS->getRawAnnotations();
1064  }
1065 
1066  unsigned getHashValue() const {
1067  // We do not use AlignInBits in hashing function here on purpose:
1068  // in most cases this param for local variable is zero (for function param
1069  // it is always zero). This leads to lots of hash collisions and errors on
1070  // cases with lots of similar variables.
1071  // clang/test/CodeGen/debug-info-257-args.c is an example of this problem,
1072  // generated IR is random for each run and test fails with Align included.
1073  // TODO: make hashing work fine with such situations
1074  return hash_combine(Scope, Name, File, Line, Type, Arg, Flags, Annotations);
1075  }
1076 };
1077 
1078 template <> struct MDNodeKeyImpl<DILabel> {
1082  unsigned Line;
1083 
1085  : Scope(Scope), Name(Name), File(File), Line(Line) {}
1087  : Scope(N->getRawScope()), Name(N->getRawName()), File(N->getRawFile()),
1088  Line(N->getLine()) {}
1089 
1090  bool isKeyOf(const DILabel *RHS) const {
1091  return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
1092  File == RHS->getRawFile() && Line == RHS->getLine();
1093  }
1094 
1095  /// Using name and line to get hash value. It should already be mostly unique.
1096  unsigned getHashValue() const {
1097  return hash_combine(Scope, Name, Line);
1098  }
1099 };
1100 
1101 template <> struct MDNodeKeyImpl<DIExpression> {
1103 
1104  MDNodeKeyImpl(ArrayRef<uint64_t> Elements) : Elements(Elements) {}
1105  MDNodeKeyImpl(const DIExpression *N) : Elements(N->getElements()) {}
1106 
1107  bool isKeyOf(const DIExpression *RHS) const {
1108  return Elements == RHS->getElements();
1109  }
1110 
1111  unsigned getHashValue() const {
1112  return hash_combine_range(Elements.begin(), Elements.end());
1113  }
1114 };
1115 
1119 
1121  : Variable(Variable), Expression(Expression) {}
1123  : Variable(N->getRawVariable()), Expression(N->getRawExpression()) {}
1124 
1125  bool isKeyOf(const DIGlobalVariableExpression *RHS) const {
1126  return Variable == RHS->getRawVariable() &&
1127  Expression == RHS->getRawExpression();
1128  }
1129 
1130  unsigned getHashValue() const { return hash_combine(Variable, Expression); }
1131 };
1132 
1133 template <> struct MDNodeKeyImpl<DIObjCProperty> {
1136  unsigned Line;
1139  unsigned Attributes;
1141 
1143  MDString *GetterName, MDString *SetterName, unsigned Attributes,
1144  Metadata *Type)
1145  : Name(Name), File(File), Line(Line), GetterName(GetterName),
1146  SetterName(SetterName), Attributes(Attributes), Type(Type) {}
1148  : Name(N->getRawName()), File(N->getRawFile()), Line(N->getLine()),
1149  GetterName(N->getRawGetterName()), SetterName(N->getRawSetterName()),
1150  Attributes(N->getAttributes()), Type(N->getRawType()) {}
1151 
1152  bool isKeyOf(const DIObjCProperty *RHS) const {
1153  return Name == RHS->getRawName() && File == RHS->getRawFile() &&
1154  Line == RHS->getLine() && GetterName == RHS->getRawGetterName() &&
1155  SetterName == RHS->getRawSetterName() &&
1156  Attributes == RHS->getAttributes() && Type == RHS->getRawType();
1157  }
1158 
1159  unsigned getHashValue() const {
1160  return hash_combine(Name, File, Line, GetterName, SetterName, Attributes,
1161  Type);
1162  }
1163 };
1164 
1165 template <> struct MDNodeKeyImpl<DIImportedEntity> {
1166  unsigned Tag;
1170  unsigned Line;
1173 
1174  MDNodeKeyImpl(unsigned Tag, Metadata *Scope, Metadata *Entity, Metadata *File,
1175  unsigned Line, MDString *Name, Metadata *Elements)
1176  : Tag(Tag), Scope(Scope), Entity(Entity), File(File), Line(Line),
1177  Name(Name), Elements(Elements) {}
1179  : Tag(N->getTag()), Scope(N->getRawScope()), Entity(N->getRawEntity()),
1180  File(N->getRawFile()), Line(N->getLine()), Name(N->getRawName()),
1181  Elements(N->getRawElements()) {}
1182 
1183  bool isKeyOf(const DIImportedEntity *RHS) const {
1184  return Tag == RHS->getTag() && Scope == RHS->getRawScope() &&
1185  Entity == RHS->getRawEntity() && File == RHS->getFile() &&
1186  Line == RHS->getLine() && Name == RHS->getRawName() &&
1187  Elements == RHS->getRawElements();
1188  }
1189 
1190  unsigned getHashValue() const {
1191  return hash_combine(Tag, Scope, Entity, File, Line, Name, Elements);
1192  }
1193 };
1194 
1195 template <> struct MDNodeKeyImpl<DIMacro> {
1196  unsigned MIType;
1197  unsigned Line;
1200 
1201  MDNodeKeyImpl(unsigned MIType, unsigned Line, MDString *Name, MDString *Value)
1202  : MIType(MIType), Line(Line), Name(Name), Value(Value) {}
1204  : MIType(N->getMacinfoType()), Line(N->getLine()), Name(N->getRawName()),
1205  Value(N->getRawValue()) {}
1206 
1207  bool isKeyOf(const DIMacro *RHS) const {
1208  return MIType == RHS->getMacinfoType() && Line == RHS->getLine() &&
1209  Name == RHS->getRawName() && Value == RHS->getRawValue();
1210  }
1211 
1212  unsigned getHashValue() const {
1213  return hash_combine(MIType, Line, Name, Value);
1214  }
1215 };
1216 
1217 template <> struct MDNodeKeyImpl<DIMacroFile> {
1218  unsigned MIType;
1219  unsigned Line;
1222 
1223  MDNodeKeyImpl(unsigned MIType, unsigned Line, Metadata *File,
1224  Metadata *Elements)
1225  : MIType(MIType), Line(Line), File(File), Elements(Elements) {}
1227  : MIType(N->getMacinfoType()), Line(N->getLine()), File(N->getRawFile()),
1228  Elements(N->getRawElements()) {}
1229 
1230  bool isKeyOf(const DIMacroFile *RHS) const {
1231  return MIType == RHS->getMacinfoType() && Line == RHS->getLine() &&
1232  File == RHS->getRawFile() && Elements == RHS->getRawElements();
1233  }
1234 
1235  unsigned getHashValue() const {
1236  return hash_combine(MIType, Line, File, Elements);
1237  }
1238 };
1239 
1240 template <> struct MDNodeKeyImpl<DIArgList> {
1242 
1244  MDNodeKeyImpl(const DIArgList *N) : Args(N->getArgs()) {}
1245 
1246  bool isKeyOf(const DIArgList *RHS) const { return Args == RHS->getArgs(); }
1247 
1248  unsigned getHashValue() const {
1249  return hash_combine_range(Args.begin(), Args.end());
1250  }
1251 };
1252 
1253 /// DenseMapInfo for MDNode subclasses.
1254 template <class NodeTy> struct MDNodeInfo {
1257 
1258  static inline NodeTy *getEmptyKey() {
1260  }
1261 
1262  static inline NodeTy *getTombstoneKey() {
1264  }
1265 
1266  static unsigned getHashValue(const KeyTy &Key) { return Key.getHashValue(); }
1267 
1268  static unsigned getHashValue(const NodeTy *N) {
1269  return KeyTy(N).getHashValue();
1270  }
1271 
1272  static bool isEqual(const KeyTy &LHS, const NodeTy *RHS) {
1273  if (RHS == getEmptyKey() || RHS == getTombstoneKey())
1274  return false;
1275  return SubsetEqualTy::isSubsetEqual(LHS, RHS) || LHS.isKeyOf(RHS);
1276  }
1277 
1278  static bool isEqual(const NodeTy *LHS, const NodeTy *RHS) {
1279  if (LHS == RHS)
1280  return true;
1281  if (RHS == getEmptyKey() || RHS == getTombstoneKey())
1282  return false;
1283  return SubsetEqualTy::isSubsetEqual(LHS, RHS);
1284  }
1285 };
1286 
1287 #define HANDLE_MDNODE_LEAF(CLASS) using CLASS##Info = MDNodeInfo<CLASS>;
1288 #include "llvm/IR/Metadata.def"
1289 
1290 /// Multimap-like storage for metadata attachments.
1292 public:
1293  struct Attachment {
1294  unsigned MDKind;
1296  };
1297 
1298 private:
1299  SmallVector<Attachment, 1> Attachments;
1300 
1301 public:
1302  bool empty() const { return Attachments.empty(); }
1303  size_t size() const { return Attachments.size(); }
1304 
1305  /// Returns the first attachment with the given ID or nullptr if no such
1306  /// attachment exists.
1307  MDNode *lookup(unsigned ID) const;
1308 
1309  /// Appends all attachments with the given ID to \c Result in insertion order.
1310  /// If the global has no attachments with the given ID, or if ID is invalid,
1311  /// leaves Result unchanged.
1312  void get(unsigned ID, SmallVectorImpl<MDNode *> &Result) const;
1313 
1314  /// Appends all attachments for the global to \c Result, sorting by attachment
1315  /// ID. Attachments with the same ID appear in insertion order. This function
1316  /// does \em not clear \c Result.
1317  void getAll(SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const;
1318 
1319  /// Set an attachment to a particular node.
1320  ///
1321  /// Set the \c ID attachment to \c MD, replacing the current attachments at \c
1322  /// ID (if anyway).
1323  void set(unsigned ID, MDNode *MD);
1324 
1325  /// Adds an attachment to a particular node.
1326  void insert(unsigned ID, MDNode &MD);
1327 
1328  /// Remove attachments with the given ID.
1329  ///
1330  /// Remove the attachments at \c ID, if any.
1331  bool erase(unsigned ID);
1332 
1333  /// Erase matching attachments.
1334  ///
1335  /// Erases all attachments matching the \c shouldRemove predicate.
1336  template <class PredTy> void remove_if(PredTy shouldRemove) {
1337  llvm::erase_if(Attachments, shouldRemove);
1338  }
1339 };
1340 
1342 public:
1343  /// OwnedModules - The set of modules instantiated in this context, and which
1344  /// will be automatically deleted if this context is deleted.
1346 
1347  /// The main remark streamer used by all the other streamers (e.g. IR, MIR,
1348  /// frontends, etc.). This should only be used by the specific streamers, and
1349  /// never directly.
1350  std::unique_ptr<remarks::RemarkStreamer> MainRemarkStreamer;
1351 
1352  std::unique_ptr<DiagnosticHandler> DiagHandler;
1355  /// The minimum hotness value a diagnostic needs in order to be included in
1356  /// optimization diagnostics.
1357  ///
1358  /// The threshold is an Optional value, which maps to one of the 3 states:
1359  /// 1). 0 => threshold disabled. All emarks will be printed.
1360  /// 2). positive int => manual threshold by user. Remarks with hotness exceed
1361  /// threshold will be printed.
1362  /// 3). None => 'auto' threshold by user. The actual value is not
1363  /// available at command line, but will be synced with
1364  /// hotness threhold from profile summary during
1365  /// compilation.
1366  ///
1367  /// State 1 and 2 are considered as terminal states. State transition is
1368  /// only allowed from 3 to 2, when the threshold is first synced with profile
1369  /// summary. This ensures that the threshold is set only once and stays
1370  /// constant.
1371  ///
1372  /// If threshold option is not specified, it is disabled (0) by default.
1374 
1375  /// The specialized remark streamer used by LLVM's OptimizationRemarkEmitter.
1376  std::unique_ptr<LLVMRemarkStreamer> LLVMRS;
1377 
1379  void *YieldOpaqueHandle = nullptr;
1380 
1381  using IntMapTy =
1384 
1385  using FPMapTy =
1388 
1392 
1396 
1398 
1399 #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
1400  DenseSet<CLASS *, CLASS##Info> CLASS##s;
1401 #include "llvm/IR/Metadata.def"
1402 
1403  // Optional map for looking up composite types by identifier.
1405 
1406  // MDNodes may be uniqued or not uniqued. When they're not uniqued, they
1407  // aren't in the MDNodeSet, but they're still shared between objects, so no
1408  // one object can destroy them. Keep track of them here so we can delete
1409  // them on context teardown.
1410  std::vector<MDNode *> DistinctMDNodes;
1411 
1413 
1416 
1419 
1422 
1424 
1426 
1428 
1430 
1433 
1435 
1437 
1439 
1442 
1443  std::unique_ptr<ConstantTokenNone> TheNoneToken;
1444 
1445  // Basic type instances.
1450 
1453 
1455 
1462 
1465  // TODO: clean up the following after we no longer support non-opaque pointer
1466  // types.
1468  DenseMap<Type*, PointerType*> PointerTypes; // Pointers in AddrSpace = 0
1470 
1471  /// ValueHandles - This map keeps track of all of the value handles that are
1472  /// watching a Value*. The Value::HasValueHandle bit is used to know
1473  /// whether or not a value has an entry in this map.
1476 
1477  /// CustomMDKindNames - Map to hold the metadata string to ID mapping.
1479 
1480  /// Collection of metadata used in this context.
1482 
1483  /// Collection of per-GlobalObject sections used in this context.
1485 
1486  /// Collection of per-GlobalValue partitions used in this context.
1488 
1489  /// DiscriminatorTable - This table maps file:line locations to an
1490  /// integer representing the next DWARF path discriminator to assign to
1491  /// instructions in different blocks at the same location.
1493 
1494  /// A set of interned tags for operand bundles. The StringMap maps
1495  /// bundle tags to their IDs.
1496  ///
1497  /// \see LLVMContext::getOperandBundleTagID
1499 
1503 
1504  /// A set of interned synchronization scopes. The StringMap maps
1505  /// synchronization scope names to their respective synchronization scope IDs.
1507 
1508  /// getOrInsertSyncScopeID - Maps synchronization scope name to
1509  /// synchronization scope ID. Every synchronization scope registered with
1510  /// LLVMContext has unique ID except pre-defined ones.
1512 
1513  /// getSyncScopeNames - Populates client supplied SmallVector with
1514  /// synchronization scope names registered with LLVMContext. Synchronization
1515  /// scope names are ordered by increasing synchronization scope IDs.
1517 
1518  /// Maintain the GC name for each function.
1519  ///
1520  /// This saves allocating an additional word in Function for programs which
1521  /// do not use GC (i.e., most programs) at the cost of increased overhead for
1522  /// clients which do use GC.
1524 
1525  /// Flag to indicate if Value (other than GlobalValue) retains their name or
1526  /// not.
1527  bool DiscardValueNames = false;
1528 
1530  ~LLVMContextImpl();
1531 
1532  /// Destroy the ConstantArrays if they are not used.
1534 
1535  mutable OptPassGate *OPG = nullptr;
1536 
1537  /// Access the object which can disable optional passes and individual
1538  /// optimizations at compile time.
1539  OptPassGate &getOptPassGate() const;
1540 
1541  /// Set the object which can disable optional passes and individual
1542  /// optimizations at compile time.
1543  ///
1544  /// The lifetime of the object must be guaranteed to extend as long as the
1545  /// LLVMContext is used by compilation.
1546  void setOptPassGate(OptPassGate&);
1547 };
1548 
1549 } // end namespace llvm
1550 
1551 #endif // LLVM_LIB_IR_LLVMCONTEXTIMPL_H
llvm::MDNodeKeyImpl< DIGlobalVariable >::IsDefinition
bool IsDefinition
Definition: LLVMContextImpl.h:983
llvm::MDNodeKeyImpl< DISubprogram >::isDefinition
bool isDefinition() const
Definition: LLVMContextImpl.h:746
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:964
llvm::MDNodeKeyImpl< DIGlobalVariableExpression >::Variable
Metadata * Variable
Definition: LLVMContextImpl.h:1117
llvm::FunctionTypeKeyInfo::getTombstoneKey
static FunctionType * getTombstoneKey()
Definition: LLVMContextImpl.h:157
llvm::LLVMContextImpl::Alloc
BumpPtrAllocator Alloc
Definition: LLVMContextImpl.h:1451
llvm::lltok::APFloat
@ APFloat
Definition: LLToken.h:495
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:1345
llvm::AnonStructTypeKeyInfo::KeyTy::ETypes
ArrayRef< Type * > ETypes
Definition: LLVMContextImpl.h:77
llvm::MDNodeKeyImpl< DICompositeType >::TemplateParams
Metadata * TemplateParams
Definition: LLVMContextImpl.h:566
llvm::MDNodeKeyImpl< DISubrange >::CountNode
Metadata * CountNode
Definition: LLVMContextImpl.h:305
llvm::MDAttachments::Attachment::MDKind
unsigned MDKind
Definition: LLVMContextImpl.h:1294
llvm::DenseMapAPFloatKeyInfo::getHashValue
static unsigned getHashValue(const APFloat &Key)
Definition: LLVMContextImpl.h:66
llvm::LLVMContextImpl::InlineAsms
ConstantUniqueMap< InlineAsm > InlineAsms
Definition: LLVMContextImpl.h:1438
llvm::MDNodeKeyImpl< DIImportedEntity >::MDNodeKeyImpl
MDNodeKeyImpl(unsigned Tag, Metadata *Scope, Metadata *Entity, Metadata *File, unsigned Line, MDString *Name, Metadata *Elements)
Definition: LLVMContextImpl.h:1174
llvm::MDNodeKeyImpl< DIImportedEntity >::Entity
Metadata * Entity
Definition: LLVMContextImpl.h:1168
llvm::MDNodeKeyImpl< DIExpression >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:1111
llvm::DILabel::getLine
unsigned getLine() const
Definition: DebugInfoMetadata.h:3231
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:889
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:3604
llvm::MDNodeKeyImpl< GenericDINode >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:297
llvm::MDNodeKeyImpl< DISubprogram >::LinkageName
MDString * LinkageName
Definition: LLVMContextImpl.h:684
llvm
This file implements support for optimizing divisions by a constant.
Definition: AllocatorList.h:23
llvm::MDNodeKeyImpl< DILexicalBlockFile >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:828
llvm::LLVMContextImpl::OpaquePointers
bool OpaquePointers
Definition: LLVMContextImpl.h:1467
llvm::DICompositeType::getRawDataLocation
Metadata * getRawDataLocation() const
Definition: DebugInfoMetadata.h:1213
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:1432
llvm::StringMapEntry< uint32_t >
Optional.h
llvm::MDNodeKeyImpl< DISubroutineType >::isKeyOf
bool isKeyOf(const DISubroutineType *RHS) const
Definition: LLVMContextImpl.h:644
llvm::MDNodeKeyImpl< DITemplateTypeParameter >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:947
llvm::MDNodeKeyImpl< DIDerivedType >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:505
llvm::DIGenericSubrange::getRawCountNode
Metadata * getRawCountNode() const
Definition: DebugInfoMetadata.h:391
llvm::DIMacroNode::getMacinfoType
unsigned getMacinfoType() const
Definition: DebugInfoMetadata.h:3478
llvm::MDNodeKeyImpl< DIModule >::IsDecl
bool IsDecl
Definition: LLVMContextImpl.h:902
llvm::MDNodeKeyImpl< DIObjCProperty >::Line
unsigned Line
Definition: LLVMContextImpl.h:1136
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:811
llvm::MDNodeKeyImpl< DISubprogram >::MDNodeKeyImpl
MDNodeKeyImpl(const DISubprogram *N)
Definition: LLVMContextImpl.h:715
llvm::DIType::getSizeInBits
uint64_t getSizeInBits() const
Definition: DebugInfoMetadata.h:701
llvm::MDNodeKeyImpl< DINamespace >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:849
llvm::DIObjCProperty::getRawGetterName
MDString * getRawGetterName() const
Definition: DebugInfoMetadata.h:3326
DebugInfoMetadata.h
llvm::LLVMContextImpl::FPConstants
FPMapTy FPConstants
Definition: LLVMContextImpl.h:1387
llvm::MDNodeKeyImpl< DIArgList >::MDNodeKeyImpl
MDNodeKeyImpl(const DIArgList *N)
Definition: LLVMContextImpl.h:1244
llvm::LLVMContextImpl::DiscardValueNames
bool DiscardValueNames
Flag to indicate if Value (other than GlobalValue) retains their name or not.
Definition: LLVMContextImpl.h:1527
llvm::MDNodeKeyImpl< MDTuple >::calculateHash
static unsigned calculateHash(MDTuple *N)
Definition: LLVMContextImpl.h:250
llvm::MDNodeKeyImpl< DIImportedEntity >::Tag
unsigned Tag
Definition: LLVMContextImpl.h:1166
llvm::DIGenericSubrange
Definition: DebugInfoMetadata.h:362
llvm::MDNodeKeyImpl< DICommonBlock >::File
Metadata * File
Definition: LLVMContextImpl.h:873
llvm::LLVMContextImpl::IntegerTypes
DenseMap< unsigned, IntegerType * > IntegerTypes
Definition: LLVMContextImpl.h:1454
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:1449
llvm::LLVMContextImpl::UVConstants
DenseMap< Type *, std::unique_ptr< UndefValue > > UVConstants
Definition: LLVMContextImpl.h:1425
llvm::MDNodeKeyImpl< DITemplateTypeParameter >::MDNodeKeyImpl
MDNodeKeyImpl(MDString *Name, Metadata *Type, bool IsDefault)
Definition: LLVMContextImpl.h:936
llvm::MDNodeKeyImpl< DIDerivedType >::Flags
unsigned Flags
Definition: LLVMContextImpl.h:472
llvm::MDNodeKeyImpl< DINamespace >::Name
MDString * Name
Definition: LLVMContextImpl.h:850
llvm::LLVMContextImpl::FloatTy
Type FloatTy
Definition: LLVMContextImpl.h:1446
llvm::DICommonBlock::getRawDecl
Metadata * getRawDecl() const
Definition: DebugInfoMetadata.h:3085
llvm::MDNodeKeyImpl< DICompositeType >::Discriminator
Metadata * Discriminator
Definition: LLVMContextImpl.h:568
llvm::MDNodeKeyImpl< DIImportedEntity >::isKeyOf
bool isKeyOf(const DIImportedEntity *RHS) const
Definition: LLVMContextImpl.h:1183
llvm::MDNodeInfo::isEqual
static bool isEqual(const NodeTy *LHS, const NodeTy *RHS)
Definition: LLVMContextImpl.h:1278
llvm::DIObjCProperty::getRawSetterName
MDString * getRawSetterName() const
Definition: DebugInfoMetadata.h:3327
llvm::MDNodeKeyImpl< DIFile >::Filename
MDString * Filename
Definition: LLVMContextImpl.h:653
llvm::DILexicalBlockFile
Definition: DebugInfoMetadata.h:2159
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:1303
llvm::MDNodeInfo::getEmptyKey
static NodeTy * getEmptyKey()
Definition: LLVMContextImpl.h:1258
llvm::DITemplateParameter::isDefault
bool isDefault() const
Definition: DebugInfoMetadata.h:2418
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:855
llvm::MDNodeKeyImpl< DISubprogram >::Declaration
Metadata * Declaration
Definition: LLVMContextImpl.h:696
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:1732
llvm::LLVMContextImpl::ExprConstants
ConstantUniqueMap< ConstantExpr > ExprConstants
Definition: LLVMContextImpl.h:1436
llvm::DIObjCProperty::getRawName
MDString * getRawName() const
Definition: DebugInfoMetadata.h:3324
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:233
llvm::MDNodeKeyImpl< DILocation >::Column
unsigned Column
Definition: LLVMContextImpl.h:258
llvm::MDNodeKeyImpl< DILocalVariable >::MDNodeKeyImpl
MDNodeKeyImpl(Metadata *Scope, MDString *Name, Metadata *File, unsigned Line, Metadata *Type, unsigned Arg, unsigned Flags, uint32_t AlignInBits, Metadata *Annotations)
Definition: LLVMContextImpl.h:1047
llvm::MDNodeInfo::getHashValue
static unsigned getHashValue(const KeyTy &Key)
Definition: LLVMContextImpl.h:1266
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:639
llvm::MDNodeKeyImpl< DIGenericSubrange >::Stride
Metadata * Stride
Definition: LLVMContextImpl.h:353
llvm::MDNodeKeyImpl< DIGlobalVariableExpression >::isKeyOf
bool isKeyOf(const DIGlobalVariableExpression *RHS) const
Definition: LLVMContextImpl.h:1125
llvm::MDNodeKeyImpl< DILocalVariable >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:1066
APInt.h
llvm::MDNodeKeyImpl< DIFile >::MDNodeKeyImpl
MDNodeKeyImpl(MDString *Filename, MDString *Directory, Optional< DIFile::ChecksumInfo< MDString * >> Checksum, Optional< MDString * > Source)
Definition: LLVMContextImpl.h:658
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:560
llvm::MDNodeKeyImpl< DIBasicType >::isKeyOf
bool isKeyOf(const DIBasicType *RHS) const
Definition: LLVMContextImpl.h:417
llvm::DILocation
Debug location.
Definition: DebugInfoMetadata.h:1580
llvm::DIType::getAlignInBits
uint32_t getAlignInBits() const
Definition: DebugInfoMetadata.h:702
llvm::MDNodeKeyImpl< DISubprogram >::Annotations
Metadata * Annotations
Definition: LLVMContextImpl.h:699
llvm::MDNodeKeyImpl< DILabel >::MDNodeKeyImpl
MDNodeKeyImpl(const DILabel *N)
Definition: LLVMContextImpl.h:1086
llvm::MDNodeKeyImpl< DILexicalBlock >::MDNodeKeyImpl
MDNodeKeyImpl(const DILexicalBlock *N)
Definition: LLVMContextImpl.h:813
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:1255
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:1350
llvm::DICompositeType::getRawVTableHolder
Metadata * getRawVTableHolder() const
Definition: DebugInfoMetadata.h:1208
llvm::GenericDINode::getRawHeader
MDString * getRawHeader() const
Definition: DebugInfoMetadata.h:271
llvm::MDNodeKeyImpl< DIImportedEntity >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:1190
llvm::MDNodeKeyImpl< DIFile >::Directory
MDString * Directory
Definition: LLVMContextImpl.h:654
llvm::MDNodeKeyImpl< DIMacro >::MDNodeKeyImpl
MDNodeKeyImpl(unsigned MIType, unsigned Line, MDString *Name, MDString *Value)
Definition: LLVMContextImpl.h:1201
llvm::MDNodeKeyImpl< DILexicalBlockFile >::isKeyOf
bool isKeyOf(const DILexicalBlockFile *RHS) const
Definition: LLVMContextImpl.h:838
llvm::MDNodeKeyImpl< DIGlobalVariableExpression >::MDNodeKeyImpl
MDNodeKeyImpl(Metadata *Variable, Metadata *Expression)
Definition: LLVMContextImpl.h:1120
llvm::LLVMContextImpl::DiagnosticsHotnessRequested
bool DiagnosticsHotnessRequested
Definition: LLVMContextImpl.h:1354
llvm::MDNodeKeyImpl< DIGlobalVariable >::File
Metadata * File
Definition: LLVMContextImpl.h:979
llvm::LLVMContextImpl::X86_AMXTy
Type X86_AMXTy
Definition: LLVMContextImpl.h:1448
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:748
llvm::MDNodeKeyImpl< DISubprogram >::ContainingType
Metadata * ContainingType
Definition: LLVMContextImpl.h:689
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:1134
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, Metadata *Annotations)
Definition: LLVMContextImpl.h:575
llvm::MDNodeKeyImpl< DIMacro >::MDNodeKeyImpl
MDNodeKeyImpl(const DIMacro *N)
Definition: LLVMContextImpl.h:1203
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:1394
llvm::MDNodeKeyImpl< DIDerivedType >::File
Metadata * File
Definition: LLVMContextImpl.h:464
llvm::DIExpression
DWARF expression.
Definition: DebugInfoMetadata.h:2586
llvm::ArrayType
Class to represent array types.
Definition: DerivedTypes.h:357
llvm::MDNodeKeyImpl< DITemplateTypeParameter >::MDNodeKeyImpl
MDNodeKeyImpl(const DITemplateTypeParameter *N)
Definition: LLVMContextImpl.h:938
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:1219
llvm::DINameKind::LinkageName
@ LinkageName
BaseType
llvm::LLVMContextImpl::ValueNames
DenseMap< const Value *, ValueName * > ValueNames
Definition: LLVMContextImpl.h:1397
llvm::LLVMContextImpl::~LLVMContextImpl
~LLVMContextImpl()
Definition: LLVMContextImpl.cpp:41
llvm::hash_value
hash_code hash_value(const APFloat &Arg)
See friend declarations above.
Definition: APFloat.cpp:4821
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, Metadata *Annotations)
Definition: LLVMContextImpl.h:476
llvm::MDNodeInfo
DenseMapInfo for MDNode subclasses.
Definition: LLVMContextImpl.h:1254
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:1434
llvm::MDNodeKeyImpl< DIGlobalVariable >::Annotations
Metadata * Annotations
Definition: LLVMContextImpl.h:987
llvm::MDNodeKeyImpl< DIEnumerator >::Value
APInt Value
Definition: LLVMContextImpl.h:380
llvm::LLVMContextImpl::AnonStructTypes
StructTypeSet AnonStructTypes
Definition: LLVMContextImpl.h:1459
llvm::MDNodeKeyImpl< DIMacroFile >::File
Metadata * File
Definition: LLVMContextImpl.h:1220
llvm::MDNodeKeyImpl< DILabel >::MDNodeKeyImpl
MDNodeKeyImpl(Metadata *Scope, MDString *Name, Metadata *File, unsigned Line)
Definition: LLVMContextImpl.h:1084
llvm::MDNodeKeyImpl< DICompositeType >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:557
llvm::MDNodeKeyImpl< DILexicalBlock >::Column
unsigned Column
Definition: LLVMContextImpl.h:809
llvm::DINamespace
Definition: DebugInfoMetadata.h:2276
llvm::LLVMContextImpl::GlobalValuePartitions
DenseMap< const GlobalValue *, StringRef > GlobalValuePartitions
Collection of per-GlobalValue partitions used in this context.
Definition: LLVMContextImpl.h:1487
llvm::LLVMContextImpl::AttrsSet
FoldingSet< AttributeImpl > AttrsSet
Definition: LLVMContextImpl.h:1389
llvm::AnonStructTypeKeyInfo
Definition: LLVMContextImpl.h:75
llvm::DILexicalBlock
Definition: DebugInfoMetadata.h:2108
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:808
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:1199
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:218
llvm::DIVariable::getRawFile
Metadata * getRawFile() const
Definition: DebugInfoMetadata.h:2568
llvm::LLVMContextImpl::TheNoneToken
std::unique_ptr< ConstantTokenNone > TheNoneToken
Definition: LLVMContextImpl.h:1443
llvm::lltok::equal
@ equal
Definition: LLToken.h:25
llvm::Annotations
Annotations lets you mark points and ranges inside source code, for tests:
Definition: Annotations.h:46
llvm::LLVMContextImpl::ArrayConstants
ArrayConstantsTy ArrayConstants
Definition: LLVMContextImpl.h:1415
llvm::MDNodeKeyImpl< DIModule >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:896
llvm::ConstantAsMetadata::getValue
Constant * getValue() const
Definition: Metadata.h:427
llvm::MDNode::getNumOperands
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1143
llvm::MDNodeKeyImpl< MDTuple >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:248
llvm::MDNodeKeyImpl< DICompositeType >::Allocated
Metadata * Allocated
Definition: LLVMContextImpl.h:571
llvm::LLVMContextImpl::X86_MMXTy
Type X86_MMXTy
Definition: LLVMContextImpl.h:1448
llvm::FunctionTypeKeyInfo::getEmptyKey
static FunctionType * getEmptyKey()
Definition: LLVMContextImpl.h:153
llvm::MDNodeKeyImpl< DILocalVariable >::Type
Metadata * Type
Definition: LLVMContextImpl.h:1041
llvm::LLVMContextImpl::MetadataTy
Type MetadataTy
Definition: LLVMContextImpl.h:1446
llvm::MDAttachments::Attachment
Definition: LLVMContextImpl.h:1293
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:529
Arg
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Definition: AMDGPULibCalls.cpp:206
llvm::LLVMContextImpl::TokenTy
Type TokenTy
Definition: LLVMContextImpl.h:1447
llvm::MDNodeKeyImpl< DISubrange >::UpperBound
Metadata * UpperBound
Definition: LLVMContextImpl.h:307
llvm::MDNodeKeyImpl< DITemplateValueParameter >::IsDefault
bool IsDefault
Definition: LLVMContextImpl.h:954
llvm::ConstantInt
This is the shared class of boolean and integer constants.
Definition: Constants.h:79
llvm::DIObjCProperty
Definition: DebugInfoMetadata.h:3253
llvm::MDNodeKeyImpl< DILabel >::File
Metadata * File
Definition: LLVMContextImpl.h:1081
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:1449
llvm::MDNodeKeyImpl< DIArgList >::Args
ArrayRef< ValueAsMetadata * > Args
Definition: LLVMContextImpl.h:1241
llvm::MDNodeKeyImpl< DIGlobalVariable >::StaticDataMemberDeclaration
Metadata * StaticDataMemberDeclaration
Definition: LLVMContextImpl.h:984
llvm::LLVMContextImpl::dropTriviallyDeadConstantArrays
void dropTriviallyDeadConstantArrays()
Destroy the ConstantArrays if they are not used.
Definition: LLVMContextImpl.cpp:131
llvm::DIType::getFlags
DIFlags getFlags() const
Definition: DebugInfoMetadata.h:705
llvm::DILocalVariable::getFlags
DIFlags getFlags() const
Definition: DebugInfoMetadata.h:3159
llvm::MDNodeKeyImpl< DICompositeType >::Elements
Metadata * Elements
Definition: LLVMContextImpl.h:563
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:1492
llvm::LLVMContextImpl::VectorTypes
DenseMap< std::pair< Type *, ElementCount >, VectorType * > VectorTypes
Definition: LLVMContextImpl.h:1464
llvm::LLVMContextImpl::NamedStructTypes
StringMap< StructType * > NamedStructTypes
Definition: LLVMContextImpl.h:1460
llvm::MDNodeKeyImpl< DICompositeType >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:624
llvm::MDNodeKeyImpl< DIGlobalVariable >::isKeyOf
bool isKeyOf(const DIGlobalVariable *RHS) const
Definition: LLVMContextImpl.h:1009
Constants.h
llvm::MDNodeKeyImpl< DILexicalBlock >::isKeyOf
bool isKeyOf(const DILexicalBlock *RHS) const
Definition: LLVMContextImpl.h:817
llvm::AnonStructTypeKeyInfo::KeyTy::KeyTy
KeyTy(const ArrayRef< Type * > &E, bool P)
Definition: LLVMContextImpl.h:80
llvm::MDNodeKeyImpl< DIObjCProperty >::File
Metadata * File
Definition: LLVMContextImpl.h:1135
llvm::MDNodeKeyImpl< DILexicalBlock >::File
Metadata * File
Definition: LLVMContextImpl.h:807
llvm::LLVMContextImpl::ValueHandles
ValueHandlesTy ValueHandles
Definition: LLVMContextImpl.h:1475
llvm::DILocalVariable
Local variable.
Definition: DebugInfoMetadata.h:3097
llvm::MDNodeKeyImpl< DIGlobalVariable >::AlignInBits
uint32_t AlignInBits
Definition: LLVMContextImpl.h:986
llvm::LLVMContextImpl::X86_FP80Ty
Type X86_FP80Ty
Definition: LLVMContextImpl.h:1448
llvm::MDNodeKeyImpl< DICompositeType >::RuntimeLang
unsigned RuntimeLang
Definition: LLVMContextImpl.h:564
llvm::MDNodeKeyImpl< DIImportedEntity >::Elements
Metadata * Elements
Definition: LLVMContextImpl.h:1172
llvm::FunctionTypeKeyInfo::isEqual
static bool isEqual(const FunctionType *LHS, const FunctionType *RHS)
Definition: LLVMContextImpl.h:178
llvm::DIMacro
Definition: DebugInfoMetadata.h:3491
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:3013
llvm::LLVMContextImpl::getOperandBundleTagID
uint32_t getOperandBundleTagID(StringRef Tag) const
Definition: LLVMContextImpl.cpp:205
llvm::MDNodeKeyImpl< DIExpression >::isKeyOf
bool isKeyOf(const DIExpression *RHS) const
Definition: LLVMContextImpl.h:1107
llvm::MDNodeInfo::isEqual
static bool isEqual(const KeyTy &LHS, const NodeTy *RHS)
Definition: LLVMContextImpl.h:1272
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:1262
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::MDNodeKeyImpl< DITemplateTypeParameter >::Type
Metadata * Type
Definition: LLVMContextImpl.h:933
llvm::MDNodeKeyImpl< DILocation >::InlinedAt
Metadata * InlinedAt
Definition: LLVMContextImpl.h:260
llvm::LLVMContextImpl
Definition: LLVMContextImpl.h:1341
llvm::DILexicalBlockBase::getRawScope
Metadata * getRawScope() const
Definition: DebugInfoMetadata.h:2100
llvm::DIMacroFile::getRawFile
Metadata * getRawFile() const
Definition: DebugInfoMetadata.h:3594
llvm::MDNodeKeyImpl< DISubprogram >::Name
MDString * Name
Definition: LLVMContextImpl.h:683
llvm::LLVMContextImpl::CAZConstants
DenseMap< Type *, std::unique_ptr< ConstantAggregateZero > > CAZConstants
Definition: LLVMContextImpl.h:1412
llvm::MDNodeKeyImpl< DILabel >::getHashValue
unsigned getHashValue() const
Using name and line to get hash value. It should already be mostly unique.
Definition: LLVMContextImpl.h:1096
llvm::MDNodeSubsetEqualImpl< DISubprogram >::isSubsetEqual
static bool isSubsetEqual(const KeyTy &LHS, const DISubprogram *RHS)
Definition: LLVMContextImpl.h:768
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:27
llvm::MDNodeKeyImpl< DIObjCProperty >::MDNodeKeyImpl
MDNodeKeyImpl(const DIObjCProperty *N)
Definition: LLVMContextImpl.h:1147
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:1174
llvm::MDNodeKeyImpl< DICompositeType >::DataLocation
Metadata * DataLocation
Definition: LLVMContextImpl.h:569
llvm::LLVMContextImpl::getOrInsertBundleTag
StringMapEntry< uint32_t > * getOrInsertBundleTag(StringRef Tag)
Definition: LLVMContextImpl.cpp:194
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:926
llvm::MDNodeKeyImpl< DIGlobalVariable >::LinkageName
MDString * LinkageName
Definition: LLVMContextImpl.h:978
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:1204
llvm::MDNodeKeyImpl< DIObjCProperty >::Attributes
unsigned Attributes
Definition: LLVMContextImpl.h:1139
llvm::DITemplateTypeParameter
Definition: DebugInfoMetadata.h:2426
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:3533
llvm::MDNodeKeyImpl< DILabel >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:1079
llvm::DIMacro::getRawName
MDString * getRawName() const
Definition: DebugInfoMetadata.h:3532
llvm::MDNodeKeyImpl< DIGlobalVariableExpression >::MDNodeKeyImpl
MDNodeKeyImpl(const DIGlobalVariableExpression *N)
Definition: LLVMContextImpl.h:1122
llvm::MDNodeKeyImpl< GenericDINode >::isKeyOf
bool isKeyOf(const GenericDINode *RHS) const
Definition: LLVMContextImpl.h:292
llvm::DIObjCProperty::getAttributes
unsigned getAttributes() const
Definition: DebugInfoMetadata.h:3305
llvm::MDNodeKeyImpl< DIFile >::isKeyOf
bool isKeyOf(const DIFile *RHS) const
Definition: LLVMContextImpl.h:667
llvm::APFloat::bitwiseIsEqual
bool bitwiseIsEqual(const APFloat &RHS) const
Definition: APFloat.h:1180
llvm::MDNodeKeyImpl< DIDerivedType >::Line
unsigned Line
Definition: LLVMContextImpl.h:465
llvm::MDNodeKeyImpl< DIGlobalVariable >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:1022
llvm::DICompositeType::getRawElements
Metadata * getRawElements() const
Definition: DebugInfoMetadata.h:1207
llvm::MDNodeKeyImpl< DIDerivedType >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:466
llvm::MDNodeKeyImpl< DISubprogram >::Unit
Metadata * Unit
Definition: LLVMContextImpl.h:694
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:879
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:1140
llvm::MDNodeKeyImpl< DICompositeType >::Associated
Metadata * Associated
Definition: LLVMContextImpl.h:570
llvm::MDNodeSubsetEqualImpl::isSubsetEqual
static bool isSubsetEqual(const NodeTy *LHS, const NodeTy *RHS)
Definition: LLVMContextImpl.h:233
llvm::LLVMContextImpl::Int1Ty
IntegerType Int1Ty
Definition: LLVMContextImpl.h:1449
llvm::MDNodeKeyImpl< DINamespace >::MDNodeKeyImpl
MDNodeKeyImpl(Metadata *Scope, MDString *Name, bool ExportSymbols)
Definition: LLVMContextImpl.h:853
llvm::LLVMContextImpl::LabelTy
Type LabelTy
Definition: LLVMContextImpl.h:1446
SmallPtrSet.h
llvm::MDNodeKeyImpl< DIFile >::MDNodeKeyImpl
MDNodeKeyImpl(const DIFile *N)
Definition: LLVMContextImpl.h:663
llvm::MDNodeKeyImpl< DIBasicType >::MDNodeKeyImpl
MDNodeKeyImpl(const DIBasicType *N)
Definition: LLVMContextImpl.h:413
StringMap.h
llvm::MDNodeKeyImpl< DIModule >::LineNo
unsigned LineNo
Definition: LLVMContextImpl.h:901
llvm::DILabel::getRawScope
Metadata * getRawScope() const
Definition: DebugInfoMetadata.h:3235
llvm::MDNodeKeyImpl< DICompositeType >::File
Metadata * File
Definition: LLVMContextImpl.h:555
llvm::MDNodeKeyImpl< DIDerivedType >::isKeyOf
bool isKeyOf(const DIDerivedType *RHS) const
Definition: LLVMContextImpl.h:493
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:1207
llvm::Metadata
Root of the metadata hierarchy.
Definition: Metadata.h:62
llvm::MDNodeKeyImpl< DILocalVariable >::Name
MDString * Name
Definition: LLVMContextImpl.h:1038
llvm::DICompositeType::getRawTemplateParams
Metadata * getRawTemplateParams() const
Definition: DebugInfoMetadata.h:1209
llvm::DINamespace::getRawScope
Metadata * getRawScope() const
Definition: DebugInfoMetadata.h:2318
llvm::MDNodeKeyImpl< DISubprogram >::ThisAdjustment
int ThisAdjustment
Definition: LLVMContextImpl.h:691
llvm::MDNodeKeyImpl< DICommonBlock >::LineNo
unsigned LineNo
Definition: LLVMContextImpl.h:874
llvm::MDNodeKeyImpl< DIExpression >::MDNodeKeyImpl
MDNodeKeyImpl(const DIExpression *N)
Definition: LLVMContextImpl.h:1105
llvm::MDNodeKeyImpl< DISubprogram >::SPFlags
unsigned SPFlags
Definition: LLVMContextImpl.h:693
llvm::MDNodeKeyImpl< DISubprogram >::TemplateParams
Metadata * TemplateParams
Definition: LLVMContextImpl.h:695
llvm::LLVMContextImpl::CDSConstants
StringMap< std::unique_ptr< ConstantDataSequential > > CDSConstants
Definition: LLVMContextImpl.h:1429
llvm::DIVariable::getRawName
MDString * getRawName() const
Definition: DebugInfoMetadata.h:2567
llvm::MDNodeKeyImpl< DISubprogram >::File
Metadata * File
Definition: LLVMContextImpl.h:685
llvm::LLVMContextImpl::DoubleTy
Type DoubleTy
Definition: LLVMContextImpl.h:1446
llvm::MDNodeKeyImpl< DICommonBlock >::Decl
Metadata * Decl
Definition: LLVMContextImpl.h:871
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:1223
llvm::DIMacroFile::getLine
unsigned getLine() const
Definition: DebugInfoMetadata.h:3587
llvm::LLVMContextImpl::RespectDiagnosticFilters
bool RespectDiagnosticFilters
Definition: LLVMContextImpl.h:1353
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:1171
llvm::MDNodeKeyImpl< DIEnumerator >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:398
StringSaver.h
llvm::DICommonBlock
Definition: DebugInfoMetadata.h:3035
llvm::MDNodeKeyImpl< DISubprogram >::Flags
unsigned Flags
Definition: LLVMContextImpl.h:692
llvm::LLVMContextImpl::BundleTagCache
StringMap< uint32_t > BundleTagCache
A set of interned tags for operand bundles.
Definition: LLVMContextImpl.h:1498
llvm::VectorType
Base class of all SIMD vector types.
Definition: DerivedTypes.h:389
llvm::LLVMContextImpl::ValueMetadata
DenseMap< const Value *, MDAttachments > ValueMetadata
Collection of metadata used in this context.
Definition: LLVMContextImpl.h:1481
llvm::DenseSet< FunctionType *, FunctionTypeKeyInfo >
llvm::MDNodeKeyImpl< DITemplateTypeParameter >::Name
MDString * Name
Definition: LLVMContextImpl.h:932
llvm::DIGlobalVariable::isDefinition
bool isDefinition() const
Definition: DebugInfoMetadata.h:3014
llvm::APFloat
Definition: APFloat.h:701
llvm::MDNodeInfo::getHashValue
static unsigned getHashValue(const NodeTy *N)
Definition: LLVMContextImpl.h:1268
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:1197
llvm::DITemplateValueParameter::getValue
Metadata * getValue() const
Definition: DebugInfoMetadata.h:2510
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:985
llvm::LLVMContextImpl::Int32Ty
IntegerType Int32Ty
Definition: LLVMContextImpl.h:1449
llvm::DILocalVariable::getArg
unsigned getArg() const
Definition: DebugInfoMetadata.h:3158
llvm::MDNodeKeyImpl< GenericDINode >::Tag
unsigned Tag
Definition: LLVMContextImpl.h:284
llvm::MDNodeKeyImpl< DIDerivedType >::ExtraData
Metadata * ExtraData
Definition: LLVMContextImpl.h:473
llvm::LLVMContextImpl::HalfTy
Type HalfTy
Definition: LLVMContextImpl.h:1446
llvm::MDNodeKeyImpl< DITemplateValueParameter >::Value
Metadata * Value
Definition: LLVMContextImpl.h:955
llvm::MDNodeKeyImpl< DITemplateValueParameter >::Type
Metadata * Type
Definition: LLVMContextImpl.h:953
llvm::LLVMContextImpl::CPNConstants
DenseMap< PointerType *, std::unique_ptr< ConstantPointerNull > > CPNConstants
Definition: LLVMContextImpl.h:1423
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:2569
uint64_t
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:1441
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:1137
llvm::MDNodeKeyImpl< DILexicalBlockFile >::MDNodeKeyImpl
MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Discriminator)
Definition: LLVMContextImpl.h:832
llvm::LLVMContextImpl::Int128Ty
IntegerType Int128Ty
Definition: LLVMContextImpl.h:1449
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:572
llvm::DIGlobalVariable
Global variables.
Definition: DebugInfoMetadata.h:2946
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:636
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:1461
llvm::MDNodeKeyImpl< DICommonBlock >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:870
llvm::MDAttachments
Multimap-like storage for metadata attachments.
Definition: LLVMContextImpl.h:1291
llvm::MDNodeKeyImpl< DILocalVariable >::Annotations
Metadata * Annotations
Definition: LLVMContextImpl.h:1045
llvm::MDNodeKeyImpl< DIFile >::Source
Optional< MDString * > Source
Definition: LLVMContextImpl.h:656
llvm::LLVMContextImpl::GlobalObjectSections
DenseMap< const GlobalObject *, StringRef > GlobalObjectSections
Collection of per-GlobalObject sections used in this context.
Definition: LLVMContextImpl.h:1484
llvm::DIGlobalVariable::getRawStaticDataMemberDeclaration
Metadata * getRawStaticDataMemberDeclaration() const
Definition: DebugInfoMetadata.h:3025
llvm::DIGlobalVariableExpression::getRawExpression
Metadata * getRawExpression() const
Definition: DebugInfoMetadata.h:3431
llvm::MDNodeKeyImpl< DICompositeType >::Line
unsigned Line
Definition: LLVMContextImpl.h:556
llvm::LLVMContextImpl::ASPointerTypes
DenseMap< std::pair< Type *, unsigned >, PointerType * > ASPointerTypes
Definition: LLVMContextImpl.h:1469
llvm::LLVMContextImpl::getOperandBundleTags
void getOperandBundleTags(SmallVectorImpl< StringRef > &Tags) const
Definition: LLVMContextImpl.cpp:199
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:957
llvm::DIImportedEntity
An imported module (C++ using directive or similar).
Definition: DebugInfoMetadata.h:3336
llvm::MDNodeKeyImpl< DIModule >::File
Metadata * File
Definition: LLVMContextImpl.h:895
llvm::MDAttachments::empty
bool empty() const
Definition: LLVMContextImpl.h:1302
llvm::PointerType
Class to represent pointers.
Definition: DerivedTypes.h:632
llvm::DenseMapInfo< APInt >
Provide DenseMapInfo for APInt.
Definition: APInt.h:2254
llvm::MDNodeKeyImpl< DICompositeType >::VTableHolder
Metadata * VTableHolder
Definition: LLVMContextImpl.h:565
llvm::DIGlobalVariable::getRawLinkageName
MDString * getRawLinkageName() const
Definition: DebugInfoMetadata.h:3024
ArrayRef.h
llvm::LLVMContextImpl::BFloatTy
Type BFloatTy
Definition: LLVMContextImpl.h:1446
llvm::MDNodeKeyImpl< DIModule >::MDNodeKeyImpl
MDNodeKeyImpl(const DIModule *N)
Definition: LLVMContextImpl.h:910
TemplateParamKind::Type
@ Type
llvm::MDNodeKeyImpl< DIMacro >::Name
MDString * Name
Definition: LLVMContextImpl.h:1198
llvm::LLVMContextImpl::OPG
OptPassGate * OPG
Definition: LLVMContextImpl.h:1535
llvm::MDNodeKeyImpl< DILexicalBlock >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:822
llvm::AnonStructTypeKeyInfo::getTombstoneKey
static StructType * getTombstoneKey()
Definition: LLVMContextImpl.h:102
llvm::MDNodeKeyImpl< DIFile >::Checksum
Optional< DIFile::ChecksumInfo< MDString * > > Checksum
Definition: LLVMContextImpl.h:655
llvm::DINamespace::getExportSymbols
bool getExportSymbols() const
Definition: DebugInfoMetadata.h:2314
llvm::MDNodeKeyImpl< DITemplateValueParameter >::Tag
unsigned Tag
Definition: LLVMContextImpl.h:951
llvm::DIMacroFile
Definition: DebugInfoMetadata.h:3540
llvm::MDNodeOpsKey
Structure for hashing arbitrary MDNode operands.
Definition: LLVMContextImpl.h:184
llvm::MDNodeKeyImpl< DILexicalBlockFile >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:843
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:1463
llvm::LLVMContextImpl::DiagHandler
std::unique_ptr< DiagnosticHandler > DiagHandler
Definition: LLVMContextImpl.h:1352
llvm::MDNodeKeyImpl< DICompositeType >::Annotations
Metadata * Annotations
Definition: LLVMContextImpl.h:573
llvm::MDNodeKeyImpl< DICompositeType >::MDNodeKeyImpl
MDNodeKeyImpl(const DICompositeType *N)
Definition: LLVMContextImpl.h:591
llvm::MDNodeKeyImpl< DILabel >::Line
unsigned Line
Definition: LLVMContextImpl.h:1082
llvm::LLVMContextImpl::TheTrueVal
ConstantInt * TheTrueVal
Definition: LLVMContextImpl.h:1440
llvm::DIArgList::getArgs
ArrayRef< ValueAsMetadata * > getArgs() const
Definition: DebugInfoMetadata.h:3636
llvm::MDNodeKeyImpl< DIBasicType >::Encoding
unsigned Encoding
Definition: LLVMContextImpl.h:406
ConstantsContext.h
llvm::LLVMContextImpl::AttrsLists
FoldingSet< AttributeListImpl > AttrsLists
Definition: LLVMContextImpl.h:1390
llvm::MDNodeKeyImpl< DISubroutineType >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:649
llvm::DIGlobalVariable::getRawTemplateParams
Metadata * getRawTemplateParams() const
Definition: DebugInfoMetadata.h:3026
llvm::DISubroutineType::getRawTypeArray
Metadata * getRawTypeArray() const
Definition: DebugInfoMetadata.h:1327
llvm::MDNode
Metadata node.
Definition: Metadata.h:906
llvm::LLVMContextImpl::YieldCallback
LLVMContext::YieldCallbackTy YieldCallback
Definition: LLVMContextImpl.h:1378
llvm::MDNodeKeyImpl< DISubprogram >
Definition: LLVMContextImpl.h:681
llvm::FunctionTypeKeyInfo::KeyTy::KeyTy
KeyTy(const FunctionType *FT)
Definition: LLVMContextImpl.h:135
llvm::DICompositeType::getRawRank
Metadata * getRawRank() const
Definition: DebugInfoMetadata.h:1234
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:536
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:75
llvm::DIType::getRawScope
Metadata * getRawScope() const
Definition: DebugInfoMetadata.h:711
llvm::MDNodeKeyImpl< DIObjCProperty >::SetterName
MDString * SetterName
Definition: LLVMContextImpl.h:1138
llvm::MDNodeKeyImpl< DISubprogram >::RetainedNodes
Metadata * RetainedNodes
Definition: LLVMContextImpl.h:697
llvm::DINode::getTag
dwarf::Tag getTag() const
Definition: DebugInfoMetadata.h:160
YAMLTraits.h
llvm::MDNodeKeyImpl< DIModule >::IncludePath
MDString * IncludePath
Definition: LLVMContextImpl.h:899
llvm::DISubroutineType::getCC
uint8_t getCC() const
Definition: DebugInfoMetadata.h:1321
llvm::LLVMContextImpl::IntConstants
IntMapTy IntConstants
Definition: LLVMContextImpl.h:1383
llvm::DISubroutineType
Type array for a subprogram.
Definition: DebugInfoMetadata.h:1281
llvm::MDNodeKeyImpl< DISubprogram >::ThrownTypes
Metadata * ThrownTypes
Definition: LLVMContextImpl.h:698
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:1196
llvm::Expression
Class representing an expression and its matching format.
Definition: FileCheckImpl.h:237
llvm::DICompositeType
Composite types.
Definition: DebugInfoMetadata.h:1060
AttributeImpl.h
llvm::BlockAddress
The address of a basic block.
Definition: Constants.h:848
llvm::MDNodeKeyImpl< DISubprogram >::Line
unsigned Line
Definition: LLVMContextImpl.h:686
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:100
llvm::MDAttachments::remove_if
void remove_if(PredTy shouldRemove)
Erase matching attachments.
Definition: LLVMContextImpl.h:1336
llvm::MDNodeKeyImpl< DIImportedEntity >::MDNodeKeyImpl
MDNodeKeyImpl(const DIImportedEntity *N)
Definition: LLVMContextImpl.h:1178
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:227
llvm::LLVMContextImpl::MDStringCache
StringMap< MDString, BumpPtrAllocator > MDStringCache
Definition: LLVMContextImpl.h:1393
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:605
llvm::MDNodeKeyImpl< DIGenericSubrange >::UpperBound
Metadata * UpperBound
Definition: LLVMContextImpl.h:352
llvm::StructType
Class to represent struct types.
Definition: DerivedTypes.h:213
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:641
llvm::MDNodeKeyImpl< DIMacroFile >::isKeyOf
bool isKeyOf(const DIMacroFile *RHS) const
Definition: LLVMContextImpl.h:1230
llvm::MDNodeKeyImpl< DIExpression >::MDNodeKeyImpl
MDNodeKeyImpl(ArrayRef< uint64_t > Elements)
Definition: LLVMContextImpl.h:1104
llvm::MDNodeKeyImpl< DISubprogram >::Type
Metadata * Type
Definition: LLVMContextImpl.h:687
llvm::FunctionTypeKeyInfo::KeyTy::operator==
bool operator==(const KeyTy &that) const
Definition: LLVMContextImpl.h:139
llvm::DIVariable::getLine
unsigned getLine() const
Definition: DebugInfoMetadata.h:2530
llvm::DILabel::getRawFile
Metadata * getRawFile() const
Definition: DebugInfoMetadata.h:3237
llvm::MDNodeKeyImpl< DISubprogram >::VirtualIndex
unsigned VirtualIndex
Definition: LLVMContextImpl.h:690
uint32_t
llvm::DIStringType::getEncoding
unsigned getEncoding() const
Definition: DebugInfoMetadata.h:904
llvm::MDNodeKeyImpl< DISubprogram >::ScopeLine
unsigned ScopeLine
Definition: LLVMContextImpl.h:688
llvm::LLVMContextImpl::StructConstants
StructConstantsTy StructConstants
Definition: LLVMContextImpl.h:1418
llvm::MDNodeKeyImpl< DISubroutineType >::Flags
unsigned Flags
Definition: LLVMContextImpl.h:635
llvm::LLVMContextImpl::getOrInsertSyncScopeID
SyncScope::ID getOrInsertSyncScopeID(StringRef SSN)
getOrInsertSyncScopeID - Maps synchronization scope name to synchronization scope ID.
Definition: LLVMContextImpl.cpp:211
llvm::MDNodeKeyImpl< DILabel >::isKeyOf
bool isKeyOf(const DILabel *RHS) const
Definition: LLVMContextImpl.h:1090
llvm::MDNodeOpsKey::MDNodeOpsKey
MDNodeOpsKey(ArrayRef< Metadata * > Ops)
Definition: LLVMContextImpl.h:190
llvm::LLVMContextImpl::PVConstants
DenseMap< Type *, std::unique_ptr< PoisonValue > > PVConstants
Definition: LLVMContextImpl.h:1427
llvm::MDNodeKeyImpl< DICompositeType >::AlignInBits
uint32_t AlignInBits
Definition: LLVMContextImpl.h:561
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:485
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:976
llvm::MDNodeKeyImpl< DIFile >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:674
llvm::DITemplateParameter::getRawName
MDString * getRawName() const
Definition: DebugInfoMetadata.h:2416
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:834
llvm::MDNodeKeyImpl< DILocalVariable >::Arg
unsigned Arg
Definition: LLVMContextImpl.h:1042
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:1523
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:970
llvm::DILexicalBlock::getLine
unsigned getLine() const
Definition: DebugInfoMetadata.h:2151
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:1080
llvm::MDNodeKeyImpl< DIDerivedType >::Annotations
Metadata * Annotations
Definition: LLVMContextImpl.h:474
llvm::ConstantAsMetadata
Definition: Metadata.h:412
llvm::MDNodeKeyImpl< DIMacroFile >::MDNodeKeyImpl
MDNodeKeyImpl(const DIMacroFile *N)
Definition: LLVMContextImpl.h:1226
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, Metadata *Annotations)
Definition: LLVMContextImpl.h:701
llvm::MDNodeKeyImpl< DILocalVariable >::Line
unsigned Line
Definition: LLVMContextImpl.h:1040
llvm::DIObjCProperty::getRawFile
Metadata * getRawFile() const
Definition: DebugInfoMetadata.h:3325
llvm::MDNodeKeyImpl< DIBasicType >::Name
MDString * Name
Definition: LLVMContextImpl.h:403
llvm::MDNodeKeyImpl< DICompositeType >::Tag
unsigned Tag
Definition: LLVMContextImpl.h:553
llvm::DICompositeType::getRawAssociated
Metadata * getRawAssociated() const
Definition: DebugInfoMetadata.h:1220
llvm::DIType::getOffsetInBits
uint64_t getOffsetInBits() const
Definition: DebugInfoMetadata.h:704
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:1478
llvm::MDNodeKeyImpl< DIObjCProperty >::isKeyOf
bool isKeyOf(const DIObjCProperty *RHS) const
Definition: LLVMContextImpl.h:1152
llvm::MDNodeKeyImpl< DITemplateValueParameter >::MDNodeKeyImpl
MDNodeKeyImpl(const DITemplateValueParameter *N)
Definition: LLVMContextImpl.h:960
llvm::DILocation::getRawScope
Metadata * getRawScope() const
Definition: DebugInfoMetadata.h:1807
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::MDNodeKeyImpl< DICommonBlock >::isKeyOf
bool isKeyOf(const DICommonBlock *RHS) const
Definition: LLVMContextImpl.h:883
LLVMRemarkStreamer.h
llvm::DICompositeType::getRawDiscriminator
Metadata * getRawDiscriminator() const
Definition: DebugInfoMetadata.h:1211
llvm::DIMacroFile::getRawElements
Metadata * getRawElements() const
Definition: DebugInfoMetadata.h:3595
llvm::MDNodeKeyImpl< DITemplateValueParameter >::Name
MDString * Name
Definition: LLVMContextImpl.h:952
llvm::DITemplateParameter::getRawType
Metadata * getRawType() const
Definition: DebugInfoMetadata.h:2417
getFlags
static uint32_t getFlags(const Symbol *Sym)
Definition: TapiFile.cpp:23
llvm::MDNodeKeyImpl< DICompositeType >::SizeInBits
uint64_t SizeInBits
Definition: LLVMContextImpl.h:559
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:1043
llvm::MDNodeKeyImpl< DILocalVariable >::MDNodeKeyImpl
MDNodeKeyImpl(const DILocalVariable *N)
Definition: LLVMContextImpl.h:1052
llvm::DICompositeType::getRawAllocated
Metadata * getRawAllocated() const
Definition: DebugInfoMetadata.h:1227
llvm::DILocation::getRawInlinedAt
Metadata * getRawInlinedAt() const
Definition: DebugInfoMetadata.h:1808
llvm::MDNodeKeyImpl< DIGlobalVariable >::Line
unsigned Line
Definition: LLVMContextImpl.h:980
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:517
llvm::AnonStructTypeKeyInfo::KeyTy
Definition: LLVMContextImpl.h:76
llvm::MDNodeKeyImpl< DIArgList >::isKeyOf
bool isKeyOf(const DIArgList *RHS) const
Definition: LLVMContextImpl.h:1246
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:1446
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::DICommonBlock::getRawFile
Metadata * getRawFile() const
Definition: DebugInfoMetadata.h:3087
llvm::MDNodeKeyImpl< DIGlobalVariableExpression >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:1130
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:2610
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:1373
llvm::LLVMContextImpl::AttrsSetNodes
FoldingSet< AttributeSetNode > AttrsSetNodes
Definition: LLVMContextImpl.h:1391
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:872
llvm::FunctionTypeKeyInfo::getHashValue
static unsigned getHashValue(const KeyTy &Key)
Definition: LLVMContextImpl.h:161
llvm::LLVMContextImpl::Int8Ty
IntegerType Int8Ty
Definition: LLVMContextImpl.h:1449
llvm::MDNodeKeyImpl< DIModule >::MDNodeKeyImpl
MDNodeKeyImpl(Metadata *File, Metadata *Scope, MDString *Name, MDString *ConfigurationMacros, MDString *IncludePath, MDString *APINotesFile, unsigned LineNo, bool IsDecl)
Definition: LLVMContextImpl.h:904
llvm::MDNodeKeyImpl< DILexicalBlock >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:806
llvm::MDNodeKeyImpl< DISubprogram >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:682
llvm::MDNodeKeyImpl< DILocation >::isKeyOf
bool isKeyOf(const DILocation *RHS) const
Definition: LLVMContextImpl.h:271
llvm::DIDerivedType
Derived types.
Definition: DebugInfoMetadata.h:917
llvm::MDNodeKeyImpl< DILocalVariable >::AlignInBits
uint32_t AlignInBits
Definition: LLVMContextImpl.h:1044
llvm::DIGlobalVariableExpression
A pair of DIGlobalVariable and DIExpression.
Definition: DebugInfoMetadata.h:3401
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:1395
llvm::MDNodeKeyImpl< DICompositeType >::Name
MDString * Name
Definition: LLVMContextImpl.h:554
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:2566
llvm::DICompositeType::getRawAnnotations
Metadata * getRawAnnotations() const
Definition: DebugInfoMetadata.h:1244
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:2468
llvm::DIGlobalVariable::getRawAnnotations
Metadata * getRawAnnotations() const
Definition: DebugInfoMetadata.h:3028
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:3086
llvm::LLVMContextImpl::Saver
UniqueStringSaver Saver
Definition: LLVMContextImpl.h:1452
llvm::LLVMContextImpl::PPC_FP128Ty
Type PPC_FP128Ty
Definition: LLVMContextImpl.h:1448
llvm::MDNodeSubsetEqualImpl< DISubprogram >::isSubsetEqual
static bool isSubsetEqual(const DISubprogram *LHS, const DISubprogram *RHS)
Definition: LLVMContextImpl.h:773
llvm::DILexicalBlock::getColumn
unsigned getColumn() const
Definition: DebugInfoMetadata.h:2152
llvm::hash_combine
hash_code hash_combine(const Ts &...args)
Combine values into a single hash_code.
Definition: Hashing.h:605
llvm::MDNodeKeyImpl< DIStringType >::isKeyOf
bool isKeyOf(const DIStringType *RHS) const
Definition: LLVMContextImpl.h:452
llvm::DICompositeType::getRawBaseType
Metadata * getRawBaseType() const
Definition: DebugInfoMetadata.h:1206
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:942
llvm::MDNodeKeyImpl< DIMacroFile >::MIType
unsigned MIType
Definition: LLVMContextImpl.h:1218
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:525
N
#define N
llvm::MDNodeKeyImpl< DILocalVariable >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:1037
llvm::MDNodeKeyImpl< DIGlobalVariable >::MDNodeKeyImpl
MDNodeKeyImpl(const DIGlobalVariable *N)
Definition: LLVMContextImpl.h:1000
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:483
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:781
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:3082
llvm::MDNodeKeyImpl< DIArgList >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:1248
llvm::MDNodeKeyImpl< DINamespace >::ExportSymbols
bool ExportSymbols
Definition: LLVMContextImpl.h:851
llvm::MDNodeKeyImpl< DISubroutineType >::TypeArray
Metadata * TypeArray
Definition: LLVMContextImpl.h:637
llvm::MDNodeKeyImpl
Definition: LLVMContextImpl.h:223
llvm::DINamespace::getRawName
MDString * getRawName() const
Definition: DebugInfoMetadata.h:2319
llvm::MDNodeKeyImpl< DICompositeType >::BaseType
Metadata * BaseType
Definition: LLVMContextImpl.h:558
llvm::LLVMContextImpl::DITypeMap
Optional< DenseMap< const MDString *, DICompositeType * > > DITypeMap
Definition: LLVMContextImpl.h:1404
llvm::MDNodeKeyImpl< DIImportedEntity >::Line
unsigned Line
Definition: LLVMContextImpl.h:1170
llvm::LLVMContextImpl::SSC
StringMap< SyncScope::ID > SSC
A set of interned synchronization scopes.
Definition: LLVMContextImpl.h:1506
llvm::MDNodeKeyImpl< DIGenericSubrange >::CountNode
Metadata * CountNode
Definition: LLVMContextImpl.h:350
llvm::MDNodeKeyImpl< DINamespace >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:864
llvm::DILocalVariable::getRawAnnotations
Metadata * getRawAnnotations() const
Definition: DebugInfoMetadata.h:3164
llvm::MDNodeKeyImpl< DILocalVariable >::isKeyOf
bool isKeyOf(const DILocalVariable *RHS) const
Definition: LLVMContextImpl.h:1058
llvm::DISubprogram
Subprogram description.
Definition: DebugInfoMetadata.h:1820
llvm::LLVMContextImpl::VectorConstants
VectorConstantsTy VectorConstants
Definition: LLVMContextImpl.h:1421
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:2535
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:2328
llvm::MDNodeKeyImpl< DICompositeType >::Flags
unsigned Flags
Definition: LLVMContextImpl.h:562
llvm::MDNodeKeyImpl< DILexicalBlockFile >::File
Metadata * File
Definition: LLVMContextImpl.h:829
DerivedTypes.h
llvm::MDNodeKeyImpl< DIExpression >::Elements
ArrayRef< uint64_t > Elements
Definition: LLVMContextImpl.h:1102
llvm::MDNodeKeyImpl< DIDerivedType >::BaseType
Metadata * BaseType
Definition: LLVMContextImpl.h:467
llvm::DIObjCProperty::getRawType
Metadata * getRawType() const
Definition: DebugInfoMetadata.h:3328
llvm::MDNodeKeyImpl< DIGlobalVariable >::Type
Metadata * Type
Definition: LLVMContextImpl.h:981
llvm::LLVMContextImpl::PointerTypes
DenseMap< Type *, PointerType * > PointerTypes
Definition: LLVMContextImpl.h:1468
llvm::MDNodeOpsKey::calculateHash
static unsigned calculateHash(MDNode *N, unsigned Offset=0)
Definition: LLVMContextImpl.cpp:177
llvm::MDNodeKeyImpl< DIMacro >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:1212
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:897
llvm::MDNodeKeyImpl< DIArgList >::MDNodeKeyImpl
MDNodeKeyImpl(ArrayRef< ValueAsMetadata * > Args)
Definition: LLVMContextImpl.h:1243
llvm::LLVMContextImpl::YieldOpaqueHandle
void * YieldOpaqueHandle
Definition: LLVMContextImpl.h:1379
llvm::DIMacro::getLine
unsigned getLine() const
Definition: DebugInfoMetadata.h:3527
llvm::MDNodeKeyImpl< DISubprogram >::isKeyOf
bool isKeyOf(const DISubprogram *RHS) const
Definition: LLVMContextImpl.h:729
llvm::LLVMContextImpl::DistinctMDNodes
std::vector< MDNode * > DistinctMDNodes
Definition: LLVMContextImpl.h:1410
llvm::MDNodeKeyImpl< DIImportedEntity >::Scope
Metadata * Scope
Definition: LLVMContextImpl.h:1167
llvm::DILabel
Label.
Definition: DebugInfoMetadata.h:3185
llvm::DIGenericSubrange::getRawStride
Metadata * getRawStride() const
Definition: DebugInfoMetadata.h:394
llvm::MDNodeKeyImpl< DINamespace >::isKeyOf
bool isKeyOf(const DINamespace *RHS) const
Definition: LLVMContextImpl.h:859
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:1169
llvm::MDNodeKeyImpl< DIObjCProperty >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:1159
llvm::MDNodeKeyImpl< DILexicalBlockFile >::Discriminator
unsigned Discriminator
Definition: LLVMContextImpl.h:830
llvm::MDNodeKeyImpl< DIGlobalVariableExpression >::Expression
Metadata * Expression
Definition: LLVMContextImpl.h:1118
llvm::LLVMContextImpl::LLVMRS
std::unique_ptr< LLVMRemarkStreamer > LLVMRS
The specialized remark streamer used by LLVM's OptimizationRemarkEmitter.
Definition: LLVMContextImpl.h:1376
llvm::LLVMContextImpl::FP128Ty
Type FP128Ty
Definition: LLVMContextImpl.h:1448
llvm::MDNodeKeyImpl< DIEnumerator >::Name
MDString * Name
Definition: LLVMContextImpl.h:381
llvm::MDNodeKeyImpl< DICompositeType >::Identifier
MDString * Identifier
Definition: LLVMContextImpl.h:567
llvm::MDNodeKeyImpl< DITemplateTypeParameter >::IsDefault
bool IsDefault
Definition: LLVMContextImpl.h:934
llvm::AnonStructTypeKeyInfo::getHashValue
static unsigned getHashValue(const KeyTy &Key)
Definition: LLVMContextImpl.h:106
llvm::MDAttachments::Attachment::Node
TrackingMDNodeRef Node
Definition: LLVMContextImpl.h:1295
llvm::MDNodeKeyImpl< DIGlobalVariable >::Name
MDString * Name
Definition: LLVMContextImpl.h:977
llvm::MDNodeKeyImpl< DICommonBlock >::MDNodeKeyImpl
MDNodeKeyImpl(Metadata *Scope, Metadata *Decl, MDString *Name, Metadata *File, unsigned LineNo)
Definition: LLVMContextImpl.h:876
llvm::MDString
A single uniqued string.
Definition: Metadata.h:611
llvm::DIGlobalVariableExpression::getRawVariable
Metadata * getRawVariable() const
Definition: DebugInfoMetadata.h:3425
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:2199
llvm::MDNodeKeyImpl< DIModule >::ConfigurationMacros
MDString * ConfigurationMacros
Definition: LLVMContextImpl.h:898
llvm::MDNode::op_begin
op_iterator op_begin() const
Definition: Metadata.h:1127
llvm::MDNodeKeyImpl< DIMacroFile >::getHashValue
unsigned getHashValue() const
Definition: LLVMContextImpl.h:1235
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:74
llvm::DILabel::getRawName
MDString * getRawName() const
Definition: DebugInfoMetadata.h:3236
llvm::MDNodeKeyImpl< DILocalVariable >::File
Metadata * File
Definition: LLVMContextImpl.h:1039
llvm::MDNodeKeyImpl< DIModule >::isKeyOf
bool isKeyOf(const DIModule *RHS) const
Definition: LLVMContextImpl.h:917
llvm::LLVMContextImpl::LLVMContextImpl
LLVMContextImpl(LLVMContext &C)
Definition: LLVMContextImpl.cpp:29
File
Instrumentation for Order File
Definition: InstrOrderFile.cpp:205
llvm::DIObjCProperty::getLine
unsigned getLine() const
Definition: DebugInfoMetadata.h:3304
llvm::ArrayRef::end
iterator end() const
Definition: ArrayRef.h:154
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, Metadata *Annotations)
Definition: LLVMContextImpl.h:989
llvm::DICompositeType::getRawIdentifier
MDString * getRawIdentifier() const
Definition: DebugInfoMetadata.h:1210
llvm::LLVMContextImpl::FunctionTypes
FunctionTypeSet FunctionTypes
Definition: LLVMContextImpl.h:1457
llvm::DICommonBlock::getRawScope
Metadata * getRawScope() const
Definition: DebugInfoMetadata.h:3084
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:1142
llvm::MDNodeKeyImpl< DIModule >::APINotesFile
MDString * APINotesFile
Definition: LLVMContextImpl.h:900
llvm::FunctionType
Class to represent function types.
Definition: DerivedTypes.h:103
llvm::MDNodeKeyImpl< DIGlobalVariable >::IsLocalToUnit
bool IsLocalToUnit
Definition: LLVMContextImpl.h:982
llvm::DenseMapAPFloatKeyInfo::isEqual
static bool isEqual(const APFloat &LHS, const APFloat &RHS)
Definition: LLVMContextImpl.h:70
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:37
llvm::MDNodeKeyImpl< DIMacroFile >::Elements
Metadata * Elements
Definition: LLVMContextImpl.h:1221