diff options
Diffstat (limited to 'tools/migration/ctoolchain_comparator_lib.py')
| -rw-r--r-- | tools/migration/ctoolchain_comparator_lib.py | 523 |
1 files changed, 523 insertions, 0 deletions
diff --git a/tools/migration/ctoolchain_comparator_lib.py b/tools/migration/ctoolchain_comparator_lib.py new file mode 100644 index 0000000..eb47305 --- /dev/null +++ b/tools/migration/ctoolchain_comparator_lib.py @@ -0,0 +1,523 @@ +# Copyright 2018 The Bazel Authors. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Module providing compare_ctoolchains function. + +compare_ctoolchains takes in two parsed CToolchains and compares them +""" + + +def _print_difference(field_name, before_value, after_value): + if not before_value and after_value: + print(("Difference in '%s' field:\nValue before change is not set\n" + "Value after change is set to '%s'") % (field_name, after_value)) + elif before_value and not after_value: + print(("Difference in '%s' field:\nValue before change is set to '%s'\n" + "Value after change is not set") % (field_name, before_value)) + else: + print(("Difference in '%s' field:\nValue before change:\t'%s'\n" + "Value after change:\t'%s'\n") % (field_name, before_value, + after_value)) + + +def _array_to_string(arr, ordered=False): + if not arr: + return "[]" + elif len(arr) == 1: + return "[" + list(arr)[0] + "]" + if not ordered: + return "[\n\t%s\n]" % "\n\t".join(arr) + else: + return "[\n\t%s\n]" % "\n\t".join(sorted(list(arr))) + + +def _check_with_feature_set_equivalence(before, after): + before_set = set() + after_set = set() + for el in before: + before_set.add((str(set(el.feature)), str(set(el.not_feature)))) + for el in after: + after_set.add((str(set(el.feature)), str(set(el.not_feature)))) + return before_set == after_set + + +def _check_tool_equivalence(before, after): + """Compares two "CToolchain.Tool"s.""" + if before.tool_path == "NOT_USED": + before.tool_path = "" + if after.tool_path == "NOT_USED": + after.tool_path = "" + if before.tool_path != after.tool_path: + return False + if set(before.execution_requirement) != set(after.execution_requirement): + return False + if not _check_with_feature_set_equivalence(before.with_feature, + after.with_feature): + return False + return True + + +def _check_flag_group_equivalence(before, after): + """Compares two "CToolchain.FlagGroup"s.""" + if before.flag != after.flag: + return False + if before.expand_if_true != after.expand_if_true: + return False + if before.expand_if_false != after.expand_if_false: + return False + if set(before.expand_if_all_available) != set(after.expand_if_all_available): + return False + if set(before.expand_if_none_available) != set( + after.expand_if_none_available): + return False + if before.iterate_over != after.iterate_over: + return False + if before.expand_if_equal != after.expand_if_equal: + return False + if len(before.flag_group) != len(after.flag_group): + return False + for (flag_group_before, flag_group_after) in zip(before.flag_group, + after.flag_group): + if not _check_flag_group_equivalence(flag_group_before, flag_group_after): + return False + return True + + +def _check_flag_set_equivalence(before, after, in_action_config=False): + """Compares two "CToolchain.FlagSet"s.""" + # ActionConfigs in proto format do not have a 'FlagSet.action' field set. + # Instead, when construction the Java ActionConfig object, we set the + # flag_set.action field to the action name. This currently causes the + # CcToolchainConfigInfo.proto to generate a CToolchain.ActionConfig that still + # has the action name in the FlagSet.action field, therefore we don't compare + # the FlagSet.action field when comparing flag_sets that belong to an + # ActionConfig. + if not in_action_config and set(before.action) != set(after.action): + return False + if not _check_with_feature_set_equivalence(before.with_feature, + after.with_feature): + return False + if len(before.flag_group) != len(after.flag_group): + return False + for (flag_group_before, flag_group_after) in zip(before.flag_group, + after.flag_group): + if not _check_flag_group_equivalence(flag_group_before, flag_group_after): + return False + return True + + +def _check_action_config_equivalence(before, after): + """Compares two "CToolchain.ActionConfig"s.""" + if before.config_name != after.config_name: + return False + if before.action_name != after.action_name: + return False + if before.enabled != after.enabled: + return False + if len(before.tool) != len(after.tool): + return False + for (tool_before, tool_after) in zip(before.tool, after.tool): + if not _check_tool_equivalence(tool_before, tool_after): + return False + if before.implies != after.implies: + return False + if len(before.flag_set) != len(after.flag_set): + return False + for (flag_set_before, flag_set_after) in zip(before.flag_set, after.flag_set): + if not _check_flag_set_equivalence(flag_set_before, flag_set_after, True): + return False + return True + + +def _check_env_set_equivalence(before, after): + """Compares two "CToolchain.EnvSet"s.""" + if set(before.action) != set(after.action): + return False + if not _check_with_feature_set_equivalence(before.with_feature, + after.with_feature): + return False + if before.env_entry != after.env_entry: + return False + return True + + +def _check_feature_equivalence(before, after): + """Compares two "CToolchain.Feature"s.""" + if before.name != after.name: + return False + if before.enabled != after.enabled: + return False + if len(before.flag_set) != len(after.flag_set): + return False + for (flag_set_before, flag_set_after) in zip(before.flag_set, after.flag_set): + if not _check_flag_set_equivalence(flag_set_before, flag_set_after): + return False + if len(before.env_set) != len(after.env_set): + return False + for (env_set_before, env_set_after) in zip(before.env_set, after.env_set): + if not _check_env_set_equivalence(env_set_before, env_set_after): + return False + if len(before.requires) != len(after.requires): + return False + for (requires_before, requires_after) in zip(before.requires, after.requires): + if set(requires_before.feature) != set(requires_after.feature): + return False + if before.implies != after.implies: + return False + if before.provides != after.provides: + return False + return True + + +def _compare_features(features_before, features_after): + """Compares two "CToolchain.FlagFeature" lists.""" + feature_name_to_feature_before = {} + feature_name_to_feature_after = {} + for feature in features_before: + feature_name_to_feature_before[feature.name] = feature + for feature in features_after: + feature_name_to_feature_after[feature.name] = feature + + feature_names_before = set(feature_name_to_feature_before.keys()) + feature_names_after = set(feature_name_to_feature_after.keys()) + + before_after_diff = feature_names_before - feature_names_after + after_before_diff = feature_names_after - feature_names_before + + diff_string = "Difference in 'feature' field:" + found_difference = False + if before_after_diff: + if not found_difference: + print(diff_string) # pylint: disable=superfluous-parens + found_difference = True + print(("* List before change contains entries for the following features " + "that the list after the change doesn't:\n%s") % _array_to_string( + before_after_diff, ordered=True)) + if after_before_diff: + if not found_difference: + print(diff_string) # pylint: disable=superfluous-parens + found_difference = True + print(("* List after change contains entries for the following features " + "that the list before the change doesn't:\n%s") % _array_to_string( + after_before_diff, ordered=True)) + + names_before = [feature.name for feature in features_before] + names_after = [feature.name for feature in features_after] + if names_before != names_after: + if not found_difference: + print(diff_string) # pylint: disable=superfluous-parens + found_difference = True + print(("Features not in right order:\n" + "* List of features before change:\t%s" + "* List of features before change:\t%s") % + (_array_to_string(names_before), _array_to_string(names_after))) + for name in feature_name_to_feature_before: + feature_before = feature_name_to_feature_before[name] + feature_after = feature_name_to_feature_after.get(name, None) + if feature_after and not _check_feature_equivalence(feature_before, + feature_after): + if not found_difference: + print(diff_string) # pylint: disable=superfluous-parens + found_difference = True + print(("* Feature '%s' differs before and after the change:\n" + "Value before change:\n%s\n" + "Value after change:\n%s") % (name, str(feature_before), + str(feature_after))) + if found_difference: + print("") # pylint: disable=superfluous-parens + return found_difference + + +def _compare_action_configs(action_configs_before, action_configs_after): + """Compares two "CToolchain.ActionConfig" lists.""" + action_name_to_action_before = {} + action_name_to_action_after = {} + for action_config in action_configs_before: + action_name_to_action_before[action_config.config_name] = action_config + for action_config in action_configs_after: + action_name_to_action_after[action_config.config_name] = action_config + + config_names_before = set(action_name_to_action_before.keys()) + config_names_after = set(action_name_to_action_after.keys()) + + before_after_diff = config_names_before - config_names_after + after_before_diff = config_names_after - config_names_before + + diff_string = "Difference in 'action_config' field:" + found_difference = False + if before_after_diff: + if not found_difference: + print(diff_string) # pylint: disable=superfluous-parens + found_difference = True + print(("* List before change contains entries for the following " + "action_configs that the list after the change doesn't:\n%s") % + _array_to_string(before_after_diff, ordered=True)) + if after_before_diff: + if not found_difference: + print(diff_string) # pylint: disable=superfluous-parens + found_difference = True + print(("* List after change contains entries for the following " + "action_configs that the list before the change doesn't:\n%s") % + _array_to_string(after_before_diff, ordered=True)) + + names_before = [config.config_name for config in action_configs_before] + names_after = [config.config_name for config in action_configs_after] + if names_before != names_after: + if not found_difference: + print(diff_string) # pylint: disable=superfluous-parens + found_difference = True + print(("Action configs not in right order:\n" + "* List of action configs before change:\t%s" + "* List of action_configs before change:\t%s") % + (_array_to_string(names_before), _array_to_string(names_after))) + for name in config_names_before: + action_config_before = action_name_to_action_before[name] + action_config_after = action_name_to_action_after.get(name, None) + if action_config_after and not _check_action_config_equivalence( + action_config_before, action_config_after): + if not found_difference: + print(diff_string) # pylint: disable=superfluous-parens + found_difference = True + print(("* Action config '%s' differs before and after the change:\n" + "Value before change:\n%s\n" + "Value after change:\n%s") % (name, str(action_config_before), + str(action_config_after))) + if found_difference: + print("") # pylint: disable=superfluous-parens + return found_difference + + +def _compare_tool_paths(tool_paths_before, tool_paths_after): + """Compares two "CToolchain.ToolPath" lists.""" + tool_to_path_before = {} + tool_to_path_after = {} + for tool_path in tool_paths_before: + tool_to_path_before[tool_path.name] = ( + tool_path.path if tool_path.path != "NOT_USED" else "") + for tool_path in tool_paths_after: + tool_to_path_after[tool_path.name] = ( + tool_path.path if tool_path.path != "NOT_USED" else "") + + tool_names_before = set(tool_to_path_before.keys()) + tool_names_after = set(tool_to_path_after.keys()) + + before_after_diff = tool_names_before - tool_names_after + after_before_diff = tool_names_after - tool_names_before + + diff_string = "Difference in 'tool_path' field:" + found_difference = False + if before_after_diff: + if not found_difference: + print(diff_string) # pylint: disable=superfluous-parens + found_difference = True + print(("* List before change contains entries for the following tools " + "that the list after the change doesn't:\n%s") % _array_to_string( + before_after_diff, ordered=True)) + if after_before_diff: + if not found_difference: + print(diff_string) # pylint: disable=superfluous-parens + found_difference = True + print(("* List after change contains entries for the following tools that " + "the list before the change doesn't:\n%s") % _array_to_string( + after_before_diff, ordered=True)) + + for tool in tool_to_path_before: + path_before = tool_to_path_before[tool] + path_after = tool_to_path_after.get(tool, None) + if path_after and path_after != path_before: + if not found_difference: + print(diff_string) # pylint: disable=superfluous-parens + found_difference = True + print(("* Path for tool '%s' differs before and after the change:\n" + "Value before change:\t'%s'\n" + "Value after change:\t'%s'") % (tool, path_before, path_after)) + if found_difference: + print("") # pylint: disable=superfluous-parens + return found_difference + + +def _compare_make_variables(make_variables_before, make_variables_after): + """Compares two "CToolchain.MakeVariable" lists.""" + name_to_variable_before = {} + name_to_variable_after = {} + for variable in make_variables_before: + name_to_variable_before[variable.name] = variable.value + for variable in make_variables_after: + name_to_variable_after[variable.name] = variable.value + + variable_names_before = set(name_to_variable_before.keys()) + variable_names_after = set(name_to_variable_after.keys()) + + before_after_diff = variable_names_before - variable_names_after + after_before_diff = variable_names_after - variable_names_before + + diff_string = "Difference in 'make_variable' field:" + found_difference = False + if before_after_diff: + if not found_difference: + print(diff_string) # pylint: disable=superfluous-parens + found_difference = True + print(("* List before change contains entries for the following variables " + "that the list after the change doesn't:\n%s") % _array_to_string( + before_after_diff, ordered=True)) + if after_before_diff: + if not found_difference: + print(diff_string) # pylint: disable=superfluous-parens + found_difference = True + print(("* List after change contains entries for the following variables " + "that the list before the change doesn't:\n%s") % _array_to_string( + after_before_diff, ordered=True)) + + for variable in name_to_variable_before: + value_before = name_to_variable_before[variable] + value_after = name_to_variable_after.get(variable, None) + if value_after and value_after != value_before: + if not found_difference: + print(diff_string) # pylint: disable=superfluous-parens + found_difference = True + print( + ("* Value for variable '%s' differs before and after the change:\n" + "Value before change:\t'%s'\n" + "Value after change:\t'%s'") % (variable, value_before, value_after)) + if found_difference: + print("") # pylint: disable=superfluous-parens + return found_difference + + +def _compare_cxx_builtin_include_directories(directories_before, + directories_after): + if directories_before != directories_after: + print(("Difference in 'cxx_builtin_include_directory' field:\n" + "List of elements before change:\n%s\n" + "List of elements after change:\n%s\n") % + (_array_to_string(directories_before), + _array_to_string(directories_after))) + return True + return False + + +def _compare_artifact_name_patterns(artifact_name_patterns_before, + artifact_name_patterns_after): + """Compares two "CToolchain.ArtifactNamePattern" lists.""" + category_to_values_before = {} + category_to_values_after = {} + for name_pattern in artifact_name_patterns_before: + category_to_values_before[name_pattern.category_name] = ( + name_pattern.prefix, name_pattern.extension) + for name_pattern in artifact_name_patterns_after: + category_to_values_after[name_pattern.category_name] = ( + name_pattern.prefix, name_pattern.extension) + + category_names_before = set(category_to_values_before.keys()) + category_names_after = set(category_to_values_after.keys()) + + before_after_diff = category_names_before - category_names_after + after_before_diff = category_names_after - category_names_before + + diff_string = "Difference in 'artifact_name_pattern' field:" + found_difference = False + if before_after_diff: + if not found_difference: + print(diff_string) # pylint: disable=superfluous-parens + found_difference = True + print(("* List before change contains entries for the following categories " + "that the list after the change doesn't:\n%s") % _array_to_string( + before_after_diff, ordered=True)) + if after_before_diff: + if not found_difference: + print(diff_string) # pylint: disable=superfluous-parens + found_difference = True + print(("* List after change contains entries for the following categories " + "that the list before the change doesn't:\n%s") % _array_to_string( + after_before_diff, ordered=True)) + + for category in category_to_values_before: + value_before = category_to_values_before[category] + value_after = category_to_values_after.get(category, None) + if value_after and value_after != value_before: + if not found_difference: + print(diff_string) # pylint: disable=superfluous-parens + found_difference = True + print(("* Value for category '%s' differs before and after the change:\n" + "Value before change:\tprefix:'%s'\textension:'%s'\n" + "Value after change:\tprefix:'%s'\textension:'%s'") % + (category, value_before[0], value_before[1], value_after[0], + value_after[1])) + if found_difference: + print("") # pylint: disable=superfluous-parens + return found_difference + + +def compare_ctoolchains(toolchain_before, toolchain_after): + """Compares two CToolchains.""" + found_difference = False + if (toolchain_before.toolchain_identifier != + toolchain_after.toolchain_identifier): + _print_difference("toolchain_identifier", + toolchain_before.toolchain_identifier, + toolchain_after.toolchain_identifier) + if toolchain_before.host_system_name != toolchain_after.host_system_name: + _print_difference("host_system_name", toolchain_before.host_system_name, + toolchain_after.host_system_name) + found_difference = True + if toolchain_before.target_system_name != toolchain_after.target_system_name: + _print_difference("target_system_name", toolchain_before.target_system_name, + toolchain_after.target_system_name) + found_difference = True + if toolchain_before.target_cpu != toolchain_after.target_cpu: + _print_difference("target_cpu", toolchain_before.target_cpu, + toolchain_after.target_cpu) + found_difference = True + if toolchain_before.target_libc != toolchain_after.target_libc: + _print_difference("target_libc", toolchain_before.target_libc, + toolchain_after.target_libc) + found_difference = True + if toolchain_before.compiler != toolchain_after.compiler: + _print_difference("compiler", toolchain_before.compiler, + toolchain_after.compiler) + found_difference = True + if toolchain_before.abi_version != toolchain_after.abi_version: + _print_difference("abi_version", toolchain_before.abi_version, + toolchain_after.abi_version) + found_difference = True + if toolchain_before.abi_libc_version != toolchain_after.abi_libc_version: + _print_difference("abi_libc_version", toolchain_before.abi_libc_version, + toolchain_after.abi_libc_version) + found_difference = True + if toolchain_before.cc_target_os != toolchain_after.cc_target_os: + _print_difference("cc_target_os", toolchain_before.cc_target_os, + toolchain_after.cc_target_os) + found_difference = True + if toolchain_before.builtin_sysroot != toolchain_after.builtin_sysroot: + _print_difference("builtin_sysroot", toolchain_before.builtin_sysroot, + toolchain_after.builtin_sysroot) + found_difference = True + found_difference = _compare_features( + toolchain_before.feature, toolchain_after.feature) or found_difference + found_difference = _compare_action_configs( + toolchain_before.action_config, + toolchain_after.action_config) or found_difference + found_difference = _compare_tool_paths( + toolchain_before.tool_path, toolchain_after.tool_path) or found_difference + found_difference = _compare_cxx_builtin_include_directories( + toolchain_before.cxx_builtin_include_directory, + toolchain_after.cxx_builtin_include_directory) or found_difference + found_difference = _compare_make_variables( + toolchain_before.make_variable, + toolchain_after.make_variable) or found_difference + found_difference = _compare_artifact_name_patterns( + toolchain_before.artifact_name_pattern, + toolchain_after.artifact_name_pattern) or found_difference + if not found_difference: + print("No difference") # pylint: disable=superfluous-parens + return found_difference |