[LLVM][Alignment] Introduce Alignment In Attributes
[llvm-core.git] / lib / IR / LLVMContextImpl.h
blob78cf707e0e748bd650960e73ab86821089b76a75
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.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_LIB_IR_LLVMCONTEXTIMPL_H
15 #define LLVM_LIB_IR_LLVMCONTEXTIMPL_H
17 #include "AttributeImpl.h"
18 #include "ConstantsContext.h"
19 #include "llvm/ADT/APFloat.h"
20 #include "llvm/ADT/APInt.h"
21 #include "llvm/ADT/ArrayRef.h"
22 #include "llvm/ADT/DenseMap.h"
23 #include "llvm/ADT/DenseMapInfo.h"
24 #include "llvm/ADT/DenseSet.h"
25 #include "llvm/ADT/FoldingSet.h"
26 #include "llvm/ADT/Hashing.h"
27 #include "llvm/ADT/Optional.h"
28 #include "llvm/ADT/STLExtras.h"
29 #include "llvm/ADT/SmallPtrSet.h"
30 #include "llvm/ADT/SmallVector.h"
31 #include "llvm/ADT/StringMap.h"
32 #include "llvm/ADT/StringRef.h"
33 #include "llvm/BinaryFormat/Dwarf.h"
34 #include "llvm/IR/Constants.h"
35 #include "llvm/IR/DebugInfoMetadata.h"
36 #include "llvm/IR/DerivedTypes.h"
37 #include "llvm/IR/LLVMContext.h"
38 #include "llvm/IR/Metadata.h"
39 #include "llvm/IR/RemarkStreamer.h"
40 #include "llvm/IR/TrackingMDRef.h"
41 #include "llvm/Support/Allocator.h"
42 #include "llvm/Support/Casting.h"
43 #include "llvm/Support/StringSaver.h"
44 #include "llvm/Support/YAMLTraits.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>
54 namespace llvm {
56 class ConstantFP;
57 class ConstantInt;
58 class Type;
59 class Value;
60 class ValueHandleBase;
62 struct DenseMapAPIntKeyInfo {
63 static inline APInt getEmptyKey() {
64 APInt V(nullptr, 0);
65 V.U.VAL = 0;
66 return V;
69 static inline APInt getTombstoneKey() {
70 APInt V(nullptr, 0);
71 V.U.VAL = 1;
72 return V;
75 static unsigned getHashValue(const APInt &Key) {
76 return static_cast<unsigned>(hash_value(Key));
79 static bool isEqual(const APInt &LHS, const APInt &RHS) {
80 return LHS.getBitWidth() == RHS.getBitWidth() && LHS == RHS;
84 struct DenseMapAPFloatKeyInfo {
85 static inline APFloat getEmptyKey() { return APFloat(APFloat::Bogus(), 1); }
86 static inline APFloat getTombstoneKey() { return APFloat(APFloat::Bogus(), 2); }
88 static unsigned getHashValue(const APFloat &Key) {
89 return static_cast<unsigned>(hash_value(Key));
92 static bool isEqual(const APFloat &LHS, const APFloat &RHS) {
93 return LHS.bitwiseIsEqual(RHS);
97 struct AnonStructTypeKeyInfo {
98 struct KeyTy {
99 ArrayRef<Type*> ETypes;
100 bool isPacked;
102 KeyTy(const ArrayRef<Type*>& E, bool P) :
103 ETypes(E), isPacked(P) {}
105 KeyTy(const StructType *ST)
106 : ETypes(ST->elements()), isPacked(ST->isPacked()) {}
108 bool operator==(const KeyTy& that) const {
109 if (isPacked != that.isPacked)
110 return false;
111 if (ETypes != that.ETypes)
112 return false;
113 return true;
115 bool operator!=(const KeyTy& that) const {
116 return !this->operator==(that);
120 static inline StructType* getEmptyKey() {
121 return DenseMapInfo<StructType*>::getEmptyKey();
124 static inline StructType* getTombstoneKey() {
125 return DenseMapInfo<StructType*>::getTombstoneKey();
128 static unsigned getHashValue(const KeyTy& Key) {
129 return hash_combine(hash_combine_range(Key.ETypes.begin(),
130 Key.ETypes.end()),
131 Key.isPacked);
134 static unsigned getHashValue(const StructType *ST) {
135 return getHashValue(KeyTy(ST));
138 static bool isEqual(const KeyTy& LHS, const StructType *RHS) {
139 if (RHS == getEmptyKey() || RHS == getTombstoneKey())
140 return false;
141 return LHS == KeyTy(RHS);
144 static bool isEqual(const StructType *LHS, const StructType *RHS) {
145 return LHS == RHS;
149 struct FunctionTypeKeyInfo {
150 struct KeyTy {
151 const Type *ReturnType;
152 ArrayRef<Type*> Params;
153 bool isVarArg;
155 KeyTy(const Type* R, const ArrayRef<Type*>& P, bool V) :
156 ReturnType(R), Params(P), isVarArg(V) {}
157 KeyTy(const FunctionType *FT)
158 : ReturnType(FT->getReturnType()), Params(FT->params()),
159 isVarArg(FT->isVarArg()) {}
161 bool operator==(const KeyTy& that) const {
162 if (ReturnType != that.ReturnType)
163 return false;
164 if (isVarArg != that.isVarArg)
165 return false;
166 if (Params != that.Params)
167 return false;
168 return true;
170 bool operator!=(const KeyTy& that) const {
171 return !this->operator==(that);
175 static inline FunctionType* getEmptyKey() {
176 return DenseMapInfo<FunctionType*>::getEmptyKey();
179 static inline FunctionType* getTombstoneKey() {
180 return DenseMapInfo<FunctionType*>::getTombstoneKey();
183 static unsigned getHashValue(const KeyTy& Key) {
184 return hash_combine(Key.ReturnType,
185 hash_combine_range(Key.Params.begin(),
186 Key.Params.end()),
187 Key.isVarArg);
190 static unsigned getHashValue(const FunctionType *FT) {
191 return getHashValue(KeyTy(FT));
194 static bool isEqual(const KeyTy& LHS, const FunctionType *RHS) {
195 if (RHS == getEmptyKey() || RHS == getTombstoneKey())
196 return false;
197 return LHS == KeyTy(RHS);
200 static bool isEqual(const FunctionType *LHS, const FunctionType *RHS) {
201 return LHS == RHS;
205 /// Structure for hashing arbitrary MDNode operands.
206 class MDNodeOpsKey {
207 ArrayRef<Metadata *> RawOps;
208 ArrayRef<MDOperand> Ops;
209 unsigned Hash;
211 protected:
212 MDNodeOpsKey(ArrayRef<Metadata *> Ops)
213 : RawOps(Ops), Hash(calculateHash(Ops)) {}
215 template <class NodeTy>
216 MDNodeOpsKey(const NodeTy *N, unsigned Offset = 0)
217 : Ops(N->op_begin() + Offset, N->op_end()), Hash(N->getHash()) {}
219 template <class NodeTy>
220 bool compareOps(const NodeTy *RHS, unsigned Offset = 0) const {
221 if (getHash() != RHS->getHash())
222 return false;
224 assert((RawOps.empty() || Ops.empty()) && "Two sets of operands?");
225 return RawOps.empty() ? compareOps(Ops, RHS, Offset)
226 : compareOps(RawOps, RHS, Offset);
229 static unsigned calculateHash(MDNode *N, unsigned Offset = 0);
231 private:
232 template <class T>
233 static bool compareOps(ArrayRef<T> Ops, const MDNode *RHS, unsigned Offset) {
234 if (Ops.size() != RHS->getNumOperands() - Offset)
235 return false;
236 return std::equal(Ops.begin(), Ops.end(), RHS->op_begin() + Offset);
239 static unsigned calculateHash(ArrayRef<Metadata *> Ops);
241 public:
242 unsigned getHash() const { return Hash; }
245 template <class NodeTy> struct MDNodeKeyImpl;
247 /// Configuration point for MDNodeInfo::isEqual().
248 template <class NodeTy> struct MDNodeSubsetEqualImpl {
249 using KeyTy = MDNodeKeyImpl<NodeTy>;
251 static bool isSubsetEqual(const KeyTy &LHS, const NodeTy *RHS) {
252 return false;
255 static bool isSubsetEqual(const NodeTy *LHS, const NodeTy *RHS) {
256 return false;
260 /// DenseMapInfo for MDTuple.
262 /// Note that we don't need the is-function-local bit, since that's implicit in
263 /// the operands.
264 template <> struct MDNodeKeyImpl<MDTuple> : MDNodeOpsKey {
265 MDNodeKeyImpl(ArrayRef<Metadata *> Ops) : MDNodeOpsKey(Ops) {}
266 MDNodeKeyImpl(const MDTuple *N) : MDNodeOpsKey(N) {}
268 bool isKeyOf(const MDTuple *RHS) const { return compareOps(RHS); }
270 unsigned getHashValue() const { return getHash(); }
272 static unsigned calculateHash(MDTuple *N) {
273 return MDNodeOpsKey::calculateHash(N);
277 /// DenseMapInfo for DILocation.
278 template <> struct MDNodeKeyImpl<DILocation> {
279 unsigned Line;
280 unsigned Column;
281 Metadata *Scope;
282 Metadata *InlinedAt;
283 bool ImplicitCode;
285 MDNodeKeyImpl(unsigned Line, unsigned Column, Metadata *Scope,
286 Metadata *InlinedAt, bool ImplicitCode)
287 : Line(Line), Column(Column), Scope(Scope), InlinedAt(InlinedAt),
288 ImplicitCode(ImplicitCode) {}
289 MDNodeKeyImpl(const DILocation *L)
290 : Line(L->getLine()), Column(L->getColumn()), Scope(L->getRawScope()),
291 InlinedAt(L->getRawInlinedAt()), ImplicitCode(L->isImplicitCode()) {}
293 bool isKeyOf(const DILocation *RHS) const {
294 return Line == RHS->getLine() && Column == RHS->getColumn() &&
295 Scope == RHS->getRawScope() && InlinedAt == RHS->getRawInlinedAt() &&
296 ImplicitCode == RHS->isImplicitCode();
299 unsigned getHashValue() const {
300 return hash_combine(Line, Column, Scope, InlinedAt, ImplicitCode);
304 /// DenseMapInfo for GenericDINode.
305 template <> struct MDNodeKeyImpl<GenericDINode> : MDNodeOpsKey {
306 unsigned Tag;
307 MDString *Header;
309 MDNodeKeyImpl(unsigned Tag, MDString *Header, ArrayRef<Metadata *> DwarfOps)
310 : MDNodeOpsKey(DwarfOps), Tag(Tag), Header(Header) {}
311 MDNodeKeyImpl(const GenericDINode *N)
312 : MDNodeOpsKey(N, 1), Tag(N->getTag()), Header(N->getRawHeader()) {}
314 bool isKeyOf(const GenericDINode *RHS) const {
315 return Tag == RHS->getTag() && Header == RHS->getRawHeader() &&
316 compareOps(RHS, 1);
319 unsigned getHashValue() const { return hash_combine(getHash(), Tag, Header); }
321 static unsigned calculateHash(GenericDINode *N) {
322 return MDNodeOpsKey::calculateHash(N, 1);
326 template <> struct MDNodeKeyImpl<DISubrange> {
327 Metadata *CountNode;
328 int64_t LowerBound;
330 MDNodeKeyImpl(Metadata *CountNode, int64_t LowerBound)
331 : CountNode(CountNode), LowerBound(LowerBound) {}
332 MDNodeKeyImpl(const DISubrange *N)
333 : CountNode(N->getRawCountNode()),
334 LowerBound(N->getLowerBound()) {}
336 bool isKeyOf(const DISubrange *RHS) const {
337 if (LowerBound != RHS->getLowerBound())
338 return false;
340 if (auto *RHSCount = RHS->getCount().dyn_cast<ConstantInt*>())
341 if (auto *MD = dyn_cast<ConstantAsMetadata>(CountNode))
342 if (RHSCount->getSExtValue() ==
343 cast<ConstantInt>(MD->getValue())->getSExtValue())
344 return true;
346 return CountNode == RHS->getRawCountNode();
349 unsigned getHashValue() const {
350 if (auto *MD = dyn_cast<ConstantAsMetadata>(CountNode))
351 return hash_combine(cast<ConstantInt>(MD->getValue())->getSExtValue(),
352 LowerBound);
353 return hash_combine(CountNode, LowerBound);
357 template <> struct MDNodeKeyImpl<DIEnumerator> {
358 int64_t Value;
359 MDString *Name;
360 bool IsUnsigned;
362 MDNodeKeyImpl(int64_t Value, bool IsUnsigned, MDString *Name)
363 : Value(Value), Name(Name), IsUnsigned(IsUnsigned) {}
364 MDNodeKeyImpl(const DIEnumerator *N)
365 : Value(N->getValue()), Name(N->getRawName()),
366 IsUnsigned(N->isUnsigned()) {}
368 bool isKeyOf(const DIEnumerator *RHS) const {
369 return Value == RHS->getValue() && IsUnsigned == RHS->isUnsigned() &&
370 Name == RHS->getRawName();
373 unsigned getHashValue() const { return hash_combine(Value, Name); }
376 template <> struct MDNodeKeyImpl<DIBasicType> {
377 unsigned Tag;
378 MDString *Name;
379 uint64_t SizeInBits;
380 uint32_t AlignInBits;
381 unsigned Encoding;
382 unsigned Flags;
384 MDNodeKeyImpl(unsigned Tag, MDString *Name, uint64_t SizeInBits,
385 uint32_t AlignInBits, unsigned Encoding, unsigned Flags)
386 : Tag(Tag), Name(Name), SizeInBits(SizeInBits), AlignInBits(AlignInBits),
387 Encoding(Encoding), Flags(Flags) {}
388 MDNodeKeyImpl(const DIBasicType *N)
389 : Tag(N->getTag()), Name(N->getRawName()), SizeInBits(N->getSizeInBits()),
390 AlignInBits(N->getAlignInBits()), Encoding(N->getEncoding()), Flags(N->getFlags()) {}
392 bool isKeyOf(const DIBasicType *RHS) const {
393 return Tag == RHS->getTag() && Name == RHS->getRawName() &&
394 SizeInBits == RHS->getSizeInBits() &&
395 AlignInBits == RHS->getAlignInBits() &&
396 Encoding == RHS->getEncoding() &&
397 Flags == RHS->getFlags();
400 unsigned getHashValue() const {
401 return hash_combine(Tag, Name, SizeInBits, AlignInBits, Encoding);
405 template <> struct MDNodeKeyImpl<DIDerivedType> {
406 unsigned Tag;
407 MDString *Name;
408 Metadata *File;
409 unsigned Line;
410 Metadata *Scope;
411 Metadata *BaseType;
412 uint64_t SizeInBits;
413 uint64_t OffsetInBits;
414 uint32_t AlignInBits;
415 Optional<unsigned> DWARFAddressSpace;
416 unsigned Flags;
417 Metadata *ExtraData;
419 MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *File, unsigned Line,
420 Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
421 uint32_t AlignInBits, uint64_t OffsetInBits,
422 Optional<unsigned> DWARFAddressSpace, unsigned Flags,
423 Metadata *ExtraData)
424 : Tag(Tag), Name(Name), File(File), Line(Line), Scope(Scope),
425 BaseType(BaseType), SizeInBits(SizeInBits), OffsetInBits(OffsetInBits),
426 AlignInBits(AlignInBits), DWARFAddressSpace(DWARFAddressSpace),
427 Flags(Flags), ExtraData(ExtraData) {}
428 MDNodeKeyImpl(const DIDerivedType *N)
429 : Tag(N->getTag()), Name(N->getRawName()), File(N->getRawFile()),
430 Line(N->getLine()), Scope(N->getRawScope()),
431 BaseType(N->getRawBaseType()), SizeInBits(N->getSizeInBits()),
432 OffsetInBits(N->getOffsetInBits()), AlignInBits(N->getAlignInBits()),
433 DWARFAddressSpace(N->getDWARFAddressSpace()), Flags(N->getFlags()),
434 ExtraData(N->getRawExtraData()) {}
436 bool isKeyOf(const DIDerivedType *RHS) const {
437 return Tag == RHS->getTag() && Name == RHS->getRawName() &&
438 File == RHS->getRawFile() && Line == RHS->getLine() &&
439 Scope == RHS->getRawScope() && BaseType == RHS->getRawBaseType() &&
440 SizeInBits == RHS->getSizeInBits() &&
441 AlignInBits == RHS->getAlignInBits() &&
442 OffsetInBits == RHS->getOffsetInBits() &&
443 DWARFAddressSpace == RHS->getDWARFAddressSpace() &&
444 Flags == RHS->getFlags() &&
445 ExtraData == RHS->getRawExtraData();
448 unsigned getHashValue() const {
449 // If this is a member inside an ODR type, only hash the type and the name.
450 // Otherwise the hash will be stronger than
451 // MDNodeSubsetEqualImpl::isODRMember().
452 if (Tag == dwarf::DW_TAG_member && Name)
453 if (auto *CT = dyn_cast_or_null<DICompositeType>(Scope))
454 if (CT->getRawIdentifier())
455 return hash_combine(Name, Scope);
457 // Intentionally computes the hash on a subset of the operands for
458 // performance reason. The subset has to be significant enough to avoid
459 // collision "most of the time". There is no correctness issue in case of
460 // collision because of the full check above.
461 return hash_combine(Tag, Name, File, Line, Scope, BaseType, Flags);
465 template <> struct MDNodeSubsetEqualImpl<DIDerivedType> {
466 using KeyTy = MDNodeKeyImpl<DIDerivedType>;
468 static bool isSubsetEqual(const KeyTy &LHS, const DIDerivedType *RHS) {
469 return isODRMember(LHS.Tag, LHS.Scope, LHS.Name, RHS);
472 static bool isSubsetEqual(const DIDerivedType *LHS, const DIDerivedType *RHS) {
473 return isODRMember(LHS->getTag(), LHS->getRawScope(), LHS->getRawName(),
474 RHS);
477 /// Subprograms compare equal if they declare the same function in an ODR
478 /// type.
479 static bool isODRMember(unsigned Tag, const Metadata *Scope,
480 const MDString *Name, const DIDerivedType *RHS) {
481 // Check whether the LHS is eligible.
482 if (Tag != dwarf::DW_TAG_member || !Name)
483 return false;
485 auto *CT = dyn_cast_or_null<DICompositeType>(Scope);
486 if (!CT || !CT->getRawIdentifier())
487 return false;
489 // Compare to the RHS.
490 return Tag == RHS->getTag() && Name == RHS->getRawName() &&
491 Scope == RHS->getRawScope();
495 template <> struct MDNodeKeyImpl<DICompositeType> {
496 unsigned Tag;
497 MDString *Name;
498 Metadata *File;
499 unsigned Line;
500 Metadata *Scope;
501 Metadata *BaseType;
502 uint64_t SizeInBits;
503 uint64_t OffsetInBits;
504 uint32_t AlignInBits;
505 unsigned Flags;
506 Metadata *Elements;
507 unsigned RuntimeLang;
508 Metadata *VTableHolder;
509 Metadata *TemplateParams;
510 MDString *Identifier;
511 Metadata *Discriminator;
513 MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *File, unsigned Line,
514 Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits,
515 uint32_t AlignInBits, uint64_t OffsetInBits, unsigned Flags,
516 Metadata *Elements, unsigned RuntimeLang,
517 Metadata *VTableHolder, Metadata *TemplateParams,
518 MDString *Identifier, Metadata *Discriminator)
519 : Tag(Tag), Name(Name), File(File), Line(Line), Scope(Scope),
520 BaseType(BaseType), SizeInBits(SizeInBits), OffsetInBits(OffsetInBits),
521 AlignInBits(AlignInBits), Flags(Flags), Elements(Elements),
522 RuntimeLang(RuntimeLang), VTableHolder(VTableHolder),
523 TemplateParams(TemplateParams), Identifier(Identifier),
524 Discriminator(Discriminator) {}
525 MDNodeKeyImpl(const DICompositeType *N)
526 : Tag(N->getTag()), Name(N->getRawName()), File(N->getRawFile()),
527 Line(N->getLine()), Scope(N->getRawScope()),
528 BaseType(N->getRawBaseType()), SizeInBits(N->getSizeInBits()),
529 OffsetInBits(N->getOffsetInBits()), AlignInBits(N->getAlignInBits()),
530 Flags(N->getFlags()), Elements(N->getRawElements()),
531 RuntimeLang(N->getRuntimeLang()), VTableHolder(N->getRawVTableHolder()),
532 TemplateParams(N->getRawTemplateParams()),
533 Identifier(N->getRawIdentifier()),
534 Discriminator(N->getRawDiscriminator()) {}
536 bool isKeyOf(const DICompositeType *RHS) const {
537 return Tag == RHS->getTag() && Name == RHS->getRawName() &&
538 File == RHS->getRawFile() && Line == RHS->getLine() &&
539 Scope == RHS->getRawScope() && BaseType == RHS->getRawBaseType() &&
540 SizeInBits == RHS->getSizeInBits() &&
541 AlignInBits == RHS->getAlignInBits() &&
542 OffsetInBits == RHS->getOffsetInBits() && Flags == RHS->getFlags() &&
543 Elements == RHS->getRawElements() &&
544 RuntimeLang == RHS->getRuntimeLang() &&
545 VTableHolder == RHS->getRawVTableHolder() &&
546 TemplateParams == RHS->getRawTemplateParams() &&
547 Identifier == RHS->getRawIdentifier() &&
548 Discriminator == RHS->getRawDiscriminator();
551 unsigned getHashValue() const {
552 // Intentionally computes the hash on a subset of the operands for
553 // performance reason. The subset has to be significant enough to avoid
554 // collision "most of the time". There is no correctness issue in case of
555 // collision because of the full check above.
556 return hash_combine(Name, File, Line, BaseType, Scope, Elements,
557 TemplateParams);
561 template <> struct MDNodeKeyImpl<DISubroutineType> {
562 unsigned Flags;
563 uint8_t CC;
564 Metadata *TypeArray;
566 MDNodeKeyImpl(unsigned Flags, uint8_t CC, Metadata *TypeArray)
567 : Flags(Flags), CC(CC), TypeArray(TypeArray) {}
568 MDNodeKeyImpl(const DISubroutineType *N)
569 : Flags(N->getFlags()), CC(N->getCC()), TypeArray(N->getRawTypeArray()) {}
571 bool isKeyOf(const DISubroutineType *RHS) const {
572 return Flags == RHS->getFlags() && CC == RHS->getCC() &&
573 TypeArray == RHS->getRawTypeArray();
576 unsigned getHashValue() const { return hash_combine(Flags, CC, TypeArray); }
579 template <> struct MDNodeKeyImpl<DIFile> {
580 MDString *Filename;
581 MDString *Directory;
582 Optional<DIFile::ChecksumInfo<MDString *>> Checksum;
583 Optional<MDString *> Source;
585 MDNodeKeyImpl(MDString *Filename, MDString *Directory,
586 Optional<DIFile::ChecksumInfo<MDString *>> Checksum,
587 Optional<MDString *> Source)
588 : Filename(Filename), Directory(Directory), Checksum(Checksum),
589 Source(Source) {}
590 MDNodeKeyImpl(const DIFile *N)
591 : Filename(N->getRawFilename()), Directory(N->getRawDirectory()),
592 Checksum(N->getRawChecksum()), Source(N->getRawSource()) {}
594 bool isKeyOf(const DIFile *RHS) const {
595 return Filename == RHS->getRawFilename() &&
596 Directory == RHS->getRawDirectory() &&
597 Checksum == RHS->getRawChecksum() &&
598 Source == RHS->getRawSource();
601 unsigned getHashValue() const {
602 return hash_combine(
603 Filename, Directory, Checksum ? Checksum->Kind : 0,
604 Checksum ? Checksum->Value : nullptr, Source.getValueOr(nullptr));
608 template <> struct MDNodeKeyImpl<DISubprogram> {
609 Metadata *Scope;
610 MDString *Name;
611 MDString *LinkageName;
612 Metadata *File;
613 unsigned Line;
614 Metadata *Type;
615 unsigned ScopeLine;
616 Metadata *ContainingType;
617 unsigned VirtualIndex;
618 int ThisAdjustment;
619 unsigned Flags;
620 unsigned SPFlags;
621 Metadata *Unit;
622 Metadata *TemplateParams;
623 Metadata *Declaration;
624 Metadata *RetainedNodes;
625 Metadata *ThrownTypes;
627 MDNodeKeyImpl(Metadata *Scope, MDString *Name, MDString *LinkageName,
628 Metadata *File, unsigned Line, Metadata *Type,
629 unsigned ScopeLine, Metadata *ContainingType,
630 unsigned VirtualIndex, int ThisAdjustment, unsigned Flags,
631 unsigned SPFlags, Metadata *Unit, Metadata *TemplateParams,
632 Metadata *Declaration, Metadata *RetainedNodes,
633 Metadata *ThrownTypes)
634 : Scope(Scope), Name(Name), LinkageName(LinkageName), File(File),
635 Line(Line), Type(Type), ScopeLine(ScopeLine),
636 ContainingType(ContainingType), VirtualIndex(VirtualIndex),
637 ThisAdjustment(ThisAdjustment), Flags(Flags), SPFlags(SPFlags),
638 Unit(Unit), TemplateParams(TemplateParams), Declaration(Declaration),
639 RetainedNodes(RetainedNodes), ThrownTypes(ThrownTypes) {}
640 MDNodeKeyImpl(const DISubprogram *N)
641 : Scope(N->getRawScope()), Name(N->getRawName()),
642 LinkageName(N->getRawLinkageName()), File(N->getRawFile()),
643 Line(N->getLine()), Type(N->getRawType()), ScopeLine(N->getScopeLine()),
644 ContainingType(N->getRawContainingType()),
645 VirtualIndex(N->getVirtualIndex()),
646 ThisAdjustment(N->getThisAdjustment()), Flags(N->getFlags()),
647 SPFlags(N->getSPFlags()), Unit(N->getRawUnit()),
648 TemplateParams(N->getRawTemplateParams()),
649 Declaration(N->getRawDeclaration()),
650 RetainedNodes(N->getRawRetainedNodes()),
651 ThrownTypes(N->getRawThrownTypes()) {}
653 bool isKeyOf(const DISubprogram *RHS) const {
654 return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
655 LinkageName == RHS->getRawLinkageName() &&
656 File == RHS->getRawFile() && Line == RHS->getLine() &&
657 Type == RHS->getRawType() && ScopeLine == RHS->getScopeLine() &&
658 ContainingType == RHS->getRawContainingType() &&
659 VirtualIndex == RHS->getVirtualIndex() &&
660 ThisAdjustment == RHS->getThisAdjustment() &&
661 Flags == RHS->getFlags() && SPFlags == RHS->getSPFlags() &&
662 Unit == RHS->getUnit() &&
663 TemplateParams == RHS->getRawTemplateParams() &&
664 Declaration == RHS->getRawDeclaration() &&
665 RetainedNodes == RHS->getRawRetainedNodes() &&
666 ThrownTypes == RHS->getRawThrownTypes();
669 bool isDefinition() const { return SPFlags & DISubprogram::SPFlagDefinition; }
671 unsigned getHashValue() const {
672 // If this is a declaration inside an ODR type, only hash the type and the
673 // name. Otherwise the hash will be stronger than
674 // MDNodeSubsetEqualImpl::isDeclarationOfODRMember().
675 if (!isDefinition() && LinkageName)
676 if (auto *CT = dyn_cast_or_null<DICompositeType>(Scope))
677 if (CT->getRawIdentifier())
678 return hash_combine(LinkageName, Scope);
680 // Intentionally computes the hash on a subset of the operands for
681 // performance reason. The subset has to be significant enough to avoid
682 // collision "most of the time". There is no correctness issue in case of
683 // collision because of the full check above.
684 return hash_combine(Name, Scope, File, Type, Line);
688 template <> struct MDNodeSubsetEqualImpl<DISubprogram> {
689 using KeyTy = MDNodeKeyImpl<DISubprogram>;
691 static bool isSubsetEqual(const KeyTy &LHS, const DISubprogram *RHS) {
692 return isDeclarationOfODRMember(LHS.isDefinition(), LHS.Scope,
693 LHS.LinkageName, LHS.TemplateParams, RHS);
696 static bool isSubsetEqual(const DISubprogram *LHS, const DISubprogram *RHS) {
697 return isDeclarationOfODRMember(LHS->isDefinition(), LHS->getRawScope(),
698 LHS->getRawLinkageName(),
699 LHS->getRawTemplateParams(), RHS);
702 /// Subprograms compare equal if they declare the same function in an ODR
703 /// type.
704 static bool isDeclarationOfODRMember(bool IsDefinition, const Metadata *Scope,
705 const MDString *LinkageName,
706 const Metadata *TemplateParams,
707 const DISubprogram *RHS) {
708 // Check whether the LHS is eligible.
709 if (IsDefinition || !Scope || !LinkageName)
710 return false;
712 auto *CT = dyn_cast_or_null<DICompositeType>(Scope);
713 if (!CT || !CT->getRawIdentifier())
714 return false;
716 // Compare to the RHS.
717 // FIXME: We need to compare template parameters here to avoid incorrect
718 // collisions in mapMetadata when RF_MoveDistinctMDs and a ODR-DISubprogram
719 // has a non-ODR template parameter (i.e., a DICompositeType that does not
720 // have an identifier). Eventually we should decouple ODR logic from
721 // uniquing logic.
722 return IsDefinition == RHS->isDefinition() && Scope == RHS->getRawScope() &&
723 LinkageName == RHS->getRawLinkageName() &&
724 TemplateParams == RHS->getRawTemplateParams();
728 template <> struct MDNodeKeyImpl<DILexicalBlock> {
729 Metadata *Scope;
730 Metadata *File;
731 unsigned Line;
732 unsigned Column;
734 MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Line, unsigned Column)
735 : Scope(Scope), File(File), Line(Line), Column(Column) {}
736 MDNodeKeyImpl(const DILexicalBlock *N)
737 : Scope(N->getRawScope()), File(N->getRawFile()), Line(N->getLine()),
738 Column(N->getColumn()) {}
740 bool isKeyOf(const DILexicalBlock *RHS) const {
741 return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
742 Line == RHS->getLine() && Column == RHS->getColumn();
745 unsigned getHashValue() const {
746 return hash_combine(Scope, File, Line, Column);
750 template <> struct MDNodeKeyImpl<DILexicalBlockFile> {
751 Metadata *Scope;
752 Metadata *File;
753 unsigned Discriminator;
755 MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Discriminator)
756 : Scope(Scope), File(File), Discriminator(Discriminator) {}
757 MDNodeKeyImpl(const DILexicalBlockFile *N)
758 : Scope(N->getRawScope()), File(N->getRawFile()),
759 Discriminator(N->getDiscriminator()) {}
761 bool isKeyOf(const DILexicalBlockFile *RHS) const {
762 return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
763 Discriminator == RHS->getDiscriminator();
766 unsigned getHashValue() const {
767 return hash_combine(Scope, File, Discriminator);
771 template <> struct MDNodeKeyImpl<DINamespace> {
772 Metadata *Scope;
773 MDString *Name;
774 bool ExportSymbols;
776 MDNodeKeyImpl(Metadata *Scope, MDString *Name, bool ExportSymbols)
777 : Scope(Scope), Name(Name), ExportSymbols(ExportSymbols) {}
778 MDNodeKeyImpl(const DINamespace *N)
779 : Scope(N->getRawScope()), Name(N->getRawName()),
780 ExportSymbols(N->getExportSymbols()) {}
782 bool isKeyOf(const DINamespace *RHS) const {
783 return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
784 ExportSymbols == RHS->getExportSymbols();
787 unsigned getHashValue() const {
788 return hash_combine(Scope, Name);
792 template <> struct MDNodeKeyImpl<DICommonBlock> {
793 Metadata *Scope;
794 Metadata *Decl;
795 MDString *Name;
796 Metadata *File;
797 unsigned LineNo;
799 MDNodeKeyImpl(Metadata *Scope, Metadata *Decl, MDString *Name,
800 Metadata *File, unsigned LineNo)
801 : Scope(Scope), Decl(Decl), Name(Name), File(File), LineNo(LineNo) {}
802 MDNodeKeyImpl(const DICommonBlock *N)
803 : Scope(N->getRawScope()), Decl(N->getRawDecl()), Name(N->getRawName()),
804 File(N->getRawFile()), LineNo(N->getLineNo()) {}
806 bool isKeyOf(const DICommonBlock *RHS) const {
807 return Scope == RHS->getRawScope() && Decl == RHS->getRawDecl() &&
808 Name == RHS->getRawName() && File == RHS->getRawFile() &&
809 LineNo == RHS->getLineNo();
812 unsigned getHashValue() const {
813 return hash_combine(Scope, Decl, Name, File, LineNo);
817 template <> struct MDNodeKeyImpl<DIModule> {
818 Metadata *Scope;
819 MDString *Name;
820 MDString *ConfigurationMacros;
821 MDString *IncludePath;
822 MDString *ISysRoot;
824 MDNodeKeyImpl(Metadata *Scope, MDString *Name, MDString *ConfigurationMacros,
825 MDString *IncludePath, MDString *ISysRoot)
826 : Scope(Scope), Name(Name), ConfigurationMacros(ConfigurationMacros),
827 IncludePath(IncludePath), ISysRoot(ISysRoot) {}
828 MDNodeKeyImpl(const DIModule *N)
829 : Scope(N->getRawScope()), Name(N->getRawName()),
830 ConfigurationMacros(N->getRawConfigurationMacros()),
831 IncludePath(N->getRawIncludePath()), ISysRoot(N->getRawISysRoot()) {}
833 bool isKeyOf(const DIModule *RHS) const {
834 return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
835 ConfigurationMacros == RHS->getRawConfigurationMacros() &&
836 IncludePath == RHS->getRawIncludePath() &&
837 ISysRoot == RHS->getRawISysRoot();
840 unsigned getHashValue() const {
841 return hash_combine(Scope, Name,
842 ConfigurationMacros, IncludePath, ISysRoot);
846 template <> struct MDNodeKeyImpl<DITemplateTypeParameter> {
847 MDString *Name;
848 Metadata *Type;
850 MDNodeKeyImpl(MDString *Name, Metadata *Type) : Name(Name), Type(Type) {}
851 MDNodeKeyImpl(const DITemplateTypeParameter *N)
852 : Name(N->getRawName()), Type(N->getRawType()) {}
854 bool isKeyOf(const DITemplateTypeParameter *RHS) const {
855 return Name == RHS->getRawName() && Type == RHS->getRawType();
858 unsigned getHashValue() const { return hash_combine(Name, Type); }
861 template <> struct MDNodeKeyImpl<DITemplateValueParameter> {
862 unsigned Tag;
863 MDString *Name;
864 Metadata *Type;
865 Metadata *Value;
867 MDNodeKeyImpl(unsigned Tag, MDString *Name, Metadata *Type, Metadata *Value)
868 : Tag(Tag), Name(Name), Type(Type), Value(Value) {}
869 MDNodeKeyImpl(const DITemplateValueParameter *N)
870 : Tag(N->getTag()), Name(N->getRawName()), Type(N->getRawType()),
871 Value(N->getValue()) {}
873 bool isKeyOf(const DITemplateValueParameter *RHS) const {
874 return Tag == RHS->getTag() && Name == RHS->getRawName() &&
875 Type == RHS->getRawType() && Value == RHS->getValue();
878 unsigned getHashValue() const { return hash_combine(Tag, Name, Type, Value); }
881 template <> struct MDNodeKeyImpl<DIGlobalVariable> {
882 Metadata *Scope;
883 MDString *Name;
884 MDString *LinkageName;
885 Metadata *File;
886 unsigned Line;
887 Metadata *Type;
888 bool IsLocalToUnit;
889 bool IsDefinition;
890 Metadata *StaticDataMemberDeclaration;
891 Metadata *TemplateParams;
892 uint32_t AlignInBits;
894 MDNodeKeyImpl(Metadata *Scope, MDString *Name, MDString *LinkageName,
895 Metadata *File, unsigned Line, Metadata *Type,
896 bool IsLocalToUnit, bool IsDefinition,
897 Metadata *StaticDataMemberDeclaration, Metadata *TemplateParams,
898 uint32_t AlignInBits)
899 : Scope(Scope), Name(Name), LinkageName(LinkageName), File(File),
900 Line(Line), Type(Type), IsLocalToUnit(IsLocalToUnit),
901 IsDefinition(IsDefinition),
902 StaticDataMemberDeclaration(StaticDataMemberDeclaration),
903 TemplateParams(TemplateParams), AlignInBits(AlignInBits) {}
904 MDNodeKeyImpl(const DIGlobalVariable *N)
905 : Scope(N->getRawScope()), Name(N->getRawName()),
906 LinkageName(N->getRawLinkageName()), File(N->getRawFile()),
907 Line(N->getLine()), Type(N->getRawType()),
908 IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()),
909 StaticDataMemberDeclaration(N->getRawStaticDataMemberDeclaration()),
910 TemplateParams(N->getRawTemplateParams()),
911 AlignInBits(N->getAlignInBits()) {}
913 bool isKeyOf(const DIGlobalVariable *RHS) const {
914 return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
915 LinkageName == RHS->getRawLinkageName() &&
916 File == RHS->getRawFile() && Line == RHS->getLine() &&
917 Type == RHS->getRawType() && IsLocalToUnit == RHS->isLocalToUnit() &&
918 IsDefinition == RHS->isDefinition() &&
919 StaticDataMemberDeclaration ==
920 RHS->getRawStaticDataMemberDeclaration() &&
921 TemplateParams == RHS->getRawTemplateParams() &&
922 AlignInBits == RHS->getAlignInBits();
925 unsigned getHashValue() const {
926 // We do not use AlignInBits in hashing function here on purpose:
927 // in most cases this param for local variable is zero (for function param
928 // it is always zero). This leads to lots of hash collisions and errors on
929 // cases with lots of similar variables.
930 // clang/test/CodeGen/debug-info-257-args.c is an example of this problem,
931 // generated IR is random for each run and test fails with Align included.
932 // TODO: make hashing work fine with such situations
933 return hash_combine(Scope, Name, LinkageName, File, Line, Type,
934 IsLocalToUnit, IsDefinition, /* AlignInBits, */
935 StaticDataMemberDeclaration);
939 template <> struct MDNodeKeyImpl<DILocalVariable> {
940 Metadata *Scope;
941 MDString *Name;
942 Metadata *File;
943 unsigned Line;
944 Metadata *Type;
945 unsigned Arg;
946 unsigned Flags;
947 uint32_t AlignInBits;
949 MDNodeKeyImpl(Metadata *Scope, MDString *Name, Metadata *File, unsigned Line,
950 Metadata *Type, unsigned Arg, unsigned Flags,
951 uint32_t AlignInBits)
952 : Scope(Scope), Name(Name), File(File), Line(Line), Type(Type), Arg(Arg),
953 Flags(Flags), AlignInBits(AlignInBits) {}
954 MDNodeKeyImpl(const DILocalVariable *N)
955 : Scope(N->getRawScope()), Name(N->getRawName()), File(N->getRawFile()),
956 Line(N->getLine()), Type(N->getRawType()), Arg(N->getArg()),
957 Flags(N->getFlags()), AlignInBits(N->getAlignInBits()) {}
959 bool isKeyOf(const DILocalVariable *RHS) const {
960 return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
961 File == RHS->getRawFile() && Line == RHS->getLine() &&
962 Type == RHS->getRawType() && Arg == RHS->getArg() &&
963 Flags == RHS->getFlags() && AlignInBits == RHS->getAlignInBits();
966 unsigned getHashValue() const {
967 // We do not use AlignInBits in hashing function here on purpose:
968 // in most cases this param for local variable is zero (for function param
969 // it is always zero). This leads to lots of hash collisions and errors on
970 // cases with lots of similar variables.
971 // clang/test/CodeGen/debug-info-257-args.c is an example of this problem,
972 // generated IR is random for each run and test fails with Align included.
973 // TODO: make hashing work fine with such situations
974 return hash_combine(Scope, Name, File, Line, Type, Arg, Flags);
978 template <> struct MDNodeKeyImpl<DILabel> {
979 Metadata *Scope;
980 MDString *Name;
981 Metadata *File;
982 unsigned Line;
984 MDNodeKeyImpl(Metadata *Scope, MDString *Name, Metadata *File, unsigned Line)
985 : Scope(Scope), Name(Name), File(File), Line(Line) {}
986 MDNodeKeyImpl(const DILabel *N)
987 : Scope(N->getRawScope()), Name(N->getRawName()), File(N->getRawFile()),
988 Line(N->getLine()) {}
990 bool isKeyOf(const DILabel *RHS) const {
991 return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
992 File == RHS->getRawFile() && Line == RHS->getLine();
995 /// Using name and line to get hash value. It should already be mostly unique.
996 unsigned getHashValue() const {
997 return hash_combine(Scope, Name, Line);
1001 template <> struct MDNodeKeyImpl<DIExpression> {
1002 ArrayRef<uint64_t> Elements;
1004 MDNodeKeyImpl(ArrayRef<uint64_t> Elements) : Elements(Elements) {}
1005 MDNodeKeyImpl(const DIExpression *N) : Elements(N->getElements()) {}
1007 bool isKeyOf(const DIExpression *RHS) const {
1008 return Elements == RHS->getElements();
1011 unsigned getHashValue() const {
1012 return hash_combine_range(Elements.begin(), Elements.end());
1016 template <> struct MDNodeKeyImpl<DIGlobalVariableExpression> {
1017 Metadata *Variable;
1018 Metadata *Expression;
1020 MDNodeKeyImpl(Metadata *Variable, Metadata *Expression)
1021 : Variable(Variable), Expression(Expression) {}
1022 MDNodeKeyImpl(const DIGlobalVariableExpression *N)
1023 : Variable(N->getRawVariable()), Expression(N->getRawExpression()) {}
1025 bool isKeyOf(const DIGlobalVariableExpression *RHS) const {
1026 return Variable == RHS->getRawVariable() &&
1027 Expression == RHS->getRawExpression();
1030 unsigned getHashValue() const { return hash_combine(Variable, Expression); }
1033 template <> struct MDNodeKeyImpl<DIObjCProperty> {
1034 MDString *Name;
1035 Metadata *File;
1036 unsigned Line;
1037 MDString *GetterName;
1038 MDString *SetterName;
1039 unsigned Attributes;
1040 Metadata *Type;
1042 MDNodeKeyImpl(MDString *Name, Metadata *File, unsigned Line,
1043 MDString *GetterName, MDString *SetterName, unsigned Attributes,
1044 Metadata *Type)
1045 : Name(Name), File(File), Line(Line), GetterName(GetterName),
1046 SetterName(SetterName), Attributes(Attributes), Type(Type) {}
1047 MDNodeKeyImpl(const DIObjCProperty *N)
1048 : Name(N->getRawName()), File(N->getRawFile()), Line(N->getLine()),
1049 GetterName(N->getRawGetterName()), SetterName(N->getRawSetterName()),
1050 Attributes(N->getAttributes()), Type(N->getRawType()) {}
1052 bool isKeyOf(const DIObjCProperty *RHS) const {
1053 return Name == RHS->getRawName() && File == RHS->getRawFile() &&
1054 Line == RHS->getLine() && GetterName == RHS->getRawGetterName() &&
1055 SetterName == RHS->getRawSetterName() &&
1056 Attributes == RHS->getAttributes() && Type == RHS->getRawType();
1059 unsigned getHashValue() const {
1060 return hash_combine(Name, File, Line, GetterName, SetterName, Attributes,
1061 Type);
1065 template <> struct MDNodeKeyImpl<DIImportedEntity> {
1066 unsigned Tag;
1067 Metadata *Scope;
1068 Metadata *Entity;
1069 Metadata *File;
1070 unsigned Line;
1071 MDString *Name;
1073 MDNodeKeyImpl(unsigned Tag, Metadata *Scope, Metadata *Entity, Metadata *File,
1074 unsigned Line, MDString *Name)
1075 : Tag(Tag), Scope(Scope), Entity(Entity), File(File), Line(Line),
1076 Name(Name) {}
1077 MDNodeKeyImpl(const DIImportedEntity *N)
1078 : Tag(N->getTag()), Scope(N->getRawScope()), Entity(N->getRawEntity()),
1079 File(N->getRawFile()), Line(N->getLine()), Name(N->getRawName()) {}
1081 bool isKeyOf(const DIImportedEntity *RHS) const {
1082 return Tag == RHS->getTag() && Scope == RHS->getRawScope() &&
1083 Entity == RHS->getRawEntity() && File == RHS->getFile() &&
1084 Line == RHS->getLine() && Name == RHS->getRawName();
1087 unsigned getHashValue() const {
1088 return hash_combine(Tag, Scope, Entity, File, Line, Name);
1092 template <> struct MDNodeKeyImpl<DIMacro> {
1093 unsigned MIType;
1094 unsigned Line;
1095 MDString *Name;
1096 MDString *Value;
1098 MDNodeKeyImpl(unsigned MIType, unsigned Line, MDString *Name, MDString *Value)
1099 : MIType(MIType), Line(Line), Name(Name), Value(Value) {}
1100 MDNodeKeyImpl(const DIMacro *N)
1101 : MIType(N->getMacinfoType()), Line(N->getLine()), Name(N->getRawName()),
1102 Value(N->getRawValue()) {}
1104 bool isKeyOf(const DIMacro *RHS) const {
1105 return MIType == RHS->getMacinfoType() && Line == RHS->getLine() &&
1106 Name == RHS->getRawName() && Value == RHS->getRawValue();
1109 unsigned getHashValue() const {
1110 return hash_combine(MIType, Line, Name, Value);
1114 template <> struct MDNodeKeyImpl<DIMacroFile> {
1115 unsigned MIType;
1116 unsigned Line;
1117 Metadata *File;
1118 Metadata *Elements;
1120 MDNodeKeyImpl(unsigned MIType, unsigned Line, Metadata *File,
1121 Metadata *Elements)
1122 : MIType(MIType), Line(Line), File(File), Elements(Elements) {}
1123 MDNodeKeyImpl(const DIMacroFile *N)
1124 : MIType(N->getMacinfoType()), Line(N->getLine()), File(N->getRawFile()),
1125 Elements(N->getRawElements()) {}
1127 bool isKeyOf(const DIMacroFile *RHS) const {
1128 return MIType == RHS->getMacinfoType() && Line == RHS->getLine() &&
1129 File == RHS->getRawFile() && Elements == RHS->getRawElements();
1132 unsigned getHashValue() const {
1133 return hash_combine(MIType, Line, File, Elements);
1137 /// DenseMapInfo for MDNode subclasses.
1138 template <class NodeTy> struct MDNodeInfo {
1139 using KeyTy = MDNodeKeyImpl<NodeTy>;
1140 using SubsetEqualTy = MDNodeSubsetEqualImpl<NodeTy>;
1142 static inline NodeTy *getEmptyKey() {
1143 return DenseMapInfo<NodeTy *>::getEmptyKey();
1146 static inline NodeTy *getTombstoneKey() {
1147 return DenseMapInfo<NodeTy *>::getTombstoneKey();
1150 static unsigned getHashValue(const KeyTy &Key) { return Key.getHashValue(); }
1152 static unsigned getHashValue(const NodeTy *N) {
1153 return KeyTy(N).getHashValue();
1156 static bool isEqual(const KeyTy &LHS, const NodeTy *RHS) {
1157 if (RHS == getEmptyKey() || RHS == getTombstoneKey())
1158 return false;
1159 return SubsetEqualTy::isSubsetEqual(LHS, RHS) || LHS.isKeyOf(RHS);
1162 static bool isEqual(const NodeTy *LHS, const NodeTy *RHS) {
1163 if (LHS == RHS)
1164 return true;
1165 if (RHS == getEmptyKey() || RHS == getTombstoneKey())
1166 return false;
1167 return SubsetEqualTy::isSubsetEqual(LHS, RHS);
1171 #define HANDLE_MDNODE_LEAF(CLASS) using CLASS##Info = MDNodeInfo<CLASS>;
1172 #include "llvm/IR/Metadata.def"
1174 /// Map-like storage for metadata attachments.
1175 class MDAttachmentMap {
1176 SmallVector<std::pair<unsigned, TrackingMDNodeRef>, 2> Attachments;
1178 public:
1179 bool empty() const { return Attachments.empty(); }
1180 size_t size() const { return Attachments.size(); }
1182 /// Get a particular attachment (if any).
1183 MDNode *lookup(unsigned ID) const;
1185 /// Set an attachment to a particular node.
1187 /// Set the \c ID attachment to \c MD, replacing the current attachment at \c
1188 /// ID (if anyway).
1189 void set(unsigned ID, MDNode &MD);
1191 /// Remove an attachment.
1193 /// Remove the attachment at \c ID, if any.
1194 bool erase(unsigned ID);
1196 /// Copy out all the attachments.
1198 /// Copies all the current attachments into \c Result, sorting by attachment
1199 /// ID. This function does \em not clear \c Result.
1200 void getAll(SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const;
1202 /// Erase matching attachments.
1204 /// Erases all attachments matching the \c shouldRemove predicate.
1205 template <class PredTy> void remove_if(PredTy shouldRemove) {
1206 Attachments.erase(llvm::remove_if(Attachments, shouldRemove),
1207 Attachments.end());
1211 /// Multimap-like storage for metadata attachments for globals. This differs
1212 /// from MDAttachmentMap in that it allows multiple attachments per metadata
1213 /// kind.
1214 class MDGlobalAttachmentMap {
1215 struct Attachment {
1216 unsigned MDKind;
1217 TrackingMDNodeRef Node;
1219 SmallVector<Attachment, 1> Attachments;
1221 public:
1222 bool empty() const { return Attachments.empty(); }
1224 /// Appends all attachments with the given ID to \c Result in insertion order.
1225 /// If the global has no attachments with the given ID, or if ID is invalid,
1226 /// leaves Result unchanged.
1227 void get(unsigned ID, SmallVectorImpl<MDNode *> &Result) const;
1229 /// Returns the first attachment with the given ID or nullptr if no such
1230 /// attachment exists.
1231 MDNode *lookup(unsigned ID) const;
1233 void insert(unsigned ID, MDNode &MD);
1234 bool erase(unsigned ID);
1236 /// Appends all attachments for the global to \c Result, sorting by attachment
1237 /// ID. Attachments with the same ID appear in insertion order. This function
1238 /// does \em not clear \c Result.
1239 void getAll(SmallVectorImpl<std::pair<unsigned, MDNode *>> &Result) const;
1242 class LLVMContextImpl {
1243 public:
1244 /// OwnedModules - The set of modules instantiated in this context, and which
1245 /// will be automatically deleted if this context is deleted.
1246 SmallPtrSet<Module*, 4> OwnedModules;
1248 LLVMContext::InlineAsmDiagHandlerTy InlineAsmDiagHandler = nullptr;
1249 void *InlineAsmDiagContext = nullptr;
1251 std::unique_ptr<DiagnosticHandler> DiagHandler;
1252 bool RespectDiagnosticFilters = false;
1253 bool DiagnosticsHotnessRequested = false;
1254 uint64_t DiagnosticsHotnessThreshold = 0;
1255 std::unique_ptr<RemarkStreamer> RemarkDiagStreamer;
1257 LLVMContext::YieldCallbackTy YieldCallback = nullptr;
1258 void *YieldOpaqueHandle = nullptr;
1260 using IntMapTy =
1261 DenseMap<APInt, std::unique_ptr<ConstantInt>, DenseMapAPIntKeyInfo>;
1262 IntMapTy IntConstants;
1264 using FPMapTy =
1265 DenseMap<APFloat, std::unique_ptr<ConstantFP>, DenseMapAPFloatKeyInfo>;
1266 FPMapTy FPConstants;
1268 FoldingSet<AttributeImpl> AttrsSet;
1269 FoldingSet<AttributeListImpl> AttrsLists;
1270 FoldingSet<AttributeSetNode> AttrsSetNodes;
1272 StringMap<MDString, BumpPtrAllocator> MDStringCache;
1273 DenseMap<Value *, ValueAsMetadata *> ValuesAsMetadata;
1274 DenseMap<Metadata *, MetadataAsValue *> MetadataAsValues;
1276 DenseMap<const Value*, ValueName*> ValueNames;
1278 #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) \
1279 DenseSet<CLASS *, CLASS##Info> CLASS##s;
1280 #include "llvm/IR/Metadata.def"
1282 // Optional map for looking up composite types by identifier.
1283 Optional<DenseMap<const MDString *, DICompositeType *>> DITypeMap;
1285 // MDNodes may be uniqued or not uniqued. When they're not uniqued, they
1286 // aren't in the MDNodeSet, but they're still shared between objects, so no
1287 // one object can destroy them. Keep track of them here so we can delete
1288 // them on context teardown.
1289 std::vector<MDNode *> DistinctMDNodes;
1291 DenseMap<Type *, std::unique_ptr<ConstantAggregateZero>> CAZConstants;
1293 using ArrayConstantsTy = ConstantUniqueMap<ConstantArray>;
1294 ArrayConstantsTy ArrayConstants;
1296 using StructConstantsTy = ConstantUniqueMap<ConstantStruct>;
1297 StructConstantsTy StructConstants;
1299 using VectorConstantsTy = ConstantUniqueMap<ConstantVector>;
1300 VectorConstantsTy VectorConstants;
1302 DenseMap<PointerType *, std::unique_ptr<ConstantPointerNull>> CPNConstants;
1304 DenseMap<Type *, std::unique_ptr<UndefValue>> UVConstants;
1306 StringMap<ConstantDataSequential*> CDSConstants;
1308 DenseMap<std::pair<const Function *, const BasicBlock *>, BlockAddress *>
1309 BlockAddresses;
1310 ConstantUniqueMap<ConstantExpr> ExprConstants;
1312 ConstantUniqueMap<InlineAsm> InlineAsms;
1314 ConstantInt *TheTrueVal = nullptr;
1315 ConstantInt *TheFalseVal = nullptr;
1317 std::unique_ptr<ConstantTokenNone> TheNoneToken;
1319 // Basic type instances.
1320 Type VoidTy, LabelTy, HalfTy, FloatTy, DoubleTy, MetadataTy, TokenTy;
1321 Type X86_FP80Ty, FP128Ty, PPC_FP128Ty, X86_MMXTy;
1322 IntegerType Int1Ty, Int8Ty, Int16Ty, Int32Ty, Int64Ty, Int128Ty;
1324 BumpPtrAllocator Alloc;
1325 UniqueStringSaver Saver{Alloc};
1327 DenseMap<unsigned, IntegerType*> IntegerTypes;
1329 using FunctionTypeSet = DenseSet<FunctionType *, FunctionTypeKeyInfo>;
1330 FunctionTypeSet FunctionTypes;
1331 using StructTypeSet = DenseSet<StructType *, AnonStructTypeKeyInfo>;
1332 StructTypeSet AnonStructTypes;
1333 StringMap<StructType*> NamedStructTypes;
1334 unsigned NamedStructTypesUniqueID = 0;
1336 DenseMap<std::pair<Type *, uint64_t>, ArrayType*> ArrayTypes;
1337 DenseMap<std::pair<Type *, ElementCount>, VectorType*> VectorTypes;
1338 DenseMap<Type*, PointerType*> PointerTypes; // Pointers in AddrSpace = 0
1339 DenseMap<std::pair<Type*, unsigned>, PointerType*> ASPointerTypes;
1341 /// ValueHandles - This map keeps track of all of the value handles that are
1342 /// watching a Value*. The Value::HasValueHandle bit is used to know
1343 /// whether or not a value has an entry in this map.
1344 using ValueHandlesTy = DenseMap<Value *, ValueHandleBase *>;
1345 ValueHandlesTy ValueHandles;
1347 /// CustomMDKindNames - Map to hold the metadata string to ID mapping.
1348 StringMap<unsigned> CustomMDKindNames;
1350 /// Collection of per-instruction metadata used in this context.
1351 DenseMap<const Instruction *, MDAttachmentMap> InstructionMetadata;
1353 /// Collection of per-GlobalObject metadata used in this context.
1354 DenseMap<const GlobalObject *, MDGlobalAttachmentMap> GlobalObjectMetadata;
1356 /// Collection of per-GlobalObject sections used in this context.
1357 DenseMap<const GlobalObject *, StringRef> GlobalObjectSections;
1359 /// Collection of per-GlobalValue partitions used in this context.
1360 DenseMap<const GlobalValue *, StringRef> GlobalValuePartitions;
1362 /// DiscriminatorTable - This table maps file:line locations to an
1363 /// integer representing the next DWARF path discriminator to assign to
1364 /// instructions in different blocks at the same location.
1365 DenseMap<std::pair<const char *, unsigned>, unsigned> DiscriminatorTable;
1367 int getOrAddScopeRecordIdxEntry(MDNode *N, int ExistingIdx);
1368 int getOrAddScopeInlinedAtIdxEntry(MDNode *Scope, MDNode *IA,int ExistingIdx);
1370 /// A set of interned tags for operand bundles. The StringMap maps
1371 /// bundle tags to their IDs.
1373 /// \see LLVMContext::getOperandBundleTagID
1374 StringMap<uint32_t> BundleTagCache;
1376 StringMapEntry<uint32_t> *getOrInsertBundleTag(StringRef Tag);
1377 void getOperandBundleTags(SmallVectorImpl<StringRef> &Tags) const;
1378 uint32_t getOperandBundleTagID(StringRef Tag) const;
1380 /// A set of interned synchronization scopes. The StringMap maps
1381 /// synchronization scope names to their respective synchronization scope IDs.
1382 StringMap<SyncScope::ID> SSC;
1384 /// getOrInsertSyncScopeID - Maps synchronization scope name to
1385 /// synchronization scope ID. Every synchronization scope registered with
1386 /// LLVMContext has unique ID except pre-defined ones.
1387 SyncScope::ID getOrInsertSyncScopeID(StringRef SSN);
1389 /// getSyncScopeNames - Populates client supplied SmallVector with
1390 /// synchronization scope names registered with LLVMContext. Synchronization
1391 /// scope names are ordered by increasing synchronization scope IDs.
1392 void getSyncScopeNames(SmallVectorImpl<StringRef> &SSNs) const;
1394 /// Maintain the GC name for each function.
1396 /// This saves allocating an additional word in Function for programs which
1397 /// do not use GC (i.e., most programs) at the cost of increased overhead for
1398 /// clients which do use GC.
1399 DenseMap<const Function*, std::string> GCNames;
1401 /// Flag to indicate if Value (other than GlobalValue) retains their name or
1402 /// not.
1403 bool DiscardValueNames = false;
1405 LLVMContextImpl(LLVMContext &C);
1406 ~LLVMContextImpl();
1408 /// Destroy the ConstantArrays if they are not used.
1409 void dropTriviallyDeadConstantArrays();
1411 mutable OptPassGate *OPG = nullptr;
1413 /// Access the object which can disable optional passes and individual
1414 /// optimizations at compile time.
1415 OptPassGate &getOptPassGate() const;
1417 /// Set the object which can disable optional passes and individual
1418 /// optimizations at compile time.
1420 /// The lifetime of the object must be guaranteed to extend as long as the
1421 /// LLVMContext is used by compilation.
1422 void setOptPassGate(OptPassGate&);
1425 } // end namespace llvm
1427 #endif // LLVM_LIB_IR_LLVMCONTEXTIMPL_H