LLVM  8.0.0svn
TpiHashing.cpp
Go to the documentation of this file.
1 //===- TpiHashing.cpp -----------------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
11 
14 #include "llvm/Support/JamCRC.h"
15 
16 using namespace llvm;
17 using namespace llvm::codeview;
18 using namespace llvm::pdb;
19 
20 // Corresponds to `fUDTAnon`.
21 static bool isAnonymous(StringRef Name) {
22  return Name == "<unnamed-tag>" || Name == "__unnamed" ||
23  Name.endswith("::<unnamed-tag>") || Name.endswith("::__unnamed");
24 }
25 
26 // Computes the hash for a user-defined type record. This could be a struct,
27 // class, union, or enum.
28 static uint32_t getHashForUdt(const TagRecord &Rec,
29  ArrayRef<uint8_t> FullRecord) {
30  ClassOptions Opts = Rec.getOptions();
31  bool ForwardRef = bool(Opts & ClassOptions::ForwardReference);
32  bool Scoped = bool(Opts & ClassOptions::Scoped);
34  bool IsAnon = HasUniqueName && isAnonymous(Rec.getName());
35 
36  if (!ForwardRef && !Scoped && !IsAnon)
37  return hashStringV1(Rec.getName());
38  if (!ForwardRef && HasUniqueName && !IsAnon)
39  return hashStringV1(Rec.getUniqueName());
40  return hashBufferV8(FullRecord);
41 }
42 
43 template <typename T>
45  T Deserialized;
46  if (auto E = TypeDeserializer::deserializeAs(const_cast<CVType &>(Rec),
47  Deserialized))
48  return std::move(E);
49  return getHashForUdt(Deserialized, Rec.data());
50 }
51 
52 template <typename T>
54  T Deserialized;
55  if (auto E = TypeDeserializer::deserializeAs(const_cast<CVType &>(Rec),
56  Deserialized))
57  return std::move(E);
58 
59  ClassOptions Opts = Deserialized.getOptions();
60 
61  bool ForwardRef = bool(Opts & ClassOptions::ForwardReference);
62 
63  uint32_t ThisRecordHash = getHashForUdt(Deserialized, Rec.data());
64 
65  // If we don't have a forward ref we can't compute the hash of it from the
66  // full record because it requires hashing the entire buffer.
67  if (!ForwardRef)
68  return TagRecordHash{std::move(Deserialized), ThisRecordHash, 0};
69 
70  bool Scoped = bool(Opts & ClassOptions::Scoped);
71 
72  StringRef NameToHash =
73  Scoped ? Deserialized.getUniqueName() : Deserialized.getName();
74  uint32_t FullHash = hashStringV1(NameToHash);
75  return TagRecordHash{std::move(Deserialized), FullHash, ThisRecordHash};
76 }
77 
78 template <typename T>
80  T Deserialized;
81  if (auto E = TypeDeserializer::deserializeAs(const_cast<CVType &>(Rec),
82  Deserialized))
83  return std::move(E);
84  char Buf[4];
85  support::endian::write32le(Buf, Deserialized.getUDT().getIndex());
86  return hashStringV1(StringRef(Buf, 4));
87 }
88 
90  switch (Type.kind()) {
91  case LF_CLASS:
92  case LF_STRUCTURE:
93  case LF_INTERFACE:
94  return getTagRecordHashForUdt<ClassRecord>(Type);
95  case LF_UNION:
96  return getTagRecordHashForUdt<UnionRecord>(Type);
97  case LF_ENUM:
98  return getTagRecordHashForUdt<EnumRecord>(Type);
99  default:
100  assert(false && "Type is not a tag record!");
101  }
102  return make_error<StringError>("Invalid record type",
104 }
105 
107  switch (Rec.kind()) {
108  case LF_CLASS:
109  case LF_STRUCTURE:
110  case LF_INTERFACE:
111  return getHashForUdt<ClassRecord>(Rec);
112  case LF_UNION:
113  return getHashForUdt<UnionRecord>(Rec);
114  case LF_ENUM:
115  return getHashForUdt<EnumRecord>(Rec);
116 
117  case LF_UDT_SRC_LINE:
118  return getSourceLineHash<UdtSourceLineRecord>(Rec);
119  case LF_UDT_MOD_SRC_LINE:
120  return getSourceLineHash<UdtModSourceLineRecord>(Rec);
121 
122  default:
123  break;
124  }
125 
126  // Run CRC32 over the bytes. This corresponds to `hashBufv8`.
127  JamCRC JC(/*Init=*/0U);
128  ArrayRef<char> Bytes(reinterpret_cast<const char *>(Rec.data().data()),
129  Rec.data().size());
130  JC.update(Bytes);
131  return JC.getCRC();
132 }
uint32_t getCRC() const
Definition: JamCRC.h:42
uint32_t hashBufferV8(ArrayRef< uint8_t > Data)
Definition: Hash.cpp:81
Kind kind() const
Definition: CVRecord.h:37
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
void write32le(void *P, uint32_t V)
Definition: Endian.h:404
static bool isAnonymous(StringRef Name)
Definition: TpiHashing.cpp:21
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool endswith(StringRef Suffix) const
Check if this string ends with the given Suffix.
Definition: StringRef.h:279
StringRef getName() const
Definition: TypeRecord.h:439
amdgpu Simplify well known AMD library false Value Value const Twine & Name
static Expected< uint32_t > getSourceLineHash(const CVType &Rec)
Definition: TpiHashing.cpp:79
Tagged union holding either a T or a Error.
Definition: CachePruning.h:23
Expected< TagRecordHash > hashTagRecord(const codeview::CVType &Type)
Given a CVType referring to a class, structure, union, or enum, compute the hash of its forward decl ...
Definition: TpiHashing.cpp:89
ClassOptions getOptions() const
Definition: TypeRecord.h:437
ArrayRef< uint8_t > data() const
Definition: CVRecord.h:38
Expected< uint32_t > hashTypeRecord(const llvm::codeview::CVType &Type)
Definition: TpiHashing.cpp:106
uint32_t hashStringV1(StringRef Str)
Definition: Hash.cpp:21
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:149
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
StringRef getUniqueName() const
Definition: TypeRecord.h:440
static Error deserializeAs(CVType &CVT, T &Record)
const T * data() const
Definition: ArrayRef.h:146
static Expected< TagRecordHash > getTagRecordHashForUdt(const CVType &Rec)
Definition: TpiHashing.cpp:53
static uint32_t getHashForUdt(const TagRecord &Rec, ArrayRef< uint8_t > FullRecord)
Definition: TpiHashing.cpp:28
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
void update(ArrayRef< char > Data)
Definition: JamCRC.cpp:92
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:77