| //===-- DiffEngine.cpp - Structural file comparison -----------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file defines the implementation of the llvm-tapi difference |
| // engine, which structurally compares two tbd files. |
| // |
| //===----------------------------------------------------------------------===/ |
| #include "DiffEngine.h" |
| #include "llvm/ADT/SmallString.h" |
| #include "llvm/Support/Casting.h" |
| #include "llvm/Support/raw_ostream.h" |
| #include "llvm/TextAPI/InterfaceFile.h" |
| #include "llvm/TextAPI/Symbol.h" |
| #include "llvm/TextAPI/Target.h" |
| #include <iterator> |
| |
| using namespace llvm; |
| using namespace MachO; |
| using namespace object; |
| |
| StringRef setOrderIndicator(InterfaceInputOrder Order) { |
| return ((Order == lhs) ? "< " : "> "); |
| } |
| |
| // The following template specialization implementations |
| // need to be explicitly placed into the llvm namespace |
| // to work around a GCC 4.8 bug. |
| namespace llvm { |
| |
| template <typename T, DiffAttrKind U> |
| inline void DiffScalarVal<T, U>::print(raw_ostream &OS, std::string Indent) { |
| OS << Indent << "\t" << setOrderIndicator(Order) << Val << "\n"; |
| } |
| |
| template <> |
| inline void |
| DiffScalarVal<StringRef, AD_Diff_Scalar_Str>::print(raw_ostream &OS, |
| std::string Indent) { |
| OS << Indent << "\t\t" << setOrderIndicator(Order) << Val << "\n"; |
| } |
| |
| template <> |
| inline void |
| DiffScalarVal<uint8_t, AD_Diff_Scalar_Unsigned>::print(raw_ostream &OS, |
| std::string Indent) { |
| OS << Indent << "\t" << setOrderIndicator(Order) << std::to_string(Val) |
| << "\n"; |
| } |
| |
| template <> |
| inline void |
| DiffScalarVal<bool, AD_Diff_Scalar_Bool>::print(raw_ostream &OS, |
| std::string Indent) { |
| OS << Indent << "\t" << setOrderIndicator(Order) |
| << ((Val == true) ? "true" : "false") << "\n"; |
| } |
| |
| } // end namespace llvm |
| |
| StringLiteral SymScalar::getSymbolNamePrefix(MachO::EncodeKind Kind) { |
| switch (Kind) { |
| case MachO::EncodeKind::GlobalSymbol: |
| return StringLiteral(""); |
| case MachO::EncodeKind::ObjectiveCClass: |
| return ObjC2MetaClassNamePrefix; |
| case MachO::EncodeKind ::ObjectiveCClassEHType: |
| return ObjC2EHTypePrefix; |
| case MachO::EncodeKind ::ObjectiveCInstanceVariable: |
| return ObjC2IVarPrefix; |
| } |
| llvm_unreachable("Unknown llvm::MachO::EncodeKind enum"); |
| } |
| |
| std::string SymScalar::getFlagString(const MachO::Symbol *Sym) { |
| if (Sym->getFlags() == SymbolFlags::None) |
| return {}; |
| SmallString<64> Flags(" - "); |
| if (Sym->isThreadLocalValue()) |
| Flags.append("Thread-Local "); |
| if (Sym->isWeakDefined()) |
| Flags.append("Weak-Defined "); |
| if (Sym->isWeakReferenced()) |
| Flags.append("Weak-Referenced "); |
| if (Sym->isUndefined()) |
| Flags.append("Undefined "); |
| if (Sym->isReexported()) |
| Flags.append("Reexported "); |
| if (Sym->isData()) |
| Flags.append("Data "); |
| if (Sym->isText()) |
| Flags.append("Text "); |
| |
| return std::string(Flags); |
| } |
| |
| void SymScalar::print(raw_ostream &OS, std::string Indent, MachO::Target Targ) { |
| if (Val->getKind() == MachO::EncodeKind::ObjectiveCClass) { |
| if (Targ.Arch == MachO::AK_i386 && Targ.Platform == MachO::PLATFORM_MACOS) { |
| OS << Indent << "\t\t" << ((Order == lhs) ? "< " : "> ") |
| << ObjC1ClassNamePrefix << Val->getName() << getFlagString(Val) |
| << "\n"; |
| return; |
| } |
| OS << Indent << "\t\t" << ((Order == lhs) ? "< " : "> ") |
| << ObjC2ClassNamePrefix << Val->getName() << getFlagString(Val) << "\n"; |
| } |
| OS << Indent << "\t\t" << ((Order == lhs) ? "< " : "> ") |
| << getSymbolNamePrefix(Val->getKind()) << Val->getName() |
| << getFlagString(Val) << "\n"; |
| } |
| |
| bool checkSymbolEquality(llvm::MachO::InterfaceFile::const_symbol_range LHS, |
| llvm::MachO::InterfaceFile::const_symbol_range RHS) { |
| if (std::distance(LHS.begin(), LHS.end()) != |
| std::distance(RHS.begin(), RHS.end())) |
| return false; |
| return std::equal(LHS.begin(), LHS.end(), RHS.begin(), |
| [&](auto LHS, auto RHS) { return *LHS == *RHS; }); |
| } |
| |
| template <typename TargetVecT, typename ValTypeT, typename V> |
| void addDiffForTargSlice(V Val, Target Targ, DiffOutput &Diff, |
| InterfaceInputOrder Order) { |
| auto TargetVector = llvm::find_if( |
| Diff.Values, [&](const std::unique_ptr<AttributeDiff> &RawTVec) { |
| if (TargetVecT *TVec = dyn_cast<TargetVecT>(RawTVec.get())) |
| return TVec->Targ == Targ; |
| return false; |
| }); |
| if (TargetVector != Diff.Values.end()) { |
| ValTypeT NewVal(Order, Val); |
| cast<TargetVecT>(TargetVector->get())->TargValues.push_back(NewVal); |
| } else { |
| auto NewTargetVec = std::make_unique<TargetVecT>(Targ); |
| ValTypeT NewVal(Order, Val); |
| NewTargetVec->TargValues.push_back(NewVal); |
| Diff.Values.push_back(std::move(NewTargetVec)); |
| } |
| } |
| |
| DiffOutput getSingleAttrDiff(const std::vector<InterfaceFileRef> &IRefVec, |
| std::string Name, InterfaceInputOrder Order) { |
| DiffOutput Diff(Name); |
| Diff.Kind = AD_Str_Vec; |
| for (const auto &IRef : IRefVec) |
| for (auto Targ : IRef.targets()) |
| addDiffForTargSlice<DiffStrVec, |
| DiffScalarVal<StringRef, AD_Diff_Scalar_Str>>( |
| IRef.getInstallName(), Targ, Diff, Order); |
| return Diff; |
| } |
| |
| DiffOutput |
| getSingleAttrDiff(const std::vector<std::pair<Target, std::string>> &PairVec, |
| std::string Name, InterfaceInputOrder Order) { |
| DiffOutput Diff(Name); |
| Diff.Kind = AD_Str_Vec; |
| for (const auto &Pair : PairVec) |
| addDiffForTargSlice<DiffStrVec, |
| DiffScalarVal<StringRef, AD_Diff_Scalar_Str>>( |
| StringRef(Pair.second), Pair.first, Diff, Order); |
| return Diff; |
| } |
| |
| DiffOutput getSingleAttrDiff(InterfaceFile::const_symbol_range SymRange, |
| std::string Name, InterfaceInputOrder Order) { |
| DiffOutput Diff(Name); |
| Diff.Kind = AD_Sym_Vec; |
| for (const auto *Sym : SymRange) |
| for (auto Targ : Sym->targets()) |
| addDiffForTargSlice<DiffSymVec, SymScalar>(Sym, Targ, Diff, Order); |
| return Diff; |
| } |
| |
| template <typename T> |
| DiffOutput getSingleAttrDiff(T SingleAttr, std::string Attribute) { |
| DiffOutput Diff(Attribute); |
| Diff.Kind = SingleAttr.getKind(); |
| Diff.Values.push_back(std::make_unique<T>(SingleAttr)); |
| return Diff; |
| } |
| |
| template <typename T, DiffAttrKind U> |
| void diffAttribute(std::string Name, std::vector<DiffOutput> &Output, |
| DiffScalarVal<T, U> Attr) { |
| Output.push_back(getSingleAttrDiff(Attr, Name)); |
| } |
| |
| template <typename T> |
| void diffAttribute(std::string Name, std::vector<DiffOutput> &Output, |
| const T &Val, InterfaceInputOrder Order) { |
| Output.push_back(getSingleAttrDiff(Val, Name, Order)); |
| } |
| |
| std::vector<DiffOutput> getSingleIF(InterfaceFile *Interface, |
| InterfaceInputOrder Order) { |
| std::vector<DiffOutput> Output; |
| diffAttribute("Install Name", Output, |
| DiffScalarVal<StringRef, AD_Diff_Scalar_Str>( |
| Order, Interface->getInstallName())); |
| for (const auto &Doc : Interface->documents()) { |
| DiffOutput Documents("Inlined Reexported Frameworks/Libraries"); |
| Documents.Kind = AD_Inline_Doc; |
| Documents.Values.push_back(std::make_unique<InlineDoc>( |
| InlineDoc(Doc->getInstallName(), getSingleIF(Doc.get(), Order)))); |
| Output.push_back(std::move(Documents)); |
| } |
| return Output; |
| } |
| |
| void findAndAddDiff(const std::vector<InterfaceFileRef> &CollectedIRefVec, |
| const std::vector<InterfaceFileRef> &LookupIRefVec, |
| DiffOutput &Result, InterfaceInputOrder Order) { |
| Result.Kind = AD_Str_Vec; |
| for (const auto &IRef : CollectedIRefVec) |
| for (auto Targ : IRef.targets()) { |
| auto FoundIRef = llvm::any_of(LookupIRefVec, [&](const auto LIRef) { |
| return llvm::is_contained(LIRef.targets(), Targ) && |
| IRef.getInstallName() == LIRef.getInstallName(); |
| }); |
| if (!FoundIRef) |
| addDiffForTargSlice<DiffStrVec, |
| DiffScalarVal<StringRef, AD_Diff_Scalar_Str>>( |
| IRef.getInstallName(), Targ, Result, Order); |
| } |
| } |
| |
| void findAndAddDiff( |
| const std::vector<std::pair<Target, std::string>> &CollectedPairs, |
| const std::vector<std::pair<Target, std::string>> &LookupPairs, |
| DiffOutput &Result, InterfaceInputOrder Order) { |
| Result.Kind = AD_Str_Vec; |
| for (const auto &Pair : CollectedPairs) { |
| auto FoundPair = llvm::find(LookupPairs, Pair); |
| if (FoundPair == LookupPairs.end()) |
| addDiffForTargSlice<DiffStrVec, |
| DiffScalarVal<StringRef, AD_Diff_Scalar_Str>>( |
| StringRef(Pair.second), Pair.first, Result, Order); |
| } |
| } |
| |
| void findAndAddDiff(InterfaceFile::const_symbol_range CollectedSyms, |
| InterfaceFile::const_symbol_range LookupSyms, |
| DiffOutput &Result, InterfaceInputOrder Order) { |
| Result.Kind = AD_Sym_Vec; |
| for (const auto *Sym : CollectedSyms) |
| for (const auto Targ : Sym->targets()) { |
| auto FoundSym = llvm::any_of(LookupSyms, [&](const auto LSym) { |
| return (Sym->getName() == LSym->getName() && |
| Sym->getKind() == LSym->getKind() && |
| Sym->getFlags() == LSym->getFlags() && |
| llvm::is_contained(LSym->targets(), Targ)); |
| }); |
| if (!FoundSym) |
| addDiffForTargSlice<DiffSymVec, SymScalar>(Sym, Targ, Result, Order); |
| } |
| } |
| |
| template <typename T> |
| DiffOutput recordDifferences(T LHS, T RHS, std::string Attr) { |
| DiffOutput Diff(Attr); |
| if (LHS.getKind() == RHS.getKind()) { |
| Diff.Kind = LHS.getKind(); |
| Diff.Values.push_back(std::make_unique<T>(LHS)); |
| Diff.Values.push_back(std::make_unique<T>(RHS)); |
| } |
| return Diff; |
| } |
| |
| template <typename T> |
| DiffOutput recordDifferences(const std::vector<T> &LHS, |
| const std::vector<T> &RHS, std::string Attr) { |
| DiffOutput Diff(Attr); |
| Diff.Kind = AD_Str_Vec; |
| findAndAddDiff(LHS, RHS, Diff, lhs); |
| findAndAddDiff(RHS, LHS, Diff, rhs); |
| return Diff; |
| } |
| |
| DiffOutput recordDifferences(llvm::MachO::InterfaceFile::const_symbol_range LHS, |
| llvm::MachO::InterfaceFile::const_symbol_range RHS, |
| std::string Attr) { |
| DiffOutput Diff(Attr); |
| Diff.Kind = AD_Sym_Vec; |
| findAndAddDiff(LHS, RHS, Diff, lhs); |
| findAndAddDiff(RHS, LHS, Diff, rhs); |
| return Diff; |
| } |
| |
| std::vector<DiffOutput> |
| DiffEngine::findDifferences(const InterfaceFile *IFLHS, |
| const InterfaceFile *IFRHS) { |
| std::vector<DiffOutput> Output; |
| if (IFLHS->getInstallName() != IFRHS->getInstallName()) |
| Output.push_back(recordDifferences( |
| DiffScalarVal<StringRef, AD_Diff_Scalar_Str>(lhs, |
| IFLHS->getInstallName()), |
| DiffScalarVal<StringRef, AD_Diff_Scalar_Str>(rhs, |
| IFRHS->getInstallName()), |
| "Install Name")); |
| |
| if (IFLHS->getCurrentVersion() != IFRHS->getCurrentVersion()) |
| Output.push_back(recordDifferences( |
| DiffScalarVal<PackedVersion, AD_Diff_Scalar_PackedVersion>( |
| lhs, IFLHS->getCurrentVersion()), |
| DiffScalarVal<PackedVersion, AD_Diff_Scalar_PackedVersion>( |
| rhs, IFRHS->getCurrentVersion()), |
| "Current Version")); |
| if (IFLHS->getCompatibilityVersion() != IFRHS->getCompatibilityVersion()) |
| Output.push_back(recordDifferences( |
| DiffScalarVal<PackedVersion, AD_Diff_Scalar_PackedVersion>( |
| lhs, IFLHS->getCompatibilityVersion()), |
| DiffScalarVal<PackedVersion, AD_Diff_Scalar_PackedVersion>( |
| rhs, IFRHS->getCompatibilityVersion()), |
| "Compatibility Version")); |
| if (IFLHS->getSwiftABIVersion() != IFRHS->getSwiftABIVersion()) |
| Output.push_back( |
| recordDifferences(DiffScalarVal<uint8_t, AD_Diff_Scalar_Unsigned>( |
| lhs, IFLHS->getSwiftABIVersion()), |
| DiffScalarVal<uint8_t, AD_Diff_Scalar_Unsigned>( |
| rhs, IFRHS->getSwiftABIVersion()), |
| "Swift ABI Version")); |
| |
| if (IFLHS->isTwoLevelNamespace() != IFRHS->isTwoLevelNamespace()) |
| Output.push_back(recordDifferences(DiffScalarVal<bool, AD_Diff_Scalar_Bool>( |
| lhs, IFLHS->isTwoLevelNamespace()), |
| DiffScalarVal<bool, AD_Diff_Scalar_Bool>( |
| rhs, IFRHS->isTwoLevelNamespace()), |
| "Two Level Namespace")); |
| |
| if (IFLHS->isApplicationExtensionSafe() != |
| IFRHS->isApplicationExtensionSafe()) |
| Output.push_back( |
| recordDifferences(DiffScalarVal<bool, AD_Diff_Scalar_Bool>( |
| lhs, IFLHS->isApplicationExtensionSafe()), |
| DiffScalarVal<bool, AD_Diff_Scalar_Bool>( |
| rhs, IFRHS->isApplicationExtensionSafe()), |
| "Application Extension Safe")); |
| |
| if (IFLHS->hasSimulatorSupport() != IFRHS->hasSimulatorSupport()) |
| Output.push_back(recordDifferences(DiffScalarVal<bool, AD_Diff_Scalar_Bool>( |
| lhs, IFLHS->hasSimulatorSupport()), |
| DiffScalarVal<bool, AD_Diff_Scalar_Bool>( |
| rhs, IFRHS->hasSimulatorSupport()), |
| "Simulator Support")); |
| |
| if (IFLHS->isOSLibNotForSharedCache() != IFRHS->isOSLibNotForSharedCache()) |
| Output.push_back( |
| recordDifferences(DiffScalarVal<bool, AD_Diff_Scalar_Bool>( |
| lhs, IFLHS->isOSLibNotForSharedCache()), |
| DiffScalarVal<bool, AD_Diff_Scalar_Bool>( |
| rhs, IFRHS->isOSLibNotForSharedCache()), |
| "Shared Cache Ineligible")); |
| |
| if (IFLHS->reexportedLibraries() != IFRHS->reexportedLibraries()) |
| Output.push_back(recordDifferences(IFLHS->reexportedLibraries(), |
| IFRHS->reexportedLibraries(), |
| "Reexported Libraries")); |
| |
| if (IFLHS->rpaths() != IFRHS->rpaths()) |
| Output.push_back(recordDifferences(IFLHS->rpaths(), IFRHS->rpaths(), |
| "Run Path Search Paths")); |
| |
| if (IFLHS->allowableClients() != IFRHS->allowableClients()) |
| Output.push_back(recordDifferences(IFLHS->allowableClients(), |
| IFRHS->allowableClients(), |
| "Allowable Clients")); |
| |
| if (IFLHS->umbrellas() != IFRHS->umbrellas()) |
| Output.push_back(recordDifferences(IFLHS->umbrellas(), IFRHS->umbrellas(), |
| "Parent Umbrellas")); |
| |
| if (!checkSymbolEquality(IFLHS->symbols(), IFRHS->symbols())) |
| Output.push_back( |
| recordDifferences(IFLHS->symbols(), IFRHS->symbols(), "Symbols")); |
| |
| if (IFLHS->documents() != IFRHS->documents()) { |
| DiffOutput Docs("Inlined Reexported Frameworks/Libraries"); |
| Docs.Kind = AD_Inline_Doc; |
| std::vector<StringRef> DocsInserted; |
| // Iterate through inline frameworks/libraries from interface file and find |
| // match based on install name. |
| for (auto DocLHS : IFLHS->documents()) { |
| auto Pair = llvm::find_if(IFRHS->documents(), [&](const auto &DocRHS) { |
| return (DocLHS->getInstallName() == DocRHS->getInstallName()); |
| }); |
| // If a match found, recursively get differences between the pair. |
| if (Pair != IFRHS->documents().end()) { |
| InlineDoc PairDiff = |
| InlineDoc(DocLHS->getInstallName(), |
| findDifferences(DocLHS.get(), Pair->get())); |
| if (!PairDiff.DocValues.empty()) |
| Docs.Values.push_back( |
| std::make_unique<InlineDoc>(std::move(PairDiff))); |
| } |
| // No matching inlined library was found. |
| else |
| Docs.Values.push_back(std::make_unique<InlineDoc>( |
| InlineDoc(DocLHS->getInstallName(), getSingleIF(DocLHS.get(), lhs), |
| /*IsMissingDoc=*/true))); |
| DocsInserted.push_back(DocLHS->getInstallName()); |
| } |
| for (auto DocRHS : IFRHS->documents()) { |
| auto WasGathered = |
| llvm::any_of(DocsInserted, [&](const auto &GatheredDoc) { |
| return (GatheredDoc == DocRHS->getInstallName()); |
| }); |
| if (!WasGathered) |
| Docs.Values.push_back(std::make_unique<InlineDoc>( |
| InlineDoc(DocRHS->getInstallName(), getSingleIF(DocRHS.get(), rhs), |
| /*IsMissingDoc=*/true))); |
| } |
| if (!Docs.Values.empty()) |
| Output.push_back(std::move(Docs)); |
| } |
| return Output; |
| } |
| |
| template <typename T> |
| void printSingleVal(std::string Indent, const DiffOutput &Attr, |
| raw_ostream &OS) { |
| if (Attr.Values.empty()) |
| return; |
| OS << Indent << Attr.Name << "\n"; |
| for (auto &RawItem : Attr.Values) |
| if (T *Item = dyn_cast<T>(RawItem.get())) |
| Item->print(OS, Indent); |
| } |
| |
| template <typename T> |
| T *castValues(const std::unique_ptr<AttributeDiff> &RawAttr) { |
| T *CastAttr = cast<T>(RawAttr.get()); |
| return CastAttr; |
| } |
| |
| template <typename T> void sortTargetValues(std::vector<T> &TargValues) { |
| llvm::stable_sort(TargValues, [](const auto &ValA, const auto &ValB) { |
| if (ValA.getOrder() == ValB.getOrder()) { |
| return ValA.getVal() < ValB.getVal(); |
| } |
| return ValA.getOrder() < ValB.getOrder(); |
| }); |
| } |
| |
| template <typename T> |
| void printVecVal(std::string Indent, const DiffOutput &Attr, raw_ostream &OS) { |
| if (Attr.Values.empty()) { |
| OS << Indent << "'" << Attr.Name << "' differ by order\n"; |
| return; |
| } |
| |
| OS << Indent << Attr.Name << "\n"; |
| |
| std::vector<T *> SortedAttrs; |
| |
| llvm::transform(Attr.Values, std::back_inserter(SortedAttrs), castValues<T>); |
| |
| llvm::sort(SortedAttrs, [&](const auto &ValA, const auto &ValB) { |
| return ValA->Targ < ValB->Targ; |
| }); |
| |
| for (auto *Vec : SortedAttrs) { |
| sortTargetValues<DiffScalarVal<StringRef, AD_Diff_Scalar_Str>>( |
| Vec->TargValues); |
| OS << Indent << "\t" << getTargetTripleName(Vec->Targ) << "\n"; |
| for (auto &Item : Vec->TargValues) |
| Item.print(OS, Indent); |
| } |
| } |
| |
| template <> |
| void printVecVal<DiffSymVec>(std::string Indent, const DiffOutput &Attr, |
| raw_ostream &OS) { |
| if (Attr.Values.empty()) |
| return; |
| |
| OS << Indent << Attr.Name << "\n"; |
| |
| std::vector<DiffSymVec *> SortedAttrs; |
| |
| llvm::transform(Attr.Values, std::back_inserter(SortedAttrs), |
| castValues<DiffSymVec>); |
| |
| llvm::sort(SortedAttrs, [&](const auto &ValA, const auto &ValB) { |
| return ValA->Targ < ValB->Targ; |
| }); |
| for (auto *SymVec : SortedAttrs) { |
| sortTargetValues<SymScalar>(SymVec->TargValues); |
| OS << Indent << "\t" << getTargetTripleName(SymVec->Targ) << "\n"; |
| for (auto &Item : SymVec->TargValues) |
| Item.print(OS, Indent, SymVec->Targ); |
| } |
| } |
| |
| void DiffEngine::printDifferences(raw_ostream &OS, |
| const std::vector<DiffOutput> &Diffs, |
| int IndentCounter) { |
| std::string Indent = std::string(IndentCounter, '\t'); |
| for (auto &Attr : Diffs) { |
| switch (Attr.Kind) { |
| case AD_Diff_Scalar_Str: |
| if (IndentCounter == 0) |
| printSingleVal<DiffScalarVal<StringRef, AD_Diff_Scalar_Str>>(Indent, |
| Attr, OS); |
| break; |
| case AD_Diff_Scalar_PackedVersion: |
| printSingleVal< |
| DiffScalarVal<PackedVersion, AD_Diff_Scalar_PackedVersion>>(Indent, |
| Attr, OS); |
| break; |
| case AD_Diff_Scalar_Unsigned: |
| printSingleVal<DiffScalarVal<uint8_t, AD_Diff_Scalar_Unsigned>>(Indent, |
| Attr, OS); |
| break; |
| case AD_Diff_Scalar_Bool: |
| printSingleVal<DiffScalarVal<bool, AD_Diff_Scalar_Bool>>(Indent, Attr, |
| OS); |
| break; |
| case AD_Str_Vec: |
| printVecVal<DiffStrVec>(Indent, Attr, OS); |
| break; |
| case AD_Sym_Vec: |
| printVecVal<DiffSymVec>(Indent, Attr, OS); |
| break; |
| case AD_Inline_Doc: |
| if (!Attr.Values.empty()) { |
| OS << Indent << Attr.Name << "\n"; |
| for (auto &Item : Attr.Values) { |
| if (InlineDoc *Doc = dyn_cast<InlineDoc>(Item.get())) { |
| if (Doc->DocValues.empty()) |
| continue; |
| IndentCounter = 2; |
| // When only one input file contains an inlined library, print out |
| // the install name for it. Otherwise print out the different values |
| // by the install name. |
| if (Doc->IsMissingDoc) { |
| printSingleVal<DiffScalarVal<StringRef, AD_Diff_Scalar_Str>>( |
| std::string(IndentCounter, '\t'), Doc->DocValues.front(), OS); |
| } else { |
| OS << Indent << "\t" << Doc->InstallName << "\n"; |
| printDifferences(OS, std::move(Doc->DocValues), IndentCounter); |
| } |
| } |
| } |
| } |
| break; |
| } |
| } |
| } |
| |
| bool DiffEngine::compareFiles(raw_ostream &OS) { |
| if (*FileLHS == *FileRHS) |
| return false; |
| OS << "< " << std::string(FileLHS->getPath().data()) << "\n> " |
| << std::string(FileRHS->getPath().data()) << "\n\n"; |
| std::vector<DiffOutput> Diffs = findDifferences(FileLHS, FileRHS); |
| printDifferences(OS, Diffs, 0); |
| return true; |
| } |
