| // 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 "diff/abi_diff.h" |
| |
| #include "utils/config_file.h" |
| |
| #include <llvm/ADT/SmallString.h> |
| #include <llvm/Support/CommandLine.h> |
| #include <llvm/Support/FileSystem.h> |
| #include <llvm/Support/Path.h> |
| #include <llvm/Support/raw_ostream.h> |
| |
| #include <fstream> |
| |
| |
| using header_checker::diff::HeaderAbiDiff; |
| using header_checker::repr::CompatibilityStatusIR; |
| using header_checker::repr::DiffPolicyOptions; |
| using header_checker::repr::TextFormatIR; |
| using header_checker::utils::ConfigFile; |
| using header_checker::utils::ConfigSection; |
| |
| |
| static llvm::cl::OptionCategory header_checker_category( |
| "header-abi-diff options"); |
| |
| static llvm::cl::opt<std::string> compatibility_report( |
| "o", llvm::cl::desc("<compatibility report>"), llvm::cl::Required, |
| llvm::cl::cat(header_checker_category)); |
| |
| static llvm::cl::opt<std::string> lib_name( |
| "lib", llvm::cl::desc("<lib name>"), llvm::cl::Required, |
| llvm::cl::cat(header_checker_category)); |
| |
| static llvm::cl::opt<std::string> arch( |
| "arch", llvm::cl::desc("<arch>"), llvm::cl::Required, |
| llvm::cl::cat(header_checker_category)); |
| |
| static llvm::cl::opt<std::string> new_dump( |
| "new", llvm::cl::desc("<new dump>"), llvm::cl::Required, |
| llvm::cl::cat(header_checker_category)); |
| |
| static llvm::cl::opt<std::string> old_dump( |
| "old", llvm::cl::desc("<old dump>"), llvm::cl::Required, |
| llvm::cl::cat(header_checker_category)); |
| |
| static llvm::cl::opt<std::string> ignore_symbol_list( |
| "ignore-symbols", llvm::cl::desc("ignore symbols"), llvm::cl::Optional, |
| llvm::cl::cat(header_checker_category)); |
| |
| static llvm::cl::opt<bool> advice_only( |
| "advice-only", llvm::cl::desc("Advisory mode only"), llvm::cl::Optional, |
| llvm::cl::cat(header_checker_category)); |
| |
| static llvm::cl::opt<bool> elf_unreferenced_symbol_errors( |
| "elf-unreferenced-symbol-errors", |
| llvm::cl::desc("This option is deprecated and has no effect."), |
| llvm::cl::Optional, llvm::cl::cat(header_checker_category)); |
| |
| static llvm::cl::opt<bool> check_all_apis( |
| "check-all-apis", |
| llvm::cl::desc("All apis, whether referenced or not, by exported symbols in" |
| " the dynsym table of a shared library are checked"), |
| llvm::cl::Optional, llvm::cl::cat(header_checker_category)); |
| |
| static llvm::cl::opt<bool> allow_extensions( |
| "allow-extensions", |
| llvm::cl::desc("Do not return a non zero status on extensions"), |
| llvm::cl::Optional, llvm::cl::cat(header_checker_category)); |
| |
| static llvm::cl::opt<bool> allow_unreferenced_elf_symbol_changes( |
| "allow-unreferenced-elf-symbol-changes", |
| llvm::cl::desc("Do not return a non zero status on changes to elf symbols" |
| "not referenced by metadata in exported headers"), |
| llvm::cl::Optional, llvm::cl::cat(header_checker_category)); |
| |
| static llvm::cl::opt<bool> allow_unreferenced_changes( |
| "allow-unreferenced-changes", |
| llvm::cl::desc("Do not return a non zero status on changes to data" |
| " structures which are not directly referenced by exported" |
| " APIs."), |
| llvm::cl::Optional, llvm::cl::cat(header_checker_category)); |
| |
| static llvm::cl::opt<bool> allow_adding_removing_referenced_apis( |
| "allow-adding-removing-referenced-apis", |
| llvm::cl::desc("Do not return a non zero status on addition or removal of " |
| "functions and variables that have corresponding symbols. " |
| "This option ignores the functions built in runtime " |
| "libraries and may not be declared in headers."), |
| llvm::cl::Optional, llvm::cl::cat(header_checker_category)); |
| |
| static llvm::cl::opt<bool> consider_opaque_types_different( |
| "consider-opaque-types-different", |
| llvm::cl::desc("Consider opaque types with different names as different. " |
| "This should not be used while comparing C++ library ABIs"), |
| llvm::cl::Optional, llvm::cl::cat(header_checker_category)); |
| |
| static llvm::cl::opt<TextFormatIR> text_format_old( |
| "input-format-old", llvm::cl::desc("Specify input format of old abi dump"), |
| llvm::cl::values(clEnumValN(TextFormatIR::ProtobufTextFormat, |
| "ProtobufTextFormat", "ProtobufTextFormat"), |
| clEnumValN(TextFormatIR::Json, "Json", "JSON")), |
| llvm::cl::init(TextFormatIR::Json), |
| llvm::cl::cat(header_checker_category)); |
| |
| static llvm::cl::opt<TextFormatIR> text_format_new( |
| "input-format-new", llvm::cl::desc("Specify input format of new abi dump"), |
| llvm::cl::values(clEnumValN(TextFormatIR::ProtobufTextFormat, |
| "ProtobufTextFormat", "ProtobufTextFormat"), |
| clEnumValN(TextFormatIR::Json, "Json", "JSON")), |
| llvm::cl::init(TextFormatIR::Json), |
| llvm::cl::cat(header_checker_category)); |
| |
| static llvm::cl::opt<TextFormatIR> text_format_diff( |
| "text-format-diff", llvm::cl::desc("Specify text format of abi-diff"), |
| llvm::cl::values(clEnumValN(TextFormatIR::ProtobufTextFormat, |
| "ProtobufTextFormat", "ProtobufTextFormat")), |
| llvm::cl::init(TextFormatIR::ProtobufTextFormat), |
| llvm::cl::cat(header_checker_category)); |
| |
| static llvm::cl::opt<bool> allow_adding_removing_weak_symbols( |
| "allow-adding-removing-weak-symbols", |
| llvm::cl::desc("Do not treat addition or removal of weak symbols as " |
| "incompatible changes."), |
| llvm::cl::init(false), llvm::cl::Optional, |
| llvm::cl::cat(header_checker_category)); |
| |
| static llvm::cl::opt<std::string> target_version( |
| "target-version", |
| llvm::cl::desc( |
| "Load the flags for <target version> and <lib name> from config.json in " |
| "the old dump's parent directory." |
| ), |
| llvm::cl::init("current"), llvm::cl::Optional, |
| llvm::cl::cat(header_checker_category)); |
| |
| static llvm::cl::list<std::string> ignore_linker_set_keys( |
| "ignore-linker-set-key", |
| llvm::cl::desc("Ignore a specific type or function in the comparison."), |
| llvm::cl::ZeroOrMore, llvm::cl::cat(header_checker_category)); |
| |
| static std::set<std::string> LoadIgnoredSymbols(std::string &symbol_list_path) { |
| std::ifstream symbol_ifstream(symbol_list_path); |
| std::set<std::string> ignored_symbols; |
| if (!symbol_ifstream) { |
| llvm::errs() << "Failed to open file containing symbols to ignore\n"; |
| ::exit(1); |
| } |
| std::string line = ""; |
| while (std::getline(symbol_ifstream, line)) { |
| ignored_symbols.insert(line); |
| } |
| return ignored_symbols; |
| } |
| |
| static std::string GetConfigFilePath(const std::string &dump_file_path) { |
| llvm::SmallString<128> config_file_path(dump_file_path); |
| llvm::sys::path::remove_filename(config_file_path); |
| llvm::sys::path::append(config_file_path, "config.json"); |
| return std::string(config_file_path); |
| } |
| |
| static void UpdateFlags(const ConfigSection §ion) { |
| for (auto &&i : section.GetIgnoredLinkerSetKeys()) { |
| ignore_linker_set_keys.push_back(i); |
| } |
| for (auto &&p : section) { |
| auto &&key = p.first; |
| bool value_bool = p.second; |
| if (key == "allow_adding_removing_weak_symbols") { |
| allow_adding_removing_weak_symbols = value_bool; |
| } else if (key == "advice_only") { |
| advice_only = value_bool; |
| } else if (key == "elf_unreferenced_symbol_errors") { |
| elf_unreferenced_symbol_errors = value_bool; |
| } else if (key == "check_all_apis") { |
| check_all_apis = value_bool; |
| } else if (key == "allow_extensions") { |
| allow_extensions = value_bool; |
| } else if (key == "allow_unreferenced_elf_symbol_changes") { |
| allow_unreferenced_elf_symbol_changes = value_bool; |
| } else if (key == "allow_unreferenced_changes") { |
| allow_unreferenced_changes = value_bool; |
| } else if (key == "allow_adding_removing_referenced_apis") { |
| allow_adding_removing_referenced_apis = value_bool; |
| } else if (key == "consider_opaque_types_different") { |
| consider_opaque_types_different = value_bool; |
| } |
| } |
| } |
| |
| static void ReadConfigFile(const std::string &config_file_path) { |
| ConfigFile cfg; |
| if (!cfg.Load(config_file_path)) { |
| ::exit(1); |
| } |
| if (cfg.HasGlobalSection()) { |
| UpdateFlags(cfg.GetGlobalSection()); |
| } |
| if (cfg.HasSection(lib_name, target_version)) { |
| UpdateFlags(cfg.GetSection(lib_name, target_version)); |
| } |
| } |
| |
| static std::string GetErrorMessage(CompatibilityStatusIR status) { |
| if (status & CompatibilityStatusIR::Incompatible) { |
| return "INCOMPATIBLE CHANGES"; |
| } |
| if (!allow_unreferenced_elf_symbol_changes && |
| (status & CompatibilityStatusIR::ElfIncompatible)) { |
| return "ELF Symbols not referenced by exported headers removed"; |
| } |
| if (!allow_extensions && (status & CompatibilityStatusIR::Extension)) { |
| return "EXTENDING CHANGES"; |
| } |
| if (!allow_extensions && !allow_unreferenced_elf_symbol_changes && |
| (status & CompatibilityStatusIR::ElfExtension)) { |
| return "ELF Symbols not referenced by exported headers added"; |
| } |
| if (!allow_unreferenced_changes && |
| (status & CompatibilityStatusIR::UnreferencedChanges)) { |
| return "changes in exported headers, which are not directly referenced " |
| "by exported symbols. This MIGHT be an ABI breaking change due to " |
| "internal typecasts"; |
| } |
| return ""; |
| } |
| |
| int main(int argc, const char **argv) { |
| llvm::cl::ParseCommandLineOptions(argc, argv, "header-checker"); |
| |
| const std::string config_file_path = GetConfigFilePath(old_dump); |
| if (llvm::sys::fs::exists(config_file_path)) { |
| ReadConfigFile(config_file_path); |
| } |
| |
| std::set<std::string> ignored_symbols; |
| if (llvm::sys::fs::exists(ignore_symbol_list)) { |
| ignored_symbols = LoadIgnoredSymbols(ignore_symbol_list); |
| } |
| |
| std::set<std::string> ignored_linker_set_keys_set( |
| ignore_linker_set_keys.begin(), ignore_linker_set_keys.end()); |
| |
| const DiffPolicyOptions diff_policy_options{ |
| .consider_opaque_types_different = consider_opaque_types_different, |
| .allow_adding_removing_referenced_apis = |
| allow_adding_removing_referenced_apis}; |
| |
| HeaderAbiDiff judge(lib_name, arch, old_dump, new_dump, compatibility_report, |
| ignored_symbols, ignored_linker_set_keys_set, |
| allow_adding_removing_weak_symbols, diff_policy_options, |
| check_all_apis, text_format_old, text_format_new, |
| text_format_diff); |
| |
| CompatibilityStatusIR status = judge.GenerateCompatibilityReport(); |
| |
| std::string status_str = GetErrorMessage(status); |
| if (!status_str.empty()) { |
| llvm::errs() << "******************************************************\n" |
| << "\033[31;1merror: \033[0m" |
| << lib_name |
| << "'s ABI has " |
| << status_str |
| << ". Please check compatibility report at: " |
| << compatibility_report << "\n" |
| << "******************************************************\n"; |
| } |
| |
| return (advice_only || status_str.empty()) ? CompatibilityStatusIR::Compatible |
| : status; |
| } |
