35
35
#include " clang/Index/IndexingAction.h"
36
36
#include " clang/Lex/Preprocessor.h"
37
37
#include " clang/Serialization/ASTReader.h"
38
+ #include " llvm/Support/BLAKE3.h"
38
39
#include " llvm/Support/Error.h"
40
+ #include " llvm/Support/HashBuilder.h"
39
41
#include " llvm/Support/Path.h"
40
42
41
43
using namespace swift ;
@@ -50,29 +52,48 @@ using clang::index::SymbolRoleSet;
50
52
// ===----------------------------------------------------------------------===//
51
53
52
54
namespace {
55
+
56
+ using HashBuilderTy =
57
+ llvm::HashBuilder<llvm::TruncatedBLAKE3<8 >, llvm::endianness::little>;
58
+
53
59
class SymbolTracker {
54
60
public:
55
61
struct SymbolRelation {
56
62
size_t symbolIndex;
57
63
SymbolRoleSet roles;
58
64
59
- llvm::hash_code hash () const { return llvm::hash_combine (symbolIndex, roles); }
65
+ SymbolRelation (size_t symbolIndex, SymbolRoleSet roles)
66
+ : symbolIndex(symbolIndex), roles(roles) {}
67
+
68
+ void hash (HashBuilderTy &HashBuilder) {
69
+ HashBuilder.add (symbolIndex);
70
+ HashBuilder.add (roles);
71
+ }
60
72
};
73
+
61
74
struct SymbolOccurrence {
62
75
size_t symbolIndex;
63
76
SymbolRoleSet roles;
64
77
unsigned line;
65
78
unsigned column;
66
79
SmallVector<SymbolRelation, 3 > related;
67
80
68
- llvm::hash_code hash () const {
69
- auto hash = llvm::hash_combine (symbolIndex, roles, line, column);
81
+ SymbolOccurrence (size_t symbolIndex, SymbolRoleSet roles, unsigned line,
82
+ unsigned column, SmallVector<SymbolRelation, 3 > related)
83
+ : symbolIndex(symbolIndex), roles(roles), line(line), column(column),
84
+ related (std::move(related)) {}
85
+
86
+ void hash (HashBuilderTy &HashBuilder) {
87
+ HashBuilder.add (symbolIndex);
88
+ HashBuilder.add (roles);
89
+ HashBuilder.add (line);
90
+ HashBuilder.add (column);
70
91
for (auto &relation : related) {
71
- hash = llvm::hash_combine (hash, relation.hash () );
92
+ relation.hash (HashBuilder );
72
93
}
73
- return hash;
74
94
}
75
95
};
96
+
76
97
struct Symbol {
77
98
StringRef name;
78
99
StringRef USR;
@@ -81,12 +102,19 @@ class SymbolTracker {
81
102
SymbolInfo symInfo;
82
103
unsigned isTestCandidate : 1 ;
83
104
84
- llvm::hash_code hash () const {
85
- return llvm::hash_combine (
86
- name, USR, group,
87
- static_cast <unsigned >(symInfo.Kind ),
88
- static_cast <unsigned >(symInfo.SubKind ),
89
- symInfo.Properties , isTestCandidate);
105
+ Symbol (StringRef name, StringRef usr, StringRef group, SymbolInfo symInfo,
106
+ bool isTestCandidate)
107
+ : name(name), USR(usr), group(group), symInfo(std::move(symInfo)),
108
+ isTestCandidate (isTestCandidate) {}
109
+
110
+ void hash (HashBuilderTy &HashBuilder) {
111
+ HashBuilder.add (name);
112
+ HashBuilder.add (USR);
113
+ HashBuilder.add (group);
114
+ HashBuilder.add (symInfo.Kind );
115
+ HashBuilder.add (symInfo.SubKind );
116
+ HashBuilder.add (symInfo.Properties );
117
+ HashBuilder.add (isTestCandidate);
90
118
}
91
119
};
92
120
@@ -114,13 +142,9 @@ class SymbolTracker {
114
142
auto pair = USRToSymbol.insert (std::make_pair (indexSym.USR .data (),
115
143
symbols.size ()));
116
144
if (pair.second ) {
117
- Symbol symbol{indexSym.name ,
118
- indexSym.USR ,
119
- indexSym.group ,
120
- indexSym.symInfo ,
121
- 0 };
122
- recordHash = llvm::hash_combine (recordHash, symbol.hash ());
123
- symbols.push_back (std::move (symbol));
145
+ symbols.emplace_back (indexSym.name , indexSym.USR , indexSym.group ,
146
+ indexSym.symInfo , 0 );
147
+ symbols.back ().hash (HashBuilder);
124
148
}
125
149
126
150
return pair.first ->second ;
@@ -131,26 +155,28 @@ class SymbolTracker {
131
155
132
156
SmallVector<SymbolRelation, 3 > relations;
133
157
for (IndexRelation indexRel: indexOccur.Relations ) {
134
- relations.push_back ({ addSymbol (indexRel), indexRel.roles } );
158
+ relations.emplace_back ( addSymbol (indexRel), indexRel.roles );
135
159
}
136
160
137
- occurrences.push_back ({/* symbolIndex=*/ addSymbol (indexOccur),
138
- indexOccur.roles ,
139
- indexOccur.line ,
140
- indexOccur.column ,
141
- std::move (relations)});
142
-
143
- recordHash = llvm::hash_combine (recordHash, occurrences.back ().hash ());
161
+ occurrences.emplace_back (addSymbol (indexOccur), indexOccur.roles ,
162
+ indexOccur.line , indexOccur.column ,
163
+ std::move (relations));
164
+ occurrences.back ().hash (HashBuilder);
144
165
}
145
166
146
- llvm::hash_code hashRecord () const { return recordHash; }
167
+ uint64_t hashRecord () {
168
+ std::array<uint8_t , 8 > recordHashArr = HashBuilder.final ();
169
+ uint64_t recordHash = 0 ;
170
+ std::memcpy (&recordHash, recordHashArr.data (), recordHashArr.size ());
171
+ return recordHash;
172
+ }
147
173
148
174
private:
149
175
llvm::DenseMap<const char *, size_t > USRToSymbol;
150
176
std::vector<Symbol> symbols;
151
177
std::vector<SymbolOccurrence> occurrences;
152
178
bool sorted = false ;
153
- llvm::hash_code recordHash = 0 ;
179
+ HashBuilderTy HashBuilder ;
154
180
};
155
181
156
182
class IndexRecordingConsumer : public IndexDataConsumer {
0 commit comments