| // Copyright (C) 2016 The Android Open Source Project |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include "abi_diff.h" |
| |
| #include <header_abi_util.h> |
| |
| #include <llvm/Support/raw_ostream.h> |
| |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| #include <stdlib.h> |
| |
| abi_util::CompatibilityStatusIR HeaderAbiDiff::GenerateCompatibilityReport() { |
| using abi_util::TextFormatToIRReader; |
| std::unique_ptr<abi_util::TextFormatToIRReader> old_reader = |
| TextFormatToIRReader::CreateTextFormatToIRReader(text_format_old_); |
| std::unique_ptr<abi_util::TextFormatToIRReader> new_reader = |
| TextFormatToIRReader::CreateTextFormatToIRReader(text_format_new_); |
| if (!old_reader || !new_reader || !old_reader->ReadDump(old_dump_) || |
| !new_reader->ReadDump(new_dump_)) { |
| llvm::errs() << "Could not create Text Format readers\n"; |
| ::exit(1); |
| } |
| std::unique_ptr<abi_util::IRDiffDumper> ir_diff_dumper = |
| abi_util::IRDiffDumper::CreateIRDiffDumper(text_format_diff_, cr_); |
| abi_util::CompatibilityStatusIR status = |
| CompareTUs(old_reader.get(), new_reader.get(), ir_diff_dumper.get()); |
| if (!ir_diff_dumper->Dump()) { |
| llvm::errs() << "Could not dump diff report\n"; |
| ::exit(1); |
| } |
| return status; |
| } |
| |
| abi_util::CompatibilityStatusIR HeaderAbiDiff::CompareTUs( |
| const abi_util::TextFormatToIRReader *old_tu, |
| const abi_util::TextFormatToIRReader *new_tu, |
| abi_util::IRDiffDumper *ir_diff_dumper) { |
| // Collect all old and new types in maps, so that we can refer to them by |
| // type name / linker_set_key later. |
| const AbiElementMap<const abi_util::TypeIR *> old_types = |
| old_tu->GetTypeGraph(); |
| const AbiElementMap<const abi_util::TypeIR *> new_types = |
| new_tu->GetTypeGraph(); |
| |
| // Collect fills in added, removed ,unsafe and safe function diffs. |
| if (!CollectDynsymExportables(old_tu->GetFunctions(), new_tu->GetFunctions(), |
| old_tu->GetElfFunctions(), |
| new_tu->GetElfFunctions(), |
| old_types, new_types, |
| ir_diff_dumper) || |
| !CollectDynsymExportables(old_tu->GetGlobalVariables(), |
| new_tu->GetGlobalVariables(), |
| old_tu->GetElfObjects(), |
| new_tu->GetElfObjects(), |
| old_types, new_types, |
| ir_diff_dumper)) { |
| llvm::errs() << "Unable to collect dynsym exportables\n"; |
| ::exit(1); |
| } |
| |
| // By the time this call is reached, all referenced types have been diffed. |
| // So all additional calls on ir_diff_dumper get DiffKind::Unreferenced. |
| if (check_all_apis_ && !CollectUserDefinedTypes(old_tu, new_tu, old_types, |
| new_types, ir_diff_dumper)) { |
| llvm::errs() << "Unable to collect user defined types\n"; |
| ::exit(1); |
| } |
| |
| abi_util::CompatibilityStatusIR combined_status = |
| ir_diff_dumper->GetCompatibilityStatusIR(); |
| |
| ir_diff_dumper->AddLibNameIR(lib_name_); |
| ir_diff_dumper->AddArchIR(arch_); |
| ir_diff_dumper->AddCompatibilityStatusIR(combined_status); |
| return combined_status; |
| } |
| |
| std::pair<AbiElementMap<const abi_util::EnumTypeIR *>, |
| AbiElementMap<const abi_util::RecordTypeIR *>> |
| HeaderAbiDiff::ExtractUserDefinedTypes( |
| const abi_util::TextFormatToIRReader *tu) { |
| AbiElementMap<const abi_util::EnumTypeIR *> enum_types; |
| AbiElementMap<const abi_util::RecordTypeIR *> record_types; |
| // Iterate through the ODRListMap, if there is more than 1 element in the |
| // list, we cannot really unique the type by name, so skip it. If not, add a |
| // map entry UniqueId -> const Record(Enum)TypeIR *. |
| for (auto &it : tu->GetODRListMap()) { |
| auto &odr_list = it.second; |
| if (odr_list.size() != 1) { |
| continue; |
| } |
| const abi_util::TypeIR *type = *(odr_list.begin()); |
| switch (type->GetKind()) { |
| case abi_util::RecordTypeKind: |
| record_types.emplace( |
| static_cast<const abi_util::RecordTypeIR *>(type)->GetUniqueId(), |
| static_cast<const abi_util::RecordTypeIR *>(type)); |
| break; |
| case abi_util::EnumTypeKind: |
| enum_types.emplace( |
| static_cast<const abi_util::EnumTypeIR *>(type)->GetUniqueId(), |
| static_cast<const abi_util::EnumTypeIR *>(type)); |
| break; |
| default: |
| // Only user defined types should have ODR list entries. |
| assert(0); |
| } |
| } |
| return std::make_pair(std::move(enum_types), std::move(record_types)); |
| } |
| |
| bool HeaderAbiDiff::CollectUserDefinedTypes( |
| const abi_util::TextFormatToIRReader *old_tu, |
| const abi_util::TextFormatToIRReader *new_tu, |
| const AbiElementMap<const abi_util::TypeIR *> &old_types_map, |
| const AbiElementMap<const abi_util::TypeIR *> &new_types_map, |
| abi_util::IRDiffDumper *ir_diff_dumper) { |
| |
| auto old_enums_and_records_extracted = ExtractUserDefinedTypes(old_tu); |
| auto new_enums_and_records_extracted = ExtractUserDefinedTypes(new_tu); |
| |
| return CollectUserDefinedTypesInternal( |
| old_enums_and_records_extracted.second, |
| new_enums_and_records_extracted.second, old_types_map, |
| new_types_map, ir_diff_dumper) && |
| CollectUserDefinedTypesInternal(old_enums_and_records_extracted.first, |
| new_enums_and_records_extracted.first, |
| old_types_map, new_types_map, |
| ir_diff_dumper); |
| } |
| |
| template <typename T> |
| bool HeaderAbiDiff::CollectUserDefinedTypesInternal( |
| const AbiElementMap<const T*> &old_ud_types_map, |
| const AbiElementMap<const T*> &new_ud_types_map, |
| const AbiElementMap<const abi_util::TypeIR *> &old_types_map, |
| const AbiElementMap<const abi_util::TypeIR *> &new_types_map, |
| abi_util::IRDiffDumper *ir_diff_dumper) { |
| |
| return Collect(old_ud_types_map, new_ud_types_map, nullptr, nullptr, |
| ir_diff_dumper, old_types_map, new_types_map) && |
| PopulateCommonElements(old_ud_types_map, new_ud_types_map, old_types_map, |
| new_types_map, ir_diff_dumper, |
| abi_util::DiffMessageIR::Unreferenced); |
| } |
| |
| template <typename T, typename ElfSymbolType> |
| bool HeaderAbiDiff::CollectDynsymExportables( |
| const AbiElementMap<T> &old_exportables, |
| const AbiElementMap<T> &new_exportables, |
| const AbiElementMap<ElfSymbolType> &old_elf_symbols, |
| const AbiElementMap<ElfSymbolType> &new_elf_symbols, |
| const AbiElementMap<const abi_util::TypeIR *> &old_types_map, |
| const AbiElementMap<const abi_util::TypeIR *> &new_types_map, |
| abi_util::IRDiffDumper *ir_diff_dumper) { |
| AbiElementMap<const T *> old_exportables_map; |
| AbiElementMap<const T *> new_exportables_map; |
| AbiElementMap<const abi_util::ElfSymbolIR *> old_elf_symbol_map; |
| AbiElementMap<const abi_util::ElfSymbolIR *> new_elf_symbol_map; |
| |
| abi_util::AddToMap(&old_exportables_map, old_exportables, |
| [](auto e) { return e->first;}, |
| [](auto e) {return &(e->second);}); |
| abi_util::AddToMap(&new_exportables_map, new_exportables, |
| [](auto e) { return e->first;}, |
| [](auto e) { return &(e->second);}); |
| |
| abi_util::AddToMap( |
| &old_elf_symbol_map, old_elf_symbols, |
| [](auto e) { return e->first;}, |
| [](auto e) {return &(e->second);}); |
| |
| abi_util::AddToMap( |
| &new_elf_symbol_map, new_elf_symbols, |
| [](auto e) { return e->first;}, |
| [](auto e) {return &(e->second);}); |
| |
| if (!Collect(old_exportables_map, |
| new_exportables_map, &old_elf_symbol_map, &new_elf_symbol_map, |
| ir_diff_dumper, old_types_map, new_types_map) || |
| !CollectElfSymbols(old_elf_symbol_map, new_elf_symbol_map, |
| ir_diff_dumper) || |
| !PopulateCommonElements(old_exportables_map, new_exportables_map, |
| old_types_map, new_types_map, ir_diff_dumper, |
| abi_util::DiffMessageIR::Referenced)) { |
| llvm::errs() << "Diffing dynsym exportables failed\n"; |
| return false; |
| } |
| return true; |
| } |
| |
| // Collect added and removed Elements. The elf set is needed since some symbols |
| // might not have meta-data about them collected through the AST. For eg: if a |
| // function Foo is defined in an assembly file on target A, but in a c/c++ file |
| // on target B, foo does not have meta-data surrounding it when building target |
| // A, this does not mean it is not in the ABI + API of the library. |
| |
| template <typename T> |
| bool HeaderAbiDiff::Collect( |
| const AbiElementMap<const T*> &old_elements_map, |
| const AbiElementMap<const T*> &new_elements_map, |
| const AbiElementMap<const abi_util::ElfSymbolIR *> *old_elf_map, |
| const AbiElementMap<const abi_util::ElfSymbolIR *> *new_elf_map, |
| abi_util::IRDiffDumper *ir_diff_dumper, |
| const AbiElementMap<const abi_util::TypeIR *> &old_types_map, |
| const AbiElementMap<const abi_util::TypeIR *> &new_types_map) { |
| if (!PopulateRemovedElements( |
| old_elements_map, new_elements_map, new_elf_map, ir_diff_dumper, |
| abi_util::DiffMessageIR::Removed, old_types_map) || |
| !PopulateRemovedElements(new_elements_map, old_elements_map, old_elf_map, |
| ir_diff_dumper, |
| abi_util::IRDiffDumper::DiffKind::Added, |
| new_types_map)) { |
| llvm::errs() << "Populating functions in report failed\n"; |
| return false; |
| } |
| return true; |
| } |
| |
| bool HeaderAbiDiff::CollectElfSymbols( |
| const AbiElementMap<const abi_util::ElfSymbolIR *> &old_symbols, |
| const AbiElementMap<const abi_util::ElfSymbolIR *> &new_symbols, |
| abi_util::IRDiffDumper *ir_diff_dumper) { |
| std::vector<const abi_util::ElfSymbolIR *> removed_elements = |
| abi_util::FindRemovedElements(old_symbols, new_symbols); |
| |
| std::vector<const abi_util::ElfSymbolIR *> added_elements = |
| abi_util::FindRemovedElements(new_symbols, old_symbols); |
| |
| return PopulateElfElements(removed_elements, ir_diff_dumper, |
| abi_util::IRDiffDumper::DiffKind::Removed) && |
| PopulateElfElements(added_elements, ir_diff_dumper, |
| abi_util::IRDiffDumper::DiffKind::Added); |
| } |
| |
| bool HeaderAbiDiff::PopulateElfElements( |
| std::vector<const abi_util::ElfSymbolIR *> &elf_elements, |
| abi_util::IRDiffDumper *ir_diff_dumper, |
| abi_util::IRDiffDumper::DiffKind diff_kind) { |
| for (auto &&elf_element : elf_elements) { |
| if (!ir_diff_dumper->AddElfSymbolMessageIR(elf_element, diff_kind)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| template <typename T> |
| bool HeaderAbiDiff::PopulateRemovedElements( |
| const AbiElementMap<const T*> &old_elements_map, |
| const AbiElementMap<const T*> &new_elements_map, |
| const AbiElementMap<const abi_util::ElfSymbolIR *> *elf_map, |
| abi_util::IRDiffDumper *ir_diff_dumper, |
| abi_util::IRDiffDumper::DiffKind diff_kind, |
| const AbiElementMap<const abi_util::TypeIR *> &removed_types_map) { |
| std::vector<const T *> removed_elements = |
| abi_util::FindRemovedElements(old_elements_map, new_elements_map); |
| if (!DumpLoneElements(removed_elements, elf_map, ir_diff_dumper, diff_kind, |
| removed_types_map)) { |
| llvm::errs() << "Dumping added / removed element to report failed\n"; |
| return false; |
| } |
| return true; |
| } |
| |
| // Find the common elements (common records, common enums, common functions etc) |
| // Dump the differences (we need type maps for this diff since we'll get |
| // reachable types from here) |
| template <typename T> |
| bool HeaderAbiDiff::PopulateCommonElements( |
| const AbiElementMap<const T *> &old_elements_map, |
| const AbiElementMap<const T *> &new_elements_map, |
| const AbiElementMap<const abi_util::TypeIR *> &old_types, |
| const AbiElementMap<const abi_util::TypeIR *> &new_types, |
| abi_util::IRDiffDumper *ir_diff_dumper, |
| abi_util::IRDiffDumper::DiffKind diff_kind) { |
| std::vector<std::pair<const T *, const T *>> common_elements = |
| abi_util::FindCommonElements(old_elements_map, new_elements_map); |
| if (!DumpDiffElements(common_elements, old_types, new_types, |
| ir_diff_dumper, diff_kind)) { |
| llvm::errs() << "Dumping difference in common element to report failed\n"; |
| return false; |
| } |
| return true; |
| } |
| |
| template <typename T> |
| bool HeaderAbiDiff::DumpLoneElements( |
| std::vector<const T *> &elements, |
| const AbiElementMap<const abi_util::ElfSymbolIR *> *elf_map, |
| abi_util::IRDiffDumper *ir_diff_dumper, |
| abi_util::IRDiffDumper::DiffKind diff_kind, |
| const AbiElementMap<const abi_util::TypeIR *> &types_map) { |
| // If the record / enum has source file information, skip it. |
| std::smatch source_file_match; |
| std::regex source_file_regex(" at "); |
| for (auto &&element : elements) { |
| if (abi_diff_wrappers::IgnoreSymbol<T>( |
| element, ignored_symbols_, |
| [](const T *e) {return e->GetLinkerSetKey();})) { |
| continue; |
| } |
| // The element does exist in the .dynsym table, we do not have meta-data |
| // surrounding the element. |
| const std::string &element_linker_set_key = element->GetLinkerSetKey(); |
| if ((elf_map != nullptr) && |
| (elf_map->find(element_linker_set_key) != elf_map->end())) { |
| continue; |
| } |
| if (std::regex_search(element_linker_set_key, source_file_match, |
| source_file_regex)) { |
| continue; |
| } |
| auto element_copy = *element; |
| ReplaceTypeIdsWithTypeNames(types_map, &element_copy); |
| if (!ir_diff_dumper->AddLinkableMessageIR(&element_copy, diff_kind)) { |
| llvm::errs() << "Couldn't dump added /removed element\n"; |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| template <typename T> |
| bool HeaderAbiDiff::DumpDiffElements( |
| std::vector<std::pair<const T *,const T *>> &pairs, |
| const AbiElementMap<const abi_util::TypeIR *> &old_types, |
| const AbiElementMap<const abi_util::TypeIR *> &new_types, |
| abi_util::IRDiffDumper *ir_diff_dumper, |
| abi_util::IRDiffDumper::DiffKind diff_kind) { |
| for (auto &&pair : pairs) { |
| const T *old_element = pair.first; |
| const T *new_element = pair.second; |
| |
| if (abi_diff_wrappers::IgnoreSymbol<T>( |
| old_element, ignored_symbols_, |
| [](const T *e) {return e->GetLinkerSetKey();})) { |
| continue; |
| } |
| abi_diff_wrappers::DiffWrapper<T> diff_wrapper(old_element, new_element, |
| ir_diff_dumper, old_types, |
| new_types, &type_cache_); |
| if (!diff_wrapper.DumpDiff(diff_kind)) { |
| llvm::errs() << "Failed to diff elements\n"; |
| return false; |
| } |
| } |
| return true; |
| } |
