blob: eb47305e1da94b66228c1f194cd5c75f8d695d80 [file] [log] [blame]
# 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