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