1 //===-- DiffEngine.cpp - Structural file comparison -----------------------===//
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 defines the implementation of the llvm-tapi difference
10 // engine, which structurally compares two tbd files.
11 //
12 //===----------------------------------------------------------------------===/
13 #include "DiffEngine.h"
14 #include "llvm/Support/Casting.h"
15 #include "llvm/Support/raw_ostream.h"
16 #include "llvm/TextAPI/InterfaceFile.h"
17 #include "llvm/TextAPI/Symbol.h"
18 #include "llvm/TextAPI/Target.h"
19
20 using namespace llvm;
21 using namespace MachO;
22 using namespace object;
23
setOrderIndicator(InterfaceInputOrder Order)24 StringRef setOrderIndicator(InterfaceInputOrder Order) {
25 return ((Order == lhs) ? "< " : "> ");
26 }
27
28 // The following template specialization implementations
29 // need to be explicitly placed into the llvm namespace
30 // to work around a GCC 4.8 bug.
31 namespace llvm {
32
33 template <typename T, DiffAttrKind U>
print(raw_ostream & OS,std::string Indent)34 inline void DiffScalarVal<T, U>::print(raw_ostream &OS, std::string Indent) {
35 OS << Indent << "\t" << setOrderIndicator(Order) << Val << "\n";
36 }
37
38 template <>
39 inline void
print(raw_ostream & OS,std::string Indent)40 DiffScalarVal<StringRef, AD_Diff_Scalar_Str>::print(raw_ostream &OS,
41 std::string Indent) {
42 OS << Indent << "\t\t" << setOrderIndicator(Order) << Val << "\n";
43 }
44
45 template <>
46 inline void
print(raw_ostream & OS,std::string Indent)47 DiffScalarVal<uint8_t, AD_Diff_Scalar_Unsigned>::print(raw_ostream &OS,
48 std::string Indent) {
49 OS << Indent << "\t" << setOrderIndicator(Order) << std::to_string(Val)
50 << "\n";
51 }
52
53 template <>
54 inline void
print(raw_ostream & OS,std::string Indent)55 DiffScalarVal<bool, AD_Diff_Scalar_Bool>::print(raw_ostream &OS,
56 std::string Indent) {
57 OS << Indent << "\t" << setOrderIndicator(Order)
58 << ((Val == true) ? "true" : "false") << "\n";
59 }
60
61 } // end namespace llvm
62
getSymbolNamePrefix(MachO::SymbolKind Kind)63 StringLiteral SymScalar::getSymbolNamePrefix(MachO::SymbolKind Kind) {
64 switch (Kind) {
65 case MachO::SymbolKind::GlobalSymbol:
66 return StringLiteral("");
67 case MachO::SymbolKind::ObjectiveCClass:
68 return ObjC2MetaClassNamePrefix;
69 case MachO::SymbolKind ::ObjectiveCClassEHType:
70 return ObjC2EHTypePrefix;
71 case MachO::SymbolKind ::ObjectiveCInstanceVariable:
72 return ObjC2IVarPrefix;
73 }
74 llvm_unreachable("Unknown llvm::MachO::SymbolKind enum");
75 }
76
stringifySymbolFlag(MachO::SymbolFlags Flag)77 std::string SymScalar::stringifySymbolFlag(MachO::SymbolFlags Flag) {
78 switch (Flag) {
79 case MachO::SymbolFlags::None:
80 return "";
81 case MachO::SymbolFlags::ThreadLocalValue:
82 return "Thread-Local";
83 case MachO::SymbolFlags::WeakDefined:
84 return "Weak-Defined";
85 case MachO::SymbolFlags::WeakReferenced:
86 return "Weak-Referenced";
87 case MachO::SymbolFlags::Undefined:
88 return "Undefined";
89 case MachO::SymbolFlags::Rexported:
90 return "Reexported";
91 }
92 llvm_unreachable("Unknown llvm::MachO::SymbolFlags enum");
93 }
94
print(raw_ostream & OS,std::string Indent,MachO::Target Targ)95 void SymScalar::print(raw_ostream &OS, std::string Indent, MachO::Target Targ) {
96 if (Val->getKind() == MachO::SymbolKind::ObjectiveCClass) {
97 if (Targ.Arch == MachO::AK_i386 && Targ.Platform == MachO::PLATFORM_MACOS) {
98 OS << Indent << "\t\t" << ((Order == lhs) ? "< " : "> ")
99 << ObjC1ClassNamePrefix << Val->getName()
100 << getFlagString(Val->getFlags()) << "\n";
101 return;
102 }
103 OS << Indent << "\t\t" << ((Order == lhs) ? "< " : "> ")
104 << ObjC2ClassNamePrefix << Val->getName()
105 << getFlagString(Val->getFlags()) << "\n";
106 }
107 OS << Indent << "\t\t" << ((Order == lhs) ? "< " : "> ")
108 << getSymbolNamePrefix(Val->getKind()) << Val->getName()
109 << getFlagString(Val->getFlags()) << "\n";
110 }
111
checkSymbolEquality(llvm::MachO::InterfaceFile::const_symbol_range LHS,llvm::MachO::InterfaceFile::const_symbol_range RHS)112 bool checkSymbolEquality(llvm::MachO::InterfaceFile::const_symbol_range LHS,
113 llvm::MachO::InterfaceFile::const_symbol_range RHS) {
114 return std::equal(LHS.begin(), LHS.end(), RHS.begin(),
115 [&](auto LHS, auto RHS) { return *LHS == *RHS; });
116 }
117
118 template <typename TargetVecT, typename ValTypeT, typename V>
addDiffForTargSlice(V Val,Target Targ,DiffOutput & Diff,InterfaceInputOrder Order)119 void addDiffForTargSlice(V Val, Target Targ, DiffOutput &Diff,
120 InterfaceInputOrder Order) {
121 auto TargetVector = llvm::find_if(
122 Diff.Values, [&](const std::unique_ptr<AttributeDiff> &RawTVec) {
123 if (TargetVecT *TVec = dyn_cast<TargetVecT>(RawTVec.get()))
124 return TVec->Targ == Targ;
125 return false;
126 });
127 if (TargetVector != Diff.Values.end()) {
128 ValTypeT NewVal(Order, Val);
129 cast<TargetVecT>(TargetVector->get())->TargValues.push_back(NewVal);
130 } else {
131 auto NewTargetVec = std::make_unique<TargetVecT>(Targ);
132 ValTypeT NewVal(Order, Val);
133 NewTargetVec->TargValues.push_back(NewVal);
134 Diff.Values.push_back(std::move(NewTargetVec));
135 }
136 }
137
getSingleAttrDiff(const std::vector<InterfaceFileRef> & IRefVec,std::string Name,InterfaceInputOrder Order)138 DiffOutput getSingleAttrDiff(const std::vector<InterfaceFileRef> &IRefVec,
139 std::string Name, InterfaceInputOrder Order) {
140 DiffOutput Diff(Name);
141 Diff.Kind = AD_Str_Vec;
142 for (const auto &IRef : IRefVec)
143 for (auto Targ : IRef.targets())
144 addDiffForTargSlice<DiffStrVec,
145 DiffScalarVal<StringRef, AD_Diff_Scalar_Str>>(
146 IRef.getInstallName(), Targ, Diff, Order);
147 return Diff;
148 }
149
150 DiffOutput
getSingleAttrDiff(const std::vector<std::pair<Target,std::string>> & PairVec,std::string Name,InterfaceInputOrder Order)151 getSingleAttrDiff(const std::vector<std::pair<Target, std::string>> &PairVec,
152 std::string Name, InterfaceInputOrder Order) {
153 DiffOutput Diff(Name);
154 Diff.Kind = AD_Str_Vec;
155 for (const auto &Pair : PairVec)
156 addDiffForTargSlice<DiffStrVec,
157 DiffScalarVal<StringRef, AD_Diff_Scalar_Str>>(
158 StringRef(Pair.second), Pair.first, Diff, Order);
159 return Diff;
160 }
161
getSingleAttrDiff(InterfaceFile::const_symbol_range SymRange,std::string Name,InterfaceInputOrder Order)162 DiffOutput getSingleAttrDiff(InterfaceFile::const_symbol_range SymRange,
163 std::string Name, InterfaceInputOrder Order) {
164 DiffOutput Diff(Name);
165 Diff.Kind = AD_Sym_Vec;
166 for (const auto *Sym : SymRange)
167 for (auto Targ : Sym->targets())
168 addDiffForTargSlice<DiffSymVec, SymScalar>(Sym, Targ, Diff, Order);
169 return Diff;
170 }
171
172 template <typename T>
getSingleAttrDiff(T SingleAttr,std::string Attribute)173 DiffOutput getSingleAttrDiff(T SingleAttr, std::string Attribute) {
174 DiffOutput Diff(Attribute);
175 Diff.Kind = SingleAttr.getKind();
176 Diff.Values.push_back(std::make_unique<T>(SingleAttr));
177 return Diff;
178 }
179
180 template <typename T, DiffAttrKind U>
diffAttribute(std::string Name,std::vector<DiffOutput> & Output,DiffScalarVal<T,U> Attr)181 void diffAttribute(std::string Name, std::vector<DiffOutput> &Output,
182 DiffScalarVal<T, U> Attr) {
183 Output.push_back(getSingleAttrDiff(Attr, Name));
184 }
185
186 template <typename T>
diffAttribute(std::string Name,std::vector<DiffOutput> & Output,const T & Val,InterfaceInputOrder Order)187 void diffAttribute(std::string Name, std::vector<DiffOutput> &Output,
188 const T &Val, InterfaceInputOrder Order) {
189 Output.push_back(getSingleAttrDiff(Val, Name, Order));
190 }
191
getSingleIF(InterfaceFile * Interface,InterfaceInputOrder Order)192 std::vector<DiffOutput> getSingleIF(InterfaceFile *Interface,
193 InterfaceInputOrder Order) {
194 std::vector<DiffOutput> Output;
195 diffAttribute("Install Name", Output,
196 DiffScalarVal<StringRef, AD_Diff_Scalar_Str>(
197 Order, Interface->getInstallName()));
198 diffAttribute("Current Version", Output,
199 DiffScalarVal<PackedVersion, AD_Diff_Scalar_PackedVersion>(
200 Order, Interface->getCurrentVersion()));
201 diffAttribute("Compatibility Version", Output,
202 DiffScalarVal<PackedVersion, AD_Diff_Scalar_PackedVersion>(
203 Order, Interface->getCompatibilityVersion()));
204 diffAttribute("Swift ABI Version", Output,
205 DiffScalarVal<uint8_t, AD_Diff_Scalar_Unsigned>(
206 Order, Interface->getSwiftABIVersion()));
207 diffAttribute("InstallAPI", Output,
208 DiffScalarVal<bool, AD_Diff_Scalar_Bool>(
209 Order, Interface->isInstallAPI()));
210 diffAttribute("Two Level Namespace", Output,
211 DiffScalarVal<bool, AD_Diff_Scalar_Bool>(
212 Order, Interface->isTwoLevelNamespace()));
213 diffAttribute("Application Extension Safe", Output,
214 DiffScalarVal<bool, AD_Diff_Scalar_Bool>(
215 Order, Interface->isApplicationExtensionSafe()));
216 diffAttribute("Reexported Libraries", Output,
217 Interface->reexportedLibraries(), Order);
218 diffAttribute("Allowable Clients", Output, Interface->allowableClients(),
219 Order);
220 diffAttribute("Parent Umbrellas", Output, Interface->umbrellas(), Order);
221 diffAttribute("Symbols", Output, Interface->symbols(), Order);
222 for (auto Doc : Interface->documents()) {
223 DiffOutput Documents("Inlined Reexported Frameworks/Libraries");
224 Documents.Kind = AD_Inline_Doc;
225 Documents.Values.push_back(std::make_unique<InlineDoc>(
226 InlineDoc(Doc->getInstallName(), getSingleIF(Doc.get(), Order))));
227 Output.push_back(std::move(Documents));
228 }
229 return Output;
230 }
231
findAndAddDiff(const std::vector<InterfaceFileRef> & CollectedIRefVec,const std::vector<InterfaceFileRef> & LookupIRefVec,DiffOutput & Result,InterfaceInputOrder Order)232 void findAndAddDiff(const std::vector<InterfaceFileRef> &CollectedIRefVec,
233 const std::vector<InterfaceFileRef> &LookupIRefVec,
234 DiffOutput &Result, InterfaceInputOrder Order) {
235 Result.Kind = AD_Str_Vec;
236 for (const auto &IRef : CollectedIRefVec)
237 for (auto Targ : IRef.targets()) {
238 auto FoundIRef = llvm::any_of(LookupIRefVec, [&](const auto LIRef) {
239 return llvm::is_contained(LIRef.targets(), Targ) &&
240 IRef.getInstallName() == LIRef.getInstallName();
241 });
242 if (!FoundIRef)
243 addDiffForTargSlice<DiffStrVec,
244 DiffScalarVal<StringRef, AD_Diff_Scalar_Str>>(
245 IRef.getInstallName(), Targ, Result, Order);
246 }
247 }
248
findAndAddDiff(const std::vector<std::pair<Target,std::string>> & CollectedPairs,const std::vector<std::pair<Target,std::string>> & LookupPairs,DiffOutput & Result,InterfaceInputOrder Order)249 void findAndAddDiff(
250 const std::vector<std::pair<Target, std::string>> &CollectedPairs,
251 const std::vector<std::pair<Target, std::string>> &LookupPairs,
252 DiffOutput &Result, InterfaceInputOrder Order) {
253 Result.Kind = AD_Str_Vec;
254 for (const auto &Pair : CollectedPairs) {
255 auto FoundPair = llvm::find(LookupPairs, Pair);
256 if (FoundPair == LookupPairs.end())
257 addDiffForTargSlice<DiffStrVec,
258 DiffScalarVal<StringRef, AD_Diff_Scalar_Str>>(
259 StringRef(Pair.second), Pair.first, Result, Order);
260 }
261 }
262
findAndAddDiff(InterfaceFile::const_symbol_range CollectedSyms,InterfaceFile::const_symbol_range LookupSyms,DiffOutput & Result,InterfaceInputOrder Order)263 void findAndAddDiff(InterfaceFile::const_symbol_range CollectedSyms,
264 InterfaceFile::const_symbol_range LookupSyms,
265 DiffOutput &Result, InterfaceInputOrder Order) {
266 Result.Kind = AD_Sym_Vec;
267 for (const auto *Sym : CollectedSyms)
268 for (const auto Targ : Sym->targets()) {
269 auto FoundSym = llvm::any_of(LookupSyms, [&](const auto LSym) {
270 return (Sym->getName() == LSym->getName() &&
271 Sym->getKind() == LSym->getKind() &&
272 Sym->getFlags() == LSym->getFlags() &&
273 llvm::is_contained(LSym->targets(), Targ));
274 });
275 if (!FoundSym)
276 addDiffForTargSlice<DiffSymVec, SymScalar>(Sym, Targ, Result, Order);
277 }
278 }
279
280 template <typename T>
recordDifferences(T LHS,T RHS,std::string Attr)281 DiffOutput recordDifferences(T LHS, T RHS, std::string Attr) {
282 DiffOutput Diff(Attr);
283 if (LHS.getKind() == RHS.getKind()) {
284 Diff.Kind = LHS.getKind();
285 Diff.Values.push_back(std::make_unique<T>(LHS));
286 Diff.Values.push_back(std::make_unique<T>(RHS));
287 }
288 return Diff;
289 }
290
291 template <typename T>
recordDifferences(const std::vector<T> & LHS,const std::vector<T> & RHS,std::string Attr)292 DiffOutput recordDifferences(const std::vector<T> &LHS,
293 const std::vector<T> &RHS, std::string Attr) {
294 DiffOutput Diff(Attr);
295 Diff.Kind = AD_Str_Vec;
296 findAndAddDiff(LHS, RHS, Diff, lhs);
297 findAndAddDiff(RHS, LHS, Diff, rhs);
298 return Diff;
299 }
300
recordDifferences(llvm::MachO::InterfaceFile::const_symbol_range LHS,llvm::MachO::InterfaceFile::const_symbol_range RHS,std::string Attr)301 DiffOutput recordDifferences(llvm::MachO::InterfaceFile::const_symbol_range LHS,
302 llvm::MachO::InterfaceFile::const_symbol_range RHS,
303 std::string Attr) {
304 DiffOutput Diff(Attr);
305 Diff.Kind = AD_Sym_Vec;
306 findAndAddDiff(LHS, RHS, Diff, lhs);
307 findAndAddDiff(RHS, LHS, Diff, rhs);
308 return Diff;
309 }
310
311 std::vector<DiffOutput>
findDifferences(const InterfaceFile * IFLHS,const InterfaceFile * IFRHS)312 DiffEngine::findDifferences(const InterfaceFile *IFLHS,
313 const InterfaceFile *IFRHS) {
314 std::vector<DiffOutput> Output;
315 if (IFLHS->getInstallName() != IFRHS->getInstallName())
316 Output.push_back(recordDifferences(
317 DiffScalarVal<StringRef, AD_Diff_Scalar_Str>(lhs,
318 IFLHS->getInstallName()),
319 DiffScalarVal<StringRef, AD_Diff_Scalar_Str>(rhs,
320 IFRHS->getInstallName()),
321 "Install Name"));
322
323 if (IFLHS->getCurrentVersion() != IFRHS->getCurrentVersion())
324 Output.push_back(recordDifferences(
325 DiffScalarVal<PackedVersion, AD_Diff_Scalar_PackedVersion>(
326 lhs, IFLHS->getCurrentVersion()),
327 DiffScalarVal<PackedVersion, AD_Diff_Scalar_PackedVersion>(
328 rhs, IFRHS->getCurrentVersion()),
329 "Current Version"));
330 if (IFLHS->getCompatibilityVersion() != IFRHS->getCompatibilityVersion())
331 Output.push_back(recordDifferences(
332 DiffScalarVal<PackedVersion, AD_Diff_Scalar_PackedVersion>(
333 lhs, IFLHS->getCompatibilityVersion()),
334 DiffScalarVal<PackedVersion, AD_Diff_Scalar_PackedVersion>(
335 rhs, IFRHS->getCompatibilityVersion()),
336 "Compatibility Version"));
337 if (IFLHS->getSwiftABIVersion() != IFRHS->getSwiftABIVersion())
338 Output.push_back(
339 recordDifferences(DiffScalarVal<uint8_t, AD_Diff_Scalar_Unsigned>(
340 lhs, IFLHS->getSwiftABIVersion()),
341 DiffScalarVal<uint8_t, AD_Diff_Scalar_Unsigned>(
342 rhs, IFRHS->getSwiftABIVersion()),
343 "Swift ABI Version"));
344 if (IFLHS->isInstallAPI() != IFRHS->isInstallAPI())
345 Output.push_back(recordDifferences(
346 DiffScalarVal<bool, AD_Diff_Scalar_Bool>(lhs, IFLHS->isInstallAPI()),
347 DiffScalarVal<bool, AD_Diff_Scalar_Bool>(rhs, IFRHS->isInstallAPI()),
348 "InstallAPI"));
349
350 if (IFLHS->isTwoLevelNamespace() != IFRHS->isTwoLevelNamespace())
351 Output.push_back(recordDifferences(DiffScalarVal<bool, AD_Diff_Scalar_Bool>(
352 lhs, IFLHS->isTwoLevelNamespace()),
353 DiffScalarVal<bool, AD_Diff_Scalar_Bool>(
354 rhs, IFRHS->isTwoLevelNamespace()),
355 "Two Level Namespace"));
356
357 if (IFLHS->isApplicationExtensionSafe() !=
358 IFRHS->isApplicationExtensionSafe())
359 Output.push_back(
360 recordDifferences(DiffScalarVal<bool, AD_Diff_Scalar_Bool>(
361 lhs, IFLHS->isApplicationExtensionSafe()),
362 DiffScalarVal<bool, AD_Diff_Scalar_Bool>(
363 rhs, IFRHS->isApplicationExtensionSafe()),
364 "Application Extension Safe"));
365
366 if (IFLHS->reexportedLibraries() != IFRHS->reexportedLibraries())
367 Output.push_back(recordDifferences(IFLHS->reexportedLibraries(),
368 IFRHS->reexportedLibraries(),
369 "Reexported Libraries"));
370
371 if (IFLHS->allowableClients() != IFRHS->allowableClients())
372 Output.push_back(recordDifferences(IFLHS->allowableClients(),
373 IFRHS->allowableClients(),
374 "Allowable Clients"));
375
376 if (IFLHS->umbrellas() != IFRHS->umbrellas())
377 Output.push_back(recordDifferences(IFLHS->umbrellas(), IFRHS->umbrellas(),
378 "Parent Umbrellas"));
379
380 if (!checkSymbolEquality(IFLHS->symbols(), IFRHS->symbols()))
381 Output.push_back(
382 recordDifferences(IFLHS->symbols(), IFRHS->symbols(), "Symbols"));
383
384 if (IFLHS->documents() != IFRHS->documents()) {
385 DiffOutput Docs("Inlined Reexported Frameworks/Libraries");
386 Docs.Kind = AD_Inline_Doc;
387 std::vector<StringRef> DocsInserted;
388 // Iterate through inline frameworks/libraries from interface file and find
389 // match based on install name.
390 for (auto DocLHS : IFLHS->documents()) {
391 auto Pair = llvm::find_if(IFRHS->documents(), [&](const auto &DocRHS) {
392 return (DocLHS->getInstallName() == DocRHS->getInstallName());
393 });
394 // If a match found, recursively get differences between the pair.
395 if (Pair != IFRHS->documents().end()) {
396 InlineDoc PairDiff =
397 InlineDoc(DocLHS->getInstallName(),
398 findDifferences(DocLHS.get(), Pair->get()));
399 if (!PairDiff.DocValues.empty())
400 Docs.Values.push_back(
401 std::make_unique<InlineDoc>(std::move(PairDiff)));
402 }
403 // If a match is not found, get attributes from single item.
404 else
405 Docs.Values.push_back(std::make_unique<InlineDoc>(InlineDoc(
406 DocLHS->getInstallName(), getSingleIF(DocLHS.get(), lhs))));
407 DocsInserted.push_back(DocLHS->getInstallName());
408 }
409 for (auto DocRHS : IFRHS->documents()) {
410 auto WasGathered =
411 llvm::any_of(DocsInserted, [&](const auto &GatheredDoc) {
412 return (GatheredDoc == DocRHS->getInstallName());
413 });
414 if (!WasGathered)
415 Docs.Values.push_back(std::make_unique<InlineDoc>(InlineDoc(
416 DocRHS->getInstallName(), getSingleIF(DocRHS.get(), rhs))));
417 }
418 if (!Docs.Values.empty())
419 Output.push_back(std::move(Docs));
420 }
421 return Output;
422 }
423
424 template <typename T>
printSingleVal(std::string Indent,const DiffOutput & Attr,raw_ostream & OS)425 void printSingleVal(std::string Indent, const DiffOutput &Attr,
426 raw_ostream &OS) {
427 if (Attr.Values.empty())
428 return;
429 OS << Indent << Attr.Name << "\n";
430 for (auto &RawItem : Attr.Values)
431 if (T *Item = dyn_cast<T>(RawItem.get()))
432 Item->print(OS, Indent);
433 }
434
435 template <typename T>
castValues(const std::unique_ptr<AttributeDiff> & RawAttr)436 T *castValues(const std::unique_ptr<AttributeDiff> &RawAttr) {
437 T *CastAttr = cast<T>(RawAttr.get());
438 return CastAttr;
439 }
440
sortTargetValues(std::vector<T> & TargValues)441 template <typename T> void sortTargetValues(std::vector<T> &TargValues) {
442 llvm::stable_sort(TargValues, [](const auto &ValA, const auto &ValB) {
443 return ValA.getOrder() < ValB.getOrder();
444 });
445 llvm::stable_sort(TargValues, [](const auto &ValA, const auto &ValB) {
446 return ValA.getOrder() == ValB.getOrder() && ValA.getVal() < ValB.getVal();
447 });
448 }
449
450 template <typename T>
printVecVal(std::string Indent,const DiffOutput & Attr,raw_ostream & OS)451 void printVecVal(std::string Indent, const DiffOutput &Attr, raw_ostream &OS) {
452 if (Attr.Values.empty())
453 return;
454
455 OS << Indent << Attr.Name << "\n";
456
457 std::vector<T *> SortedAttrs;
458
459 llvm::transform(Attr.Values, std::back_inserter(SortedAttrs), castValues<T>);
460
461 llvm::sort(SortedAttrs, [&](const auto &ValA, const auto &ValB) {
462 return ValA->Targ < ValB->Targ;
463 });
464
465 for (auto *Vec : SortedAttrs) {
466 sortTargetValues<DiffScalarVal<StringRef, AD_Diff_Scalar_Str>>(
467 Vec->TargValues);
468 OS << Indent << "\t" << getTargetTripleName(Vec->Targ) << "\n";
469 for (auto &Item : Vec->TargValues)
470 Item.print(OS, Indent);
471 }
472 }
473
474 template <>
printVecVal(std::string Indent,const DiffOutput & Attr,raw_ostream & OS)475 void printVecVal<DiffSymVec>(std::string Indent, const DiffOutput &Attr,
476 raw_ostream &OS) {
477 if (Attr.Values.empty())
478 return;
479
480 OS << Indent << Attr.Name << "\n";
481
482 std::vector<DiffSymVec *> SortedAttrs;
483
484 llvm::transform(Attr.Values, std::back_inserter(SortedAttrs),
485 castValues<DiffSymVec>);
486
487 llvm::sort(SortedAttrs, [&](const auto &ValA, const auto &ValB) {
488 return ValA->Targ < ValB->Targ;
489 });
490 for (auto *SymVec : SortedAttrs) {
491 sortTargetValues<SymScalar>(SymVec->TargValues);
492 OS << Indent << "\t" << getTargetTripleName(SymVec->Targ) << "\n";
493 for (auto &Item : SymVec->TargValues)
494 Item.print(OS, Indent, SymVec->Targ);
495 }
496 }
497
printDifferences(raw_ostream & OS,const std::vector<DiffOutput> & Diffs,int IndentCounter)498 void DiffEngine::printDifferences(raw_ostream &OS,
499 const std::vector<DiffOutput> &Diffs,
500 int IndentCounter) {
501 std::string Indent = std::string(IndentCounter, '\t');
502 for (auto &Attr : Diffs) {
503 switch (Attr.Kind) {
504 case AD_Diff_Scalar_Str:
505 if (IndentCounter == 0)
506 printSingleVal<DiffScalarVal<StringRef, AD_Diff_Scalar_Str>>(Indent,
507 Attr, OS);
508 break;
509 case AD_Diff_Scalar_PackedVersion:
510 printSingleVal<
511 DiffScalarVal<PackedVersion, AD_Diff_Scalar_PackedVersion>>(Indent,
512 Attr, OS);
513 break;
514 case AD_Diff_Scalar_Unsigned:
515 printSingleVal<DiffScalarVal<uint8_t, AD_Diff_Scalar_Unsigned>>(Indent,
516 Attr, OS);
517 break;
518 case AD_Diff_Scalar_Bool:
519 printSingleVal<DiffScalarVal<bool, AD_Diff_Scalar_Bool>>(Indent, Attr,
520 OS);
521 break;
522 case AD_Str_Vec:
523 printVecVal<DiffStrVec>(Indent, Attr, OS);
524 break;
525 case AD_Sym_Vec:
526 printVecVal<DiffSymVec>(Indent, Attr, OS);
527 break;
528 case AD_Inline_Doc:
529 if (!Attr.Values.empty()) {
530 OS << Indent << Attr.Name << "\n";
531 for (auto &Item : Attr.Values)
532 if (InlineDoc *Doc = dyn_cast<InlineDoc>(Item.get()))
533 if (!Doc->DocValues.empty()) {
534 OS << Indent << "\t" << Doc->InstallName << "\n";
535 printDifferences(OS, std::move(Doc->DocValues), 2);
536 }
537 }
538 break;
539 }
540 }
541 }
542
compareFiles(raw_ostream & OS)543 bool DiffEngine::compareFiles(raw_ostream &OS) {
544 const auto *IFLHS = &(FileLHS->getInterfaceFile());
545 const auto *IFRHS = &(FileRHS->getInterfaceFile());
546 if (*IFLHS == *IFRHS)
547 return false;
548 OS << "< " << std::string(IFLHS->getPath().data()) << "\n> "
549 << std::string(IFRHS->getPath().data()) << "\n\n";
550 std::vector<DiffOutput> Diffs = findDifferences(IFLHS, IFRHS);
551 printDifferences(OS, Diffs, 0);
552 return true;
553 }
554