From patchwork Mon May 4 12:34:02 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Giuliano Procida X-Patchwork-Id: 39198 From: gprocida@google.com (Giuliano Procida) Date: Mon, 4 May 2020 13:34:02 +0100 Subject: [PATCH v4 01/15] Tidy #includes in a few files. In-Reply-To: <20200504123416.243214-1-gprocida@google.com> References: <20200424092132.150547-1-gprocida@google.com> <20200504123416.243214-1-gprocida@google.com> Message-ID: <20200504123416.243214-2-gprocida@google.com> Following review of a recent change to move regex definitions into their own files, this commit ensures that #include directives are separated into categories and sorted alphabetically within the categories, subject to known ordering constraints (such as "config.h" first, "abg-internal.h" before visibility directives etc.). There are no behavioural changes. * src/abg-corpus-priv.h: Separate and sort #include directives. * src/abg-corpus.cc: Ditto. * src/abg-regex.cc: Ditto. * src/abg-suppression-priv.h: Ditto. * src/abg-suppression.cc: Ditto. Signed-off-by: Giuliano Procida Reviewed-by: Matthias Maennich --- src/abg-corpus-priv.h | 4 ++-- src/abg-corpus.cc | 12 +++++++----- src/abg-regex.cc | 3 ++- src/abg-suppression-priv.h | 4 ++-- src/abg-suppression.cc | 1 + 5 files changed, 14 insertions(+), 10 deletions(-) diff --git a/src/abg-corpus-priv.h b/src/abg-corpus-priv.h index e65f7c8f..2b42007b 100644 --- a/src/abg-corpus-priv.h +++ b/src/abg-corpus-priv.h @@ -29,9 +29,9 @@ #ifndef __ABG_CORPUS_PRIV_H__ #define __ABG_CORPUS_PRIV_H__ -#include "abg-sptr-utils.h" -#include "abg-regex.h" #include "abg-internal.h" +#include "abg-regex.h" +#include "abg-sptr-utils.h" namespace abigail { diff --git a/src/abg-corpus.cc b/src/abg-corpus.cc index 2dcc0ac7..7f763d56 100644 --- a/src/abg-corpus.cc +++ b/src/abg-corpus.cc @@ -21,23 +21,25 @@ /// @file #include "config.h" + +#include +#include #include #include -#include #include -#include #include "abg-cxx-compat.h" #include "abg-internal.h" + // ABG_BEGIN_EXPORT_DECLARATIONS -#include "abg-sptr-utils.h" -#include "abg-ir.h" #include "abg-corpus.h" +#include "abg-ir.h" #include "abg-reader.h" -#include "abg-writer.h" +#include "abg-sptr-utils.h" #include "abg-tools-utils.h" +#include "abg-writer.h" #if WITH_ZIP_ARCHIVE #include "abg-libzip-utils.h" diff --git a/src/abg-regex.cc b/src/abg-regex.cc index 79a89033..cf0663a2 100644 --- a/src/abg-regex.cc +++ b/src/abg-regex.cc @@ -24,8 +24,9 @@ /// #include -#include "abg-sptr-utils.h" + #include "abg-regex.h" +#include "abg-sptr-utils.h" namespace abigail { diff --git a/src/abg-suppression-priv.h b/src/abg-suppression-priv.h index c37ceff6..0ccfde05 100644 --- a/src/abg-suppression-priv.h +++ b/src/abg-suppression-priv.h @@ -29,9 +29,9 @@ #define __ABG_SUPPRESSION_PRIV_H__ #include "abg-fwd.h" -#include "abg-suppression.h" -#include "abg-sptr-utils.h" #include "abg-regex.h" +#include "abg-sptr-utils.h" +#include "abg-suppression.h" namespace abigail { diff --git a/src/abg-suppression.cc b/src/abg-suppression.cc index 34eb9616..8b5712fb 100644 --- a/src/abg-suppression.cc +++ b/src/abg-suppression.cc @@ -26,6 +26,7 @@ /// libabigail. #include + #include "abg-cxx-compat.h" #include "abg-internal.h" From patchwork Mon May 4 12:34:03 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Giuliano Procida X-Patchwork-Id: 39197 From: gprocida@google.com (Giuliano Procida) Date: Mon, 4 May 2020 13:34:03 +0100 Subject: [PATCH v4 02/15] Document ^_^ regex in generate_from_strings. In-Reply-To: <20200504123416.243214-1-gprocida@google.com> References: <20200424092132.150547-1-gprocida@google.com> <20200504123416.243214-1-gprocida@google.com> Message-ID: <20200504123416.243214-3-gprocida@google.com> Following review of the change to simplify generation of symbol whitelist regexes, this commit clarifies the purpose of the ^_^ regex as one which will not match any string. * src/abg-regex.cc (generate_from_strings): Document ^_^ regex. Signed-off-by: Giuliano Procida Reviewed-by: Matthias Maennich --- src/abg-regex.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/src/abg-regex.cc b/src/abg-regex.cc index cf0663a2..0451d111 100644 --- a/src/abg-regex.cc +++ b/src/abg-regex.cc @@ -69,6 +69,7 @@ std::string generate_from_strings(const std::vector& strs) { if (strs.empty()) + // This cute-looking regex does not match any string. return "^_^"; std::ostringstream os; std::vector::const_iterator i = strs.begin(); From patchwork Mon May 4 12:34:04 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Giuliano Procida X-Patchwork-Id: 39203 From: gprocida@google.com (Giuliano Procida) Date: Mon, 4 May 2020 13:34:04 +0100 Subject: [PATCH v4 03/15] Escape names used in symbol whitelisting regex. In-Reply-To: <20200504123416.243214-1-gprocida@google.com> References: <20200424092132.150547-1-gprocida@google.com> <20200504123416.243214-1-gprocida@google.com> Message-ID: <20200504123416.243214-4-gprocida@google.com> There is the theoretical possibility that symbols may contain special regex characters like '.' and '$'. This patch ensures all such characters in symbol names are escaped before they are added to the whitelisting regex. * include/regex.h (escape): New string reference holder class. (operator<<): Declaration of std::ostream, regex::escape overload. * include/regex.cc (operator<<): New std::ostream, regex::escape overload that outputs regex-escaped strings. * src/abg-tools-utils.cc (gen_suppr_spec_from_kernel_abi_whitelists): Make sure any special regex characters in symbol names are escaped. Signed-off-by: Giuliano Procida Reviewed-by: Matthias Maennich --- include/abg-regex.h | 10 ++++++++++ src/abg-regex.cc | 28 ++++++++++++++++++++++++++-- 2 files changed, 36 insertions(+), 2 deletions(-) diff --git a/include/abg-regex.h b/include/abg-regex.h index d39ada46..164083cc 100644 --- a/include/abg-regex.h +++ b/include/abg-regex.h @@ -58,6 +58,16 @@ struct regex_t_deleter } };//end struct regex_deleter +/// A class to hold a reference to a string to regex escape. +struct escape +{ + escape(const std::string& str) : ref(str) { } + const std::string& ref; +}; + +std::ostream& +operator<<(std::ostream& os, const escape& esc); + std::string generate_from_strings(const std::vector& strs); diff --git a/src/abg-regex.cc b/src/abg-regex.cc index 0451d111..a12ecc88 100644 --- a/src/abg-regex.cc +++ b/src/abg-regex.cc @@ -24,6 +24,7 @@ /// #include +#include #include "abg-regex.h" #include "abg-sptr-utils.h" @@ -57,6 +58,29 @@ sptr_utils::build_sptr() namespace regex { +/// Escape regex special charaters in input string. +/// +/// @param os the output stream being written to. +/// +/// @param esc the regex_escape object holding a reference to the string +/// needing to be escaped. +/// +/// @return the output stream. +std::ostream& +operator<<(std::ostream& os, const escape& esc) +{ + // ']' and '}' are only conditionally special, so could be removed. + static const std::string specials = "^.[]$()|*+?{}\\"; + const std::string str = esc.ref; + for (std::string::const_iterator i = str.begin(); i != str.end(); ++i) + { + if (specials.find(*i) != std::string::npos) + os << '\\'; + os << *i; + } + return os; +} + /// Generate a regex pattern equivalent to testing set membership. /// /// A string will match the resulting pattern regex, if and only if it @@ -73,9 +97,9 @@ generate_from_strings(const std::vector& strs) return "^_^"; std::ostringstream os; std::vector::const_iterator i = strs.begin(); - os << "^(" << *i++; + os << "^(" << escape(*i++); while (i != strs.end()) - os << "|" << *i++; + os << "|" << escape(*i++); os << ")$"; return os.str(); } From patchwork Mon May 4 12:34:05 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Giuliano Procida X-Patchwork-Id: 39196 From: gprocida@google.com (Giuliano Procida) Date: Mon, 4 May 2020 13:34:05 +0100 Subject: [PATCH v4 04/15] abg-suppression.cc: More uniform variable naming. In-Reply-To: <20200504123416.243214-1-gprocida@google.com> References: <20200424092132.150547-1-gprocida@google.com> <20200504123416.243214-1-gprocida@google.com> Message-ID: <20200504123416.243214-5-gprocida@google.com> In abg-suppression.cc most of the read_*_suppression functions populate and return a single variable "result". Others vary a little from this, having variables "nil" or "suppr". This patch makes all the functions use a single variable "result". This will make the next patches a bit simpler. There are no behavioural changes. * src/abg-suppression.cc (read_type_suppression): Rename "nil" variable to "result" and reset it instead of introducing "suppr" later on. (read_function_suppression): Rename "nil" variable to "result" and reset it instead of introducing "result" later on. Reviewed-by: Matthias Maennich Signed-off-by: Giuliano Procida --- src/abg-suppression.cc | 64 +++++++++++++++++++++--------------------- 1 file changed, 32 insertions(+), 32 deletions(-) diff --git a/src/abg-suppression.cc b/src/abg-suppression.cc index 8b5712fb..217ec5e9 100644 --- a/src/abg-suppression.cc +++ b/src/abg-suppression.cc @@ -1542,10 +1542,10 @@ read_suppression_reach_kind(const string& input) static type_suppression_sptr read_type_suppression(const ini::config::section& section) { - type_suppression_sptr nil; + type_suppression_sptr result; if (section.get_name() != "suppress_type") - return nil; + return result; ini::simple_property_sptr drop_artifact = is_simple_property(section.find_property("drop_artifact")); @@ -1669,7 +1669,7 @@ read_type_suppression(const ini::config::section& section) type_suppression::insertion_range::create_fn_call_expr_boundary(ini::read_function_call_expr(ins_point))) begin = expr; else - return nil; + return result; end = type_suppression::insertion_range::create_integer_boundary(-1); type_suppression::insertion_range_sptr insert_range @@ -1712,7 +1712,7 @@ read_type_suppression(const ini::config::section& section) type_suppression::insertion_range::create_fn_call_expr_boundary(ini::read_function_call_expr(str))) begin = expr; else - return nil; + return result; str = val->get_content()[1]; if (str == "end") @@ -1725,7 +1725,7 @@ read_type_suppression(const ini::config::section& section) type_suppression::insertion_range::create_fn_call_expr_boundary(ini::read_function_call_expr(str))) end = expr; else - return nil; + return result; type_suppression::insertion_range_sptr insert_range (new type_suppression::insertion_range(begin, end)); @@ -1736,7 +1736,7 @@ read_type_suppression(const ini::config::section& section) // the 'has_data_member_inserted_between' property has a wrong // value type, so let's discard the endire [suppress_type] // section. - return nil; + return result; } // Support has_data_members_inserted_between @@ -1787,7 +1787,7 @@ read_type_suppression(const ini::config::section& section) type_suppression::insertion_range::create_fn_call_expr_boundary(ini::read_function_call_expr(str))) begin = expr; else - return nil; + return result; str = list_value->get_content()[1]; if (str == "end") @@ -1800,7 +1800,7 @@ read_type_suppression(const ini::config::section& section) type_suppression::insertion_range::create_fn_call_expr_boundary(ini::read_function_call_expr(str))) end = expr; else - return nil; + return result; type_suppression::insertion_range_sptr insert_range (new type_suppression::insertion_range(begin, end)); @@ -1808,7 +1808,7 @@ read_type_suppression(const ini::config::section& section) consider_data_member_insertion = true; } if (!is_well_formed) - return nil; + return result; } /// Support 'changed_enumerators = foo, bar, baz' @@ -1846,59 +1846,58 @@ read_type_suppression(const ini::config::section& section) && !consider_type_kind && srcloc_not_regexp_str.empty() && srcloc_not_in.empty()) - return nil; + return result; + + result.reset(new type_suppression(label_str, name_regex_str, name_str)); - type_suppression_sptr suppr(new type_suppression(label_str, - name_regex_str, - name_str)); if (consider_type_kind) { - suppr->set_consider_type_kind(true); - suppr->set_type_kind(type_kind); + result->set_consider_type_kind(true); + result->set_type_kind(type_kind); } if (consider_reach_kind) { - suppr->set_consider_reach_kind(true); - suppr->set_reach_kind(reach_kind); + result->set_consider_reach_kind(true); + result->set_reach_kind(reach_kind); } if (consider_data_member_insertion) - suppr->set_data_member_insertion_ranges(insert_ranges); + result->set_data_member_insertion_ranges(insert_ranges); if (!name_not_regex_str.empty()) - suppr->set_type_name_not_regex_str(name_not_regex_str); + result->set_type_name_not_regex_str(name_not_regex_str); if (!file_name_regex_str.empty()) - suppr->set_file_name_regex_str(file_name_regex_str); + result->set_file_name_regex_str(file_name_regex_str); if (!file_name_not_regex_str.empty()) - suppr->set_file_name_not_regex_str(file_name_not_regex_str); + result->set_file_name_not_regex_str(file_name_not_regex_str); if (!soname_regex_str.empty()) - suppr->set_soname_regex_str(soname_regex_str); + result->set_soname_regex_str(soname_regex_str); if (!soname_not_regex_str.empty()) - suppr->set_soname_not_regex_str(soname_not_regex_str); + result->set_soname_not_regex_str(soname_not_regex_str); if (!srcloc_not_in.empty()) - suppr->set_source_locations_to_keep(srcloc_not_in); + result->set_source_locations_to_keep(srcloc_not_in); if (!srcloc_not_regexp_str.empty()) - suppr->set_source_location_to_keep_regex_str(srcloc_not_regexp_str); + result->set_source_location_to_keep_regex_str(srcloc_not_regexp_str); if ((drop_artifact_str == "yes" || drop_artifact_str == "true") && ((!name_regex_str.empty() || !name_str.empty() || !srcloc_not_regexp_str.empty() || !srcloc_not_in.empty()))) - suppr->set_drops_artifact_from_ir(true); + result->set_drops_artifact_from_ir(true); - if (suppr->get_type_kind() == type_suppression::ENUM_TYPE_KIND + if (result->get_type_kind() == type_suppression::ENUM_TYPE_KIND && !changed_enumerator_names.empty()) - suppr->set_changed_enumerator_names(changed_enumerator_names); + result->set_changed_enumerator_names(changed_enumerator_names); - return suppr; + return result; } // @@ -3153,10 +3152,10 @@ read_parameter_spec_from_string(const string& str) static function_suppression_sptr read_function_suppression(const ini::config::section& section) { - function_suppression_sptr nil; + function_suppression_sptr result; if (section.get_name() != "suppress_function") - return nil; + return result; ini::simple_property_sptr drop_artifact = is_simple_property(section.find_property("drop_artifact")); @@ -3284,7 +3283,6 @@ read_function_suppression(const ini::config::section& section) parms.push_back(parm); } - function_suppression_sptr result; if (!label_str.empty() || !name.empty() || !name_regex_str.empty() @@ -3301,6 +3299,7 @@ read_function_suppression(const ini::config::section& section) || !sym_version.empty() || !sym_ver_regex_str.empty() || !parms.empty()) + result.reset(new function_suppression(label_str, name, name_regex_str, return_type_name, @@ -4337,6 +4336,7 @@ read_file_suppression(const ini::config::section& section) && soname_regex_str.empty() && soname_not_regex_str.empty()) return result; + result.reset(new file_suppression(label_str, file_name_regex_str, file_name_not_regex_str)); From patchwork Mon May 4 12:34:06 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Giuliano Procida X-Patchwork-Id: 39200 From: gprocida@google.com (Giuliano Procida) Date: Mon, 4 May 2020 13:34:06 +0100 Subject: [PATCH v4 05/15] diff suppression: Fix handling of change kinds. In-Reply-To: <20200504123416.243214-1-gprocida@google.com> References: <20200424092132.150547-1-gprocida@google.com> <20200504123416.243214-1-gprocida@google.com> Message-ID: <20200504123416.243214-6-gprocida@google.com> When parsing suppression specifications, libabigail attempts to detect and ignore suppressions that are empty and so would match everything in their category by default. Unfortunately, with the way the parser currently works, these checks have to be against an exhaustive list of fields that matter, rather than by listing the fields that don't (like label). They are fragile in the face of changes that add new fields. Two of the short-cut checks are in fact buggy, missing out the change_kind field. One of the checks also risks a null pointer dereference as it doesn't actually trigger a return from the function. This patch eliminates (rather than fixes up) this short-cutting on the grounds that it is a maintenance burden and inconsistent behaviour. Users should be able to do this: [suppress_variable] label = Suppress all changes to variables We could reinstate the logic when the code has global knowledge of which fields are present and which have no suppression (restriction) semantics, or perhaps just emit a warning message to the user if they have supplied a completely empty (no label even) specification. The patch also corrects 4 affected test cases to reflect that suppression is actually happening (according to change_kind). * src/abg-suppression.cc (read_type_suppression): Remove short-circuiting of useless suppressions. (read_function_suppression): Ditto. (read_variable_suppression: Ditto. (read_file_suppression): Ditto. tests/data/test-diff-suppr/test15-suppr-added-fn-report-5.txt: Fix test - something is actually suppressed. * tests/data/test-diff-suppr/test16-suppr-removed-fn-report-5.txt: Ditto. * tests/data/test-diff-suppr/test17-suppr-added-var-report-5.txt: Ditto. * tests/data/test-diff-suppr/test18-suppr-removed-var-report-5.txt: Ditto. Signed-off-by: Giuliano Procida Reviewed-by: Matthias Maennich --- src/abg-suppression.cc | 91 +++++-------------- .../test15-suppr-added-fn-report-5.txt | 6 +- .../test16-suppr-removed-fn-report-5.txt | 15 +-- .../test17-suppr-added-var-report-5.txt | 15 +-- .../test18-suppr-removed-var-report-5.txt | 15 +-- 5 files changed, 26 insertions(+), 116 deletions(-) diff --git a/src/abg-suppression.cc b/src/abg-suppression.cc index 217ec5e9..51885cf2 100644 --- a/src/abg-suppression.cc +++ b/src/abg-suppression.cc @@ -1835,19 +1835,6 @@ read_type_suppression(const ini::config::section& section) changed_enumerator_names.push_back(p->get_value()->as_string()); } - if (file_name_regex_str.empty() - && file_name_not_regex_str.empty() - && soname_regex_str.empty() - && soname_not_regex_str.empty() - && (!name_regex_prop || name_regex_prop->get_value()->as_string().empty()) - && (!name_not_regex_prop - || name_not_regex_prop->get_value()->as_string().empty()) - && (!name_prop || name_prop->get_value()->as_string().empty()) - && !consider_type_kind - && srcloc_not_regexp_str.empty() - && srcloc_not_in.empty()) - return result; - result.reset(new type_suppression(label_str, name_regex_str, name_str)); if (consider_type_kind) @@ -3283,32 +3270,16 @@ read_function_suppression(const ini::config::section& section) parms.push_back(parm); } - if (!label_str.empty() - || !name.empty() - || !name_regex_str.empty() - || !name_not_regex_str.empty() - || !file_name_regex_str.empty() - || !file_name_not_regex_str.empty() - || !soname_regex_str.empty() - || !soname_not_regex_str.empty() - || !return_type_name.empty() - || !return_type_regex_str.empty() - || !sym_name.empty() - || !sym_name_regex_str.empty() - || !sym_name_not_regex_str.empty() - || !sym_version.empty() - || !sym_ver_regex_str.empty() - || !parms.empty()) - - result.reset(new function_suppression(label_str, name, - name_regex_str, - return_type_name, - return_type_regex_str, - parms, - sym_name, - sym_name_regex_str, - sym_version, - sym_ver_regex_str)); + result.reset(new function_suppression(label_str, + name, + name_regex_str, + return_type_name, + return_type_regex_str, + parms, + sym_name, + sym_name_regex_str, + sym_version, + sym_ver_regex_str)); if ((drop_artifact_str == "yes" || drop_artifact_str == "true") && (!name.empty() @@ -3319,11 +3290,11 @@ read_function_suppression(const ini::config::section& section) || !sym_name_not_regex_str.empty())) result->set_drops_artifact_from_ir(true); - if (result && !change_kind_str.empty()) + if (!change_kind_str.empty()) result->set_change_kind (function_suppression::parse_change_kind(change_kind_str)); - if (result && !allow_other_aliases.empty()) + if (!allow_other_aliases.empty()) result->set_allow_other_aliases(allow_other_aliases == "yes" || allow_other_aliases == "true"); @@ -4151,27 +4122,15 @@ read_variable_suppression(const ini::config::section& section) ? type_name_regex_prop->get_value()->as_string() : ""; - if (label_str.empty() - && name_str.empty() - && name_regex_str.empty() - && name_not_regex_str.empty() - && file_name_regex_str.empty() - && file_name_not_regex_str.empty() - && soname_regex_str.empty() - && soname_not_regex_str.empty() - && symbol_name.empty() - && symbol_name_regex_str.empty() - && symbol_name_not_regex_str.empty() - && symbol_version.empty() - && symbol_version_regex_str.empty() - && type_name_str.empty() - && type_name_regex_str.empty()) - return result; - - result.reset(new variable_suppression(label_str, name_str, name_regex_str, - symbol_name, symbol_name_regex_str, - symbol_version, symbol_version_regex_str, - type_name_str, type_name_regex_str)); + result.reset(new variable_suppression(label_str, + name_str, + name_regex_str, + symbol_name, + symbol_name_regex_str, + symbol_version, + symbol_version_regex_str, + type_name_str, + type_name_regex_str)); if ((drop_artifact_str == "yes" || drop_artifact_str == "true") && (!name_str.empty() @@ -4188,7 +4147,7 @@ read_variable_suppression(const ini::config::section& section) if (!symbol_name_not_regex_str.empty()) result->set_symbol_name_not_regex_str(symbol_name_not_regex_str); - if (result && !change_kind_str.empty()) + if (!change_kind_str.empty()) result->set_change_kind (variable_suppression::parse_change_kind(change_kind_str)); @@ -4331,12 +4290,6 @@ read_file_suppression(const ini::config::section& section) ? soname_not_regex_prop->get_value()->as_string() : ""; - if (file_name_regex_str.empty() - && file_name_not_regex_str.empty() - && soname_regex_str.empty() - && soname_not_regex_str.empty()) - return result; - result.reset(new file_suppression(label_str, file_name_regex_str, file_name_not_regex_str)); diff --git a/tests/data/test-diff-suppr/test15-suppr-added-fn-report-5.txt b/tests/data/test-diff-suppr/test15-suppr-added-fn-report-5.txt index 4eaba5b7..83dfe326 100644 --- a/tests/data/test-diff-suppr/test15-suppr-added-fn-report-5.txt +++ b/tests/data/test-diff-suppr/test15-suppr-added-fn-report-5.txt @@ -1,10 +1,6 @@ -Functions changes summary: 0 Removed, 1 Changed, 1 Added functions +Functions changes summary: 0 Removed, 1 Changed, 0 Added (1 filtered out) functions Variables changes summary: 0 Removed, 0 Changed, 0 Added variable -1 Added function: - - [A] 'function void bar()' {_Z3barv} - 1 function with some indirect sub-type change: [C] 'function void bar(S&)' has some indirect sub-type changes: diff --git a/tests/data/test-diff-suppr/test16-suppr-removed-fn-report-5.txt b/tests/data/test-diff-suppr/test16-suppr-removed-fn-report-5.txt index b28fbd16..851f7728 100644 --- a/tests/data/test-diff-suppr/test16-suppr-removed-fn-report-5.txt +++ b/tests/data/test-diff-suppr/test16-suppr-removed-fn-report-5.txt @@ -1,16 +1,3 @@ -Functions changes summary: 1 Removed, 1 Changed, 0 Added functions +Functions changes summary: 0 Removed (1 filtered out), 0 Changed (1 filtered out), 0 Added functions Variables changes summary: 0 Removed, 0 Changed, 0 Added variable -1 Removed function: - - [D] 'function void bar()' {_Z3barv} - -1 function with some indirect sub-type change: - - [C] 'function void bar(S*)' has some indirect sub-type changes: - parameter 1 of type 'S*' has sub-type changes: - in pointed to type 'struct S': - type size changed from 32 to 64 (in bits) - 1 data member insertion: - 'unsigned int S::bar', at offset 32 (in bits) - diff --git a/tests/data/test-diff-suppr/test17-suppr-added-var-report-5.txt b/tests/data/test-diff-suppr/test17-suppr-added-var-report-5.txt index 6965a151..f4e0aa29 100644 --- a/tests/data/test-diff-suppr/test17-suppr-added-var-report-5.txt +++ b/tests/data/test-diff-suppr/test17-suppr-added-var-report-5.txt @@ -1,16 +1,3 @@ Functions changes summary: 0 Removed, 0 Changed, 0 Added function -Variables changes summary: 0 Removed, 1 Changed, 1 Added variables - -1 Added variable: - - [A] 'int var1' {var1} - -1 Changed variable: - - [C] 'S* var0' was changed: - type of variable changed: - in pointed to type 'struct S': - type size changed from 32 to 64 (in bits) - 1 data member insertion: - 'char S::m1', at offset 32 (in bits) +Variables changes summary: 0 Removed, 0 Changed (1 filtered out), 0 Added (1 filtered out) variables diff --git a/tests/data/test-diff-suppr/test18-suppr-removed-var-report-5.txt b/tests/data/test-diff-suppr/test18-suppr-removed-var-report-5.txt index 3edf2bd1..ac380a4a 100644 --- a/tests/data/test-diff-suppr/test18-suppr-removed-var-report-5.txt +++ b/tests/data/test-diff-suppr/test18-suppr-removed-var-report-5.txt @@ -1,16 +1,3 @@ Functions changes summary: 0 Removed, 0 Changed, 0 Added function -Variables changes summary: 1 Removed, 1 Changed, 0 Added variables - -1 Removed variable: - - [D] 'int var1' {var1} - -1 Changed variable: - - [C] 'S* var0' was changed: - type of variable changed: - in pointed to type 'struct S': - type size changed from 32 to 64 (in bits) - 1 data member insertion: - 'char S::m1', at offset 32 (in bits) +Variables changes summary: 0 Removed (1 filtered out), 0 Changed (1 filtered out), 0 Added variables From patchwork Mon May 4 12:34:07 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Giuliano Procida X-Patchwork-Id: 39201 From: gprocida@google.com (Giuliano Procida) Date: Mon, 4 May 2020 13:34:07 +0100 Subject: [PATCH v4 06/15] Add POSIX regex wrapper functions. In-Reply-To: <20200504123416.243214-1-gprocida@google.com> References: <20200424092132.150547-1-gprocida@google.com> <20200504123416.243214-1-gprocida@google.com> Message-ID: <20200504123416.243214-7-gprocida@google.com> libabigail code uses the POSIX regex library consistently: - compile std::string to regex, with the flag REG_EXTENDED - store regex using a shared pointer wrapper - check match of regex against std::string All the C string / std::string logic and so on is repeated at every call site. This patch introduces wrapper functions to take care of this logic. There are no behavioural changes. * include/abg-regex.h (compile): Declare new function. (match): Declare new function. * src/abg-regex.cc (compile): Add new function wrapping regcomp. (match): Add new function wrapping regexec. Reviewed-by: Matthias Maennich Signed-off-by: Giuliano Procida --- include/abg-regex.h | 6 ++++++ src/abg-regex.cc | 40 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 46 insertions(+) diff --git a/include/abg-regex.h b/include/abg-regex.h index 164083cc..7ab9fc08 100644 --- a/include/abg-regex.h +++ b/include/abg-regex.h @@ -71,6 +71,12 @@ operator<<(std::ostream& os, const escape& esc); std::string generate_from_strings(const std::vector& strs); +regex_t_sptr +compile(const std::string& str); + +bool +match(const regex_t_sptr& r, const std::string& str); + }// end namespace regex namespace sptr_utils diff --git a/src/abg-regex.cc b/src/abg-regex.cc index a12ecc88..cd7c41ce 100644 --- a/src/abg-regex.cc +++ b/src/abg-regex.cc @@ -23,12 +23,22 @@ /// Some specialization for shared pointer utility templates. /// +#include "config.h" + #include #include +#include "abg-internal.h" + +// +ABG_BEGIN_EXPORT_DECLARATIONS + #include "abg-regex.h" #include "abg-sptr-utils.h" +ABG_END_EXPORT_DECLARATIONS +// + namespace abigail { @@ -104,6 +114,36 @@ generate_from_strings(const std::vector& strs) return os.str(); } +/// Compile a regex from a string. +/// +/// The result is held in a shared pointer. This will be null if regex +/// compilation fails. +/// +/// @param str the string representation of the regex. +/// +/// @return shared pointer holder of a compiled regex object. +regex_t_sptr +compile(const std::string& str) +{ + regex_t_sptr r = sptr_utils::build_sptr(new regex_t); + if (regcomp(r.get(), str.c_str(), REG_EXTENDED)) + r.reset(); + return r; +} + +/// See if a string matches a regex. +/// +/// @param r a shared pointer holder of a compiled regex object. +/// +/// @param str a string. +/// +/// @return whether there was a match. +bool +match(const regex_t_sptr& r, const std::string& str) +{ + return !regexec(r.get(), str.c_str(), 0, NULL, 0); +} + }//end namespace regex }//end namespace abigail From patchwork Mon May 4 12:34:08 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Giuliano Procida X-Patchwork-Id: 39202 From: gprocida@google.com (Giuliano Procida) Date: Mon, 4 May 2020 13:34:08 +0100 Subject: [PATCH v4 07/15] Use regex::compile wrapper instead of regcomp. In-Reply-To: <20200504123416.243214-1-gprocida@google.com> References: <20200424092132.150547-1-gprocida@google.com> <20200504123416.243214-1-gprocida@google.com> Message-ID: <20200504123416.243214-8-gprocida@google.com> This patch eliminates all calls to regcomp except that by regex::compile itself. * src/abg-corpus-priv.h: Mechanically substitute use of regcomp with regex::compile wrapper. * src/abg-suppression-priv.h: Ditto. There are no behavioural changes. Reviewed-by: Matthias Maennich Signed-off-by: Giuliano Procida --- src/abg-corpus-priv.h | 16 +-- src/abg-suppression-priv.h | 198 ++++++------------------------------- 2 files changed, 38 insertions(+), 176 deletions(-) diff --git a/src/abg-corpus-priv.h b/src/abg-corpus-priv.h index 2b42007b..f408e453 100644 --- a/src/abg-corpus-priv.h +++ b/src/abg-corpus-priv.h @@ -123,8 +123,8 @@ public: i != fns_suppress_regexps_.end(); ++i) { - regex_t_sptr r = sptr_utils::build_sptr(new regex_t); - if (regcomp(r.get(), i->c_str(), REG_EXTENDED) == 0) + regex_t_sptr r = regex::compile(*i); + if (r) compiled_fns_suppress_regexp_.push_back(r); } } @@ -145,8 +145,8 @@ public: i != fns_keep_regexps_.end(); ++i) { - regex_t_sptr r = sptr_utils::build_sptr(new regex_t); - if (regcomp(r.get(), i->c_str(), REG_EXTENDED) == 0) + regex_t_sptr r = regex::compile(*i); + if (r) compiled_fns_keep_regexps_.push_back(r); } } @@ -167,8 +167,8 @@ public: i != vars_suppress_regexps_.end(); ++i) { - regex_t_sptr r = sptr_utils::build_sptr(new regex_t); - if (regcomp(r.get(), i->c_str(), REG_EXTENDED) == 0) + regex_t_sptr r = regex::compile(*i); + if (r) compiled_vars_suppress_regexp_.push_back(r); } } @@ -189,8 +189,8 @@ public: i != vars_keep_regexps_.end(); ++i) { - regex_t_sptr r = sptr_utils::build_sptr(new regex_t); - if (regcomp(r.get(), i->c_str(), REG_EXTENDED) == 0) + regex_t_sptr r = regex::compile(*i); + if (r) compiled_vars_keep_regexps_.push_back(r); } } diff --git a/src/abg-suppression-priv.h b/src/abg-suppression-priv.h index 0ccfde05..65d919a8 100644 --- a/src/abg-suppression-priv.h +++ b/src/abg-suppression-priv.h @@ -91,17 +91,8 @@ public: const regex::regex_t_sptr& get_file_name_regex() const { - if (!file_name_regex_) - { - if (!file_name_regex_str_.empty()) - { - regex::regex_t_sptr r = sptr_utils::build_sptr(); - if (regcomp(r.get(), - file_name_regex_str_.c_str(), - REG_EXTENDED) == 0) - file_name_regex_ = r; - } - } + if (!file_name_regex_ && !file_name_regex_str_.empty()) + file_name_regex_ = regex::compile(file_name_regex_str_); return file_name_regex_; } @@ -116,17 +107,8 @@ public: const regex::regex_t_sptr& get_file_name_not_regex() const { - if (!file_name_not_regex_) - { - if (!file_name_not_regex_str_.empty()) - { - regex::regex_t_sptr r = sptr_utils::build_sptr(); - if (regcomp(r.get(), - file_name_not_regex_str_.c_str(), - REG_EXTENDED) == 0) - file_name_not_regex_ = r; - } - } + if (!file_name_not_regex_ && !file_name_not_regex_str_.empty()) + file_name_not_regex_ = regex::compile(file_name_not_regex_str_); return file_name_not_regex_; } @@ -141,17 +123,8 @@ public: const regex::regex_t_sptr& get_soname_regex() const { - if (!soname_regex_) - { - if (!soname_regex_str_.empty()) - { - regex::regex_t_sptr r = sptr_utils::build_sptr(); - if (regcomp(r.get(), - soname_regex_str_.c_str(), - REG_EXTENDED) == 0) - soname_regex_ = r; - } - } + if (!soname_regex_ && !soname_regex_str_.empty()) + soname_regex_ = regex::compile(soname_regex_str_); return soname_regex_; } @@ -166,17 +139,8 @@ public: const regex::regex_t_sptr& get_soname_not_regex() const { - if (!soname_not_regex_) - { - if (!soname_not_regex_str_.empty()) - { - regex::regex_t_sptr r = sptr_utils::build_sptr(); - if (regcomp(r.get(), - soname_not_regex_str_.c_str(), - REG_EXTENDED) == 0) - soname_not_regex_ = r; - } - } + if (!soname_not_regex_ && !soname_not_regex_str_.empty()) + soname_not_regex_ = regex::compile(soname_not_regex_str_); return soname_not_regex_; } @@ -282,13 +246,7 @@ class function_suppression::parameter_spec::priv get_type_name_regex() const { if (!type_name_regex_ && !type_name_regex_str_.empty()) - { - regex::regex_t_sptr r = sptr_utils::build_sptr(); - if (regcomp(r.get(), - type_name_regex_str_.c_str(), - REG_EXTENDED) == 0) - type_name_regex_ = r; - } + type_name_regex_ = regex::compile(type_name_regex_str_); return type_name_regex_; } }; // end class function_suppression::parameter_spec::priv @@ -361,13 +319,7 @@ struct function_suppression::priv get_name_regex() const { if (!name_regex_ && !name_regex_str_.empty()) - { - regex::regex_t_sptr r = sptr_utils::build_sptr(); - if (regcomp(r.get(), - name_regex_str_.c_str(), - REG_EXTENDED) == 0) - name_regex_ = r; - } + name_regex_ = regex::compile(name_regex_str_); return name_regex_; } @@ -384,13 +336,7 @@ struct function_suppression::priv get_name_not_regex() const { if (!name_not_regex_ && !name_not_regex_str_.empty()) - { - regex::regex_t_sptr r = sptr_utils::build_sptr(); - if (regcomp(r.get(), - name_not_regex_str_.c_str(), - REG_EXTENDED) == 0) - name_not_regex_ = r; - } + name_not_regex_ = regex::compile(name_not_regex_str_); return name_not_regex_; } @@ -407,13 +353,7 @@ struct function_suppression::priv get_return_type_regex() const { if (!return_type_regex_ && !return_type_regex_str_.empty()) - { - regex::regex_t_sptr r = sptr_utils::build_sptr(); - if (regcomp(r.get(), - return_type_regex_str_.c_str(), - REG_EXTENDED) == 0) - return_type_regex_ = r; - } + return_type_regex_ = regex::compile(return_type_regex_str_); return return_type_regex_; } @@ -430,13 +370,7 @@ struct function_suppression::priv get_symbol_name_regex() const { if (!symbol_name_regex_ && !symbol_name_regex_str_.empty()) - { - regex::regex_t_sptr r = sptr_utils::build_sptr(); - if (regcomp(r.get(), - symbol_name_regex_str_.c_str(), - REG_EXTENDED) == 0) - symbol_name_regex_ = r; - } + symbol_name_regex_ = regex::compile(symbol_name_regex_str_); return symbol_name_regex_; } @@ -453,13 +387,7 @@ struct function_suppression::priv get_symbol_name_not_regex() const { if (!symbol_name_not_regex_ && !symbol_name_not_regex_str_.empty()) - { - regex::regex_t_sptr r = sptr_utils::build_sptr(); - if (regcomp(r.get(), - symbol_name_not_regex_str_.c_str(), - REG_EXTENDED) == 0) - symbol_name_not_regex_ = r; - } + symbol_name_not_regex_ = regex::compile(symbol_name_not_regex_str_); return symbol_name_not_regex_; } @@ -475,14 +403,8 @@ struct function_suppression::priv const regex::regex_t_sptr get_symbol_version_regex() const { - if (!symbol_version_regex_ && ! symbol_version_regex_str_.empty()) - { - regex::regex_t_sptr r = sptr_utils::build_sptr(); - if (regcomp(r.get(), - symbol_version_regex_str_.c_str(), - REG_EXTENDED) == 0) - symbol_version_regex_ = r; - } + if (!symbol_version_regex_ && !symbol_version_regex_str_.empty()) + symbol_version_regex_ = regex::compile(symbol_version_regex_str_); return symbol_version_regex_; } }; // end class function_suppression::priv @@ -609,13 +531,7 @@ struct variable_suppression::priv get_name_regex() const { if (!name_regex_ && !name_regex_str_.empty()) - { - regex::regex_t_sptr r = sptr_utils::build_sptr(); - if (regcomp(r.get(), - name_regex_str_.c_str(), - REG_EXTENDED) == 0) - name_regex_ = r; - } + name_regex_ = regex::compile(name_regex_str_); return name_regex_; } @@ -632,13 +548,7 @@ struct variable_suppression::priv get_name_not_regex() const { if (!name_not_regex_ && !name_not_regex_str_.empty()) - { - regex::regex_t_sptr r = sptr_utils::build_sptr(); - if (regcomp(r.get(), - name_not_regex_str_.c_str(), - REG_EXTENDED) == 0) - name_not_regex_ = r; - } + name_not_regex_ = regex::compile(name_not_regex_str_); return name_not_regex_; } @@ -655,13 +565,7 @@ struct variable_suppression::priv get_symbol_name_regex() const { if (!symbol_name_regex_ && !symbol_name_regex_str_.empty()) - { - regex::regex_t_sptr r = sptr_utils::build_sptr(); - if (regcomp(r.get(), - symbol_name_regex_str_.c_str(), - REG_EXTENDED) == 0) - symbol_name_regex_ = r; - } + symbol_name_regex_ = regex::compile(symbol_name_regex_str_); return symbol_name_regex_; } @@ -678,12 +582,7 @@ struct variable_suppression::priv get_symbol_name_not_regex() const { if (!symbol_name_not_regex_ && !symbol_name_not_regex_str_.empty()) - { - regex::regex_t_sptr r = sptr_utils::build_sptr(); - if (regcomp(r.get(), symbol_name_not_regex_str_.c_str(), - REG_EXTENDED) == 0) - symbol_name_not_regex_ = r; - } + symbol_name_not_regex_ = regex::compile(symbol_name_not_regex_str_); return symbol_name_not_regex_; } @@ -700,13 +599,7 @@ struct variable_suppression::priv get_symbol_version_regex() const { if (!symbol_version_regex_ && !symbol_version_regex_str_.empty()) - { - regex::regex_t_sptr r = sptr_utils::build_sptr(); - if (regcomp(r.get(), - symbol_version_regex_str_.c_str(), - REG_EXTENDED) == 0) - symbol_version_regex_ = r; - } + symbol_version_regex_ = regex::compile(symbol_version_regex_str_); return symbol_version_regex_; } @@ -723,13 +616,7 @@ struct variable_suppression::priv get_type_name_regex() const { if (!type_name_regex_ && !type_name_regex_str_.empty()) - { - regex::regex_t_sptr r = sptr_utils::build_sptr(); - if (regcomp(r.get(), - type_name_regex_str_.c_str(), - REG_EXTENDED) == 0) - type_name_regex_ = r; - } + type_name_regex_ = regex::compile(type_name_regex_str_); return type_name_regex_; } };// end class variable_supppression::priv @@ -809,17 +696,8 @@ public: const regex::regex_t_sptr get_type_name_regex() const { - if (!type_name_regex_) - { - if (!type_name_regex_str_.empty()) - { - regex::regex_t_sptr r = sptr_utils::build_sptr(); - if (regcomp(r.get(), - type_name_regex_str_.c_str(), - REG_EXTENDED) == 0) - type_name_regex_ = r; - } - } + if (!type_name_regex_ && !type_name_regex_str_.empty()) + type_name_regex_ = regex::compile(type_name_regex_str_); return type_name_regex_; } @@ -841,17 +719,8 @@ public: const regex::regex_t_sptr get_type_name_not_regex() const { - if (!type_name_not_regex_) - { - if (!type_name_not_regex_str_.empty()) - { - regex::regex_t_sptr r = sptr_utils::build_sptr(); - if (regcomp(r.get(), - type_name_not_regex_str_.c_str(), - REG_EXTENDED) == 0) - type_name_not_regex_ = r; - } - } + if (!type_name_not_regex_ && !type_name_not_regex_str_.empty()) + type_name_not_regex_ = regex::compile(type_name_not_regex_str_); return type_name_not_regex_; } @@ -886,17 +755,10 @@ public: const regex::regex_t_sptr get_source_location_to_keep_regex() const { - if (!source_location_to_keep_regex_) - { - if (!source_location_to_keep_regex_str_.empty()) - { - regex::regex_t_sptr r = sptr_utils::build_sptr(); - if (regcomp(r.get(), - source_location_to_keep_regex_str_.c_str(), - REG_EXTENDED) == 0) - source_location_to_keep_regex_ = r; - } - } + if (!source_location_to_keep_regex_ + && !source_location_to_keep_regex_str_.empty()) + source_location_to_keep_regex_ = + regex::compile(source_location_to_keep_regex_str_); return source_location_to_keep_regex_; } From patchwork Mon May 4 12:34:09 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Giuliano Procida X-Patchwork-Id: 39204 From: gprocida@google.com (Giuliano Procida) Date: Mon, 4 May 2020 13:34:09 +0100 Subject: [PATCH v4 08/15] Use regex::match wrapper instead of regexec. In-Reply-To: <20200504123416.243214-1-gprocida@google.com> References: <20200424092132.150547-1-gprocida@google.com> <20200504123416.243214-1-gprocida@google.com> Message-ID: <20200504123416.243214-9-gprocida@google.com> This patch eliminates all calls to regexec except that by regex::match itself. There are no behavioural changes. * src/abg-corpus-priv.h: Mechanically substitute use of regexec with regex::match wrapper. * src/abg-suppression-priv.h: Ditto. * src/abg-suppression.cc: Ditto. Reviewed-by: Matthias Maennich Signed-off-by: Giuliano Procida --- src/abg-corpus-priv.h | 8 +-- src/abg-suppression-priv.h | 10 ++-- src/abg-suppression.cc | 119 +++++++++++-------------------------- 3 files changed, 44 insertions(+), 93 deletions(-) diff --git a/src/abg-corpus-priv.h b/src/abg-corpus-priv.h index f408e453..ee8c8239 100644 --- a/src/abg-corpus-priv.h +++ b/src/abg-corpus-priv.h @@ -521,7 +521,7 @@ public: compiled_regex_fns_suppress().begin(); i != compiled_regex_fns_suppress().end(); ++i) - if (regexec(i->get(), frep.c_str(), 0, NULL, 0) == 0) + if (regex::match(*i, frep)) { keep = false; break; @@ -554,7 +554,7 @@ public: compiled_regex_fns_keep().begin(); i != compiled_regex_fns_keep().end(); ++i) - if (regexec(i->get(), frep.c_str(), 0, NULL, 0) == 0) + if (regex::match(*i, frep)) { keep = true; break; @@ -628,7 +628,7 @@ public: compiled_regex_vars_suppress().begin(); i != compiled_regex_vars_suppress().end(); ++i) - if (regexec(i->get(), frep.c_str(), 0, NULL, 0) == 0) + if (regex::match(*i, frep)) { keep = false; break; @@ -662,7 +662,7 @@ public: compiled_regex_vars_keep().begin(); i != compiled_regex_vars_keep().end(); ++i) - if (regexec(i->get(), frep.c_str(), 0, NULL, 0) == 0) + if (regex::match(*i, frep)) { keep = true; break; diff --git a/src/abg-suppression-priv.h b/src/abg-suppression-priv.h index 65d919a8..deb08269 100644 --- a/src/abg-suppression-priv.h +++ b/src/abg-suppression-priv.h @@ -160,14 +160,14 @@ public: if (regex::regex_t_sptr regexp = get_soname_regex()) { has_regexp = true; - if (regexec(regexp.get(), soname.c_str(), 0, NULL, 0) != 0) + if (!regex::match(regexp, soname)) return false; } if (regex::regex_t_sptr regexp = get_soname_not_regex()) { has_regexp = true; - if (regexec(regexp.get(), soname.c_str(), 0, NULL, 0) == 0) + if (regex::match(regexp, soname)) return false; } @@ -195,16 +195,14 @@ public: if (regex::regex_t_sptr regexp = get_file_name_regex()) { has_regexp = true; - if (regexec(regexp.get(), binary_name.c_str(), - 0, NULL, 0) != 0) + if (!regex::match(regexp, binary_name)) return false; } if (regex::regex_t_sptr regexp = get_file_name_not_regex()) { has_regexp = true; - if (regexec(regexp.get(), binary_name.c_str(), - 0, NULL, 0) == 0) + if (regex::match(regexp, binary_name)) return false; } diff --git a/src/abg-suppression.cc b/src/abg-suppression.cc index 51885cf2..c89201b6 100644 --- a/src/abg-suppression.cc +++ b/src/abg-suppression.cc @@ -990,18 +990,14 @@ suppression_matches_type_name(const type_suppression& s, if (const regex_t_sptr& type_name_regex = s.priv_->get_type_name_regex()) { - if (regexec(type_name_regex.get(), - type_name.c_str(), - 0, NULL, 0) != 0) + if (!regex::match(type_name_regex, type_name)) return false; } if (const regex_t_sptr type_name_not_regex = s.priv_->get_type_name_not_regex()) { - if (regexec(type_name_not_regex.get(), - type_name.c_str(), - 0, NULL, 0) == 0) + if (regex::match(type_name_not_regex, type_name)) return false; } } @@ -1048,7 +1044,7 @@ suppression_matches_type_location(const type_suppression& s, loc.expand(loc_path, loc_line, loc_column); if (regex_t_sptr regexp = s.priv_->get_source_location_to_keep_regex()) - if (regexec(regexp.get(), loc_path.c_str(), 0, NULL, 0) == 0) + if (regex::match(regexp, loc_path)) return false; tools_utils::base_name(loc_path, loc_path_base); @@ -2484,9 +2480,7 @@ function_suppression::suppresses_function(const function_decl* fn, const regex_t_sptr name_regex = priv_->get_name_regex(); if (name_regex) { - if (regexec(name_regex.get(), - fname.c_str(), - 0, NULL, 0) != 0) + if (!regex::match(name_regex, fname)) return false; if (get_allow_other_aliases() @@ -2507,9 +2501,7 @@ function_suppression::suppresses_function(const function_decl* fn, for (elf_symbol_sptr a = sym->get_next_alias(); a && !a->is_main_symbol(); a = a->get_next_alias()) - if (regexec(name_regex.get(), - a->get_name().c_str(), - 0, NULL, 0) != 0) + if (!regex::match(name_regex, a->get_name())) return false; } } @@ -2519,9 +2511,7 @@ function_suppression::suppresses_function(const function_decl* fn, const regex_t_sptr name_not_regex = priv_->get_name_not_regex(); if (name_not_regex) { - if (regexec(name_not_regex.get(), - fname.c_str(), - 0, NULL, 0) == 0) + if (regex::match(name_not_regex, fname)) return false; if (get_allow_other_aliases() @@ -2542,9 +2532,7 @@ function_suppression::suppresses_function(const function_decl* fn, for (elf_symbol_sptr a = sym->get_next_alias(); a && !a->is_main_symbol(); a = a->get_next_alias()) - if (regexec(name_regex.get(), - a->get_name().c_str(), - 0, NULL, 0) == 0) + if (regex::match(name_regex, a->get_name())) return false; } } @@ -2568,9 +2556,7 @@ function_suppression::suppresses_function(const function_decl* fn, { const regex_t_sptr return_type_regex = priv_->get_return_type_regex(); if (return_type_regex - && (regexec(return_type_regex.get(), - fn_return_type_name.c_str(), - 0, NULL, 0) != 0)) + && !regex::match(return_type_regex, fn_return_type_name)) return false; } @@ -2607,18 +2593,13 @@ function_suppression::suppresses_function(const function_decl* fn, else if (sym) { const regex_t_sptr symbol_name_regex = priv_->get_symbol_name_regex(); - if (symbol_name_regex - && (regexec(symbol_name_regex.get(), - fn_sym_name.c_str(), - 0, NULL, 0) != 0)) + if (symbol_name_regex && !regex::match(symbol_name_regex, fn_sym_name)) return false; const regex_t_sptr symbol_name_not_regex = priv_->get_symbol_name_not_regex(); if (symbol_name_not_regex - && (regexec(symbol_name_not_regex.get(), - fn_sym_name.c_str(), - 0, NULL, 0) == 0)) + && regex::match(symbol_name_not_regex, fn_sym_name)) return false; if (get_allow_other_aliases()) @@ -2633,15 +2614,11 @@ function_suppression::suppresses_function(const function_decl* fn, a = a->get_next_alias()) { if (symbol_name_regex - && (regexec(symbol_name_regex.get(), - a->get_name().c_str(), - 0, NULL, 0) != 0)) + && !regex::match(symbol_name_regex, a->get_name())) return false; if (symbol_name_not_regex - && (regexec(symbol_name_not_regex.get(), - a->get_name().c_str(), - 0, NULL, 0) == 0)) + && regex::match(symbol_name_not_regex, a->get_name())) return false; } } @@ -2660,9 +2637,7 @@ function_suppression::suppresses_function(const function_decl* fn, const regex_t_sptr symbol_version_regex = priv_->get_symbol_version_regex(); if (symbol_version_regex - && (regexec(symbol_version_regex.get(), - fn_sym_version.c_str(), - 0, NULL, 0) != 0)) + && !regex::match(symbol_version_regex, fn_sym_version)) return false; } @@ -2703,9 +2678,8 @@ function_suppression::suppresses_function(const function_decl* fn, (*p)->priv_->get_type_name_regex(); if (parm_type_name_regex) { - if ((regexec(parm_type_name_regex.get(), - fn_parm_type_qualified_name.c_str(), - 0, NULL, 0) != 0)) + if (!regex::match(parm_type_name_regex, + fn_parm_type_qualified_name)) return false; } } @@ -2793,10 +2767,7 @@ function_suppression::suppresses_function_symbol(const elf_symbol* sym, else if (!get_symbol_name_regex_str().empty()) { const regex_t_sptr symbol_name_regex = priv_->get_symbol_name_regex(); - if (symbol_name_regex - && (regexec(symbol_name_regex.get(), - sym_name.c_str(), - 0, NULL, 0) != 0)) + if (symbol_name_regex && !regex::match(symbol_name_regex, sym_name)) return false; } else @@ -2813,9 +2784,7 @@ function_suppression::suppresses_function_symbol(const elf_symbol* sym, const regex_t_sptr symbol_version_regex = priv_->get_symbol_version_regex(); if (symbol_version_regex - && (regexec(symbol_version_regex.get(), - sym_version.c_str(), - 0, NULL, 0) != 0)) + && !regex::match(symbol_version_regex, sym_version)) return false; } else @@ -2907,12 +2876,12 @@ suppression_matches_function_name(const suppr::function_suppression& s, { if (regex_t_sptr regexp = s.priv_->get_name_regex()) { - if (regexec(regexp.get(), fn_name.c_str(), 0, NULL, 0) != 0) + if (!regex::match(regexp, fn_name)) return false; } else if (regex_t_sptr regexp = s.priv_->get_name_not_regex()) { - if (regexec(regexp.get(), fn_name.c_str(), 0, NULL, 0) == 0) + if (regex::match(regexp, fn_name)) return false; } else if (s.priv_->name_.empty()) @@ -2943,12 +2912,12 @@ suppression_matches_function_sym_name(const suppr::function_suppression& s, { if (regex_t_sptr regexp = s.priv_->get_symbol_name_regex()) { - if (regexec(regexp.get(), fn_linkage_name.c_str(), 0, NULL, 0) != 0) + if (!regex::match(regexp, fn_linkage_name)) return false; } else if (regex_t_sptr regexp = s.priv_->get_symbol_name_not_regex()) { - if (regexec(regexp.get(), fn_linkage_name.c_str(), 0, NULL, 0) == 0) + if (regex::match(regexp, fn_linkage_name)) return false; } else if (s.priv_->symbol_name_.empty()) @@ -2976,12 +2945,12 @@ suppression_matches_variable_name(const suppr::variable_suppression& s, { if (regex_t_sptr regexp = s.priv_->get_name_regex()) { - if (regexec(regexp.get(), var_name.c_str(), 0, NULL, 0) != 0) + if (!regex::match(regexp, var_name)) return false; } else if (regex_t_sptr regexp = s.priv_->get_name_not_regex()) { - if (regexec(regexp.get(), var_name.c_str(), 0, NULL, 0) == 0) + if (regex::match(regexp, var_name)) return false; } else if (s.priv_->name_.empty()) @@ -3010,13 +2979,13 @@ suppression_matches_variable_sym_name(const suppr::variable_suppression& s, { if (regex_t_sptr regexp = s.priv_->get_symbol_name_regex()) { - if (regexec(regexp.get(), var_linkage_name.c_str(), 0, NULL, 0) != 0) + if (!regex::match(regexp, var_linkage_name)) return false; } else if (regex_t_sptr regexp = s.priv_->get_symbol_name_not_regex()) { - if (regexec(regexp.get(), var_linkage_name.c_str(), 0, NULL, 0) == 0) + if (regex::match(regexp, var_linkage_name)) return false; } else if (s.priv_->symbol_name_.empty()) @@ -3045,7 +3014,7 @@ suppression_matches_type(const suppr::type_suppression& s, { if (regex_t_sptr regexp = s.priv_->get_type_name_regex()) { - if (regexec(regexp.get(), type_name.c_str(), 0, NULL, 0) != 0) + if (!regex::match(regexp, type_name)) return false; } else if (!s.get_type_name().empty()) @@ -3743,15 +3712,11 @@ variable_suppression::suppresses_variable(const var_decl* var, if (get_name().empty()) { const regex_t_sptr name_regex = priv_->get_name_regex(); - if (name_regex - && (regexec(name_regex.get(), var_name.c_str(), - 0, NULL, 0) != 0)) + if (name_regex && !regex::match(name_regex, var_name)) return false; const regex_t_sptr name_not_regex = priv_->get_name_not_regex(); - if (name_not_regex - && (regexec(name_not_regex.get(), var_name.c_str(), - 0, NULL, 0) == 0)) + if (name_not_regex && regex::match(name_not_regex, var_name)) return false; } } @@ -3767,16 +3732,12 @@ variable_suppression::suppresses_variable(const var_decl* var, else { const regex_t_sptr sym_name_regex = priv_->get_symbol_name_regex(); - if (sym_name_regex - && (regexec(sym_name_regex.get(), var_sym_name.c_str(), - 0, NULL, 0) != 0)) + if (sym_name_regex && !regex::match(sym_name_regex, var_sym_name)) return false; const regex_t_sptr sym_name_not_regex = priv_->get_symbol_name_not_regex(); - if (sym_name_not_regex - && (regexec(sym_name_not_regex.get(), var_sym_name.c_str(), - 0, NULL, 0) == 0)) + if (sym_name_not_regex && regex::match(sym_name_not_regex, var_sym_name)) return false; } @@ -3793,9 +3754,7 @@ variable_suppression::suppresses_variable(const var_decl* var, const regex_t_sptr symbol_version_regex = priv_->get_symbol_version_regex(); if (symbol_version_regex - && (regexec(symbol_version_regex.get(), - var_sym_version.c_str(), - 0, NULL, 0) != 0)) + && !regex::match(symbol_version_regex, var_sym_version)) return false; } @@ -3813,9 +3772,7 @@ variable_suppression::suppresses_variable(const var_decl* var, if (get_type_name().empty()) { const regex_t_sptr type_name_regex = priv_->get_type_name_regex(); - if (type_name_regex - && (regexec(type_name_regex.get(), var_type_name.c_str(), - 0, NULL, 0) != 0)) + if (type_name_regex && !regex::match(type_name_regex, var_type_name)) return false; } } @@ -3906,9 +3863,7 @@ variable_suppression::suppresses_variable_symbol(const elf_symbol* sym, else if (!get_symbol_name_regex_str().empty()) { const regex_t_sptr sym_name_regex = priv_->get_symbol_name_regex(); - if (sym_name_regex - && (regexec(sym_name_regex.get(), sym_name.c_str(), - 0, NULL, 0) != 0)) + if (sym_name_regex && !regex::match(sym_name_regex, sym_name)) return false; } else @@ -3925,9 +3880,7 @@ variable_suppression::suppresses_variable_symbol(const elf_symbol* sym, const regex_t_sptr symbol_version_regex = priv_->get_symbol_version_regex(); if (symbol_version_regex - && (regexec(symbol_version_regex.get(), - sym_version.c_str(), - 0, NULL, 0) != 0)) + && !regex::match(symbol_version_regex, sym_version)) return false; } else @@ -4223,14 +4176,14 @@ file_suppression::suppresses_file(const string& file_path) if (regex_t_sptr regexp = suppression_base::priv_->get_file_name_regex()) { has_regexp = true; - if (regexec(regexp.get(), fname.c_str(), 0, NULL, 0) != 0) + if (!regex::match(regexp, fname)) return false; } if (regex_t_sptr regexp = suppression_base::priv_->get_file_name_not_regex()) { has_regexp = true; - if (regexec(regexp.get(), fname.c_str(), 0, NULL, 0) == 0) + if (regex::match(regexp, fname)) return false; } From patchwork Mon May 4 12:34:10 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Giuliano Procida X-Patchwork-Id: 39205 From: gprocida@google.com (Giuliano Procida) Date: Mon, 4 May 2020 13:34:10 +0100 Subject: [PATCH v4 09/15] Refactor read_parameter_spec_from_string logic. In-Reply-To: <20200504123416.243214-1-gprocida@google.com> References: <20200424092132.150547-1-gprocida@google.com> <20200504123416.243214-1-gprocida@google.com> Message-ID: <20200504123416.243214-10-gprocida@google.com> This function extracts either a string or a regex from the same input. This patch simplifies the string vs regex conditional logic, in order to make following patches simpler. There are no behavioural changes. * src/abg-suppression.cc (read_parameter_spec_from_string): Use separate string and regex variables to simplify the creation of returned parameter specification. Reviewed-by: Matthias Maennich Signed-off-by: Giuliano Procida Acked-by: Dodji Seketeli --- src/abg-suppression.cc | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/src/abg-suppression.cc b/src/abg-suppression.cc index c89201b6..4014ff06 100644 --- a/src/abg-suppression.cc +++ b/src/abg-suppression.cc @@ -3085,13 +3085,15 @@ read_parameter_spec_from_string(const string& str) if (!index_str.empty() || !type_name.empty()) { - function_suppression::parameter_spec* p; + std::string type_name_regex; if (is_regex) - p = new function_suppression::parameter_spec(atoi(index_str.c_str()), - "", type_name); - else - p = new function_suppression::parameter_spec(atoi(index_str.c_str()), - type_name, ""); + { + type_name_regex = type_name; + type_name.clear(); + } + function_suppression::parameter_spec* p = + new function_suppression::parameter_spec(atoi(index_str.c_str()), + type_name, type_name_regex); result.reset(p); } From patchwork Mon May 4 12:34:11 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Giuliano Procida X-Patchwork-Id: 39209 From: gprocida@google.com (Giuliano Procida) Date: Mon, 4 May 2020 13:34:11 +0100 Subject: [PATCH v4 10/15] Compile suppression regexes earlier. In-Reply-To: <20200504123416.243214-1-gprocida@google.com> References: <20200424092132.150547-1-gprocida@google.com> <20200504123416.243214-1-gprocida@google.com> Message-ID: <20200504123416.243214-11-gprocida@google.com> Regexes are used in suppression specifications for various things. They are currently compiled on first use, rather than on construction of the specifications. This patches changes the suppression specification types to hold compiled regexes directly which is a significant simplification and is a prerequisite for early error reporting. There are no behavioural changes. * include/abg-suppression.h (suppression_base): In constructor, take regex arguments as regex_t_sptr. Replace all set_*_regex_str and get_*_regex_str methods with set_*_regex and get_*_regex methods. (type_suppression): In constructor, take regex arguments as regex_t_sptr. Replace all set_*_regex_str and get_*_regex_str methods with set_*_regex and get_*_regex methods. (function_suppression): In constructor, take regex arguments as regex_t_sptr. Replace all set_*_regex_str and get_*_regex_str methods with set_*_regex and get_*_regex methods. (function_suppression::parameter_spec): In constructor, take regex arguments as regex_t_sptr. Replace all set_*_regex_str and get_*_regex_str methods with set_*_regex and get_*_regex methods. (variable_suppression): In constructor, take regex arguments as regex_t_sptr. Replace all set_*_regex_str and get_*_regex_str methods with set_*_regex and get_*_regex methods. (file_suppression): In constructor, take regex arguments as regex_t_sptr. * src/abg-suppression-priv.h (suppression_base::priv): Drop all *_regex_str_ members. Drop mutable qualifier on all *_regex_ members. In constructor, take regexes instead of strings for regex arguments. Update all get_*_regex methods to remove regex compilation and update comments. (function_suppression::parameter_spec::priv): Drop all *_regex_str_ members. Drop mutable qualifier on all *_regex_ members. In constructor, take regexes instead of strings for regex arguments. Update get_*_regex methods to remove regex compilation and update comments. (function_suppression::priv): Drop all *_regex_str_ members. Drop mutable qualifier on all *_regex_ members. In constructor, take regexes instead of strings for regex arguments. Update all get_*_regex methods to remove regex compilation and update comments. (variable_suppression::priv): Drop all *_regex_str_ members. Drop mutable qualifier on all *_regex_ members. In constructor, take regexes instead of strings for regex arguments. Update all get_*_regex methods to remove regex compilation and update comments. (type_suppression::priv): Drop all *_regex_str_ members. Drop mutable qualifier on all *_regex_ members. In constructor, take regexes instead of strings for regex arguments. Update all get_*_regex methods to remove regex compilation and update comments. Drop set_type_name_regex_str and get_type_name_regex_str methods. * src/abg-suppression.cc (suppression_base): In constructor, take regexes instead of strings for regex arguments. Replace all set_*_regex_str and get_*_regex_str methods with set_*_regex and get_*_regex methods. Update has_file_name_related_property and has_soname_related_property methods. (type_suppression): In constructor, take regexes instead of strings for regex arguments. Replace all set_*_regex_str and get_*_regex_str methods with set_*_regex and get_*_regex methods. Update has_file_name_related_property and has_soname_related_property methods. (read_type_suppression): Compile regexes instead of keeping them as strings. Pass them to type_suppression constructor and setters. (function_suppression::parameter_spec): In constructor, take regexes instead of strings for regex arguments. Replace all set_*_regex_str and get_*_regex_str methods with set_*_regex and get_*_regex methods. (function_suppression): In constructor, take regexes instead of strings for regex arguments. Replace all set_*_regex_str and get_*_regex_str methods with set_*_regex and get_*_regex methods. Update suppresses_function_symbol method. (read_parameter_spec_from_string): Change type of type_name_regex from string to regex and compile when needed. (read_function_suppression): Compile regexes instead of keeping them as strings. Pass them to function_suppression constructor and setters. (variable_suppression): In constructor, take regexes instead of strings for regex arguments. Replace all set_*_regex_str and get_*_regex_str methods with set_*_regex and get_*_regex methods. (file_suppression): In constructor, take regexes instead of strings for regex arguments. Replace all set_*_regex_str and get_*_regex_str methods with set_*_regex and get_*_regex methods. * src/abg-tools-utils.cc (handle_file_entry): Compile and check regex for /usr/include. (gen_suppr_spec_from_kernel_abi_whitelists): Compile and check whitelisting regex. * tests/test-kmi-whitelist.cc (random_symbols) Add array of symbols. (test_suppressions_are_consistent): Rework to test by matching regexes against symbols, now that uncompiled regex strings are no longer available. Signed-off-by: Giuliano Procida Reviewed-by: Matthias Maennich --- include/abg-suppression.h | 165 ++++----- src/abg-suppression-priv.h | 357 ++++--------------- src/abg-suppression.cc | 694 ++++++++++++++++++------------------ src/abg-tools-utils.cc | 17 +- tests/test-kmi-whitelist.cc | 60 +++- 5 files changed, 583 insertions(+), 710 deletions(-) diff --git a/include/abg-suppression.h b/include/abg-suppression.h index 6383b932..8256f9b8 100644 --- a/include/abg-suppression.h +++ b/include/abg-suppression.h @@ -26,6 +26,7 @@ #include "abg-cxx-compat.h" #include "abg-ini.h" #include "abg-comparison.h" +#include "abg-regex.h" namespace abigail { @@ -64,8 +65,8 @@ public: suppression_base(const string& label); suppression_base(const string& label, - const string& file_name_regex_str, - const string& file_name_not_regex_str); + const regex::regex_t_sptr& file_name_regex, + const regex::regex_t_sptr& file_name_not_regex); bool get_drops_artifact_from_ir() const; @@ -86,31 +87,31 @@ public: set_label(const string&); void - set_file_name_regex_str(const string& regexp); + set_file_name_regex(const regex::regex_t_sptr& regexp); - const string& - get_file_name_regex_str() const; + const regex::regex_t_sptr& + get_file_name_regex() const; void - set_file_name_not_regex_str(const string& regexp); + set_file_name_not_regex(const regex::regex_t_sptr& regexp); - const string& - get_file_name_not_regex_str() const; + const regex::regex_t_sptr& + get_file_name_not_regex() const; bool has_file_name_related_property() const; void - set_soname_regex_str(const string& regexp); + set_soname_regex(const regex::regex_t_sptr& regexp); - const string& - get_soname_regex_str() const; + const regex::regex_t_sptr& + get_soname_regex() const; void - set_soname_not_regex_str(const string& regexp); + set_soname_not_regex(const regex::regex_t_sptr& regexp); - const string& - get_soname_not_regex_str() const; + const regex::regex_t_sptr& + get_soname_not_regex() const; bool has_soname_related_property() const; @@ -204,22 +205,22 @@ public: typedef vector insertion_ranges; type_suppression(const string& label, - const string& type_name_regexp, + const regex::regex_t_sptr& type_name_regexp, const string& type_name); virtual ~type_suppression(); void - set_type_name_regex_str(const string& name_regex_str); + set_type_name_regex(const regex::regex_t_sptr& name_regex); - const string& - get_type_name_regex_str() const; + const regex::regex_t_sptr& + get_type_name_regex() const; void - set_type_name_not_regex_str(const string& name_regex_str); + set_type_name_not_regex(const regex::regex_t_sptr& name_regex); - const string& - get_type_name_not_regex_str() const; + const regex::regex_t_sptr& + get_type_name_not_regex() const; void set_type_name(const string& name); @@ -269,11 +270,11 @@ public: void set_source_locations_to_keep(const unordered_set&); - const string& - get_source_location_to_keep_regex_str() const; + const regex::regex_t_sptr& + get_source_location_to_keep_regex() const; void - set_source_location_to_keep_regex_str(const string&); + set_source_location_to_keep_regex(const regex::regex_t_sptr&); const vector& get_changed_enumerator_names() const; @@ -460,16 +461,16 @@ public: function_suppression(); - function_suppression(const string& label, - const string& name, - const string& name_regex, - const string& return_type_name, - const string& return_type_regex, - parameter_specs_type& parm_specs, - const string& symbol_name, - const string& symbol_name_regex, - const string& symbol_version, - const string& symbol_version_regex_str); + function_suppression(const string& label, + const string& name, + const regex::regex_t_sptr& name_regex, + const string& return_type_name, + const regex::regex_t_sptr& return_type_regex, + parameter_specs_type& parm_specs, + const string& symbol_name, + const regex::regex_t_sptr& symbol_name_regex, + const string& symbol_version, + const regex::regex_t_sptr& symbol_version_regex); virtual ~function_suppression(); @@ -488,17 +489,17 @@ public: void set_name(const string&); - const string& - get_name_regex_str() const; + const regex::regex_t_sptr& + get_name_regex() const; void - set_name_regex_str(const string&); + set_name_regex(const regex::regex_t_sptr&); - const string& - get_name_not_regex_str() const; + const regex::regex_t_sptr& + get_name_not_regex() const; void - set_name_not_regex_str(const string&); + set_name_not_regex(const regex::regex_t_sptr&); const string& get_return_type_name() const; @@ -506,11 +507,11 @@ public: void set_return_type_name(const string&); - const string& - get_return_type_regex_str() const; + const regex::regex_t_sptr& + get_return_type_regex() const; void - set_return_type_regex_str(const string& r); + set_return_type_regex(const regex::regex_t_sptr& r); const parameter_specs_type& get_parameter_specs() const; @@ -527,17 +528,17 @@ public: void set_symbol_name(const string& n); - const string& - get_symbol_name_regex_str() const; + const regex::regex_t_sptr& + get_symbol_name_regex() const; void - set_symbol_name_regex_str(const string&); + set_symbol_name_regex(const regex::regex_t_sptr&); - const string& - get_symbol_name_not_regex_str() const; + const regex::regex_t_sptr& + get_symbol_name_not_regex() const; void - set_symbol_name_not_regex_str(const string&); + set_symbol_name_not_regex(const regex::regex_t_sptr&); const string& get_symbol_version() const; @@ -545,11 +546,11 @@ public: void set_symbol_version(const string&); - const string& - get_symbol_version_regex_str() const; + const regex::regex_t_sptr& + get_symbol_version_regex() const; void - set_symbol_version_regex_str(const string&); + set_symbol_version_regex(const regex::regex_t_sptr&); bool get_allow_other_aliases() const; @@ -609,7 +610,7 @@ class function_suppression::parameter_spec public: parameter_spec(size_t index, const string& type_name, - const string& type_name_regex); + const regex::regex_t_sptr& type_name_regex); size_t get_index() const; @@ -623,11 +624,11 @@ public: void set_parameter_type_name(const string&); - const string& - get_parameter_type_name_regex_str() const; + const regex::regex_t_sptr& + get_parameter_type_name_regex() const; void - set_parameter_type_name_regex_str(const string&); + set_parameter_type_name_regex(const regex::regex_t_sptr&); };// end class function_suppression::parameter_spec class variable_suppression; @@ -679,13 +680,17 @@ public: variable_suppression(const string& label = "", const string& name = "", - const string& name_regex_str = "", + const regex::regex_t_sptr& name_regex = + regex::regex_t_sptr(), const string& symbol_name = "", - const string& symbol_name_regex_str = "", + const regex::regex_t_sptr& symbol_name_regex = + regex::regex_t_sptr(), const string& symbol_version = "", - const string& symbol_version_regex_str = "", + const regex::regex_t_sptr& symbol_version_regex = + regex::regex_t_sptr(), const string& type_name = "", - const string& type_name_regex_str = ""); + const regex::regex_t_sptr& type_name_regex = + regex::regex_t_sptr()); virtual ~variable_suppression(); @@ -704,17 +709,17 @@ public: void set_name(const string&); - const string& - get_name_regex_str() const; + const regex::regex_t_sptr& + get_name_regex() const; void - set_name_regex_str(const string&); + set_name_regex(const regex::regex_t_sptr&); - const string& - get_name_not_regex_str() const; + const regex::regex_t_sptr& + get_name_not_regex() const; void - set_name_not_regex_str(const string&); + set_name_not_regex(const regex::regex_t_sptr&); const string& get_symbol_name() const; @@ -722,17 +727,17 @@ public: void set_symbol_name(const string&); - const string& - get_symbol_name_regex_str() const; + const regex::regex_t_sptr& + get_symbol_name_regex() const; void - set_symbol_name_regex_str(const string&); + set_symbol_name_regex(const regex::regex_t_sptr&); - const string& - get_symbol_name_not_regex_str() const; + const regex::regex_t_sptr& + get_symbol_name_not_regex() const; void - set_symbol_name_not_regex_str(const string&); + set_symbol_name_not_regex(const regex::regex_t_sptr&); const string& get_symbol_version() const; @@ -740,11 +745,11 @@ public: void set_symbol_version(const string&); - const string& - get_symbol_version_regex_str() const; + const regex::regex_t_sptr& + get_symbol_version_regex() const; void - set_symbol_version_regex_str(const string&); + set_symbol_version_regex(const regex::regex_t_sptr&); const string& get_type_name() const; @@ -752,11 +757,11 @@ public: void set_type_name(const string&); - const string& - get_type_name_regex_str() const; + const regex::regex_t_sptr& + get_type_name_regex() const; void - set_type_name_regex_str(const string&); + set_type_name_regex(const regex::regex_t_sptr&); bool suppresses_diff(const diff* d) const; @@ -816,8 +821,8 @@ class file_suppression: public suppression_base public: file_suppression(const string& label, - const string& file_name_regex, - const string& file_name_not_regex); + const regex::regex_t_sptr& file_name_regex, + const regex::regex_t_sptr& file_name_not_regex); virtual bool suppresses_diff(const diff* diff) const; diff --git a/src/abg-suppression-priv.h b/src/abg-suppression-priv.h index deb08269..c5f99c15 100644 --- a/src/abg-suppression-priv.h +++ b/src/abg-suppression-priv.h @@ -47,14 +47,10 @@ class suppression_base::priv bool is_artificial_; bool drops_artifact_; string label_; - string file_name_regex_str_; - mutable regex::regex_t_sptr file_name_regex_; - string file_name_not_regex_str_; - mutable regex::regex_t_sptr file_name_not_regex_; - string soname_regex_str_; - mutable regex::regex_t_sptr soname_regex_; - string soname_not_regex_str_; - mutable regex::regex_t_sptr soname_not_regex_; + regex::regex_t_sptr file_name_regex_; + regex::regex_t_sptr file_name_not_regex_; + regex::regex_t_sptr soname_regex_; + regex::regex_t_sptr soname_not_regex_; public: priv() @@ -69,78 +65,46 @@ public: {} priv(const string& label, - const string& file_name_regex_str, - const string& file_name_not_regex_str) + const regex::regex_t_sptr& file_name_regex, + const regex::regex_t_sptr& file_name_not_regex) : is_artificial_(), drops_artifact_(), label_(label), - file_name_regex_str_(file_name_regex_str), - file_name_not_regex_str_(file_name_not_regex_str) + file_name_regex_(file_name_regex), + file_name_not_regex_(file_name_not_regex) {} friend class suppression_base; - /// Get the regular expression object associated to the 'file_name_regex' - /// property of @ref suppression_base. - /// - /// If the regular expression object is not created, this method - /// creates it and returns it. - /// - /// If the 'file_name_regex' property of @ref suppression_base is - /// empty then this method returns nil. + /// Get the regular expression object associated to the + /// 'file_name_regex' property of @ref suppression_base. const regex::regex_t_sptr& get_file_name_regex() const { - if (!file_name_regex_ && !file_name_regex_str_.empty()) - file_name_regex_ = regex::compile(file_name_regex_str_); return file_name_regex_; } /// Get the regular expression object associated to the /// 'file_name_not_regex' property of @ref suppression_base. - /// - /// If the regular expression object is not created, this method - /// creates it and returns it. - /// - /// If the 'file_name_not_regex' property of @ref suppression_base - /// is empty then this method returns nil. const regex::regex_t_sptr& get_file_name_not_regex() const { - if (!file_name_not_regex_ && !file_name_not_regex_str_.empty()) - file_name_not_regex_ = regex::compile(file_name_not_regex_str_); return file_name_not_regex_; } - /// Get the regular expression object associated to the - /// 'soname_regex' property of @ref suppression_base. - /// - /// If the regular expression object is not created, this method - /// creates it and returns it. - /// - /// If the 'soname_regex' property of @ref suppression_base is empty - /// then this method returns nil. + /// Get the regular expression object associated to the 'soname_regex' + /// property of @ref suppression_base. const regex::regex_t_sptr& get_soname_regex() const { - if (!soname_regex_ && !soname_regex_str_.empty()) - soname_regex_ = regex::compile(soname_regex_str_); return soname_regex_; } /// Get the regular expression object associated to the /// 'soname_not_regex' property of @ref suppression_base. - /// - /// If the regular expression object is not created, this method - /// creates it and returns it. - /// - /// If the 'soname_not_regex' property of @ref suppression_base is - /// empty then this method returns nil. const regex::regex_t_sptr& get_soname_not_regex() const { - if (!soname_not_regex_ && !soname_not_regex_str_.empty()) - soname_not_regex_ = regex::compile(soname_not_regex_str_); return soname_not_regex_; } @@ -225,8 +189,7 @@ class function_suppression::parameter_spec::priv size_t index_; string type_name_; - string type_name_regex_str_; - mutable regex::regex_t_sptr type_name_regex_; + regex::regex_t_sptr type_name_regex_; priv() : index_() @@ -236,15 +199,16 @@ class function_suppression::parameter_spec::priv : index_(i), type_name_(tn) {} - priv(size_t i, const string& tn, const string& tn_regex) - : index_(i), type_name_(tn), type_name_regex_str_(tn_regex) + priv(size_t i, const string& tn, const regex::regex_t_sptr& tn_regex) + : index_(i), type_name_(tn), type_name_regex_(tn_regex) {} + /// Get the regular expression object associated to the + /// 'type_name_regex' property of @ref + /// function_suppression::parameter_spec. const regex::regex_t_sptr get_type_name_regex() const { - if (!type_name_regex_ && !type_name_regex_str_.empty()) - type_name_regex_ = regex::compile(type_name_regex_str_); return type_name_regex_; } }; // end class function_suppression::parameter_spec::priv @@ -258,22 +222,16 @@ struct function_suppression::priv change_kind change_kind_; string name_; - string name_regex_str_; - mutable regex::regex_t_sptr name_regex_; - string name_not_regex_str_; - mutable regex::regex_t_sptr name_not_regex_; + regex::regex_t_sptr name_regex_; + regex::regex_t_sptr name_not_regex_; string return_type_name_; - string return_type_regex_str_; - mutable regex::regex_t_sptr return_type_regex_; + regex::regex_t_sptr return_type_regex_; parameter_specs_type parm_specs_; string symbol_name_; - string symbol_name_regex_str_; - mutable regex::regex_t_sptr symbol_name_regex_; - string symbol_name_not_regex_str_; - mutable regex::regex_t_sptr symbol_name_not_regex_; + regex::regex_t_sptr symbol_name_regex_; + regex::regex_t_sptr symbol_name_not_regex_; string symbol_version_; - string symbol_version_regex_str_; - mutable regex::regex_t_sptr symbol_version_regex_; + regex::regex_t_sptr symbol_version_regex_; bool allow_other_aliases_; priv(): @@ -282,127 +240,72 @@ struct function_suppression::priv {} priv(const string& name, - const string& name_regex_str, + const regex::regex_t_sptr& name_regex, const string& return_type_name, - const string& return_type_regex_str, + const regex::regex_t_sptr& return_type_regex, const parameter_specs_type& parm_specs, const string& symbol_name, - const string& symbol_name_regex_str, + const regex::regex_t_sptr& symbol_name_regex, const string& symbol_version, - const string& symbol_version_regex_str) + const regex::regex_t_sptr& symbol_version_regex) : change_kind_(ALL_CHANGE_KIND), name_(name), - name_regex_str_(name_regex_str), + name_regex_(name_regex), return_type_name_(return_type_name), - return_type_regex_str_(return_type_regex_str), + return_type_regex_(return_type_regex), parm_specs_(parm_specs), symbol_name_(symbol_name), - symbol_name_regex_str_(symbol_name_regex_str), + symbol_name_regex_(symbol_name_regex), symbol_version_(symbol_version), - symbol_version_regex_str_(symbol_version_regex_str), + symbol_version_regex_(symbol_version_regex), allow_other_aliases_(true) {} - - /// Getter for a pointer to a regular expression object built from - /// the regular expression string - /// function_suppression::priv::name_regex_str_. - /// - /// If that string is empty, then an empty regular expression object - /// pointer is returned. - /// - /// @return a pointer to the regular expression object of - /// function_suppression::priv::name_regex_str_.. + /// Get the regular expression object associated to the 'name_regex' + /// property of @ref function_suppression. const regex::regex_t_sptr get_name_regex() const { - if (!name_regex_ && !name_regex_str_.empty()) - name_regex_ = regex::compile(name_regex_str_); return name_regex_; } - /// Getter for a pointer to a regular expression object built from - /// the regular expression string - /// function_suppression::priv::name_not_regex_str_. - /// - /// If that string is empty, then an empty regular expression object - /// pointer is returned. - /// - /// @return a pointer to the regular expression object of - /// function_suppression::priv::name_not_regex_str_.. + /// Get the regular expression object associated to the + /// 'name_not_regex' property of @ref function_suppression. const regex::regex_t_sptr get_name_not_regex() const { - if (!name_not_regex_ && !name_not_regex_str_.empty()) - name_not_regex_ = regex::compile(name_not_regex_str_); return name_not_regex_; } - /// Getter for a pointer to a regular expression object built from - /// the regular expression string - /// function_suppression::priv::return_type_regex_str_. - /// - /// If that string is empty, then an empty regular expression object - /// pointer is returned. - /// - /// @return a pointer to the regular expression object of - /// function_suppression::priv::return_type_regex_str_. + /// Get the regular expression object associated to the + /// 'return_type_regex' property of @ref function_suppression. const regex::regex_t_sptr get_return_type_regex() const { - if (!return_type_regex_ && !return_type_regex_str_.empty()) - return_type_regex_ = regex::compile(return_type_regex_str_); return return_type_regex_; } - /// Getter for a pointer to a regular expression object built from - /// the regular expression string - /// function_suppression::priv::symbol_name_regex_str_. - /// - /// If that string is empty, then an empty regular expression object - /// pointer is returned. - /// - /// @return a pointer to the regular expression object of - /// function_suppression::priv::symbol_name_regex_str_. + /// Get the regular expression object associated to the + /// 'symbol_name_regex' property of @ref function_suppression. const regex::regex_t_sptr get_symbol_name_regex() const { - if (!symbol_name_regex_ && !symbol_name_regex_str_.empty()) - symbol_name_regex_ = regex::compile(symbol_name_regex_str_); return symbol_name_regex_; } - /// Getter for a pointer to a regular expression object built from - /// the regular expression string - /// function_suppression::priv::symbol_name_not_regex_str_. - /// - /// If that string is empty, then an empty regular expression object - /// pointer is returned. - /// - /// @return a pointer to the regular expression object of - /// function_suppression::priv::symbol_name_not_regex_str_. + /// Get the regular expression object associated to the + /// 'symbol_name_not_regex' property of @ref function_suppression. const regex::regex_t_sptr get_symbol_name_not_regex() const { - if (!symbol_name_not_regex_ && !symbol_name_not_regex_str_.empty()) - symbol_name_not_regex_ = regex::compile(symbol_name_not_regex_str_); return symbol_name_not_regex_; } - /// Getter for a pointer to a regular expression object built from - /// the regular expression string - /// function_suppression::priv::symbol_version_regex_str_. - /// - /// If that string is empty, then an empty regular expression object - /// pointer is returned. - /// - /// @return a pointer to the regular expression object of - /// function_suppression::priv::symbol_version_regex_str_. + /// Get the regular expression object associated to the + /// 'symbol_version_regex' property of @ref function_suppression. const regex::regex_t_sptr get_symbol_version_regex() const { - if (!symbol_version_regex_ && !symbol_version_regex_str_.empty()) - symbol_version_regex_ = regex::compile(symbol_version_regex_str_); return symbol_version_regex_; } }; // end class function_suppression::priv @@ -481,140 +384,80 @@ struct variable_suppression::priv change_kind change_kind_; string name_; - string name_regex_str_; - mutable regex::regex_t_sptr name_regex_; - string name_not_regex_str_; - mutable regex::regex_t_sptr name_not_regex_; + regex::regex_t_sptr name_regex_; + regex::regex_t_sptr name_not_regex_; string symbol_name_; - string symbol_name_regex_str_; - mutable regex::regex_t_sptr symbol_name_regex_; - string symbol_name_not_regex_str_; - mutable regex::regex_t_sptr symbol_name_not_regex_; + regex::regex_t_sptr symbol_name_regex_; + regex::regex_t_sptr symbol_name_not_regex_; string symbol_version_; - string symbol_version_regex_str_; - mutable regex::regex_t_sptr symbol_version_regex_; + regex::regex_t_sptr symbol_version_regex_; string type_name_; - string type_name_regex_str_; - mutable regex::regex_t_sptr type_name_regex_; + regex::regex_t_sptr type_name_regex_; priv(const string& name, - const string& name_regex_str, + const regex::regex_t_sptr& name_regex, const string& symbol_name, - const string& symbol_name_regex_str, + const regex::regex_t_sptr& symbol_name_regex, const string& symbol_version, - const string& symbol_version_regex_str, + const regex::regex_t_sptr& symbol_version_regex, const string& type_name, - const string& type_name_regex_str) + const regex::regex_t_sptr& type_name_regex) : change_kind_(ALL_CHANGE_KIND), name_(name), - name_regex_str_(name_regex_str), + name_regex_(name_regex), symbol_name_(symbol_name), - symbol_name_regex_str_(symbol_name_regex_str), + symbol_name_regex_(symbol_name_regex), symbol_version_(symbol_version), - symbol_version_regex_str_(symbol_version_regex_str), + symbol_version_regex_(symbol_version_regex), type_name_(type_name), - type_name_regex_str_(type_name_regex_str) + type_name_regex_(type_name_regex) {} - /// Getter for a pointer to a regular expression object built from - /// the regular expression string - /// variable_suppression::priv::name_regex_str_. - /// - /// If that string is empty, then an empty regular expression object - /// pointer is returned. - /// - /// @return a pointer to the regular expression object of - /// variable_suppression::priv::name_regex_str_. + /// Get the regular expression object associated to the 'name_regex' + /// property of @ref variable_suppression. const regex::regex_t_sptr get_name_regex() const { - if (!name_regex_ && !name_regex_str_.empty()) - name_regex_ = regex::compile(name_regex_str_); return name_regex_; } - /// Getter for a pointer to a regular expression object built from - /// the regular expression string - /// variable_suppression::priv::name_not_regex_str_. - /// - /// If that string is empty, then an empty regular expression object - /// pointer is returned. - /// - /// @return a pointer to the regular expression object of - /// variable_suppression::priv::name_not_regex_str_.. + /// Get the regular expression object associated to the + /// 'name_not_regex' property of @ref variable_suppression. const regex::regex_t_sptr get_name_not_regex() const { - if (!name_not_regex_ && !name_not_regex_str_.empty()) - name_not_regex_ = regex::compile(name_not_regex_str_); return name_not_regex_; } - /// Getter for a pointer to a regular expression object built from - /// the regular expression string - /// variable_suppression::priv::symbol_name_regex_str_. - /// - /// If that string is empty, then an empty regular expression object - /// pointer is returned. - /// - /// @return a pointer to the regular expression object of - /// variable_suppression::priv::symbol_name_regex_str_. + /// Get the regular expression object associated to the + /// 'symbol_name_regex' property of @ref variable_suppression. const regex::regex_t_sptr get_symbol_name_regex() const { - if (!symbol_name_regex_ && !symbol_name_regex_str_.empty()) - symbol_name_regex_ = regex::compile(symbol_name_regex_str_); return symbol_name_regex_; } - /// Getter for a pointer to a regular expression object built from - /// the regular expression string - /// variable_suppression::priv::symbol_name_not_regex_str_. - /// - /// If that string is empty, then an empty regular expression object - /// pointer is returned. - /// - /// @return a pointer to the regular expression object of - /// variable_suppression::priv::symbol_name_not_regex_str_. + /// Get the regular expression object associated to the + /// 'symbol_name_not_regex' property of @ref variable_suppression. const regex::regex_t_sptr get_symbol_name_not_regex() const { - if (!symbol_name_not_regex_ && !symbol_name_not_regex_str_.empty()) - symbol_name_not_regex_ = regex::compile(symbol_name_not_regex_str_); return symbol_name_not_regex_; } - /// Getter for a pointer to a regular expression object built from - /// the regular expression string - /// variable_suppression::priv::symbol_version_regex_str_. - /// - /// If that string is empty, then an empty regular expression object - /// pointer is returned. - /// - /// @return a pointer to the regular expression object of - /// variable_suppression::priv::symbol_version_regex_str_. + /// Get the regular expression object associated to the + /// 'symbol_version_regex' property of @ref variable_suppression. const regex::regex_t_sptr get_symbol_version_regex() const { - if (!symbol_version_regex_ && !symbol_version_regex_str_.empty()) - symbol_version_regex_ = regex::compile(symbol_version_regex_str_); return symbol_version_regex_; } - /// Getter for a pointer to a regular expression object built from - /// the regular expression string - /// variable_suppression::priv::type_name_regex_str_. - /// - /// If that string is empty, then an empty regular expression object - /// pointer is returned. - /// - /// @return a pointer to the regular expression object of - /// variable_suppression::priv::type_name_regex_str_. + /// Get the regular expression object associated to the + /// 'type_name_regex' property of @ref variable_suppression. const regex::regex_t_sptr get_type_name_regex() const { - if (!type_name_regex_ && !type_name_regex_str_.empty()) - type_name_regex_ = regex::compile(type_name_regex_str_); return type_name_regex_; } };// end class variable_supppression::priv @@ -651,31 +494,28 @@ variable_is_suppressed(const ReadContextType& ctxt, /// The private data for @ref type_suppression. class type_suppression::priv { - string type_name_regex_str_; - mutable regex::regex_t_sptr type_name_regex_; + regex::regex_t_sptr type_name_regex_; string type_name_; - string type_name_not_regex_str_; - mutable regex::regex_t_sptr type_name_not_regex_; + regex::regex_t_sptr type_name_not_regex_; bool consider_type_kind_; type_suppression::type_kind type_kind_; bool consider_reach_kind_; type_suppression::reach_kind reach_kind_; type_suppression::insertion_ranges insertion_ranges_; unordered_set source_locations_to_keep_; - string source_location_to_keep_regex_str_; - mutable regex::regex_t_sptr source_location_to_keep_regex_; + regex::regex_t_sptr source_location_to_keep_regex_; mutable vector changed_enumerator_names_; priv(); public: - priv(const string& type_name_regexp, + priv(const regex::regex_t_sptr& type_name_regexp, const string& type_name, bool consider_type_kind, type_suppression::type_kind type_kind, bool consider_reach_kind, type_suppression::reach_kind reach_kind) - : type_name_regex_str_(type_name_regexp), + : type_name_regex_(type_name_regexp), type_name_(type_name), consider_type_kind_(consider_type_kind), type_kind_(type_kind), @@ -683,19 +523,11 @@ public: reach_kind_(reach_kind) {} - /// Get the regular expression object associated to the 'type_name_regex' - /// property of @ref type_suppression. - /// - /// If the regular expression object is not created, this method - /// creates it and returns it. - /// - /// If the 'type_name_regex' property of @ref type_suppression is - /// empty then this method returns nil. + /// Get the regular expression object associated to the + /// 'type_name_regex' property of @ref type_suppression. const regex::regex_t_sptr get_type_name_regex() const { - if (!type_name_regex_ && !type_name_regex_str_.empty()) - type_name_regex_ = regex::compile(type_name_regex_str_); return type_name_regex_; } @@ -708,17 +540,9 @@ public: /// Get the regular expression object associated to the /// 'type_name_not_regex' property of @ref type_suppression. - /// - /// If the regular expression object is not created, this method - /// creates it and returns it. - /// - /// If the 'type_name_not_regex' property of @ref type_suppression is - /// empty then this method returns nil. const regex::regex_t_sptr get_type_name_not_regex() const { - if (!type_name_not_regex_ && !type_name_not_regex_str_.empty()) - type_name_not_regex_ = regex::compile(type_name_not_regex_str_); return type_name_not_regex_; } @@ -729,34 +553,11 @@ public: set_type_name_not_regex(regex::regex_t_sptr r) {type_name_not_regex_ = r;} - /// Getter for the string that denotes the 'type_name_not_regex' - /// property. - /// - /// @return the value of the string value of the - /// 'type_name_not_regex' property. - const string& - get_type_name_not_regex_str() const - {return type_name_not_regex_str_;} - - /// Setter for the string that denotes the 'type_name_not_regex' - /// property. - /// - /// @return the value of the string value of the - /// 'type_name_not_regex' property. - void - set_type_name_not_regex_str(const string regex_str) - {type_name_not_regex_str_ = regex_str;} - - /// Getter for the source_location_to_keep_regex object. - /// - /// This function builds the regex if it's not yet built. + /// Get the regular expression object associated to the + /// 'source_location_to_keep_regex' property of @ref type_suppression. const regex::regex_t_sptr get_source_location_to_keep_regex() const { - if (!source_location_to_keep_regex_ - && !source_location_to_keep_regex_str_.empty()) - source_location_to_keep_regex_ = - regex::compile(source_location_to_keep_regex_str_); return source_location_to_keep_regex_; } diff --git a/src/abg-suppression.cc b/src/abg-suppression.cc index 4014ff06..80ac1e9f 100644 --- a/src/abg-suppression.cc +++ b/src/abg-suppression.cc @@ -67,17 +67,17 @@ suppression_base::suppression_base(const string& label) /// @param a label for the suppression. This represents just a /// comment. /// -/// @param file_name_regex_str the regular expression that denotes the +/// @param file_name_regex the regular expression that denotes the /// file name to match. /// -/// @param file_name_not_regex_str the regular expression that denotes +/// @param file_name_not_regex the regular expression that denotes /// the file name to *NOT* match. suppression_base::suppression_base(const string& label, - const string& file_name_regex_str, - const string& file_name_not_regex_str) + const regex_t_sptr& file_name_regex, + const regex_t_sptr& file_name_not_regex) : priv_(new priv(label, - file_name_regex_str, - file_name_not_regex_str)) + file_name_regex, + file_name_not_regex)) { } @@ -139,52 +139,50 @@ suppression_base::set_label(const string& label) /// Setter for the "file_name_regex" property of the current instance /// of @ref suppression_base. /// -/// The "file_name_regex" property is a regular expression string that +/// The "file_name_regex" property is a regular expression that /// designates the file name that contains the ABI artifact this /// suppression should apply to. /// -/// @param regexp the new regular expression string. +/// @param regexp the new regular expression. void -suppression_base::set_file_name_regex_str(const string& regexp) -{priv_->file_name_regex_str_ = regexp;} +suppression_base::set_file_name_regex(const regex_t_sptr& regexp) +{priv_->file_name_regex_ = regexp;} /// Getter for the "file_name_regex" property of the current instance /// of @ref suppression_base. /// -/// The "file_name_regex" property is a regular expression string that +/// The "file_name_regex" property is a regular expression that /// designates the file name that contains the ABI artifacts this /// suppression should apply to. /// -/// @return the regular expression string. -const string& -suppression_base::get_file_name_regex_str() const -{return priv_->file_name_regex_str_;} +/// @return the regular expression. +const regex_t_sptr& +suppression_base::get_file_name_regex() const +{return priv_->file_name_regex_;} /// Setter for the "file_name_not_regex" property of the current /// instance of @ref suppression_base. /// /// The current suppression specification should apply to ABI /// artifacts of a file which name does *NOT* match the regular -/// expression string designated by the "file_name_not_regex" -/// property. +/// expression designated by the "file_name_not_regex" property. /// -/// @param regexp the new regular expression string. +/// @param regexp the new regular expression. void -suppression_base::set_file_name_not_regex_str(const string& regexp) -{priv_->file_name_not_regex_str_ = regexp;} +suppression_base::set_file_name_not_regex(const regex_t_sptr& regexp) +{priv_->file_name_not_regex_ = regexp;} /// Getter for the "file_name_not_regex" property of the current /// instance of @ref suppression_base. /// /// The current suppression specification should apply to ABI /// artifacts of a file which name does *NOT* match the regular -/// expression string designated by the "file_name_not_regex" -/// property. +/// expression designated by the "file_name_not_regex" property. /// -/// @return the regular expression string. -const string& -suppression_base::get_file_name_not_regex_str() const -{return priv_->file_name_not_regex_str_;} +/// @return the regular expression. +const regex_t_sptr& +suppression_base::get_file_name_not_regex() const +{return priv_->file_name_not_regex_;} /// Test if the current suppression has a property related to file /// name. @@ -194,59 +192,56 @@ suppression_base::get_file_name_not_regex_str() const bool suppression_base::has_file_name_related_property() const { - return (!(get_file_name_regex_str().empty() - && get_file_name_not_regex_str().empty())); + return get_file_name_regex() || get_file_name_not_regex(); } -/// Setter of the "soname_regex_str property of the current instance +/// Setter of the "soname_regex" property of the current instance /// of @ref suppression_base. /// -/// The "soname_regex_str" is a regular expression string that -/// designates the soname of the shared library that contains the ABI -/// artifacts this suppression should apply to. +/// The "soname_regex" is a regular expression that designates the +/// soname of the shared library that contains the ABI artifacts this +/// suppression should apply to. /// -/// @param regexp the new regular expression string. +/// @param regexp the new regular expression. void -suppression_base::set_soname_regex_str(const string& regexp) -{priv_->soname_regex_str_ = regexp;} +suppression_base::set_soname_regex(const regex_t_sptr& regexp) +{priv_->soname_regex_ = regexp;} -/// Getter of the "soname_regex_str property of the current instance +/// Getter of the "soname_regex" property of the current instance /// of @ref suppression_base. /// -/// The "soname_regex_str" is a regular expression string that -/// designates the soname of the shared library that contains the ABI -/// artifacts this suppression should apply to. +/// The "soname_regex" is a regular expression that designates the +/// soname of the shared library that contains the ABI artifacts this +/// suppression should apply to. /// -/// @return the regular expression string. -const string& -suppression_base::get_soname_regex_str() const -{return priv_->soname_regex_str_;} +/// @return the regular expression. +const regex_t_sptr& +suppression_base::get_soname_regex() const +{return priv_->soname_regex_;} -/// Setter of the "soname_not_regex_str property of the current +/// Setter of the "soname_not_regex" property of the current /// instance of @ref suppression_base. /// /// The current suppression specification should apply to ABI /// artifacts of a shared library which SONAME does *NOT* match the -/// regular expression string designated by the "soname_not_regex" -/// property. +/// regular expression designated by the "soname_not_regex" property. /// -/// @param regexp the new regular expression string. +/// @param regexp the new regular expression. void -suppression_base::set_soname_not_regex_str(const string& regexp) -{priv_->soname_not_regex_str_ = regexp;} +suppression_base::set_soname_not_regex(const regex_t_sptr& regexp) +{priv_->soname_not_regex_ = regexp;} -/// Getter of the "soname_not_regex_str property of the current +/// Getter of the "soname_not_regex" property of the current /// instance of @ref suppression_base. /// /// The current suppression specification should apply to ABI /// artifacts of a shared library which SONAME does *NOT* match the -/// regular expression string designated by the "soname_not_regex" -/// property. +/// regular expression designated by the "soname_not_regex" property. /// -/// @return the regular expression string. -const string& -suppression_base::get_soname_not_regex_str() const -{return priv_->soname_not_regex_str_;} +/// @return the regular expression. +const regex_t_sptr& +suppression_base::get_soname_not_regex() const +{return priv_->soname_not_regex_;} /// Test if the current suppression has a property related to SONAMEs. /// @@ -255,8 +250,7 @@ suppression_base::get_soname_not_regex_str() const bool suppression_base::has_soname_related_property() const { - return (!(get_soname_regex_str().empty() - && get_soname_not_regex_str().empty())); + return get_soname_regex() || get_soname_not_regex(); } /// Check if the SONAMEs of the two binaries being compared match the @@ -398,8 +392,8 @@ read_suppressions(const string& file_path, /// form comment explaining what the suppression is about. /// /// @param type_name_regexp the regular expression describing the -/// types about which diff reports should be suppressed. If it's an -/// empty string, the parameter is ignored. +/// types about which diff reports should be suppressed. If it's a +/// null shared pointer, the parameter is ignored. /// /// @param type_name the name of the type about which diff reports /// should be suppressed. If it's an empty string, the parameter is @@ -409,7 +403,7 @@ read_suppressions(const string& file_path, /// should not necessarily be populated. It usually is either one or /// the other that the user wants. type_suppression::type_suppression(const string& label, - const string& type_name_regexp, + const regex_t_sptr& type_name_regexp, const string& type_name) : suppression_base(label), priv_(new priv(type_name_regexp, @@ -429,43 +423,43 @@ type_suppression::~type_suppression() /// This sets a regular expression that specifies the family of types /// about which diff reports should be suppressed. /// -/// @param name_regex_str the new regular expression to set. +/// @param name_regex the new regular expression to set. void -type_suppression::set_type_name_regex_str(const string& name_regex_str) -{priv_->type_name_regex_str_ = name_regex_str;} +type_suppression::set_type_name_regex(const regex_t_sptr& name_regex) +{priv_->type_name_regex_ = name_regex;} /// Getter for the "type_name_regex" property of the type suppression /// specification. /// -/// This returns a regular expression string that specifies the family +/// This returns a regular expression that specifies the family /// of types about which diff reports should be suppressed. /// -/// @return the regular expression string. -const string& -type_suppression::get_type_name_regex_str() const -{return priv_->type_name_regex_str_;} +/// @return the regular expression. +const regex_t_sptr& +type_suppression::get_type_name_regex() const +{return priv_->type_name_regex_;} -/// Setter for the "type_name_not_regex_str" property of the type +/// Setter for the "type_name_not_regex" property of the type /// suppression specification. /// -/// This returns a regular expression string that specifies the family +/// This sets a regular expression that specifies the family /// of types that should be kept after suppression. /// /// @param r the new regexp string. void -type_suppression::set_type_name_not_regex_str(const string& r) -{priv_->set_type_name_not_regex_str(r);} +type_suppression::set_type_name_not_regex(const regex_t_sptr& r) +{priv_->set_type_name_not_regex(r);} -/// Getter for the "type_name_not_regex_str" property of the type +/// Getter for the "type_name_not_regex" property of the type /// suppression specification. /// -/// This returns a regular expression string that specifies the family +/// This returns a regular expression that specifies the family /// of types that should be kept after suppression. /// /// @return the new regexp string. -const string& -type_suppression::get_type_name_not_regex_str() const -{return priv_->get_type_name_not_regex_str();} +const regex_t_sptr& +type_suppression::get_type_name_not_regex() const +{return priv_->type_name_not_regex_;} /// Setter for the name of the type about which diff reports should be /// suppressed. @@ -612,21 +606,21 @@ type_suppression::set_source_locations_to_keep (const unordered_set& l) {priv_->source_locations_to_keep_ = l;} -/// Getter of the regular expression string that designates the source +/// Getter of the regular expression that designates the source /// location paths of types that should not be suppressed. /// -/// @return the regular expression string. -const string& -type_suppression::get_source_location_to_keep_regex_str() const -{return priv_->source_location_to_keep_regex_str_;} +/// @return the regular expression. +const regex_t_sptr& +type_suppression::get_source_location_to_keep_regex() const +{return priv_->source_location_to_keep_regex_;} -/// Setter of the regular expression string that designates the source +/// Setter of the regular expression that designates the source /// location paths of types that should not be suppressed. /// /// @param r the new regular expression. void -type_suppression::set_source_location_to_keep_regex_str(const string& r) -{priv_->source_location_to_keep_regex_str_ = r;} +type_suppression::set_source_location_to_keep_regex(const regex_t_sptr& r) +{priv_->source_location_to_keep_regex_ = r;} /// Getter of the vector of the changed enumerators that are supposed /// to be suppressed. Note that this will be "valid" only if the type @@ -1558,39 +1552,43 @@ read_type_suppression(const ini::config::section& section) ini::simple_property_sptr file_name_regex_prop = is_simple_property(section.find_property("file_name_regexp")); - string file_name_regex_str = - file_name_regex_prop ? file_name_regex_prop->get_value()->as_string() : ""; + regex_t_sptr file_name_regex; + if (file_name_regex_prop) + file_name_regex = + regex::compile(file_name_regex_prop->get_value()->as_string()); ini::simple_property_sptr file_name_not_regex_prop = is_simple_property(section.find_property("file_name_not_regexp")); - string file_name_not_regex_str = - file_name_not_regex_prop - ? file_name_not_regex_prop->get_value()->as_string() - : ""; + regex_t_sptr file_name_not_regex; + if (file_name_not_regex_prop) + file_name_not_regex = + regex::compile(file_name_not_regex_prop->get_value()->as_string()); ini::simple_property_sptr soname_regex_prop = is_simple_property(section.find_property("soname_regexp")); - string soname_regex_str = - soname_regex_prop ? soname_regex_prop->get_value()->as_string() : ""; + regex_t_sptr soname_regex; + if (soname_regex_prop) + soname_regex = regex::compile(soname_regex_prop->get_value()->as_string()); ini::simple_property_sptr soname_not_regex_prop = is_simple_property(section.find_property("soname_not_regexp")); - string soname_not_regex_str = - soname_not_regex_prop - ? soname_not_regex_prop->get_value()->as_string() - : ""; + regex_t_sptr soname_not_regex; + if (soname_not_regex_prop) + soname_not_regex = + regex::compile(soname_not_regex_prop->get_value()->as_string()); ini::simple_property_sptr name_regex_prop = is_simple_property(section.find_property("name_regexp")); - string name_regex_str = name_regex_prop - ? name_regex_prop->get_value()->as_string() - : ""; + regex_t_sptr name_regex; + if (name_regex_prop) + name_regex = regex::compile(name_regex_prop->get_value()->as_string()); ini::simple_property_sptr name_not_regex_prop = is_simple_property(section.find_property("name_not_regexp")); - string name_not_regex_str = name_not_regex_prop - ? name_not_regex_prop->get_value()->as_string() - : ""; + regex_t_sptr name_not_regex; + if (name_not_regex_prop) + name_not_regex = + regex::compile(name_not_regex_prop->get_value()->as_string()); ini::simple_property_sptr name_prop = is_simple_property(section.find_property("name")); @@ -1622,9 +1620,10 @@ read_type_suppression(const ini::config::section& section) ini::simple_property_sptr srcloc_not_regexp_prop = is_simple_property(section.find_property("source_location_not_regexp")); - string srcloc_not_regexp_str; + regex_t_sptr srcloc_not_regex; if (srcloc_not_regexp_prop) - srcloc_not_regexp_str = srcloc_not_regexp_prop->get_value()->as_string(); + srcloc_not_regex = + regex::compile(srcloc_not_regexp_prop->get_value()->as_string()); bool consider_type_kind = false; type_suppression::type_kind type_kind = type_suppression::UNKNOWN_TYPE_KIND; @@ -1831,7 +1830,7 @@ read_type_suppression(const ini::config::section& section) changed_enumerator_names.push_back(p->get_value()->as_string()); } - result.reset(new type_suppression(label_str, name_regex_str, name_str)); + result.reset(new type_suppression(label_str, name_regex, name_str)); if (consider_type_kind) { @@ -1848,31 +1847,31 @@ read_type_suppression(const ini::config::section& section) if (consider_data_member_insertion) result->set_data_member_insertion_ranges(insert_ranges); - if (!name_not_regex_str.empty()) - result->set_type_name_not_regex_str(name_not_regex_str); + if (name_not_regex) + result->set_type_name_not_regex(name_not_regex); - if (!file_name_regex_str.empty()) - result->set_file_name_regex_str(file_name_regex_str); + if (file_name_regex) + result->set_file_name_regex(file_name_regex); - if (!file_name_not_regex_str.empty()) - result->set_file_name_not_regex_str(file_name_not_regex_str); + if (file_name_not_regex) + result->set_file_name_not_regex(file_name_not_regex); - if (!soname_regex_str.empty()) - result->set_soname_regex_str(soname_regex_str); + if (soname_regex) + result->set_soname_regex(soname_regex); - if (!soname_not_regex_str.empty()) - result->set_soname_not_regex_str(soname_not_regex_str); + if (soname_not_regex) + result->set_soname_not_regex(soname_not_regex); if (!srcloc_not_in.empty()) result->set_source_locations_to_keep(srcloc_not_in); - if (!srcloc_not_regexp_str.empty()) - result->set_source_location_to_keep_regex_str(srcloc_not_regexp_str); + if (srcloc_not_regex) + result->set_source_location_to_keep_regex(srcloc_not_regex); if ((drop_artifact_str == "yes" || drop_artifact_str == "true") - && ((!name_regex_str.empty() + && ((name_regex || !name_str.empty() - || !srcloc_not_regexp_str.empty() + || srcloc_not_regex || !srcloc_not_in.empty()))) result->set_drops_artifact_from_ir(true); @@ -1898,7 +1897,7 @@ read_type_suppression(const ini::config::section& section) /// account only if the parameter @p tn is empty. function_suppression::parameter_spec::parameter_spec(size_t i, const string& tn, - const string& tn_regex) + const regex_t_sptr& tn_regex) : priv_(new priv(i, tn, tn_regex)) {} @@ -1943,9 +1942,9 @@ function_suppression::parameter_spec::set_parameter_type_name(const string& tn) /// empty. /// /// @return the regular expression or the parameter type name. -const string& -function_suppression::parameter_spec::get_parameter_type_name_regex_str() const -{return priv_->type_name_regex_str_;} +const regex_t_sptr& +function_suppression::parameter_spec::get_parameter_type_name_regex() const +{return priv_->type_name_regex_;} /// Setter for the regular expression that defines a set of type names /// for the parameter designated by this specification. @@ -1955,12 +1954,12 @@ function_suppression::parameter_spec::get_parameter_type_name_regex_str() const /// function_suppression::parameter_spec::get_parameter_type_name() is /// empty. /// -/// @param type_name_regex_str the new type name regular expression to +/// @param type_name_regex the new type name regular expression to /// set. void -function_suppression::parameter_spec::set_parameter_type_name_regex_str -(const string& type_name_regex_str) -{priv_->type_name_regex_str_ = type_name_regex_str;} +function_suppression::parameter_spec::set_parameter_type_name_regex +(const regex_t_sptr& type_name_regex) +{priv_->type_name_regex_ = type_name_regex;} /// Default constructor for the @ref function_suppression type. /// @@ -2028,14 +2027,14 @@ function_suppression::function_suppression() /// case it's ignored at evaluation time. function_suppression::function_suppression(const string& label, const string& name, - const string& nr, + const regex_t_sptr& nr, const string& ret_tn, - const string& ret_tr, + const regex_t_sptr& ret_tr, parameter_specs_type& ps, const string& sym_n, - const string& sym_nr, + const regex_t_sptr& sym_nr, const string& sym_v, - const string& sym_vr) + const regex_t_sptr& sym_vr) : suppression_base(label), priv_(new priv(name, nr, ret_tn, ret_tr, ps, sym_n, sym_nr, sym_v, sym_vr)) @@ -2103,9 +2102,9 @@ function_suppression::set_name(const string& n) /// /// @return the regular expression for the possible names of the /// function(s). -const string& -function_suppression::get_name_regex_str() const -{return priv_->name_regex_str_;} +const regex_t_sptr& +function_suppression::get_name_regex() const +{return priv_->name_regex_;} /// Setter for a regular expression for a family of names of functions /// the user wants the current specification to designate. @@ -2113,8 +2112,8 @@ function_suppression::get_name_regex_str() const /// @param r the new the regular expression for the possible names of /// the function(s). void -function_suppression::set_name_regex_str(const string& r) -{priv_->name_regex_str_ = r;} +function_suppression::set_name_regex(const regex_t_sptr& r) +{priv_->name_regex_ = r;} /// Getter for a regular expression of a family of names of functions /// the user wants the current specification to designate the negation @@ -2122,9 +2121,9 @@ function_suppression::set_name_regex_str(const string& r) /// /// @return the regular expression for the possible names of the /// function(s). -const string& -function_suppression::get_name_not_regex_str() const -{return priv_->name_not_regex_str_;} +const regex_t_sptr& +function_suppression::get_name_not_regex() const +{return priv_->name_not_regex_;} /// Setter for a regular expression for a family of names of functions /// the user wants the current specification to designate the negation @@ -2133,8 +2132,8 @@ function_suppression::get_name_not_regex_str() const /// @param r the new the regular expression for the possible names of /// the function(s). void -function_suppression::set_name_not_regex_str(const string& r) -{priv_->name_not_regex_str_ = r;} +function_suppression::set_name_not_regex(const regex_t_sptr& r) +{priv_->name_not_regex_ = r;} /// Getter for the name of the return type of the function the user /// wants this specification to designate. This property might be @@ -2166,9 +2165,9 @@ function_suppression::set_return_type_name(const string& tr) /// /// @return the regular expression for the possible names of the /// return types of the function(s). -const string& -function_suppression::get_return_type_regex_str() const -{return priv_->return_type_regex_str_;} +const regex_t_sptr& +function_suppression::get_return_type_regex() const +{return priv_->return_type_regex_;} /// Setter for a regular expression for a family of return type names /// for functions the user wants the current specification to @@ -2183,8 +2182,8 @@ function_suppression::get_return_type_regex_str() const /// @param r the new regular expression for the possible names of the /// return types of the function(s) to set. void -function_suppression::set_return_type_regex_str(const string& r) -{priv_->return_type_regex_str_ = r;} +function_suppression::set_return_type_regex(const regex_t_sptr& r) +{priv_->return_type_regex_ = r;} /// Getter for a vector of parameter specifications to specify /// properties of the parameters of the functions the user wants this @@ -2252,9 +2251,9 @@ function_suppression::set_symbol_name(const string& n) /// /// @return the regular expression for a family of names of symbols of /// functions to designate. -const string& -function_suppression::get_symbol_name_regex_str() const -{return priv_->symbol_name_regex_str_;} +const regex_t_sptr& +function_suppression::get_symbol_name_regex() const +{return priv_->symbol_name_regex_;} /// Setter for a regular expression for a family of names of symbols /// of functions the user wants this specification to designate. @@ -2269,8 +2268,8 @@ function_suppression::get_symbol_name_regex_str() const /// @param r the new regular expression for a family of names of /// symbols of functions to set. void -function_suppression::set_symbol_name_regex_str(const string& r) -{priv_->symbol_name_regex_str_ = r;} +function_suppression::set_symbol_name_regex(const regex_t_sptr& r) +{priv_->symbol_name_regex_ = r;} /// Getter for a regular expression for a family of names of symbols /// of functions the user wants this specification to designate. @@ -2285,11 +2284,11 @@ function_suppression::set_symbol_name_regex_str(const string& r) /// This property might be empty, in which case it's ignored at /// evaluation time. /// -/// @return the regular expression string for a family of names of +/// @return the regular expression for a family of names of /// symbols that is to be *NOT* suppressed by this suppression specification. -const string& -function_suppression::get_symbol_name_not_regex_str() const -{return priv_->symbol_name_not_regex_str_;} +const regex_t_sptr& +function_suppression::get_symbol_name_not_regex() const +{return priv_->symbol_name_not_regex_;} /// Setter for a regular expression for a family of names of symbols /// of functions the user wants this specification to designate. @@ -2304,12 +2303,12 @@ function_suppression::get_symbol_name_not_regex_str() const /// This property might be empty, in which case it's ignored at /// evaluation time. /// -/// @param the new regular expression string for a family of names of +/// @param the new regular expression for a family of names of /// symbols that is to be *NOT* suppressed by this suppression /// specification. void -function_suppression::set_symbol_name_not_regex_str(const string& r) -{priv_->symbol_name_not_regex_str_ = r;} +function_suppression::set_symbol_name_not_regex(const regex_t_sptr& r) +{priv_->symbol_name_not_regex_ = r;} /// Getter for the name of the version of the symbol of the function /// the user wants this specification to designate. @@ -2344,9 +2343,9 @@ function_suppression::set_symbol_version(const string& v) /// /// @return the regular expression for the versions of symbols of /// functions to designate. -const string& -function_suppression::get_symbol_version_regex_str() const -{return priv_->symbol_version_regex_str_;} +const regex_t_sptr& +function_suppression::get_symbol_version_regex() const +{return priv_->symbol_version_regex_;} /// Setter for a regular expression for a family of versions of /// symbols of functions the user wants the current specification to @@ -2360,8 +2359,8 @@ function_suppression::get_symbol_version_regex_str() const /// @param the new regular expression for the versions of symbols of /// functions to designate. void -function_suppression::set_symbol_version_regex_str(const string& r) -{priv_->symbol_version_regex_str_ = r;} +function_suppression::set_symbol_version_regex(const regex_t_sptr& r) +{priv_->symbol_version_regex_ = r;} /// Getter for the "allow_other_aliases" property of the function /// suppression specification. @@ -2764,7 +2763,7 @@ function_suppression::suppresses_function_symbol(const elf_symbol* sym, if (sym_name != get_symbol_name()) return false; } - else if (!get_symbol_name_regex_str().empty()) + else if (get_symbol_name_regex()) { const regex_t_sptr symbol_name_regex = priv_->get_symbol_name_regex(); if (symbol_name_regex && !regex::match(symbol_name_regex, sym_name)) @@ -2779,7 +2778,7 @@ function_suppression::suppresses_function_symbol(const elf_symbol* sym, if (sym_version != get_symbol_version()) return false; } - else if (!get_symbol_version_regex_str().empty()) + else if (get_symbol_version_regex()) { const regex_t_sptr symbol_version_regex = priv_->get_symbol_version_regex(); @@ -3085,10 +3084,10 @@ read_parameter_spec_from_string(const string& str) if (!index_str.empty() || !type_name.empty()) { - std::string type_name_regex; + regex_t_sptr type_name_regex; if (is_regex) { - type_name_regex = type_name; + type_name_regex = regex::compile(type_name); type_name.clear(); } function_suppression::parameter_spec* p = @@ -3138,27 +3137,30 @@ read_function_suppression(const ini::config::section& section) ini::simple_property_sptr file_name_regex_prop = is_simple_property(section.find_property("file_name_regexp")); - string file_name_regex_str = - file_name_regex_prop ? file_name_regex_prop->get_value()->as_string() : ""; + regex_t_sptr file_name_regex; + if (file_name_regex_prop) + file_name_regex = + regex::compile(file_name_regex_prop->get_value()->as_string()); ini::simple_property_sptr file_name_not_regex_prop = is_simple_property(section.find_property("file_name_not_regexp")); - string file_name_not_regex_str = - file_name_not_regex_prop - ? file_name_not_regex_prop->get_value()->as_string() - : ""; + regex_t_sptr file_name_not_regex; + if (file_name_not_regex_prop) + file_name_not_regex = + regex::compile(file_name_not_regex_prop->get_value()->as_string()); ini::simple_property_sptr soname_regex_prop = is_simple_property(section.find_property("soname_regexp")); - string soname_regex_str = - soname_regex_prop ? soname_regex_prop->get_value()->as_string() : ""; + regex_t_sptr soname_regex; + if (soname_regex_prop) + soname_regex = regex::compile(soname_regex_prop->get_value()->as_string()); ini::simple_property_sptr soname_not_regex_prop = is_simple_property(section.find_property("soname_not_regexp")); - string soname_not_regex_str = - soname_not_regex_prop - ? soname_not_regex_prop->get_value()->as_string() - : ""; + regex_t_sptr soname_not_regex; + if (soname_not_regex_prop) + soname_not_regex = + regex::compile(soname_not_regex_prop->get_value()->as_string()); ini::simple_property_sptr name_prop = is_simple_property(section.find_property("name")); @@ -3168,15 +3170,16 @@ read_function_suppression(const ini::config::section& section) ini::simple_property_sptr name_regex_prop = is_simple_property(section.find_property("name_regexp")); - string name_regex_str = name_regex_prop - ? name_regex_prop->get_value()->as_string() - : ""; + regex_t_sptr name_regex; + if (name_regex_prop) + name_regex = regex::compile(name_regex_prop->get_value()->as_string()); ini::simple_property_sptr name_not_regex_prop = is_simple_property(section.find_property("name_not_regexp")); - string name_not_regex_str = name_not_regex_prop - ? name_not_regex_prop->get_value()->as_string() - : ""; + regex_t_sptr name_not_regex; + if (name_not_regex_prop) + name_not_regex = + regex::compile(name_not_regex_prop->get_value()->as_string()); ini::simple_property_sptr return_type_name_prop = is_simple_property(section.find_property("return_type_name")); @@ -3186,9 +3189,10 @@ read_function_suppression(const ini::config::section& section) ini::simple_property_sptr return_type_regex_prop = is_simple_property(section.find_property("return_type_regexp")); - string return_type_regex_str = return_type_regex_prop - ? return_type_regex_prop->get_value()->as_string() - : ""; + regex_t_sptr return_type_regex; + if (return_type_regex_prop) + return_type_regex = + regex::compile(return_type_regex_prop->get_value()->as_string()); ini::simple_property_sptr sym_name_prop = is_simple_property(section.find_property("symbol_name")); @@ -3198,15 +3202,17 @@ read_function_suppression(const ini::config::section& section) ini::simple_property_sptr sym_name_regex_prop = is_simple_property(section.find_property("symbol_name_regexp")); - string sym_name_regex_str = sym_name_regex_prop - ? sym_name_regex_prop->get_value()->as_string() - : ""; + regex_t_sptr sym_name_regex; + if (sym_name_regex_prop) + sym_name_regex = + regex::compile(sym_name_regex_prop->get_value()->as_string()); ini::simple_property_sptr sym_name_not_regex_prop = is_simple_property(section.find_property("symbol_name_not_regexp")); - string sym_name_not_regex_str = sym_name_not_regex_prop - ? sym_name_not_regex_prop->get_value()->as_string() - : ""; + regex_t_sptr sym_name_not_regex; + if (sym_name_not_regex_prop) + sym_name_not_regex = + regex::compile(sym_name_not_regex_prop->get_value()->as_string()); ini::simple_property_sptr sym_ver_prop = is_simple_property(section.find_property("symbol_version")); @@ -3216,9 +3222,10 @@ read_function_suppression(const ini::config::section& section) ini::simple_property_sptr sym_ver_regex_prop = is_simple_property(section.find_property("symbol_version_regexp")); - string sym_ver_regex_str = sym_ver_regex_prop - ? sym_ver_regex_prop->get_value()->as_string() - : ""; + regex_t_sptr sym_ver_regex; + if (sym_ver_regex_prop) + sym_ver_regex = + regex::compile(sym_ver_regex_prop->get_value()->as_string()); ini::simple_property_sptr allow_other_aliases_prop = is_simple_property(section.find_property("allow_other_aliases")); @@ -3243,22 +3250,22 @@ read_function_suppression(const ini::config::section& section) result.reset(new function_suppression(label_str, name, - name_regex_str, + name_regex, return_type_name, - return_type_regex_str, + return_type_regex, parms, sym_name, - sym_name_regex_str, + sym_name_regex, sym_version, - sym_ver_regex_str)); + sym_ver_regex)); if ((drop_artifact_str == "yes" || drop_artifact_str == "true") && (!name.empty() - || !name_regex_str.empty() - || !name_not_regex_str.empty() + || name_regex + || name_not_regex || !sym_name.empty() - || !sym_name_regex_str.empty() - || !sym_name_not_regex_str.empty())) + || sym_name_regex + || sym_name_not_regex)) result->set_drops_artifact_from_ir(true); if (!change_kind_str.empty()) @@ -3269,23 +3276,23 @@ read_function_suppression(const ini::config::section& section) result->set_allow_other_aliases(allow_other_aliases == "yes" || allow_other_aliases == "true"); - if (!name_not_regex_str.empty()) - result->set_name_not_regex_str(name_not_regex_str); + if (name_not_regex) + result->set_name_not_regex(name_not_regex); - if (!sym_name_not_regex_str.empty()) - result->set_symbol_name_not_regex_str(sym_name_not_regex_str); + if (sym_name_not_regex) + result->set_symbol_name_not_regex(sym_name_not_regex); - if (!file_name_regex_str.empty()) - result->set_file_name_regex_str(file_name_regex_str); + if (file_name_regex) + result->set_file_name_regex(file_name_regex); - if (!file_name_not_regex_str.empty()) - result->set_file_name_not_regex_str(file_name_not_regex_str); + if (file_name_not_regex) + result->set_file_name_not_regex(file_name_not_regex); - if (!soname_regex_str.empty()) - result->set_soname_regex_str(soname_regex_str); + if (soname_regex) + result->set_soname_regex(soname_regex); - if (!soname_not_regex_str.empty()) - result->set_soname_not_regex_str(soname_not_regex_str); + if (soname_not_regex) + result->set_soname_not_regex(soname_not_regex); return result; } @@ -3305,7 +3312,7 @@ read_function_suppression(const ini::config::section& section) /// specification to designate. This parameter might be empty, in /// which case it's ignored at evaluation time. /// -/// @param name_regex_str if @p name is empty, this parameter is a +/// @param name_regex if @p name is empty, this parameter is a /// regular expression for a family of names of variables the user /// wants the current specification to designate. If @p name is not /// empty, then this parameter is ignored at evaluation time. This @@ -3339,7 +3346,7 @@ read_function_suppression(const ini::config::section& section) /// wants the current specification to designate. This parameter /// might be empty, in which case it's ignored at evaluation time. /// -/// @param type_name_regex_str if @p type_name is empty, then this +/// @param type_name_regex if @p type_name is empty, then this /// parameter is a regular expression for a family of type names of /// variables the user wants the current specification to designate. /// If @p type_name is not empty, then this parameter is ignored at @@ -3347,18 +3354,18 @@ read_function_suppression(const ini::config::section& section) /// ignored at evaluation time. variable_suppression::variable_suppression(const string& label, const string& name, - const string& name_regex_str, + const regex_t_sptr& name_regex, const string& symbol_name, - const string& symbol_name_regex_str, + const regex_t_sptr& symbol_name_regex, const string& symbol_version, - const string& symbol_version_regex, + const regex_t_sptr& symbol_version_regex, const string& type_name, - const string& type_name_regex_str) + const regex_t_sptr& type_name_regex) : suppression_base(label), - priv_(new priv(name, name_regex_str, - symbol_name, symbol_name_regex_str, + priv_(new priv(name, name_regex, + symbol_name, symbol_name_regex, symbol_version, symbol_version_regex, - type_name, type_name_regex_str)) + type_name, type_name_regex)) {} /// Virtual destructor for the @erf variable_suppression type. @@ -3428,9 +3435,9 @@ variable_suppression::set_name(const string& n) /// which case it's ignored at evaluation time. /// /// @return the regular expression for the variable name. -const string& -variable_suppression::get_name_regex_str() const -{return priv_->name_regex_str_;} +const regex_t_sptr& +variable_suppression::get_name_regex() const +{return priv_->name_regex_;} /// Setter for the regular expression for a family of names of /// variables the user wants the current specification to designate. @@ -3441,22 +3448,22 @@ variable_suppression::get_name_regex_str() const /// /// @param r the new regular expression for the variable name. void -variable_suppression::set_name_regex_str(const string& r) -{priv_->name_regex_str_ = r;} +variable_suppression::set_name_regex(const regex_t_sptr& r) +{priv_->name_regex_ = r;} /// Getter for the "name_not_regexp" property of the specification. /// /// @return the value of the "name_not_regexp" property. -const string& -variable_suppression::get_name_not_regex_str() const -{return priv_->name_not_regex_str_;} +const regex_t_sptr& +variable_suppression::get_name_not_regex() const +{return priv_->name_not_regex_;} /// Setter for the "name_not_regexp" property of the specification. /// /// @param r the new value of the "name_not_regexp" property. void -variable_suppression::set_name_not_regex_str(const string& r) -{priv_->name_not_regex_str_ = r;} +variable_suppression::set_name_not_regex(const regex_t_sptr& r) +{priv_->name_not_regex_ = r;} /// Getter for the name of the symbol of the variable the user wants /// the current specification to designate. @@ -3489,9 +3496,9 @@ variable_suppression::set_symbol_name(const string& n) /// empty. /// /// @return the regular expression for a symbol name of the variable. -const string& -variable_suppression::get_symbol_name_regex_str() const -{return priv_->symbol_name_regex_str_;} +const regex_t_sptr& +variable_suppression::get_symbol_name_regex() const +{return priv_->symbol_name_regex_;} /// Setter of the regular expression for a family of symbol names of /// the variables this specification is about to designate. @@ -3503,8 +3510,8 @@ variable_suppression::get_symbol_name_regex_str() const /// /// @param r the regular expression for a symbol name of the variable. void -variable_suppression::set_symbol_name_regex_str(const string& r) -{priv_->symbol_name_regex_str_ = r;} +variable_suppression::set_symbol_name_regex(const regex_t_sptr& r) +{priv_->symbol_name_regex_ = r;} /// Getter for a regular expression for a family of names of symbols /// of variables the user wants this specification to designate. @@ -3519,11 +3526,11 @@ variable_suppression::set_symbol_name_regex_str(const string& r) /// This property might be empty, in which case it's ignored at /// evaluation time. /// -/// @return the regular expression string for a family of names of +/// @return the regular expression for a family of names of /// symbols that is to be *NOT* suppressed by this suppression specification. -const string& -variable_suppression::get_symbol_name_not_regex_str() const -{return priv_->symbol_name_not_regex_str_;} +const regex_t_sptr& +variable_suppression::get_symbol_name_not_regex() const +{return priv_->symbol_name_not_regex_;} /// Setter for a regular expression for a family of names of symbols /// of variables the user wants this specification to designate. @@ -3538,12 +3545,12 @@ variable_suppression::get_symbol_name_not_regex_str() const /// This property might be empty, in which case it's ignored at /// evaluation time. /// -/// @param the new regular expression string for a family of names of +/// @param the new regular expression for a family of names of /// symbols that is to be *NOT* suppressed by this suppression /// specification. void -variable_suppression::set_symbol_name_not_regex_str(const string& r) -{priv_->symbol_name_not_regex_str_ = r;} +variable_suppression::set_symbol_name_not_regex(const regex_t_sptr& r) +{priv_->symbol_name_not_regex_ = r;} /// Getter for the version of the symbol of the variable the user /// wants the current specification to designate. This property might @@ -3571,9 +3578,9 @@ variable_suppression::set_symbol_version(const string& v) /// /// @return the regular expression of the symbol version of the /// variable. -const string& -variable_suppression::get_symbol_version_regex_str() const -{return priv_->symbol_version_regex_str_;} +const regex_t_sptr& +variable_suppression::get_symbol_version_regex() const +{return priv_->symbol_version_regex_;} /// Setter of the regular expression for a family of versions of /// symbol for the variables the user wants the current specification @@ -3584,8 +3591,8 @@ variable_suppression::get_symbol_version_regex_str() const /// @param v the new regular expression of the symbol version of the /// variable. void -variable_suppression::set_symbol_version_regex_str(const string& r) -{priv_->symbol_version_regex_str_ = r;} +variable_suppression::set_symbol_version_regex(const regex_t_sptr& r) +{priv_->symbol_version_regex_ = r;} /// Getter for the name of the type of the variable the user wants the /// current specification to designate. @@ -3618,9 +3625,9 @@ variable_suppression::set_type_name(const string& n) /// empty, in which case it's ignored at evaluation time. /// /// @return the regular expression of the variable type name. -const string& -variable_suppression::get_type_name_regex_str() const -{return priv_->type_name_regex_str_;} +const regex_t_sptr& +variable_suppression::get_type_name_regex() const +{return priv_->type_name_regex_;} /// Setter for the regular expression for a family of type names of /// variables the user wants the current specification to designate. @@ -3632,8 +3639,8 @@ variable_suppression::get_type_name_regex_str() const /// /// @param r the regular expression of the variable type name. void -variable_suppression::set_type_name_regex_str(const string& r) -{priv_->type_name_regex_str_ = r;} +variable_suppression::set_type_name_regex(const regex_t_sptr& r) +{priv_->type_name_regex_ = r;} /// Evaluate this suppression specification on a given diff node and /// say if the diff node should be suppressed or not. @@ -3862,7 +3869,7 @@ variable_suppression::suppresses_variable_symbol(const elf_symbol* sym, if (get_symbol_name() != sym_name) return false; } - else if (!get_symbol_name_regex_str().empty()) + else if (get_symbol_name_regex()) { const regex_t_sptr sym_name_regex = priv_->get_symbol_name_regex(); if (sym_name_regex && !regex::match(sym_name_regex, sym_name)) @@ -3877,7 +3884,7 @@ variable_suppression::suppresses_variable_symbol(const elf_symbol* sym, if (get_symbol_version() != sym_version) return false; } - else if (!get_symbol_version_regex_str().empty()) + else if (get_symbol_version_regex()) { const regex_t_sptr symbol_version_regex = priv_->get_symbol_version_regex(); @@ -3995,27 +4002,30 @@ read_variable_suppression(const ini::config::section& section) ini::simple_property_sptr file_name_regex_prop = is_simple_property(section.find_property("file_name_regexp")); - string file_name_regex_str = - file_name_regex_prop ? file_name_regex_prop->get_value()->as_string() : ""; + regex_t_sptr file_name_regex; + if (file_name_regex_prop) + file_name_regex = + regex::compile(file_name_regex_prop->get_value()->as_string()); ini::simple_property_sptr file_name_not_regex_prop = - is_simple_property(section.find_property("file_name_not_regexp")); - string file_name_not_regex_str = - file_name_not_regex_prop - ? file_name_not_regex_prop->get_value()->as_string() - : ""; + is_simple_property(section.find_property("file_name_not_regexp")); + regex_t_sptr file_name_not_regex; + if (file_name_not_regex_prop) + file_name_not_regex = + regex::compile(file_name_not_regex_prop->get_value()->as_string()); ini::simple_property_sptr soname_regex_prop = is_simple_property(section.find_property("soname_regexp")); - string soname_regex_str = - soname_regex_prop ? soname_regex_prop->get_value()->as_string() : ""; + regex_t_sptr soname_regex; + if (soname_regex_prop) + soname_regex = regex::compile(soname_regex_prop->get_value()->as_string()); ini::simple_property_sptr soname_not_regex_prop = is_simple_property(section.find_property("soname_not_regexp")); - string soname_not_regex_str = - soname_not_regex_prop - ? soname_not_regex_prop->get_value()->as_string() - : ""; + regex_t_sptr soname_not_regex; + if (soname_not_regex_prop) + soname_not_regex = + regex::compile(soname_not_regex_prop->get_value()->as_string()); ini::simple_property_sptr name_prop = is_simple_property(section.find_property("name")); @@ -4025,15 +4035,16 @@ read_variable_suppression(const ini::config::section& section) ini::simple_property_sptr name_regex_prop = is_simple_property(section.find_property("name_regexp")); - string name_regex_str = (name_regex_prop - ? name_regex_prop->get_value()->as_string() - : ""); + regex_t_sptr name_regex; + if (name_regex_prop) + name_regex = regex::compile(name_regex_prop->get_value()->as_string()); ini::simple_property_sptr name_not_regex_prop = is_simple_property(section.find_property("name_not_regexp")); - string name_not_regex_str = name_not_regex_prop - ? name_not_regex_prop->get_value()->as_string() - : ""; + regex_t_sptr name_not_regex; + if (name_not_regex_prop) + name_not_regex = + regex::compile(name_not_regex_prop->get_value()->as_string()); ini::simple_property_sptr sym_name_prop = is_simple_property(section.find_property("symbol_name")); @@ -4043,15 +4054,17 @@ read_variable_suppression(const ini::config::section& section) ini::simple_property_sptr sym_name_regex_prop = is_simple_property(section.find_property("symbol_name_regexp")); - string symbol_name_regex_str = sym_name_regex_prop - ? sym_name_regex_prop->get_value()->as_string() - : ""; + regex_t_sptr symbol_name_regex; + if (sym_name_regex_prop) + symbol_name_regex = + regex::compile(sym_name_regex_prop->get_value()->as_string()); ini::simple_property_sptr sym_name_not_regex_prop = is_simple_property(section.find_property("symbol_name_not_regexp")); - string symbol_name_not_regex_str = sym_name_not_regex_prop - ? sym_name_not_regex_prop->get_value()->as_string() - : ""; + regex_t_sptr symbol_name_not_regex; + if (sym_name_not_regex_prop) + symbol_name_not_regex = + regex::compile(sym_name_not_regex_prop->get_value()->as_string()); ini::simple_property_sptr sym_version_prop = is_simple_property(section.find_property("symbol_version")); @@ -4061,9 +4074,10 @@ read_variable_suppression(const ini::config::section& section) ini::simple_property_sptr sym_version_regex_prop = is_simple_property(section.find_property("symbol_version_regexp")); - string symbol_version_regex_str = sym_version_regex_prop - ? sym_version_regex_prop->get_value()->as_string() - : ""; + regex_t_sptr symbol_version_regex; + if (sym_version_regex_prop) + symbol_version_regex = + regex::compile(sym_version_regex_prop->get_value()->as_string()); ini::simple_property_sptr type_name_prop = is_simple_property(section.find_property("type_name")); @@ -4073,50 +4087,51 @@ read_variable_suppression(const ini::config::section& section) ini::simple_property_sptr type_name_regex_prop = is_simple_property(section.find_property("type_name_regexp")); - string type_name_regex_str = type_name_regex_prop - ? type_name_regex_prop->get_value()->as_string() - : ""; + regex_t_sptr type_name_regex; + if (type_name_regex_prop) + type_name_regex = + regex::compile(type_name_regex_prop->get_value()->as_string()); result.reset(new variable_suppression(label_str, name_str, - name_regex_str, + name_regex, symbol_name, - symbol_name_regex_str, + symbol_name_regex, symbol_version, - symbol_version_regex_str, + symbol_version_regex, type_name_str, - type_name_regex_str)); + type_name_regex)); if ((drop_artifact_str == "yes" || drop_artifact_str == "true") && (!name_str.empty() - || !name_regex_str.empty() - || !name_not_regex_str.empty() + || name_regex + || name_not_regex || !symbol_name.empty() - || !symbol_name_regex_str.empty() - || !symbol_name_not_regex_str.empty())) + || symbol_name_regex + || symbol_name_not_regex)) result->set_drops_artifact_from_ir(true); - if (!name_not_regex_str.empty()) - result->set_name_not_regex_str(name_not_regex_str); + if (name_not_regex) + result->set_name_not_regex(name_not_regex); - if (!symbol_name_not_regex_str.empty()) - result->set_symbol_name_not_regex_str(symbol_name_not_regex_str); + if (symbol_name_not_regex) + result->set_symbol_name_not_regex(symbol_name_not_regex); if (!change_kind_str.empty()) result->set_change_kind (variable_suppression::parse_change_kind(change_kind_str)); - if (!file_name_regex_str.empty()) - result->set_file_name_regex_str(file_name_regex_str); + if (file_name_regex) + result->set_file_name_regex(file_name_regex); - if (!file_name_not_regex_str.empty()) - result->set_file_name_not_regex_str(file_name_not_regex_str); + if (file_name_not_regex) + result->set_file_name_not_regex(file_name_not_regex); - if (!soname_regex_str.empty()) - result->set_soname_regex_str(soname_regex_str); + if (soname_regex) + result->set_soname_regex(soname_regex); - if (!soname_not_regex_str.empty()) - result->set_soname_not_regex_str(soname_not_regex_str); + if (soname_not_regex) + result->set_soname_not_regex(soname_not_regex); return result; } @@ -4129,21 +4144,21 @@ read_variable_suppression(const ini::config::section& section) /// /// @param label the label of the suppression directive. /// -/// @param fname_regex_str the regular expression string that +/// @param fname_regex the regular expression that /// designates the file name that instances of @ref file_suppression /// should match. /// -/// @param fname_not_regex_str the regular expression string that +/// @param fname_not_regex the regular expression that /// designates the file name that instances of @ref file_suppression /// shoult *NOT* match. In other words, this file_suppression should /// be activated if its file name does not match the regular -/// expression @p fname_not_regex_str. +/// expression @p fname_not_regex. file_suppression::file_suppression(const string& label, - const string& fname_regex_str, - const string& fname_not_regex_str) + const regex_t_sptr& fname_regex, + const regex_t_sptr& fname_not_regex) : suppression_base(label, - fname_regex_str, - fname_not_regex_str) + fname_regex, + fname_not_regex) {} /// Test if instances of this @ref file_suppression suppresses a @@ -4223,41 +4238,44 @@ read_file_suppression(const ini::config::section& section) ini::simple_property_sptr file_name_regex_prop = is_simple_property(section.find_property("file_name_regexp")); - string file_name_regex_str = - file_name_regex_prop ? file_name_regex_prop->get_value()->as_string() : ""; + regex_t_sptr file_name_regex; + if (file_name_regex_prop) + file_name_regex = + regex::compile(file_name_regex_prop->get_value()->as_string()); ini::simple_property_sptr file_name_not_regex_prop = is_simple_property(section.find_property("file_name_not_regexp")); - string file_name_not_regex_str = - file_name_not_regex_prop - ? file_name_not_regex_prop->get_value()->as_string() - : ""; + regex_t_sptr file_name_not_regex; + if (file_name_not_regex_prop) + file_name_not_regex = + regex::compile(file_name_not_regex_prop->get_value()->as_string()); ini::simple_property_sptr soname_regex_prop = is_simple_property(section.find_property("soname_regexp")); - string soname_regex_str = - soname_regex_prop ? soname_regex_prop->get_value()->as_string() : ""; + regex_t_sptr soname_regex; + if (soname_regex_prop) + soname_regex = regex::compile(soname_regex_prop->get_value()->as_string()); ini::simple_property_sptr soname_not_regex_prop = is_simple_property(section.find_property("soname_not_regexp")); - string soname_not_regex_str = - soname_not_regex_prop - ? soname_not_regex_prop->get_value()->as_string() - : ""; + regex_t_sptr soname_not_regex; + if (soname_not_regex_prop) + soname_not_regex = + regex::compile(soname_not_regex_prop->get_value()->as_string()); result.reset(new file_suppression(label_str, - file_name_regex_str, - file_name_not_regex_str)); + file_name_regex, + file_name_not_regex)); - if (!soname_regex_str.empty()) + if (soname_regex) { - result->set_soname_regex_str(soname_regex_str); + result->set_soname_regex(soname_regex); result->set_drops_artifact_from_ir(true); } - if (!soname_not_regex_str.empty()) + if (soname_not_regex) { - result->set_soname_not_regex_str(soname_not_regex_str); + result->set_soname_not_regex(soname_not_regex); result->set_drops_artifact_from_ir(true); } diff --git a/src/abg-tools-utils.cc b/src/abg-tools-utils.cc index 11486a21..fe0de750 100644 --- a/src/abg-tools-utils.cc +++ b/src/abg-tools-utils.cc @@ -1810,13 +1810,15 @@ handle_file_entry(const string& file_path, { if (!suppr) { - suppr.reset(new type_suppression(get_private_types_suppr_spec_label(), - /*type_name_regexp=*/"", - /*type_name=*/"")); + suppr.reset( + new type_suppression(get_private_types_suppr_spec_label(), + /*type_name_regexp=*/regex::regex_t_sptr(), + /*type_name=*/"")); // Types that are defined in system headers are usually // OK to be considered as public types. - suppr->set_source_location_to_keep_regex_str("^/usr/include/"); + regex::regex_t_sptr headers_regex = regex::compile("^/usr/include/"); + suppr->set_source_location_to_keep_regex(headers_regex); suppr->set_is_artificial(true); } @@ -2004,7 +2006,8 @@ gen_suppr_spec_from_kernel_abi_whitelists // Build a regular expression representing the union of all // the function and variable names expressed in the white list. - const std::string regex = regex::generate_from_strings(whitelisted_names); + regex::regex_t_sptr regex = + regex::compile(regex::generate_from_strings(whitelisted_names)); // Build a suppression specification which *keeps* functions // whose ELF symbols match the regular expression contained @@ -2013,7 +2016,7 @@ gen_suppr_spec_from_kernel_abi_whitelists // match this regexp. function_suppression_sptr fn_suppr(new function_suppression); fn_suppr->set_label("whitelist"); - fn_suppr->set_symbol_name_not_regex_str(regex); + fn_suppr->set_symbol_name_not_regex(regex); fn_suppr->set_drops_artifact_from_ir(true); result.push_back(fn_suppr); @@ -2024,7 +2027,7 @@ gen_suppr_spec_from_kernel_abi_whitelists // match this regexp. variable_suppression_sptr var_suppr(new variable_suppression); var_suppr->set_label("whitelist"); - var_suppr->set_symbol_name_not_regex_str(regex); + var_suppr->set_symbol_name_not_regex(regex); var_suppr->set_drops_artifact_from_ir(true); result.push_back(var_suppr); } diff --git a/tests/test-kmi-whitelist.cc b/tests/test-kmi-whitelist.cc index bcc5adee..16cc1861 100644 --- a/tests/test-kmi-whitelist.cc +++ b/tests/test-kmi-whitelist.cc @@ -29,10 +29,14 @@ #include "lib/catch.hpp" #include "abg-fwd.h" -#include "abg-suppression.h" +#include "abg-regex.h" #include "abg-tools-utils.h" +#include "abg-suppression.h" #include "test-utils.h" +using abigail::regex::regex_t_sptr; +using abigail::regex::compile; +using abigail::regex::match; using abigail::tools_utils::gen_suppr_spec_from_kernel_abi_whitelists; using abigail::suppr::suppression_sptr; using abigail::suppr::suppressions_type; @@ -57,9 +61,30 @@ const static std::string whitelist_with_duplicate_entry = std::string(abigail::tests::get_src_dir()) + "/tests/data/test-kmi-whitelist/whitelist-with-duplicate-entry"; +// These are strings, not regexes, we cannot exhaustively check all +// strings, but we can do some sampling and match sure we haven't got +// the regex logic completely wrong. +static const char* const random_symbols[] = +{ + "", + ".*", + "^$", + "test_symbol", + "test-symbol", + "test symbol", + "Test Symbol", + "est_symbo", + ".*test_symbol.*", + "test_symbol ", + " test_symbol", + " test_symbol ", + "test_another_symbol", + "$test_another_symbol", +}; + void test_suppressions_are_consistent(const suppressions_type& suppr, - const std::string& expr) + const std::string& expr) { REQUIRE(suppr.size() == 2); @@ -74,11 +99,32 @@ test_suppressions_are_consistent(const suppressions_type& suppr, // same mode REQUIRE(left->get_drops_artifact_from_ir() == right->get_drops_artifact_from_ir()); - // same regex - REQUIRE(left->get_symbol_name_not_regex_str() - == right->get_symbol_name_not_regex_str()); - // regex as expected - REQUIRE(left->get_symbol_name_not_regex_str() == expr); + + // these parts of the symbol name matching should be absent + REQUIRE(left->get_symbol_name().empty()); + REQUIRE(!left->get_symbol_name_regex()); + REQUIRE(right->get_symbol_name().empty()); + REQUIRE(!right->get_symbol_name_regex()); + + regex_t_sptr left_regex = left->get_symbol_name_not_regex(); + regex_t_sptr right_regex = right->get_symbol_name_not_regex(); + regex_t_sptr check_regex = compile(expr); + + // all regexes present (compiled) + REQUIRE(left_regex); + REQUIRE(right_regex); + REQUIRE(check_regex); + + // all regexes match or do not match a random symbol + for (size_t i = 0; i < sizeof(random_symbols)/sizeof(random_symbols[0]); ++i) + { + const std::string symbol(random_symbols[i]); + bool left_matches = match(left_regex, symbol); + bool right_matches = match(right_regex, symbol); + bool check_matches = match(check_regex, symbol); + REQUIRE(left_matches == right_matches); + REQUIRE(left_matches == check_matches); + } } TEST_CASE("NoWhitelists", "[whitelists]") From patchwork Mon May 4 12:34:12 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Giuliano Procida X-Patchwork-Id: 39206 From: gprocida@google.com (Giuliano Procida) Date: Mon, 4 May 2020 13:34:12 +0100 Subject: [PATCH v4 11/15] Reduce direct access to suppression priv_ members. In-Reply-To: <20200504123416.243214-1-gprocida@google.com> References: <20200424092132.150547-1-gprocida@google.com> <20200504123416.243214-1-gprocida@google.com> Message-ID: <20200504123416.243214-12-gprocida@google.com> Most suppression type functionality is available on the types themselves via methods, particularly now that there are getters for all the regex members. This patch eliminates lots of accesses via priv_ members. There are no behavioural changes. * src/abg-suppression.cc (sonames_of_binaries_match): Use suppression_matches_soname helper function. (suppression_matches_type_name): Use type_suppression regex getters. (suppression_matches_type_location): Use type_suppression regex getters. (function::suppression::suppresses_function): Use own regex getters. (function::suppression::suppresses_function_symbol): Use own regex getters. (suppression_matches_function_name): Use function_suppression regex and name getters. (suppression_matches_function_sym_name): Use function_suppression regex and symbol name getters. (suppression_matches_variable_name): Use variable__suppression regex and name getters. (suppression_matches_variable_sym_name): Use variable_suppression regex and symbol name getters. (suppression_matches_type): Use type_suppression regex getter. (variable_suppression::suppresses_variable): Use own regex getters. (variable_suppression::suppresses_variable_symbol): Use own regex getters. (type_suppression::suppresses_file): Use own regex getters. (suppression_matches_soname_or_filename): Indentation fix, en passant. Reviewed-by: Matthias Maennich Signed-off-by: Giuliano Procida --- src/abg-suppression.cc | 107 +++++++++++++++++++---------------------- 1 file changed, 50 insertions(+), 57 deletions(-) diff --git a/src/abg-suppression.cc b/src/abg-suppression.cc index 80ac1e9f..4f44b175 100644 --- a/src/abg-suppression.cc +++ b/src/abg-suppression.cc @@ -276,8 +276,8 @@ sonames_of_binaries_match(const suppression_base& suppr, if (!suppr.has_soname_related_property()) return false; - if (!suppr.priv_->matches_soname(first_soname) - && !suppr.priv_->matches_soname(second_soname)) + if (!suppression_matches_soname(first_soname, suppr) + && !suppression_matches_soname(second_soname, suppr)) return false; return true; @@ -965,8 +965,8 @@ suppression_matches_type_name(const type_suppression& s, const string& type_name) { if (!s.get_type_name().empty() - || s.priv_->get_type_name_regex() - || s.priv_->get_type_name_not_regex()) + || s.get_type_name_regex() + || s.get_type_name_not_regex()) { // Check if there is an exact type name match. if (!s.get_type_name().empty()) @@ -982,14 +982,14 @@ suppression_matches_type_name(const type_suppression& s, // the regular expression of the type name, then this // suppression doesn't apply. if (const regex_t_sptr& type_name_regex = - s.priv_->get_type_name_regex()) + s.get_type_name_regex()) { if (!regex::match(type_name_regex, type_name)) return false; } if (const regex_t_sptr type_name_not_regex = - s.priv_->get_type_name_not_regex()) + s.get_type_name_not_regex()) { if (regex::match(type_name_not_regex, type_name)) return false; @@ -1037,7 +1037,7 @@ suppression_matches_type_location(const type_suppression& s, unsigned loc_line = 0, loc_column = 0; loc.expand(loc_path, loc_line, loc_column); - if (regex_t_sptr regexp = s.priv_->get_source_location_to_keep_regex()) + if (regex_t_sptr regexp = s.get_source_location_to_keep_regex()) if (regex::match(regexp, loc_path)) return false; @@ -1052,7 +1052,7 @@ suppression_matches_type_location(const type_suppression& s, else { if (!s.get_source_locations_to_keep().empty() - || s.priv_->get_source_location_to_keep_regex()) + || s.get_source_location_to_keep_regex()) // The user provided a "source_location_not_regexp" or // a "source_location_not_in" property that was not // triggered. This means the current type suppression @@ -1103,7 +1103,7 @@ suppression_matches_type_location(const type_suppression& s, } } if (!s.get_source_locations_to_keep().empty() - || s.priv_->get_source_location_to_keep_regex()) + || s.get_source_location_to_keep_regex()) // The user provided a "source_location_not_regexp" or // a "source_location_not_in" property that was not // triggered. This means the current type suppression @@ -2476,7 +2476,7 @@ function_suppression::suppresses_function(const function_decl* fn, } // check if the "name_regexp" property matches. - const regex_t_sptr name_regex = priv_->get_name_regex(); + const regex_t_sptr name_regex = get_name_regex(); if (name_regex) { if (!regex::match(name_regex, fname)) @@ -2507,7 +2507,7 @@ function_suppression::suppresses_function(const function_decl* fn, } // check if the "name_not_regexp" property matches. - const regex_t_sptr name_not_regex = priv_->get_name_not_regex(); + const regex_t_sptr name_not_regex = get_name_not_regex(); if (name_not_regex) { if (regex::match(name_not_regex, fname)) @@ -2553,7 +2553,7 @@ function_suppression::suppresses_function(const function_decl* fn, } else { - const regex_t_sptr return_type_regex = priv_->get_return_type_regex(); + const regex_t_sptr return_type_regex = get_return_type_regex(); if (return_type_regex && !regex::match(return_type_regex, fn_return_type_name)) return false; @@ -2591,12 +2591,11 @@ function_suppression::suppresses_function(const function_decl* fn, } else if (sym) { - const regex_t_sptr symbol_name_regex = priv_->get_symbol_name_regex(); + const regex_t_sptr symbol_name_regex = get_symbol_name_regex(); if (symbol_name_regex && !regex::match(symbol_name_regex, fn_sym_name)) return false; - const regex_t_sptr symbol_name_not_regex = - priv_->get_symbol_name_not_regex(); + const regex_t_sptr symbol_name_not_regex = get_symbol_name_not_regex(); if (symbol_name_not_regex && regex::match(symbol_name_not_regex, fn_sym_name)) return false; @@ -2633,8 +2632,7 @@ function_suppression::suppresses_function(const function_decl* fn, } else if (sym) { - const regex_t_sptr symbol_version_regex = - priv_->get_symbol_version_regex(); + const regex_t_sptr symbol_version_regex = get_symbol_version_regex(); if (symbol_version_regex && !regex::match(symbol_version_regex, fn_sym_version)) return false; @@ -2674,7 +2672,7 @@ function_suppression::suppresses_function(const function_decl* fn, else { const regex_t_sptr parm_type_name_regex = - (*p)->priv_->get_type_name_regex(); + (*p)->get_parameter_type_name_regex(); if (parm_type_name_regex) { if (!regex::match(parm_type_name_regex, @@ -2765,7 +2763,7 @@ function_suppression::suppresses_function_symbol(const elf_symbol* sym, } else if (get_symbol_name_regex()) { - const regex_t_sptr symbol_name_regex = priv_->get_symbol_name_regex(); + const regex_t_sptr symbol_name_regex = get_symbol_name_regex(); if (symbol_name_regex && !regex::match(symbol_name_regex, sym_name)) return false; } @@ -2780,8 +2778,7 @@ function_suppression::suppresses_function_symbol(const elf_symbol* sym, } else if (get_symbol_version_regex()) { - const regex_t_sptr symbol_version_regex = - priv_->get_symbol_version_regex(); + const regex_t_sptr symbol_version_regex = get_symbol_version_regex(); if (symbol_version_regex && !regex::match(symbol_version_regex, sym_version)) return false; @@ -2873,21 +2870,21 @@ bool suppression_matches_function_name(const suppr::function_suppression& s, const string& fn_name) { - if (regex_t_sptr regexp = s.priv_->get_name_regex()) + if (regex_t_sptr regexp = s.get_name_regex()) { if (!regex::match(regexp, fn_name)) return false; } - else if (regex_t_sptr regexp = s.priv_->get_name_not_regex()) + else if (regex_t_sptr regexp = s.get_name_not_regex()) { if (regex::match(regexp, fn_name)) return false; } - else if (s.priv_->name_.empty()) + else if (s.get_name().empty()) return false; - else // if (!s.priv_->name_.empty()) + else // if (!s.get_name().empty()) { - if (s.priv_->name_ != fn_name) + if (s.get_name() != fn_name) return false; } @@ -2909,21 +2906,21 @@ bool suppression_matches_function_sym_name(const suppr::function_suppression& s, const string& fn_linkage_name) { - if (regex_t_sptr regexp = s.priv_->get_symbol_name_regex()) + if (regex_t_sptr regexp = s.get_symbol_name_regex()) { if (!regex::match(regexp, fn_linkage_name)) return false; } - else if (regex_t_sptr regexp = s.priv_->get_symbol_name_not_regex()) + else if (regex_t_sptr regexp = s.get_symbol_name_not_regex()) { if (regex::match(regexp, fn_linkage_name)) return false; } - else if (s.priv_->symbol_name_.empty()) + else if (s.get_symbol_name().empty()) return false; - else // if (!s.priv_->symbol_name_.empty()) + else // if (!s.get_symbol_name().empty()) { - if (s.priv_->symbol_name_ != fn_linkage_name) + if (s.get_symbol_name() != fn_linkage_name) return false; } @@ -2942,21 +2939,21 @@ bool suppression_matches_variable_name(const suppr::variable_suppression& s, const string& var_name) { - if (regex_t_sptr regexp = s.priv_->get_name_regex()) + if (regex_t_sptr regexp = s.get_name_regex()) { if (!regex::match(regexp, var_name)) return false; } - else if (regex_t_sptr regexp = s.priv_->get_name_not_regex()) + else if (regex_t_sptr regexp = s.get_name_not_regex()) { if (regex::match(regexp, var_name)) return false; } - else if (s.priv_->name_.empty()) + else if (s.get_name().empty()) return false; - else // if (!s.priv_->name_.empty()) + else // if (!s.get_name().empty()) { - if (s.priv_->name_ != var_name) + if (s.get_name() != var_name) return false; } @@ -2976,22 +2973,21 @@ bool suppression_matches_variable_sym_name(const suppr::variable_suppression& s, const string& var_linkage_name) { - if (regex_t_sptr regexp = s.priv_->get_symbol_name_regex()) + if (regex_t_sptr regexp = s.get_symbol_name_regex()) { if (!regex::match(regexp, var_linkage_name)) return false; } - else if (regex_t_sptr regexp = - s.priv_->get_symbol_name_not_regex()) + else if (regex_t_sptr regexp = s.get_symbol_name_not_regex()) { if (regex::match(regexp, var_linkage_name)) return false; } - else if (s.priv_->symbol_name_.empty()) + else if (s.get_symbol_name().empty()) return false; - else // if (!s.priv_->symbol_name_.empty()) + else // if (!s.get_symbol_name().empty()) { - if (s.priv_->symbol_name_ != var_linkage_name) + if (s.get_symbol_name() != var_linkage_name) return false; } @@ -3011,7 +3007,7 @@ bool suppression_matches_type(const suppr::type_suppression& s, const string& type_name) { - if (regex_t_sptr regexp = s.priv_->get_type_name_regex()) + if (regex_t_sptr regexp = s.get_type_name_regex()) { if (!regex::match(regexp, type_name)) return false; @@ -3720,11 +3716,11 @@ variable_suppression::suppresses_variable(const var_decl* var, // "name_regex" and "name_not_regex" properties match if (get_name().empty()) { - const regex_t_sptr name_regex = priv_->get_name_regex(); + const regex_t_sptr name_regex = get_name_regex(); if (name_regex && !regex::match(name_regex, var_name)) return false; - const regex_t_sptr name_not_regex = priv_->get_name_not_regex(); + const regex_t_sptr name_not_regex = get_name_not_regex(); if (name_not_regex && regex::match(name_not_regex, var_name)) return false; } @@ -3740,12 +3736,11 @@ variable_suppression::suppresses_variable(const var_decl* var, } else { - const regex_t_sptr sym_name_regex = priv_->get_symbol_name_regex(); + const regex_t_sptr sym_name_regex = get_symbol_name_regex(); if (sym_name_regex && !regex::match(sym_name_regex, var_sym_name)) return false; - const regex_t_sptr sym_name_not_regex = - priv_->get_symbol_name_not_regex(); + const regex_t_sptr sym_name_not_regex = get_symbol_name_not_regex(); if (sym_name_not_regex && regex::match(sym_name_not_regex, var_sym_name)) return false; } @@ -3760,8 +3755,7 @@ variable_suppression::suppresses_variable(const var_decl* var, } else { - const regex_t_sptr symbol_version_regex = - priv_->get_symbol_version_regex(); + const regex_t_sptr symbol_version_regex = get_symbol_version_regex(); if (symbol_version_regex && !regex::match(symbol_version_regex, var_sym_version)) return false; @@ -3780,7 +3774,7 @@ variable_suppression::suppresses_variable(const var_decl* var, { if (get_type_name().empty()) { - const regex_t_sptr type_name_regex = priv_->get_type_name_regex(); + const regex_t_sptr type_name_regex = get_type_name_regex(); if (type_name_regex && !regex::match(type_name_regex, var_type_name)) return false; } @@ -3871,7 +3865,7 @@ variable_suppression::suppresses_variable_symbol(const elf_symbol* sym, } else if (get_symbol_name_regex()) { - const regex_t_sptr sym_name_regex = priv_->get_symbol_name_regex(); + const regex_t_sptr sym_name_regex = get_symbol_name_regex(); if (sym_name_regex && !regex::match(sym_name_regex, sym_name)) return false; } @@ -3886,8 +3880,7 @@ variable_suppression::suppresses_variable_symbol(const elf_symbol* sym, } else if (get_symbol_version_regex()) { - const regex_t_sptr symbol_version_regex = - priv_->get_symbol_version_regex(); + const regex_t_sptr symbol_version_regex = get_symbol_version_regex(); if (symbol_version_regex && !regex::match(symbol_version_regex, sym_version)) return false; @@ -4190,14 +4183,14 @@ file_suppression::suppresses_file(const string& file_path) bool has_regexp = false; - if (regex_t_sptr regexp = suppression_base::priv_->get_file_name_regex()) + if (regex_t_sptr regexp = get_file_name_regex()) { has_regexp = true; if (!regex::match(regexp, fname)) return false; } - if (regex_t_sptr regexp = suppression_base::priv_->get_file_name_not_regex()) + if (regex_t_sptr regexp = get_file_name_not_regex()) { has_regexp = true; if (regex::match(regexp, fname)) @@ -4350,7 +4343,7 @@ suppression_matches_soname_or_filename(const string& soname, const suppression_base& suppr) { return (suppression_matches_soname(soname, suppr) - || suppr.priv_->matches_binary_name(filename)); + || suppr.priv_->matches_binary_name(filename)); } /// @return the name of the artificial private type suppression From patchwork Mon May 4 12:34:13 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Giuliano Procida X-Patchwork-Id: 39207 From: gprocida@google.com (Giuliano Procida) Date: Mon, 4 May 2020 13:34:13 +0100 Subject: [PATCH v4 12/15] Move match methods from priv to suppression_base. In-Reply-To: <20200504123416.243214-1-gprocida@google.com> References: <20200424092132.150547-1-gprocida@google.com> <20200504123416.243214-1-gprocida@google.com> Message-ID: <20200504123416.243214-13-gprocida@google.com> The suppression_base::priv methods matches_soname and matches_binary_name do not require special access to the priv class and can be moved to the main suppression_base class and use its getters. This is a step towards simplifying the suppression type priv classes to the point they are simple data containers. There are no behavioural changes. * include/abg-suppression.h (suppression_base::matches_soname): Add declaration. (suppression_base::matches_binary_name): Add declaration. (suppression_base): Remove friend declarations of suppression_matches_soname and suppression_matches_soname_or_filename. * src/abg-dwarf-reader.cc (suppression_can_match): Call matches_soname and matches_binary_name on suppression values directly. * src/abg-reader.cc (suppression_can_match): Call matches_soname and matches_binary_name on suppression values directly. * src/abg-suppression-priv.h (suppression_base::priv::matches_soname): Remove method. (suppression_base::priv::matches_binary_name): Remove method. * src/abg-suppression.cc (suppression_base::matches_soname): Add definition. (suppression_base::matches_binary_name): Add definition. (names_of_binaries_match): Call matches_binary_name on suppression values directly. (suppression_matches_soname): Call matches_soname on suppression values directly. (suppression_matches_soname_or_filename): Call matches_binary_name on suppression values directly. Reviewed-by: Matthias Maennich Signed-off-by: Giuliano Procida --- include/abg-suppression.h | 15 +++----- src/abg-dwarf-reader.cc | 4 +- src/abg-reader.cc | 4 +- src/abg-suppression-priv.h | 71 +---------------------------------- src/abg-suppression.cc | 76 ++++++++++++++++++++++++++++++++++++-- 5 files changed, 83 insertions(+), 87 deletions(-) diff --git a/include/abg-suppression.h b/include/abg-suppression.h index 8256f9b8..ed6ca65c 100644 --- a/include/abg-suppression.h +++ b/include/abg-suppression.h @@ -116,19 +116,16 @@ public: bool has_soname_related_property() const; + bool + matches_soname(const std::string& soname) const; + + bool + matches_binary_name(const std::string& binary_name) const; + virtual bool suppresses_diff(const diff*) const = 0; virtual ~suppression_base(); - - friend bool - suppression_matches_soname(const string& soname, - const suppression_base& suppr); - - friend bool - suppression_matches_soname_or_filename(const string& soname, - const string& filename, - const suppression_base& suppr); }; // end class suppression_base void diff --git a/src/abg-dwarf-reader.cc b/src/abg-dwarf-reader.cc index 63837554..221ebc54 100644 --- a/src/abg-dwarf-reader.cc +++ b/src/abg-dwarf-reader.cc @@ -7723,14 +7723,14 @@ public: bool suppression_can_match(const suppr::suppression_base& s) const { - if (!s.priv_->matches_soname(dt_soname())) + if (!s.matches_soname(dt_soname())) if (s.has_soname_related_property()) // The suppression has some SONAME related properties, but // none of them match the SONAME of the current binary. So // the suppression cannot match the current binary. return false; - if (!s.priv_->matches_binary_name(elf_path())) + if (!s.matches_binary_name(elf_path())) if (s.has_file_name_related_property()) // The suppression has some file_name related properties, but // none of them match the file name of the current binary. So diff --git a/src/abg-reader.cc b/src/abg-reader.cc index 47ac6229..6c429446 100644 --- a/src/abg-reader.cc +++ b/src/abg-reader.cc @@ -999,14 +999,14 @@ public: { corpus_sptr corp = get_corpus(); - if (!s.priv_->matches_soname(corp->get_soname())) + if (!s.matches_soname(corp->get_soname())) if (s.has_soname_related_property()) // The suppression has some SONAME related properties, but // none of them match the SONAME of the current binary. So // the suppression cannot match the current binary. return false; - if (!s.priv_->matches_binary_name(corp->get_path())) + if (!s.matches_binary_name(corp->get_path())) if (s.has_file_name_related_property()) // The suppression has some file_name related properties, but // none of them match the file name of the current binary. So diff --git a/src/abg-suppression-priv.h b/src/abg-suppression-priv.h index c5f99c15..5027571a 100644 --- a/src/abg-suppression-priv.h +++ b/src/abg-suppression-priv.h @@ -107,76 +107,7 @@ public: { return soname_not_regex_; } - - /// Test if the current suppression matches a given SONAME. - /// - /// @param soname the SONAME to consider. - /// - /// @return true iff the suppression matches the SONAME denoted by - /// @p soname. - /// - /// Note that if the suppression contains no property that is - /// related to SONAMEs, the function returns false. - bool - matches_soname(const string& soname) const - { - bool has_regexp = false; - if (regex::regex_t_sptr regexp = get_soname_regex()) - { - has_regexp = true; - if (!regex::match(regexp, soname)) - return false; - } - - if (regex::regex_t_sptr regexp = get_soname_not_regex()) - { - has_regexp = true; - if (regex::match(regexp, soname)) - return false; - } - - if (!has_regexp) - return false; - - return true; - } - - /// Test if the current suppression matches the full file path to a - /// given binary. - /// - /// @param binary_name the full path to the binary. - /// - /// @return true iff the suppression matches the path denoted by @p - /// binary_name. - /// - /// Note that if the suppression contains no property that is - /// related to file name, the function returns false. - bool - matches_binary_name(const string& binary_name) const - { - bool has_regexp = false; - - if (regex::regex_t_sptr regexp = get_file_name_regex()) - { - has_regexp = true; - if (!regex::match(regexp, binary_name)) - return false; - } - - if (regex::regex_t_sptr regexp = get_file_name_not_regex()) - { - has_regexp = true; - if (regex::match(regexp, binary_name)) - return false; - } - - if (!has_regexp) - return false; - - return true; - } - -}; // end clas suppression_base::priv +}; // end class suppression_base::priv // diff --git a/src/abg-suppression.cc b/src/abg-suppression.cc index 4f44b175..2618b135 100644 --- a/src/abg-suppression.cc +++ b/src/abg-suppression.cc @@ -253,6 +253,74 @@ suppression_base::has_soname_related_property() const return get_soname_regex() || get_soname_not_regex(); } +/// Test if the current suppression matches a given SONAME. +/// +/// @param soname the SONAME to consider. +/// +/// @return true iff the suppression matches the SONAME denoted by +/// @p soname. +/// +/// Note that if the suppression contains no property that is +/// related to SONAMEs, the function returns false. +bool +suppression_base::matches_soname(const std::string& soname) const +{ + bool has_regexp = false; + if (regex_t_sptr regexp = get_soname_regex()) + { + has_regexp = true; + if (!regex::match(regexp, soname)) + return false; + } + + if (regex_t_sptr regexp = get_soname_not_regex()) + { + has_regexp = true; + if (regex::match(regexp, soname)) + return false; + } + + if (!has_regexp) + return false; + + return true; +} + +/// Test if the current suppression matches the full file path to a +/// given binary. +/// +/// @param binary_name the full path to the binary. +/// +/// @return true iff the suppression matches the path denoted by @p +/// binary_name. +/// +/// Note that if the suppression contains no property that is +/// related to file name, the function returns false. +bool +suppression_base::matches_binary_name(const std::string& binary_name) const +{ + bool has_regexp = false; + + if (regex_t_sptr regexp = get_file_name_regex()) + { + has_regexp = true; + if (!regex::match(regexp, binary_name)) + return false; + } + + if (regex_t_sptr regexp = get_file_name_not_regex()) + { + has_regexp = true; + if (regex::match(regexp, binary_name)) + return false; + } + + if (!has_regexp) + return false; + + return true; +} + /// Check if the SONAMEs of the two binaries being compared match the /// content of the properties "soname_regexp" and "soname_not_regexp" /// of the current suppression specification. @@ -306,8 +374,8 @@ names_of_binaries_match(const suppression_base& suppr, if (!suppr.has_file_name_related_property()) return false; - if (!suppr.priv_->matches_binary_name(first_binary_path) - && !suppr.priv_->matches_binary_name(second_binary_path)) + if (!suppr.matches_binary_name(first_binary_path) + && !suppr.matches_binary_name(second_binary_path)) return false; return true; @@ -4323,7 +4391,7 @@ bool suppression_matches_soname(const string& soname, const suppression_base& suppr) { - return suppr.priv_->matches_soname(soname); + return suppr.matches_soname(soname); } /// Test if a given SONAME or file name is matched by a given @@ -4343,7 +4411,7 @@ suppression_matches_soname_or_filename(const string& soname, const suppression_base& suppr) { return (suppression_matches_soname(soname, suppr) - || suppr.priv_->matches_binary_name(filename)); + || suppr.matches_binary_name(filename)); } /// @return the name of the artificial private type suppression From patchwork Mon May 4 12:34:14 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Giuliano Procida X-Patchwork-Id: 39208 From: gprocida@google.com (Giuliano Procida) Date: Mon, 4 May 2020 13:34:14 +0100 Subject: [PATCH v4 13/15] Remove suppression type priv class methods. In-Reply-To: <20200504123416.243214-1-gprocida@google.com> References: <20200424092132.150547-1-gprocida@google.com> <20200504123416.243214-1-gprocida@google.com> Message-ID: <20200504123416.243214-14-gprocida@google.com> The type_suppression::set_type_name_not_regex method is the only remaining user of all the various suppression_type::priv member functions. This is easily remedied and all the remaining priv member functions (regex getters and setters) can be dropped. This patches leaves all the various suppression priv types as simple data containers (modulo their constructors). There are no behavioural changes. * src/abg-suppression-priv.h (suppression_base::priv): Drop all regex getter methods. (function_suppression::parameter_spec::priv): Drop all regex getter methods. (function_suppression::priv): Drop all regex getter methods. (variable_suppression::priv): Drop all regex getter methods. (type_suppression::priv): Drop all regex getter and setter methods. * src/abg-suppression.cc (set_type_name_not_regex): Access priv_->type_name_not_regex_ directly. Reviewed-by: Matthias Maennich Signed-off-by: Giuliano Procida --- src/abg-suppression-priv.h | 182 ------------------------------------- src/abg-suppression.cc | 2 +- 2 files changed, 1 insertion(+), 183 deletions(-) diff --git a/src/abg-suppression-priv.h b/src/abg-suppression-priv.h index 5027571a..38adc190 100644 --- a/src/abg-suppression-priv.h +++ b/src/abg-suppression-priv.h @@ -75,38 +75,6 @@ public: {} friend class suppression_base; - - /// Get the regular expression object associated to the - /// 'file_name_regex' property of @ref suppression_base. - const regex::regex_t_sptr& - get_file_name_regex() const - { - return file_name_regex_; - } - - /// Get the regular expression object associated to the - /// 'file_name_not_regex' property of @ref suppression_base. - const regex::regex_t_sptr& - get_file_name_not_regex() const - { - return file_name_not_regex_; - } - - /// Get the regular expression object associated to the 'soname_regex' - /// property of @ref suppression_base. - const regex::regex_t_sptr& - get_soname_regex() const - { - return soname_regex_; - } - - /// Get the regular expression object associated to the - /// 'soname_not_regex' property of @ref suppression_base. - const regex::regex_t_sptr& - get_soname_not_regex() const - { - return soname_not_regex_; - } }; // end class suppression_base::priv // @@ -133,15 +101,6 @@ class function_suppression::parameter_spec::priv priv(size_t i, const string& tn, const regex::regex_t_sptr& tn_regex) : index_(i), type_name_(tn), type_name_regex_(tn_regex) {} - - /// Get the regular expression object associated to the - /// 'type_name_regex' property of @ref - /// function_suppression::parameter_spec. - const regex::regex_t_sptr - get_type_name_regex() const - { - return type_name_regex_; - } }; // end class function_suppression::parameter_spec::priv @@ -191,54 +150,6 @@ struct function_suppression::priv symbol_version_regex_(symbol_version_regex), allow_other_aliases_(true) {} - - /// Get the regular expression object associated to the 'name_regex' - /// property of @ref function_suppression. - const regex::regex_t_sptr - get_name_regex() const - { - return name_regex_; - } - - /// Get the regular expression object associated to the - /// 'name_not_regex' property of @ref function_suppression. - const regex::regex_t_sptr - get_name_not_regex() const - { - return name_not_regex_; - } - - /// Get the regular expression object associated to the - /// 'return_type_regex' property of @ref function_suppression. - const regex::regex_t_sptr - get_return_type_regex() const - { - return return_type_regex_; - } - - /// Get the regular expression object associated to the - /// 'symbol_name_regex' property of @ref function_suppression. - const regex::regex_t_sptr - get_symbol_name_regex() const - { - return symbol_name_regex_; - } - - /// Get the regular expression object associated to the - /// 'symbol_name_not_regex' property of @ref function_suppression. - const regex::regex_t_sptr - get_symbol_name_not_regex() const - { - return symbol_name_not_regex_; - } - - /// Get the regular expression object associated to the - /// 'symbol_version_regex' property of @ref function_suppression. - const regex::regex_t_sptr - get_symbol_version_regex() const - { - return symbol_version_regex_; - } }; // end class function_suppression::priv bool @@ -343,54 +254,6 @@ struct variable_suppression::priv type_name_(type_name), type_name_regex_(type_name_regex) {} - - /// Get the regular expression object associated to the 'name_regex' - /// property of @ref variable_suppression. - const regex::regex_t_sptr - get_name_regex() const - { - return name_regex_; - } - - /// Get the regular expression object associated to the - /// 'name_not_regex' property of @ref variable_suppression. - const regex::regex_t_sptr - get_name_not_regex() const - { - return name_not_regex_; - } - - /// Get the regular expression object associated to the - /// 'symbol_name_regex' property of @ref variable_suppression. - const regex::regex_t_sptr - get_symbol_name_regex() const - { - return symbol_name_regex_; - } - - /// Get the regular expression object associated to the - /// 'symbol_name_not_regex' property of @ref variable_suppression. - const regex::regex_t_sptr - get_symbol_name_not_regex() const - { - return symbol_name_not_regex_; - } - - /// Get the regular expression object associated to the - /// 'symbol_version_regex' property of @ref variable_suppression. - const regex::regex_t_sptr - get_symbol_version_regex() const - { - return symbol_version_regex_; - } - - /// Get the regular expression object associated to the - /// 'type_name_regex' property of @ref variable_suppression. - const regex::regex_t_sptr - get_type_name_regex() const - { - return type_name_regex_; - } };// end class variable_supppression::priv template @@ -454,51 +317,6 @@ public: reach_kind_(reach_kind) {} - /// Get the regular expression object associated to the - /// 'type_name_regex' property of @ref type_suppression. - const regex::regex_t_sptr - get_type_name_regex() const - { - return type_name_regex_; - } - - /// Setter for the type_name_regex object. - /// - /// @param r the new type_name_regex object. - void - set_type_name_regex(regex::regex_t_sptr r) - {type_name_regex_ = r;} - - /// Get the regular expression object associated to the - /// 'type_name_not_regex' property of @ref type_suppression. - const regex::regex_t_sptr - get_type_name_not_regex() const - { - return type_name_not_regex_; - } - - /// Setter for the type_name_not_regex object. - /// - /// @param r the new type_name_not_regex object. - void - set_type_name_not_regex(regex::regex_t_sptr r) - {type_name_not_regex_ = r;} - - /// Get the regular expression object associated to the - /// 'source_location_to_keep_regex' property of @ref type_suppression. - const regex::regex_t_sptr - get_source_location_to_keep_regex() const - { - return source_location_to_keep_regex_; - } - - /// Setter for the source_location_to_keep_regex object. - /// - /// @param r the new regex object. - void - set_source_location_to_keep_regex(regex::regex_t_sptr r) - {source_location_to_keep_regex_ = r;} - friend class type_suppression; }; // class type_suppression::priv diff --git a/src/abg-suppression.cc b/src/abg-suppression.cc index 2618b135..4883168d 100644 --- a/src/abg-suppression.cc +++ b/src/abg-suppression.cc @@ -516,7 +516,7 @@ type_suppression::get_type_name_regex() const /// @param r the new regexp string. void type_suppression::set_type_name_not_regex(const regex_t_sptr& r) -{priv_->set_type_name_not_regex(r);} +{priv_->type_name_not_regex_ = r;} /// Getter for the "type_name_not_regex" property of the type /// suppression specification. From patchwork Mon May 4 12:34:15 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Giuliano Procida X-Patchwork-Id: 39210 From: gprocida@google.com (Giuliano Procida) Date: Mon, 4 May 2020 13:34:15 +0100 Subject: [PATCH v4 14/15] abg-suppression.cc: More consistent regex matching. In-Reply-To: <20200504123416.243214-1-gprocida@google.com> References: <20200424092132.150547-1-gprocida@google.com> <20200504123416.243214-1-gprocida@google.com> Message-ID: <20200504123416.243214-15-gprocida@google.com> Following previous patches, various minor inconsistencies in the suppression regex matching code were more readily apparent. - regex_t_sptr values are fetched both by reference and by value (which has a reference count mutation cost) - there's a mixture of code styles for testing regex presence - regex = ...; if (regex && ...) - if (regex = ...) if (...) the latter has the advantage that the variable has a smaller scope and can be given a shorter name - in some cases there are redundant tests (always true due to previous conditional logic) This patch ensures all shared pointers to compiled regexes are fetched by const reference and that the code uses the nested if style of presence checking where possible. It simplifies some logic where there's redundancy. There are no behavioural changes. There may be performance improvements. * src/abg-suppression.cc (suppression_matches_type_name): Get regexes by const reference. (suppression_matches_type_location): Get regexes by const reference. (function_suppression::suppresses_function): Get regexes by const reference; use nested if checks; simplify logic around symbol version checks. (function_suppression::suppresses_function_symbol): Get regexes by const reference; use nested if checks; remove redundant regex presence checks. (suppression_matches_function_name): Get regexes by const reference. (suppression_matches_function_sym_name): Get regexes by const reference. (suppression_matches_variable_name): Get regexes by const reference. (suppression_matches_variable_sym_name): Get regexes by const reference. (suppression_matches_type): Get regexes by const reference. (variable_suppression::suppresses_variable): Get regexes by const reference; use nested if checks; remove redundant type_name empty check. (variable_suppression::suppresses_variable_symbol): Get regexes by const reference; use nested if checks. Signed-off-by: Giuliano Procida Reviewed-by: Matthias Maennich --- src/abg-suppression.cc | 167 +++++++++++++++++++---------------------- 1 file changed, 76 insertions(+), 91 deletions(-) diff --git a/src/abg-suppression.cc b/src/abg-suppression.cc index 4883168d..24f75b9a 100644 --- a/src/abg-suppression.cc +++ b/src/abg-suppression.cc @@ -1049,15 +1049,14 @@ suppression_matches_type_name(const type_suppression& s, // If the qualified name of the considered type doesn't match // the regular expression of the type name, then this // suppression doesn't apply. - if (const regex_t_sptr& type_name_regex = - s.get_type_name_regex()) + if (const regex_t_sptr& type_name_regex = s.get_type_name_regex()) { if (!regex::match(type_name_regex, type_name)) return false; } - if (const regex_t_sptr type_name_not_regex = - s.get_type_name_not_regex()) + if (const regex_t_sptr& type_name_not_regex = + s.get_type_name_not_regex()) { if (regex::match(type_name_not_regex, type_name)) return false; @@ -1105,7 +1104,7 @@ suppression_matches_type_location(const type_suppression& s, unsigned loc_line = 0, loc_column = 0; loc.expand(loc_path, loc_line, loc_column); - if (regex_t_sptr regexp = s.get_source_location_to_keep_regex()) + if (const regex_t_sptr& regexp = s.get_source_location_to_keep_regex()) if (regex::match(regexp, loc_path)) return false; @@ -2544,7 +2543,7 @@ function_suppression::suppresses_function(const function_decl* fn, } // check if the "name_regexp" property matches. - const regex_t_sptr name_regex = get_name_regex(); + const regex_t_sptr& name_regex = get_name_regex(); if (name_regex) { if (!regex::match(name_regex, fname)) @@ -2575,7 +2574,7 @@ function_suppression::suppresses_function(const function_decl* fn, } // check if the "name_not_regexp" property matches. - const regex_t_sptr name_not_regex = get_name_not_regex(); + const regex_t_sptr& name_not_regex = get_name_not_regex(); if (name_not_regex) { if (regex::match(name_not_regex, fname)) @@ -2619,11 +2618,9 @@ function_suppression::suppresses_function(const function_decl* fn, if (fn_return_type_name != get_return_type_name()) return false; } - else + else if (const regex_t_sptr& regex = get_return_type_regex()) { - const regex_t_sptr return_type_regex = get_return_type_regex(); - if (return_type_regex - && !regex::match(return_type_regex, fn_return_type_name)) + if (!regex::match(regex, fn_return_type_name)) return false; } @@ -2659,14 +2656,15 @@ function_suppression::suppresses_function(const function_decl* fn, } else if (sym) { - const regex_t_sptr symbol_name_regex = get_symbol_name_regex(); - if (symbol_name_regex && !regex::match(symbol_name_regex, fn_sym_name)) - return false; + const regex_t_sptr& symbol_name_regex = get_symbol_name_regex(); + const regex_t_sptr& symbol_name_not_regex = get_symbol_name_not_regex(); - const regex_t_sptr symbol_name_not_regex = get_symbol_name_not_regex(); - if (symbol_name_not_regex - && regex::match(symbol_name_not_regex, fn_sym_name)) - return false; + if (symbol_name_regex) + if (!regex::match(symbol_name_regex, fn_sym_name)) + return false; + if (symbol_name_not_regex) + if (regex::match(symbol_name_not_regex, fn_sym_name)) + return false; if (get_allow_other_aliases()) { @@ -2679,13 +2677,13 @@ function_suppression::suppresses_function(const function_decl* fn, a && !a->is_main_symbol(); a = a->get_next_alias()) { - if (symbol_name_regex - && !regex::match(symbol_name_regex, a->get_name())) - return false; - - if (symbol_name_not_regex - && regex::match(symbol_name_not_regex, a->get_name())) - return false; + const std::string& alias_name = a->get_name(); + if (symbol_name_regex) + if (!regex::match(symbol_name_regex, alias_name)) + return false; + if (symbol_name_not_regex) + if (regex::match(symbol_name_not_regex, alias_name)) + return false; } } } @@ -2693,17 +2691,19 @@ function_suppression::suppresses_function(const function_decl* fn, // Check if the "symbol_version" and "symbol_version_regexp" // properties match. - if (sym && !get_symbol_version().empty()) - { - if (fn_sym_version != get_symbol_version()) - return false; - } - else if (sym) + if (sym) { - const regex_t_sptr symbol_version_regex = get_symbol_version_regex(); - if (symbol_version_regex - && !regex::match(symbol_version_regex, fn_sym_version)) - return false; + if (!get_symbol_version().empty()) + { + if (fn_sym_version != get_symbol_version()) + return false; + } + else + { + if (const regex_t_sptr& regex = get_symbol_version_regex()) + if (!regex::match(regex, fn_sym_version)) + return false; + } } // Check the 'parameter' property. @@ -2737,16 +2737,11 @@ function_suppression::suppresses_function(const function_decl* fn, if (tn != fn_parm_type_qualified_name) return false; } - else + else if (const regex_t_sptr& regex = + (*p)->get_parameter_type_name_regex()) { - const regex_t_sptr parm_type_name_regex = - (*p)->get_parameter_type_name_regex(); - if (parm_type_name_regex) - { - if (!regex::match(parm_type_name_regex, - fn_parm_type_qualified_name)) - return false; - } + if (!regex::match(regex, fn_parm_type_qualified_name)) + return false; } } } @@ -2829,10 +2824,9 @@ function_suppression::suppresses_function_symbol(const elf_symbol* sym, if (sym_name != get_symbol_name()) return false; } - else if (get_symbol_name_regex()) + else if (const regex_t_sptr& regex = get_symbol_name_regex()) { - const regex_t_sptr symbol_name_regex = get_symbol_name_regex(); - if (symbol_name_regex && !regex::match(symbol_name_regex, sym_name)) + if (!regex::match(regex, sym_name)) return false; } else @@ -2844,11 +2838,9 @@ function_suppression::suppresses_function_symbol(const elf_symbol* sym, if (sym_version != get_symbol_version()) return false; } - else if (get_symbol_version_regex()) + else if (const regex_t_sptr& regex = get_symbol_version_regex()) { - const regex_t_sptr symbol_version_regex = get_symbol_version_regex(); - if (symbol_version_regex - && !regex::match(symbol_version_regex, sym_version)) + if (!regex::match(regex, sym_version)) return false; } else @@ -2938,12 +2930,12 @@ bool suppression_matches_function_name(const suppr::function_suppression& s, const string& fn_name) { - if (regex_t_sptr regexp = s.get_name_regex()) + if (const regex_t_sptr& regexp = s.get_name_regex()) { if (!regex::match(regexp, fn_name)) return false; } - else if (regex_t_sptr regexp = s.get_name_not_regex()) + else if (const regex_t_sptr& regexp = s.get_name_not_regex()) { if (regex::match(regexp, fn_name)) return false; @@ -2974,12 +2966,12 @@ bool suppression_matches_function_sym_name(const suppr::function_suppression& s, const string& fn_linkage_name) { - if (regex_t_sptr regexp = s.get_symbol_name_regex()) + if (const regex_t_sptr& regexp = s.get_symbol_name_regex()) { if (!regex::match(regexp, fn_linkage_name)) return false; } - else if (regex_t_sptr regexp = s.get_symbol_name_not_regex()) + else if (const regex_t_sptr& regexp = s.get_symbol_name_not_regex()) { if (regex::match(regexp, fn_linkage_name)) return false; @@ -3007,12 +2999,12 @@ bool suppression_matches_variable_name(const suppr::variable_suppression& s, const string& var_name) { - if (regex_t_sptr regexp = s.get_name_regex()) + if (const regex_t_sptr& regexp = s.get_name_regex()) { if (!regex::match(regexp, var_name)) return false; } - else if (regex_t_sptr regexp = s.get_name_not_regex()) + else if (const regex_t_sptr& regexp = s.get_name_not_regex()) { if (regex::match(regexp, var_name)) return false; @@ -3041,12 +3033,12 @@ bool suppression_matches_variable_sym_name(const suppr::variable_suppression& s, const string& var_linkage_name) { - if (regex_t_sptr regexp = s.get_symbol_name_regex()) + if (const regex_t_sptr& regexp = s.get_symbol_name_regex()) { if (!regex::match(regexp, var_linkage_name)) return false; } - else if (regex_t_sptr regexp = s.get_symbol_name_not_regex()) + else if (const regex_t_sptr& regexp = s.get_symbol_name_not_regex()) { if (regex::match(regexp, var_linkage_name)) return false; @@ -3075,7 +3067,7 @@ bool suppression_matches_type(const suppr::type_suppression& s, const string& type_name) { - if (regex_t_sptr regexp = s.get_type_name_regex()) + if (const regex_t_sptr& regexp = s.get_type_name_regex()) { if (!regex::match(regexp, type_name)) return false; @@ -3784,13 +3776,13 @@ variable_suppression::suppresses_variable(const var_decl* var, // "name_regex" and "name_not_regex" properties match if (get_name().empty()) { - const regex_t_sptr name_regex = get_name_regex(); - if (name_regex && !regex::match(name_regex, var_name)) - return false; + if (const regex_t_sptr& regex = get_name_regex()) + if (!regex::match(regex, var_name)) + return false; - const regex_t_sptr name_not_regex = get_name_not_regex(); - if (name_not_regex && regex::match(name_not_regex, var_name)) - return false; + if (const regex_t_sptr& regex = get_name_not_regex()) + if (regex::match(regex, var_name)) + return false; } } @@ -3804,13 +3796,13 @@ variable_suppression::suppresses_variable(const var_decl* var, } else { - const regex_t_sptr sym_name_regex = get_symbol_name_regex(); - if (sym_name_regex && !regex::match(sym_name_regex, var_sym_name)) - return false; + if (const regex_t_sptr& regex = get_symbol_name_regex()) + if (!regex::match(regex, var_sym_name)) + return false; - const regex_t_sptr sym_name_not_regex = get_symbol_name_not_regex(); - if (sym_name_not_regex && regex::match(sym_name_not_regex, var_sym_name)) - return false; + if (const regex_t_sptr& regex = get_symbol_name_not_regex()) + if (regex::match(regex, var_sym_name)) + return false; } // Check for symbol_version and symbol_version_regexp property match @@ -3823,10 +3815,9 @@ variable_suppression::suppresses_variable(const var_decl* var, } else { - const regex_t_sptr symbol_version_regex = get_symbol_version_regex(); - if (symbol_version_regex - && !regex::match(symbol_version_regex, var_sym_version)) - return false; + if (const regex_t_sptr& regex = get_symbol_version_regex()) + if (!regex::match(regex, var_sym_version)) + return false; } // Check for the "type_name" and type_name_regex properties match. @@ -3840,12 +3831,9 @@ variable_suppression::suppresses_variable(const var_decl* var, } else { - if (get_type_name().empty()) - { - const regex_t_sptr type_name_regex = get_type_name_regex(); - if (type_name_regex && !regex::match(type_name_regex, var_type_name)) - return false; - } + if (const regex_t_sptr& regex = get_type_name_regex()) + if (!regex::match(regex, var_type_name)) + return false; } return true; @@ -3931,10 +3919,9 @@ variable_suppression::suppresses_variable_symbol(const elf_symbol* sym, if (get_symbol_name() != sym_name) return false; } - else if (get_symbol_name_regex()) + else if (const regex_t_sptr& regex = get_symbol_name_regex()) { - const regex_t_sptr sym_name_regex = get_symbol_name_regex(); - if (sym_name_regex && !regex::match(sym_name_regex, sym_name)) + if (!regex::match(regex, sym_name)) return false; } else @@ -3946,11 +3933,9 @@ variable_suppression::suppresses_variable_symbol(const elf_symbol* sym, if (get_symbol_version() != sym_version) return false; } - else if (get_symbol_version_regex()) + else if (const regex_t_sptr& regex = get_symbol_version_regex()) { - const regex_t_sptr symbol_version_regex = get_symbol_version_regex(); - if (symbol_version_regex - && !regex::match(symbol_version_regex, sym_version)) + if (!regex::match(regex, sym_version)) return false; } else @@ -4251,14 +4236,14 @@ file_suppression::suppresses_file(const string& file_path) bool has_regexp = false; - if (regex_t_sptr regexp = get_file_name_regex()) + if (const regex_t_sptr& regexp = get_file_name_regex()) { has_regexp = true; if (!regex::match(regexp, fname)) return false; } - if (regex_t_sptr regexp = get_file_name_not_regex()) + if (const regex_t_sptr& regexp = get_file_name_not_regex()) { has_regexp = true; if (regex::match(regexp, fname)) From patchwork Mon May 4 12:34:16 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Giuliano Procida X-Patchwork-Id: 39211 From: gprocida@google.com (Giuliano Procida) Date: Mon, 4 May 2020 13:34:16 +0100 Subject: [PATCH v4 15/15] abg-tools-utils.cc: Assert generated regexes OK. In-Reply-To: <20200504123416.243214-1-gprocida@google.com> References: <20200424092132.150547-1-gprocida@google.com> <20200504123416.243214-1-gprocida@google.com> Message-ID: <20200504123416.243214-16-gprocida@google.com> There are a couple of places where regexes are generated internally. Assert they compile OK. This is just paranoia. There should be no behavioural changes. * src/abg-tools-utils.cc (handle_file_entry): Assert internally-generated regex compiles. (gen_suppr_spec_from_kernel_abi_whitelists): Assert internally-generated regex compiles. Reviewed-by: Matthias Maennich Signed-off-by: Giuliano Procida --- src/abg-tools-utils.cc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/abg-tools-utils.cc b/src/abg-tools-utils.cc index fe0de750..3af9fc49 100644 --- a/src/abg-tools-utils.cc +++ b/src/abg-tools-utils.cc @@ -1818,6 +1818,7 @@ handle_file_entry(const string& file_path, // Types that are defined in system headers are usually // OK to be considered as public types. regex::regex_t_sptr headers_regex = regex::compile("^/usr/include/"); + ABG_ASSERT(headers_regex); suppr->set_source_location_to_keep_regex(headers_regex); suppr->set_is_artificial(true); } @@ -2008,6 +2009,7 @@ gen_suppr_spec_from_kernel_abi_whitelists // the function and variable names expressed in the white list. regex::regex_t_sptr regex = regex::compile(regex::generate_from_strings(whitelisted_names)); + ABG_ASSERT(regex); // Build a suppression specification which *keeps* functions // whose ELF symbols match the regular expression contained