|
121
|
1 //===- Diff.cpp - PDB diff utility ------------------------------*- C++ -*-===//
|
|
|
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
|
|
|
10 #include "Diff.h"
|
|
|
11
|
|
|
12 #include "DiffPrinter.h"
|
|
|
13 #include "FormatUtil.h"
|
|
|
14 #include "StreamUtil.h"
|
|
|
15 #include "llvm-pdbutil.h"
|
|
|
16
|
|
|
17 #include "llvm/ADT/StringSet.h"
|
|
|
18
|
|
|
19 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
|
|
|
20 #include "llvm/DebugInfo/PDB/Native/Formatters.h"
|
|
|
21 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
|
|
|
22 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
|
|
|
23 #include "llvm/DebugInfo/PDB/Native/PDBStringTable.h"
|
|
|
24 #include "llvm/DebugInfo/PDB/Native/RawConstants.h"
|
|
|
25
|
|
|
26 #include "llvm/Support/FormatAdapters.h"
|
|
|
27 #include "llvm/Support/FormatProviders.h"
|
|
|
28 #include "llvm/Support/FormatVariadic.h"
|
|
|
29 #include "llvm/Support/Path.h"
|
|
|
30
|
|
|
31 using namespace llvm;
|
|
|
32 using namespace llvm::pdb;
|
|
|
33
|
|
|
34 namespace {
|
|
|
35 // Compare and format two stream numbers. Stream numbers are considered
|
|
|
36 // identical if they contain the same value, equivalent if they are both
|
|
|
37 // the invalid stream or neither is the invalid stream, and different if
|
|
|
38 // one is the invalid stream and another isn't.
|
|
|
39 struct StreamNumberProvider {
|
|
|
40 static DiffResult compare(uint16_t L, uint16_t R) {
|
|
|
41 if (L == R)
|
|
|
42 return DiffResult::IDENTICAL;
|
|
|
43 bool LP = L != kInvalidStreamIndex;
|
|
|
44 bool RP = R != kInvalidStreamIndex;
|
|
|
45 if (LP != RP)
|
|
|
46 return DiffResult::DIFFERENT;
|
|
|
47 return DiffResult::EQUIVALENT;
|
|
|
48 }
|
|
|
49
|
|
|
50 static std::string format(uint16_t SN, bool Right) {
|
|
|
51 if (SN == kInvalidStreamIndex)
|
|
|
52 return "(not present)";
|
|
|
53 return formatv("{0}", SN).str();
|
|
|
54 }
|
|
|
55 };
|
|
|
56
|
|
|
57 // Compares and formats two module indices. Modis are considered identical
|
|
|
58 // if they are identical, equivalent if they either both contain a value or
|
|
|
59 // both don't contain a value, and different if one contains a value and the
|
|
|
60 // other doesn't.
|
|
|
61 struct ModiProvider {
|
|
|
62 DiffResult compare(Optional<uint32_t> L, Optional<uint32_t> R) {
|
|
|
63 if (L == R)
|
|
|
64 return DiffResult::IDENTICAL;
|
|
|
65 if (L.hasValue() != R.hasValue())
|
|
|
66 return DiffResult::DIFFERENT;
|
|
|
67 return DiffResult::EQUIVALENT;
|
|
|
68 }
|
|
|
69
|
|
|
70 std::string format(Optional<uint32_t> Modi, bool Right) {
|
|
|
71 if (!Modi.hasValue())
|
|
|
72 return "(not present)";
|
|
|
73 return formatv("{0}", *Modi).str();
|
|
|
74 }
|
|
|
75 };
|
|
|
76
|
|
|
77 // Compares and formats two paths embedded in the PDB, ignoring the beginning
|
|
|
78 // of the path if the user specified it as a "root path" on the command line.
|
|
|
79 struct BinaryPathProvider {
|
|
|
80 explicit BinaryPathProvider(uint32_t MaxLen) : MaxLen(MaxLen) {}
|
|
|
81
|
|
|
82 DiffResult compare(StringRef L, StringRef R) {
|
|
|
83 if (L == R)
|
|
|
84 return DiffResult::IDENTICAL;
|
|
|
85
|
|
|
86 SmallString<64> LN = removeRoot(L, false);
|
|
|
87 SmallString<64> RN = removeRoot(R, true);
|
|
|
88
|
|
|
89 return (LN.equals_lower(RN)) ? DiffResult::EQUIVALENT
|
|
|
90 : DiffResult::DIFFERENT;
|
|
|
91 }
|
|
|
92
|
|
|
93 std::string format(StringRef S, bool Right) {
|
|
|
94 if (S.empty())
|
|
|
95 return "(empty)";
|
|
|
96
|
|
|
97 SmallString<64> Native = removeRoot(S, Right);
|
|
|
98 return truncateStringFront(Native.str(), MaxLen);
|
|
|
99 }
|
|
|
100
|
|
|
101 SmallString<64> removeRoot(StringRef Path, bool IsRight) const {
|
|
|
102 SmallString<64> Native(Path);
|
|
|
103 auto &RootOpt = IsRight ? opts::diff::RightRoot : opts::diff::LeftRoot;
|
|
|
104 SmallString<64> Root(static_cast<std::string>(RootOpt));
|
|
|
105 // pdb paths always use windows syntax, convert slashes to backslashes.
|
|
|
106 sys::path::native(Root, sys::path::Style::windows);
|
|
|
107 if (sys::path::has_stem(Root, sys::path::Style::windows))
|
|
|
108 sys::path::append(Root, sys::path::Style::windows,
|
|
|
109 sys::path::get_separator(sys::path::Style::windows));
|
|
|
110
|
|
|
111 sys::path::replace_path_prefix(Native, Root, "", sys::path::Style::windows);
|
|
|
112 return Native;
|
|
|
113 }
|
|
|
114 uint32_t MaxLen;
|
|
|
115 };
|
|
|
116
|
|
|
117 // Compare and format two stream purposes. For general streams, this just
|
|
|
118 // compares the description. For module streams it uses the path comparison
|
|
|
119 // algorithm taking into consideration the binary root, described above.
|
|
|
120 // Formatting stream purposes just prints the stream purpose, except for
|
|
|
121 // module streams and named streams, where it prefixes the name / module
|
|
|
122 // with an identifier. Example:
|
|
|
123 //
|
|
|
124 // Named Stream "\names"
|
|
|
125 // Module Stream "foo.obj"
|
|
|
126 //
|
|
|
127 // If a named stream is too long to fit in a column, it is truncated at the
|
|
|
128 // end, and if a module is too long to fit in a column, it is truncated at the
|
|
|
129 // beginning. Example:
|
|
|
130 //
|
|
|
131 // Named Stream "\Really Long Str..."
|
|
|
132 // Module Stream "...puts\foo.obj"
|
|
|
133 //
|
|
|
134 struct StreamPurposeProvider {
|
|
|
135 explicit StreamPurposeProvider(uint32_t MaxLen) : MaxLen(MaxLen) {}
|
|
|
136
|
|
|
137 DiffResult compare(const StreamInfo &L, const StreamInfo &R) {
|
|
|
138 if (L.getPurpose() != R.getPurpose())
|
|
|
139 return DiffResult::DIFFERENT;
|
|
|
140 if (L.getPurpose() == StreamPurpose::ModuleStream) {
|
|
|
141 BinaryPathProvider PathProvider(MaxLen);
|
|
|
142 return PathProvider.compare(L.getShortName(), R.getShortName());
|
|
|
143 }
|
|
|
144 return (L.getShortName() == R.getShortName()) ? DiffResult::IDENTICAL
|
|
|
145 : DiffResult::DIFFERENT;
|
|
|
146 }
|
|
|
147
|
|
|
148 std::string format(const StreamInfo &P, bool Right) {
|
|
|
149 if (P.getPurpose() == StreamPurpose::Other ||
|
|
|
150 P.getPurpose() == StreamPurpose::Symbols)
|
|
|
151 return truncateStringBack(P.getShortName(), MaxLen);
|
|
|
152 if (P.getPurpose() == StreamPurpose::NamedStream)
|
|
|
153 return truncateQuotedNameBack("Named Stream", P.getShortName(), MaxLen);
|
|
|
154
|
|
|
155 assert(P.getPurpose() == StreamPurpose::ModuleStream);
|
|
|
156 uint32_t ExtraChars = strlen("Module \"\"");
|
|
|
157 BinaryPathProvider PathProvider(MaxLen - ExtraChars);
|
|
|
158 std::string Result = PathProvider.format(P.getShortName(), Right);
|
|
|
159 return formatv("Module \"{0}\"", Result);
|
|
|
160 }
|
|
|
161
|
|
|
162 uint32_t MaxLen;
|
|
|
163 };
|
|
|
164 } // namespace
|
|
|
165
|
|
|
166 namespace llvm {
|
|
|
167 template <> struct format_provider<PdbRaw_FeatureSig> {
|
|
|
168 static void format(const PdbRaw_FeatureSig &Sig, raw_ostream &Stream,
|
|
|
169 StringRef Style) {
|
|
|
170 switch (Sig) {
|
|
|
171 case PdbRaw_FeatureSig::MinimalDebugInfo:
|
|
|
172 Stream << "MinimalDebugInfo";
|
|
|
173 break;
|
|
|
174 case PdbRaw_FeatureSig::NoTypeMerge:
|
|
|
175 Stream << "NoTypeMerge";
|
|
|
176 break;
|
|
|
177 case PdbRaw_FeatureSig::VC110:
|
|
|
178 Stream << "VC110";
|
|
|
179 break;
|
|
|
180 case PdbRaw_FeatureSig::VC140:
|
|
|
181 Stream << "VC140";
|
|
|
182 break;
|
|
|
183 }
|
|
|
184 }
|
|
|
185 };
|
|
|
186 }
|
|
|
187
|
|
|
188 template <typename R> using ValueOfRange = llvm::detail::ValueOfRange<R>;
|
|
|
189
|
|
|
190 DiffStyle::DiffStyle(PDBFile &File1, PDBFile &File2)
|
|
|
191 : File1(File1), File2(File2) {}
|
|
|
192
|
|
|
193 Error DiffStyle::dump() {
|
|
|
194 if (auto EC = diffSuperBlock())
|
|
|
195 return EC;
|
|
|
196
|
|
|
197 if (auto EC = diffFreePageMap())
|
|
|
198 return EC;
|
|
|
199
|
|
|
200 if (auto EC = diffStreamDirectory())
|
|
|
201 return EC;
|
|
|
202
|
|
|
203 if (auto EC = diffStringTable())
|
|
|
204 return EC;
|
|
|
205
|
|
|
206 if (auto EC = diffInfoStream())
|
|
|
207 return EC;
|
|
|
208
|
|
|
209 if (auto EC = diffDbiStream())
|
|
|
210 return EC;
|
|
|
211
|
|
|
212 if (auto EC = diffSectionContribs())
|
|
|
213 return EC;
|
|
|
214
|
|
|
215 if (auto EC = diffSectionMap())
|
|
|
216 return EC;
|
|
|
217
|
|
|
218 if (auto EC = diffFpoStream())
|
|
|
219 return EC;
|
|
|
220
|
|
|
221 if (auto EC = diffTpiStream(StreamTPI))
|
|
|
222 return EC;
|
|
|
223
|
|
|
224 if (auto EC = diffTpiStream(StreamIPI))
|
|
|
225 return EC;
|
|
|
226
|
|
|
227 if (auto EC = diffPublics())
|
|
|
228 return EC;
|
|
|
229
|
|
|
230 if (auto EC = diffGlobals())
|
|
|
231 return EC;
|
|
|
232
|
|
|
233 return Error::success();
|
|
|
234 }
|
|
|
235
|
|
|
236 Error DiffStyle::diffSuperBlock() {
|
|
|
237 DiffPrinter D(2, "MSF Super Block", 16, 20, opts::diff::PrintResultColumn,
|
|
|
238 opts::diff::PrintValueColumns, outs());
|
|
|
239 D.printExplicit("File", DiffResult::UNSPECIFIED,
|
|
|
240 truncateStringFront(File1.getFilePath(), 18),
|
|
|
241 truncateStringFront(File2.getFilePath(), 18));
|
|
|
242 D.print("Block Size", File1.getBlockSize(), File2.getBlockSize());
|
|
|
243 D.print("Block Count", File1.getBlockCount(), File2.getBlockCount());
|
|
|
244 D.print("Unknown 1", File1.getUnknown1(), File2.getUnknown1());
|
|
|
245 D.print("Directory Size", File1.getNumDirectoryBytes(),
|
|
|
246 File2.getNumDirectoryBytes());
|
|
|
247 return Error::success();
|
|
|
248 }
|
|
|
249
|
|
|
250 Error DiffStyle::diffStreamDirectory() {
|
|
|
251 DiffPrinter D(2, "Stream Directory", 30, 20, opts::diff::PrintResultColumn,
|
|
|
252 opts::diff::PrintValueColumns, outs());
|
|
|
253 D.printExplicit("File", DiffResult::UNSPECIFIED,
|
|
|
254 truncateStringFront(File1.getFilePath(), 18),
|
|
|
255 truncateStringFront(File2.getFilePath(), 18));
|
|
|
256
|
|
|
257 SmallVector<StreamInfo, 32> P;
|
|
|
258 SmallVector<StreamInfo, 32> Q;
|
|
|
259 discoverStreamPurposes(File1, P);
|
|
|
260 discoverStreamPurposes(File2, Q);
|
|
|
261 D.print("Stream Count", File1.getNumStreams(), File2.getNumStreams());
|
|
|
262 auto PI = to_vector<32>(enumerate(P));
|
|
|
263 auto QI = to_vector<32>(enumerate(Q));
|
|
|
264
|
|
|
265 // Scan all streams in the left hand side, looking for ones that are also
|
|
|
266 // in the right. Each time we find one, remove it. When we're done, Q
|
|
|
267 // should contain all the streams that are in the right but not in the left.
|
|
|
268 StreamPurposeProvider StreamProvider(28);
|
|
|
269 for (const auto &P : PI) {
|
|
|
270 typedef decltype(PI) ContainerType;
|
|
|
271 typedef typename ContainerType::value_type value_type;
|
|
|
272
|
|
|
273 auto Iter = llvm::find_if(QI, [P, &StreamProvider](const value_type &V) {
|
|
|
274 DiffResult Result = StreamProvider.compare(P.value(), V.value());
|
|
|
275 return Result == DiffResult::EQUIVALENT ||
|
|
|
276 Result == DiffResult::IDENTICAL;
|
|
|
277 });
|
|
|
278
|
|
|
279 if (Iter == QI.end()) {
|
|
|
280 D.printExplicit(StreamProvider.format(P.value(), false),
|
|
|
281 DiffResult::DIFFERENT, P.index(), "(not present)");
|
|
|
282 continue;
|
|
|
283 }
|
|
|
284
|
|
|
285 D.print<EquivalentDiffProvider>(StreamProvider.format(P.value(), false),
|
|
|
286 P.index(), Iter->index());
|
|
|
287 QI.erase(Iter);
|
|
|
288 }
|
|
|
289
|
|
|
290 for (const auto &Q : QI) {
|
|
|
291 D.printExplicit(StreamProvider.format(Q.value(), true),
|
|
|
292 DiffResult::DIFFERENT, "(not present)", Q.index());
|
|
|
293 }
|
|
|
294
|
|
|
295 return Error::success();
|
|
|
296 }
|
|
|
297
|
|
|
298 Error DiffStyle::diffStringTable() {
|
|
|
299 DiffPrinter D(2, "String Table", 30, 20, opts::diff::PrintResultColumn,
|
|
|
300 opts::diff::PrintValueColumns, outs());
|
|
|
301 D.printExplicit("File", DiffResult::UNSPECIFIED,
|
|
|
302 truncateStringFront(File1.getFilePath(), 18),
|
|
|
303 truncateStringFront(File2.getFilePath(), 18));
|
|
|
304
|
|
|
305 auto ExpectedST1 = File1.getStringTable();
|
|
|
306 auto ExpectedST2 = File2.getStringTable();
|
|
|
307 bool Has1 = !!ExpectedST1;
|
|
|
308 bool Has2 = !!ExpectedST2;
|
|
|
309 std::string Count1 = Has1 ? llvm::utostr(ExpectedST1->getNameCount())
|
|
|
310 : "(string table not present)";
|
|
|
311 std::string Count2 = Has2 ? llvm::utostr(ExpectedST2->getNameCount())
|
|
|
312 : "(string table not present)";
|
|
|
313 D.print("Number of Strings", Count1, Count2);
|
|
|
314
|
|
|
315 if (!Has1 || !Has2) {
|
|
|
316 consumeError(ExpectedST1.takeError());
|
|
|
317 consumeError(ExpectedST2.takeError());
|
|
|
318 return Error::success();
|
|
|
319 }
|
|
|
320
|
|
|
321 auto &ST1 = *ExpectedST1;
|
|
|
322 auto &ST2 = *ExpectedST2;
|
|
|
323
|
|
|
324 D.print("Hash Version", ST1.getHashVersion(), ST2.getHashVersion());
|
|
|
325 D.print("Byte Size", ST1.getByteSize(), ST2.getByteSize());
|
|
|
326 D.print("Signature", ST1.getSignature(), ST2.getSignature());
|
|
|
327
|
|
|
328 // Both have a valid string table, dive in and compare individual strings.
|
|
|
329
|
|
|
330 auto IdList1 = ST1.name_ids();
|
|
|
331 auto IdList2 = ST2.name_ids();
|
|
|
332 StringSet<> LS;
|
|
|
333 StringSet<> RS;
|
|
|
334 uint32_t Empty1 = 0;
|
|
|
335 uint32_t Empty2 = 0;
|
|
|
336 for (auto ID : IdList1) {
|
|
|
337 auto S = ST1.getStringForID(ID);
|
|
|
338 if (!S)
|
|
|
339 return S.takeError();
|
|
|
340 if (S->empty())
|
|
|
341 ++Empty1;
|
|
|
342 else
|
|
|
343 LS.insert(*S);
|
|
|
344 }
|
|
|
345 for (auto ID : IdList2) {
|
|
|
346 auto S = ST2.getStringForID(ID);
|
|
|
347 if (!S)
|
|
|
348 return S.takeError();
|
|
|
349 if (S->empty())
|
|
|
350 ++Empty2;
|
|
|
351 else
|
|
|
352 RS.insert(*S);
|
|
|
353 }
|
|
|
354 D.print("Empty Strings", Empty1, Empty2);
|
|
|
355
|
|
|
356 for (const auto &S : LS) {
|
|
|
357 auto R = RS.find(S.getKey());
|
|
|
358 std::string Truncated = truncateStringMiddle(S.getKey(), 28);
|
|
|
359 uint32_t I = cantFail(ST1.getIDForString(S.getKey()));
|
|
|
360 if (R == RS.end()) {
|
|
|
361 D.printExplicit(Truncated, DiffResult::DIFFERENT, I, "(not present)");
|
|
|
362 continue;
|
|
|
363 }
|
|
|
364
|
|
|
365 uint32_t J = cantFail(ST2.getIDForString(R->getKey()));
|
|
|
366 D.print<EquivalentDiffProvider>(Truncated, I, J);
|
|
|
367 RS.erase(R);
|
|
|
368 }
|
|
|
369
|
|
|
370 for (const auto &S : RS) {
|
|
|
371 auto L = LS.find(S.getKey());
|
|
|
372 std::string Truncated = truncateStringMiddle(S.getKey(), 28);
|
|
|
373 uint32_t J = cantFail(ST2.getIDForString(S.getKey()));
|
|
|
374 if (L == LS.end()) {
|
|
|
375 D.printExplicit(Truncated, DiffResult::DIFFERENT, "(not present)", J);
|
|
|
376 continue;
|
|
|
377 }
|
|
|
378
|
|
|
379 uint32_t I = cantFail(ST1.getIDForString(L->getKey()));
|
|
|
380 D.print<EquivalentDiffProvider>(Truncated, I, J);
|
|
|
381 }
|
|
|
382 return Error::success();
|
|
|
383 }
|
|
|
384
|
|
|
385 Error DiffStyle::diffFreePageMap() { return Error::success(); }
|
|
|
386
|
|
|
387 Error DiffStyle::diffInfoStream() {
|
|
|
388 DiffPrinter D(2, "PDB Stream", 22, 40, opts::diff::PrintResultColumn,
|
|
|
389 opts::diff::PrintValueColumns, outs());
|
|
|
390 D.printExplicit("File", DiffResult::UNSPECIFIED,
|
|
|
391 truncateStringFront(File1.getFilePath(), 38),
|
|
|
392 truncateStringFront(File2.getFilePath(), 38));
|
|
|
393
|
|
|
394 auto ExpectedInfo1 = File1.getPDBInfoStream();
|
|
|
395 auto ExpectedInfo2 = File2.getPDBInfoStream();
|
|
|
396
|
|
|
397 bool Has1 = !!ExpectedInfo1;
|
|
|
398 bool Has2 = !!ExpectedInfo2;
|
|
|
399 if (!(Has1 && Has2)) {
|
|
|
400 std::string L = Has1 ? "(present)" : "(not present)";
|
|
|
401 std::string R = Has2 ? "(present)" : "(not present)";
|
|
|
402 D.print("Stream", L, R);
|
|
|
403
|
|
|
404 consumeError(ExpectedInfo1.takeError());
|
|
|
405 consumeError(ExpectedInfo2.takeError());
|
|
|
406 return Error::success();
|
|
|
407 }
|
|
|
408
|
|
|
409 auto &IS1 = *ExpectedInfo1;
|
|
|
410 auto &IS2 = *ExpectedInfo2;
|
|
|
411 D.print("Stream Size", IS1.getStreamSize(), IS2.getStreamSize());
|
|
|
412 D.print("Age", IS1.getAge(), IS2.getAge());
|
|
|
413 D.print("Guid", IS1.getGuid(), IS2.getGuid());
|
|
|
414 D.print("Signature", IS1.getSignature(), IS2.getSignature());
|
|
|
415 D.print("Version", IS1.getVersion(), IS2.getVersion());
|
|
|
416 D.diffUnorderedArray("Feature", IS1.getFeatureSignatures(),
|
|
|
417 IS2.getFeatureSignatures());
|
|
|
418 D.print("Named Stream Size", IS1.getNamedStreamMapByteSize(),
|
|
|
419 IS2.getNamedStreamMapByteSize());
|
|
|
420 StringMap<uint32_t> NSL = IS1.getNamedStreams().getStringMap();
|
|
|
421 StringMap<uint32_t> NSR = IS2.getNamedStreams().getStringMap();
|
|
|
422 D.diffUnorderedMap<EquivalentDiffProvider>("Named Stream", NSL, NSR);
|
|
|
423 return Error::success();
|
|
|
424 }
|
|
|
425
|
|
|
426 typedef std::pair<uint32_t, DbiModuleDescriptor> IndexedModuleDescriptor;
|
|
|
427 typedef std::vector<IndexedModuleDescriptor> IndexedModuleDescriptorList;
|
|
|
428
|
|
|
429 static IndexedModuleDescriptorList
|
|
|
430 getModuleDescriptors(const DbiModuleList &ML) {
|
|
|
431 IndexedModuleDescriptorList List;
|
|
|
432 List.reserve(ML.getModuleCount());
|
|
|
433 for (uint32_t I = 0; I < ML.getModuleCount(); ++I)
|
|
|
434 List.emplace_back(I, ML.getModuleDescriptor(I));
|
|
|
435 return List;
|
|
|
436 }
|
|
|
437
|
|
|
438 static IndexedModuleDescriptorList::iterator
|
|
|
439 findOverrideEquivalentModule(uint32_t Modi,
|
|
|
440 IndexedModuleDescriptorList &OtherList) {
|
|
|
441 auto &EqMap = opts::diff::Equivalences;
|
|
|
442
|
|
|
443 auto Iter = EqMap.find(Modi);
|
|
|
444 if (Iter == EqMap.end())
|
|
|
445 return OtherList.end();
|
|
|
446
|
|
|
447 uint32_t EqValue = Iter->second;
|
|
|
448
|
|
|
449 return llvm::find_if(OtherList,
|
|
|
450 [EqValue](const IndexedModuleDescriptor &Desc) {
|
|
|
451 return Desc.first == EqValue;
|
|
|
452 });
|
|
|
453 }
|
|
|
454
|
|
|
455 static IndexedModuleDescriptorList::iterator
|
|
|
456 findEquivalentModule(const IndexedModuleDescriptor &Item,
|
|
|
457 IndexedModuleDescriptorList &OtherList, bool ItemIsRight) {
|
|
|
458
|
|
|
459 if (!ItemIsRight) {
|
|
|
460 uint32_t Modi = Item.first;
|
|
|
461 auto OverrideIter = findOverrideEquivalentModule(Modi, OtherList);
|
|
|
462 if (OverrideIter != OtherList.end())
|
|
|
463 return OverrideIter;
|
|
|
464 }
|
|
|
465
|
|
|
466 BinaryPathProvider PathProvider(28);
|
|
|
467
|
|
|
468 auto Iter = OtherList.begin();
|
|
|
469 auto End = OtherList.end();
|
|
|
470 for (; Iter != End; ++Iter) {
|
|
|
471 const IndexedModuleDescriptor *Left = &Item;
|
|
|
472 const IndexedModuleDescriptor *Right = &*Iter;
|
|
|
473 if (ItemIsRight)
|
|
|
474 std::swap(Left, Right);
|
|
|
475 DiffResult Result = PathProvider.compare(Left->second.getModuleName(),
|
|
|
476 Right->second.getModuleName());
|
|
|
477 if (Result == DiffResult::EQUIVALENT || Result == DiffResult::IDENTICAL)
|
|
|
478 return Iter;
|
|
|
479 }
|
|
|
480 return OtherList.end();
|
|
|
481 }
|
|
|
482
|
|
|
483 static void diffOneModule(DiffPrinter &D, const IndexedModuleDescriptor &Item,
|
|
|
484 IndexedModuleDescriptorList &Other,
|
|
|
485 bool ItemIsRight) {
|
|
|
486 StreamPurposeProvider HeaderProvider(70);
|
|
|
487 StreamInfo Info = StreamInfo::createModuleStream(
|
|
|
488 Item.second.getModuleName(), Item.second.getModuleStreamIndex(),
|
|
|
489 Item.first);
|
|
|
490 D.printFullRow(HeaderProvider.format(Info, ItemIsRight));
|
|
|
491
|
|
|
492 const auto *L = &Item;
|
|
|
493
|
|
|
494 auto Iter = findEquivalentModule(Item, Other, ItemIsRight);
|
|
|
495 if (Iter == Other.end()) {
|
|
|
496 // We didn't find this module at all on the other side. Just print one row
|
|
|
497 // and continue.
|
|
|
498 if (ItemIsRight)
|
|
|
499 D.print<ModiProvider>("- Modi", None, Item.first);
|
|
|
500 else
|
|
|
501 D.print<ModiProvider>("- Modi", Item.first, None);
|
|
|
502 return;
|
|
|
503 }
|
|
|
504
|
|
|
505 // We did find this module. Go through and compare each field.
|
|
|
506 const auto *R = &*Iter;
|
|
|
507 if (ItemIsRight)
|
|
|
508 std::swap(L, R);
|
|
|
509
|
|
|
510 BinaryPathProvider PathProvider(28);
|
|
|
511 D.print<ModiProvider>("- Modi", L->first, R->first);
|
|
|
512 D.print<BinaryPathProvider>("- Obj File Name", L->second.getObjFileName(),
|
|
|
513 R->second.getObjFileName(), PathProvider);
|
|
|
514 D.print<StreamNumberProvider>("- Debug Stream",
|
|
|
515 L->second.getModuleStreamIndex(),
|
|
|
516 R->second.getModuleStreamIndex());
|
|
|
517 D.print("- C11 Byte Size", L->second.getC11LineInfoByteSize(),
|
|
|
518 R->second.getC11LineInfoByteSize());
|
|
|
519 D.print("- C13 Byte Size", L->second.getC13LineInfoByteSize(),
|
|
|
520 R->second.getC13LineInfoByteSize());
|
|
|
521 D.print("- # of files", L->second.getNumberOfFiles(),
|
|
|
522 R->second.getNumberOfFiles());
|
|
|
523 D.print("- Pdb File Path Index", L->second.getPdbFilePathNameIndex(),
|
|
|
524 R->second.getPdbFilePathNameIndex());
|
|
|
525 D.print("- Source File Name Index", L->second.getSourceFileNameIndex(),
|
|
|
526 R->second.getSourceFileNameIndex());
|
|
|
527 D.print("- Symbol Byte Size", L->second.getSymbolDebugInfoByteSize(),
|
|
|
528 R->second.getSymbolDebugInfoByteSize());
|
|
|
529 Other.erase(Iter);
|
|
|
530 }
|
|
|
531
|
|
|
532 Error DiffStyle::diffDbiStream() {
|
|
|
533 DiffPrinter D(2, "DBI Stream", 40, 30, opts::diff::PrintResultColumn,
|
|
|
534 opts::diff::PrintValueColumns, outs());
|
|
|
535 D.printExplicit("File", DiffResult::UNSPECIFIED,
|
|
|
536 truncateStringFront(File1.getFilePath(), 28),
|
|
|
537 truncateStringFront(File2.getFilePath(), 28));
|
|
|
538
|
|
|
539 auto ExpectedDbi1 = File1.getPDBDbiStream();
|
|
|
540 auto ExpectedDbi2 = File2.getPDBDbiStream();
|
|
|
541
|
|
|
542 bool Has1 = !!ExpectedDbi1;
|
|
|
543 bool Has2 = !!ExpectedDbi2;
|
|
|
544 if (!(Has1 && Has2)) {
|
|
|
545 std::string L = Has1 ? "(present)" : "(not present)";
|
|
|
546 std::string R = Has2 ? "(present)" : "(not present)";
|
|
|
547 D.print("Stream", L, R);
|
|
|
548
|
|
|
549 consumeError(ExpectedDbi1.takeError());
|
|
|
550 consumeError(ExpectedDbi2.takeError());
|
|
|
551 return Error::success();
|
|
|
552 }
|
|
|
553
|
|
|
554 auto &DL = *ExpectedDbi1;
|
|
|
555 auto &DR = *ExpectedDbi2;
|
|
|
556
|
|
|
557 D.print("Dbi Version", (uint32_t)DL.getDbiVersion(),
|
|
|
558 (uint32_t)DR.getDbiVersion());
|
|
|
559 D.print("Age", DL.getAge(), DR.getAge());
|
|
|
560 D.print("Machine", (uint16_t)DL.getMachineType(),
|
|
|
561 (uint16_t)DR.getMachineType());
|
|
|
562 D.print("Flags", DL.getFlags(), DR.getFlags());
|
|
|
563 D.print("Build Major", DL.getBuildMajorVersion(), DR.getBuildMajorVersion());
|
|
|
564 D.print("Build Minor", DL.getBuildMinorVersion(), DR.getBuildMinorVersion());
|
|
|
565 D.print("Build Number", DL.getBuildNumber(), DR.getBuildNumber());
|
|
|
566 D.print("PDB DLL Version", DL.getPdbDllVersion(), DR.getPdbDllVersion());
|
|
|
567 D.print("PDB DLL RBLD", DL.getPdbDllRbld(), DR.getPdbDllRbld());
|
|
|
568 D.print<StreamNumberProvider>("DBG (FPO)",
|
|
|
569 DL.getDebugStreamIndex(DbgHeaderType::FPO),
|
|
|
570 DR.getDebugStreamIndex(DbgHeaderType::FPO));
|
|
|
571 D.print<StreamNumberProvider>(
|
|
|
572 "DBG (Exception)", DL.getDebugStreamIndex(DbgHeaderType::Exception),
|
|
|
573 DR.getDebugStreamIndex(DbgHeaderType::Exception));
|
|
|
574 D.print<StreamNumberProvider>("DBG (Fixup)",
|
|
|
575 DL.getDebugStreamIndex(DbgHeaderType::Fixup),
|
|
|
576 DR.getDebugStreamIndex(DbgHeaderType::Fixup));
|
|
|
577 D.print<StreamNumberProvider>(
|
|
|
578 "DBG (OmapToSrc)", DL.getDebugStreamIndex(DbgHeaderType::OmapToSrc),
|
|
|
579 DR.getDebugStreamIndex(DbgHeaderType::OmapToSrc));
|
|
|
580 D.print<StreamNumberProvider>(
|
|
|
581 "DBG (OmapFromSrc)", DL.getDebugStreamIndex(DbgHeaderType::OmapFromSrc),
|
|
|
582 DR.getDebugStreamIndex(DbgHeaderType::OmapFromSrc));
|
|
|
583 D.print<StreamNumberProvider>(
|
|
|
584 "DBG (SectionHdr)", DL.getDebugStreamIndex(DbgHeaderType::SectionHdr),
|
|
|
585 DR.getDebugStreamIndex(DbgHeaderType::SectionHdr));
|
|
|
586 D.print<StreamNumberProvider>(
|
|
|
587 "DBG (TokenRidMap)", DL.getDebugStreamIndex(DbgHeaderType::TokenRidMap),
|
|
|
588 DR.getDebugStreamIndex(DbgHeaderType::TokenRidMap));
|
|
|
589 D.print<StreamNumberProvider>("DBG (Xdata)",
|
|
|
590 DL.getDebugStreamIndex(DbgHeaderType::Xdata),
|
|
|
591 DR.getDebugStreamIndex(DbgHeaderType::Xdata));
|
|
|
592 D.print<StreamNumberProvider>("DBG (Pdata)",
|
|
|
593 DL.getDebugStreamIndex(DbgHeaderType::Pdata),
|
|
|
594 DR.getDebugStreamIndex(DbgHeaderType::Pdata));
|
|
|
595 D.print<StreamNumberProvider>("DBG (NewFPO)",
|
|
|
596 DL.getDebugStreamIndex(DbgHeaderType::NewFPO),
|
|
|
597 DR.getDebugStreamIndex(DbgHeaderType::NewFPO));
|
|
|
598 D.print<StreamNumberProvider>(
|
|
|
599 "DBG (SectionHdrOrig)",
|
|
|
600 DL.getDebugStreamIndex(DbgHeaderType::SectionHdrOrig),
|
|
|
601 DR.getDebugStreamIndex(DbgHeaderType::SectionHdrOrig));
|
|
|
602 D.print<StreamNumberProvider>("Globals Stream",
|
|
|
603 DL.getGlobalSymbolStreamIndex(),
|
|
|
604 DR.getGlobalSymbolStreamIndex());
|
|
|
605 D.print<StreamNumberProvider>("Publics Stream",
|
|
|
606 DL.getPublicSymbolStreamIndex(),
|
|
|
607 DR.getPublicSymbolStreamIndex());
|
|
|
608 D.print<StreamNumberProvider>("Symbol Records", DL.getSymRecordStreamIndex(),
|
|
|
609 DR.getSymRecordStreamIndex());
|
|
|
610 D.print("Has CTypes", DL.hasCTypes(), DR.hasCTypes());
|
|
|
611 D.print("Is Incrementally Linked", DL.isIncrementallyLinked(),
|
|
|
612 DR.isIncrementallyLinked());
|
|
|
613 D.print("Is Stripped", DL.isStripped(), DR.isStripped());
|
|
|
614 const DbiModuleList &ML = DL.modules();
|
|
|
615 const DbiModuleList &MR = DR.modules();
|
|
|
616 D.print("Module Count", ML.getModuleCount(), MR.getModuleCount());
|
|
|
617 D.print("Source File Count", ML.getSourceFileCount(),
|
|
|
618 MR.getSourceFileCount());
|
|
|
619 auto MDL = getModuleDescriptors(ML);
|
|
|
620 auto MDR = getModuleDescriptors(MR);
|
|
|
621 // Scan all module descriptors from the left, and look for corresponding
|
|
|
622 // module descriptors on the right.
|
|
|
623 for (const auto &L : MDL)
|
|
|
624 diffOneModule(D, L, MDR, false);
|
|
|
625
|
|
|
626 for (const auto &R : MDR)
|
|
|
627 diffOneModule(D, R, MDL, true);
|
|
|
628
|
|
|
629 return Error::success();
|
|
|
630 }
|
|
|
631
|
|
|
632 Error DiffStyle::diffSectionContribs() { return Error::success(); }
|
|
|
633
|
|
|
634 Error DiffStyle::diffSectionMap() { return Error::success(); }
|
|
|
635
|
|
|
636 Error DiffStyle::diffFpoStream() { return Error::success(); }
|
|
|
637
|
|
|
638 Error DiffStyle::diffTpiStream(int Index) { return Error::success(); }
|
|
|
639
|
|
|
640 Error DiffStyle::diffModuleInfoStream(int Index) { return Error::success(); }
|
|
|
641
|
|
|
642 Error DiffStyle::diffPublics() { return Error::success(); }
|
|
|
643
|
|
|
644 Error DiffStyle::diffGlobals() { return Error::success(); }
|
