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