diff options
| -rw-r--r-- | SConstruct | 7 | ||||
| -rw-r--r-- | buildscripts/libdeps/gacli.py | 164 | ||||
| -rw-r--r-- | buildscripts/libdeps/graph_analyzer.py | 326 | ||||
| -rw-r--r-- | site_scons/libdeps_next.py | 110 |
4 files changed, 570 insertions, 37 deletions
diff --git a/SConstruct b/SConstruct index 3ef6caa14d2..0fc772c2b75 100644 --- a/SConstruct +++ b/SConstruct @@ -4998,9 +4998,4 @@ for i, s in enumerate(BUILD_TARGETS): # SConscripts have been read but before building begins. if get_option('build-tools') == 'next': libdeps.LibdepLinter(env).final_checks() - env.Command( - target="${BUILD_DIR}/libdeps/libdeps.graphml", - source=env.get('LIBDEPS_SYMBOL_DEP_FILES', []), - action=SCons.Action.FunctionAction( - libdeps.generate_graph, - {"cmdstr": "Generating libdeps graph"})) + libdeps.generate_libdeps_graph(env)
\ No newline at end of file diff --git a/buildscripts/libdeps/gacli.py b/buildscripts/libdeps/gacli.py new file mode 100644 index 00000000000..a89f8d7346e --- /dev/null +++ b/buildscripts/libdeps/gacli.py @@ -0,0 +1,164 @@ +#!/usr/bin/env python3 +# +# Copyright 2020 MongoDB Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY +# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE +# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# +""" +Graph Analysis Command Line Interface. + +A Command line interface to the graph analysis module. +""" + +import argparse +import textwrap +import sys +from pathlib import Path + +import networkx +import graph_analyzer + + +class LinterSplitArgs(argparse.Action): + """Custom argument action for checking multiple choice comma separated list.""" + + def __call__(self, parser, namespace, values, option_string=None): + """Create a multi choice comma separated list.""" + + selected_choices = [v for v in ''.join(values).split(',') if v] + invalid_choices = [ + choice for choice in selected_choices if choice not in self.valid_choices + ] + if invalid_choices: + raise Exception( + f"Invalid choices: {invalid_choices}\nMust use choices from {self.valid_choices}") + if graph_analyzer.CountTypes.all.name in selected_choices or selected_choices == []: + selected_choices = self.valid_choices + setattr(namespace, self.dest, [opt.replace('-', '_') for opt in selected_choices]) + + +class CountSplitArgs(LinterSplitArgs): + """Special case of common custom arg action for Count types.""" + + valid_choices = [ + name[0].replace('_', '-') for name in graph_analyzer.CountTypes.__members__.items() + ] + + +class CustomFormatter(argparse.RawTextHelpFormatter, argparse.ArgumentDefaultsHelpFormatter): + """Custom arg help formatter for modifying the defaults printed for the custom list action.""" + + def _get_help_string(self, action): + + if isinstance(action, CountSplitArgs): + max_length = max( + [len(name[0]) for name in graph_analyzer.CountTypes.__members__.items()]) + count_help = {} + for name in graph_analyzer.CountTypes.__members__.items(): + count_help[name[0]] = name[0] + ('-' * (max_length - len(name[0]))) + ": " + return textwrap.dedent(f"""\ + {action.help} + default: all, choices: + {count_help[graph_analyzer.CountTypes.all.name]}perform all counts + {count_help[graph_analyzer.CountTypes.node.name]}count nodes + {count_help[graph_analyzer.CountTypes.edge.name]}count edges + {count_help[graph_analyzer.CountTypes.dir_edge.name]}count edges declared directly on a node + {count_help[graph_analyzer.CountTypes.trans_edge.name]}count edges induced by direct public edges + {count_help[graph_analyzer.CountTypes.dir_pub_edge.name]}count edges that are directly public + {count_help[graph_analyzer.CountTypes.pub_edge.name]}count edges that are public + {count_help[graph_analyzer.CountTypes.priv_edge.name]}count edges that are private + {count_help[graph_analyzer.CountTypes.if_edge.name]}count edges that are interface + """) + return super()._get_help_string(action) + + +def setup_args_parser(): + """Add and parse the input args.""" + + parser = argparse.ArgumentParser(formatter_class=CustomFormatter) + + parser.add_argument('--graph-file', type=str, action='store', help="The LIBDEPS graph to load.", + default="build/opt/libdeps/libdeps.graphml") + + parser.add_argument( + '--build-dir', type=str, action='store', help= + "The path where the generic build files live, corresponding to BUILD_DIR in the Sconscripts.", + default=None) + + parser.add_argument('--format', choices=['pretty', 'json'], default='pretty', + help="The output format type.") + + parser.add_argument('--counts', metavar='COUNT,', nargs='*', action=CountSplitArgs, + help="Output various counts from the graph. Comma separated list.") + + parser.add_argument('--direct-depends', action='append', + help="Print the nodes which depends on a given node.") + + parser.add_argument('--common-depends', nargs='+', action='append', + help="Print the nodes which have a common dependency on all N nodes.") + + parser.add_argument( + '--exclude-depends', nargs='+', action='append', help= + "Print nodes which depend on the first node of N nodes, but exclude all nodes listed there after." + ) + + return parser.parse_args() + + +def load_graph_data(graph_file, output_format): + """Load a graphml file into a LibdepsGraph.""" + + if output_format == "pretty": + sys.stdout.write("Loading graph data...") + sys.stdout.flush() + graph = graph = networkx.read_graphml(graph_file) + if output_format == "pretty": + sys.stdout.write("Loaded!\n\n") + return graph + + +def main(): + """Perform graph analysis based on input args.""" + + args = setup_args_parser() + if not args.build_dir: + args.build_dir = str(Path(args.graph_file).parents[1]) + graph = load_graph_data(args.graph_file, args.format) + + depends_reports = { + graph_analyzer.DependsReportTypes.direct_depends.name: args.direct_depends, + graph_analyzer.DependsReportTypes.common_depends.name: args.common_depends, + graph_analyzer.DependsReportTypes.exclude_depends.name: args.exclude_depends, + } + libdeps = graph_analyzer.LibdepsGraph(graph) + ga = graph_analyzer.LibdepsGraphAnalysis(libdeps, args.build_dir, args.counts, depends_reports) + + if args.format == 'pretty': + ga_printer = graph_analyzer.GaPrettyPrinter(ga) + elif args.format == 'json': + ga_printer = graph_analyzer.GaJsonPrinter(ga) + else: + return + + ga_printer.print() + + +if __name__ == "__main__": + main() diff --git a/buildscripts/libdeps/graph_analyzer.py b/buildscripts/libdeps/graph_analyzer.py new file mode 100644 index 00000000000..ac3d7339b7f --- /dev/null +++ b/buildscripts/libdeps/graph_analyzer.py @@ -0,0 +1,326 @@ +#!/usr/bin/env python3 +# +# Copyright 2020 MongoDB Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY +# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE +# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# +""" +Libdeps Graph Analysis Tool. + +This will perform various metric's gathering and linting on the +graph generated from SCons generate-libdeps-graph target. The graph +represents the dependency information between all binaries from the build. +""" + +from enum import Enum, auto +from pathlib import Path + +import networkx + + +class CountTypes(Enum): + """Enums for the different types of counts to perform on a graph.""" + + all = auto() + node = auto() + edge = auto() + dir_edge = auto() + trans_edge = auto() + dir_pub_edge = auto() + pub_edge = auto() + priv_edge = auto() + if_edge = auto() + + +class DependsReportTypes(Enum): + """Enums for the different type of depends reports to perform on a graph.""" + + direct_depends = auto() + common_depends = auto() + exclude_depends = auto() + + +class EdgeProps(Enum): + """Enums for edge properties.""" + + direct = auto() + visibility = auto() + + +class LibdepsGraph(networkx.DiGraph): + """Class for analyzing the graph.""" + + def __init__(self, graph=networkx.DiGraph()): + """Load the graph data.""" + + super().__init__(incoming_graph_data=graph) + + # Load in the graph and store a reversed version as well for quick look ups + # the in directions. + self.rgraph = graph.reverse() + + def number_of_edge_types(self, edge_type, value): + """Count the graphs edges based on type.""" + + return len([edge for edge in self.edges(data=True) if edge[2].get(edge_type) == value]) + + def node_count(self): + """Count the graphs nodes.""" + + return self.number_of_nodes() + + def edge_count(self): + """Count the graphs edges.""" + + return self.number_of_edges() + + def direct_edge_count(self): + """Count the graphs direct edges.""" + + return self.number_of_edge_types(EdgeProps.direct.name, 1) + + def transitive_edge_count(self): + """Count the graphs transitive edges.""" + + return self.number_of_edge_types(EdgeProps.direct.name, 0) + + def direct_public_edge_count(self): + """Count the graphs direct public edges.""" + + return len([ + edge for edge in self.edges(data=True) if edge[2].get(EdgeProps.direct.name) == 1 + and edge[2].get(EdgeProps.visibility.name) == 0 + ]) + + def public_edge_count(self): + """Count the graphs public edges.""" + + return self.number_of_edge_types(EdgeProps.visibility.name, 0) + + def private_edge_count(self): + """Count the graphs private edges.""" + + return self.number_of_edge_types(EdgeProps.visibility.name, 1) + + def interface_edge_count(self): + """Count the graphs interface edges.""" + + return self.number_of_edge_types(EdgeProps.visibility.name, 2) + + def direct_depends(self, node): + """For given nodes, report what nodes depend directly on that node.""" + + return [ + depender for depender in self[node] + if self[node][depender].get(EdgeProps.direct.name) == 1 + ] + + def common_depends(self, nodes): + """For a given set of nodes, report what nodes depend on all nodes from that set.""" + + neighbor_sets = [set(self[node]) for node in nodes] + return list(set.intersection(*neighbor_sets)) + + def exclude_depends(self, nodes): + """Find depends with exclusions. + + Given a node, and a set of other nodes, find what nodes depend on the given + node, but do not depend on the set of nodes. + """ + + valid_depender_nodes = [] + for depender_node in set(self[nodes[0]]): + if all([ + bool(excludes_node not in set(self.rgraph[depender_node])) + for excludes_node in nodes[1:] + ]): + valid_depender_nodes.append(depender_node) + return valid_depender_nodes + + +class LibdepsGraphAnalysis: + """Runs the given analysis on the input graph.""" + + def __init__(self, libdeps_graph, build_dir='build/opt', counts='all', depends_reports=None): + """Perform analysis based off input args.""" + + self.build_dir = Path(build_dir) + self.libdeps_graph = libdeps_graph + + self.results = {} + + self.count_types = { + CountTypes.node.name: ("num_nodes", libdeps_graph.node_count), + CountTypes.edge.name: ("num_edges", libdeps_graph.edge_count), + CountTypes.dir_edge.name: ("num_direct_edges", libdeps_graph.direct_edge_count), + CountTypes.trans_edge.name: ("num_trans_edges", libdeps_graph.transitive_edge_count), + CountTypes.dir_pub_edge.name: ("num_direct_public_edges", + libdeps_graph.direct_public_edge_count), + CountTypes.pub_edge.name: ("num_public_edges", libdeps_graph.public_edge_count), + CountTypes.priv_edge.name: ("num_private_edges", libdeps_graph.private_edge_count), + CountTypes.if_edge.name: ("num_interface_edges", libdeps_graph.interface_edge_count), + } + + for name in DependsReportTypes.__members__.items(): + setattr(self, f'{name[0]}_key', name[0]) + + if counts: + self.run_graph_counters(counts) + if depends_reports: + self.run_depend_reports(depends_reports) + + def get_results(self): + """Return the results fo the analysis.""" + + return self.results + + def _strip_build_dir(self, node): + """Small util function for making args match the graph paths.""" + + node = Path(node) + if str(node.absolute()).startswith(str(self.build_dir.absolute())): + return str(node.relative_to(self.build_dir)) + else: + raise Exception( + f"build path not in node path: node: {node} build_dir: {self.build_dir}") + + def _strip_build_dirs(self, nodes): + """Small util function for making a list of nodes match graph paths.""" + + for node in nodes: + yield self._strip_build_dir(node) + + def run_graph_counters(self, counts): + """Run the various graph counters for nodes and edges.""" + + for count_type in CountTypes.__members__.items(): + if count_type[0] in self.count_types: + dict_name, func = self.count_types[count_type[0]] + + if count_type[0] in counts: + self.results[dict_name] = func() + + def run_depend_reports(self, depends_reports): + """Run the various dependency reports.""" + + if depends_reports.get(self.direct_depends_key): + self.results[self.direct_depends_key] = {} + for node in depends_reports[self.direct_depends_key]: + self.results[self.direct_depends_key][node] = self.libdeps_graph.direct_depends( + self._strip_build_dir(node)) + + if depends_reports.get(self.common_depends_key): + self.results[self.common_depends_key] = {} + for nodes in depends_reports[self.common_depends_key]: + nodes = frozenset(self._strip_build_dirs(nodes)) + self.results[self.common_depends_key][nodes] = self.libdeps_graph.common_depends( + nodes) + + if depends_reports.get(self.exclude_depends_key): + self.results[self.exclude_depends_key] = {} + for nodes in depends_reports[self.exclude_depends_key]: + nodes = tuple(self._strip_build_dirs(nodes)) + self.results[self.exclude_depends_key][nodes] = self.libdeps_graph.exclude_depends( + nodes) + + +class GaPrinter: + """Base class for printers of the graph analysis.""" + + def __init__(self, libdeps_graph_analysis): + """Store the graph analysis for use when printing.""" + + self.libdeps_graph_analysis = libdeps_graph_analysis + + +class GaJsonPrinter(GaPrinter): + """Printer for json output.""" + + def serialize(self, dictionary): + """Serialize the k,v pairs in the dictionary.""" + + new = {} + for key, value in dictionary.items(): + if isinstance(value, dict): + value = self.serialize(value) + new[str(key)] = value + return new + + def print(self): + """Print the result data.""" + + import json + results = self.libdeps_graph_analysis.get_results() + print(json.dumps(self.serialize(results))) + + +class GaPrettyPrinter(GaPrinter): + """Printer for pretty console output.""" + + count_desc = { + CountTypes.node.name: ("num_nodes", "Nodes in Graph: {}"), + CountTypes.edge.name: ("num_edges", "Edges in Graph: {}"), + CountTypes.dir_edge.name: ("num_direct_edges", "Direct Edges in Graph: {}"), + CountTypes.trans_edge.name: ("num_trans_edges", "Transitive Edges in Graph: {}"), + CountTypes.dir_pub_edge.name: ("num_direct_public_edges", + "Direct Public Edges in Graph: {}"), + CountTypes.pub_edge.name: ("num_public_edges", "Public Edges in Graph: {}"), + CountTypes.priv_edge.name: ("num_private_edges", "Private Edges in Graph: {}"), + CountTypes.if_edge.name: ("num_interface_edges", "Interface Edges in Graph: {}"), + } + + @staticmethod + def _print_results_node_list(heading, nodes): + """Util function for printing a list of nodes for depend reports.""" + + print(heading) + for i, depender in enumerate(nodes, start=1): + print(f"\t{i}: {depender}") + print("") + + def print(self): + """Print the result data.""" + + results = self.libdeps_graph_analysis.get_results() + for count_type in CountTypes.__members__.items(): + if count_type[0] in self.count_desc: + dict_name, desc = self.count_desc[count_type[0]] + if dict_name in results: + print(desc.format(results[dict_name])) + + if DependsReportTypes.direct_depends.name in results: + print("\nNodes that directly depend on:") + for node in results[DependsReportTypes.direct_depends.name]: + self._print_results_node_list(f'=>depends on {node}:', + results[DependsReportTypes.direct_depends.name][node]) + + if DependsReportTypes.common_depends.name in results: + print("\nNodes that commonly depend on:") + for nodes in results[DependsReportTypes.common_depends.name]: + self._print_results_node_list( + f'=>depends on {nodes}:', + results[DependsReportTypes.common_depends.name][nodes]) + + if DependsReportTypes.exclude_depends.name in results: + print("\nNodes that depend on a node, but exclude others:") + for nodes in results[DependsReportTypes.exclude_depends.name]: + self._print_results_node_list( + f"=>depends: {nodes[0]}, exclude: {nodes[1:]}:", + results[DependsReportTypes.exclude_depends.name][nodes]) diff --git a/site_scons/libdeps_next.py b/site_scons/libdeps_next.py index 6da1a232a97..195567eda75 100644 --- a/site_scons/libdeps_next.py +++ b/site_scons/libdeps_next.py @@ -814,14 +814,6 @@ def _get_node_with_ixes(env, node, node_builder_type): _get_node_with_ixes.node_type_ixes = dict() -def add_libdeps_node(env, target, libdeps): - if str(target).endswith(env["SHLIBSUFFIX"]): - t_str = _get_node_with_ixes(env, str(target.abspath), target.get_builder().get_name(env)).abspath - env.GetLibdepsGraph().add_node(t_str) - for libdep in libdeps: - if str(libdep.target_node).endswith(env["SHLIBSUFFIX"]): - env.GetLibdepsGraph().add_edge(str(libdep.target_node.abspath), t_str, visibility=libdep.dependency_type) - def make_libdeps_emitter( dependency_builder, dependency_map=dependency_visibility_ignored, @@ -868,10 +860,6 @@ def make_libdeps_emitter( if not any("conftest" in str(t) for t in target): LibdepLinter(env, target).lint_libdeps(libdeps) - if env.get('SYMBOLDEPSSUFFIX', None): - for t in target: - add_libdeps_node(env, t, libdeps) - # We ignored the dependency_map until now because we needed to use # original dependency value for linting. Now go back through and # use the map to convert to the desired dependencies, for example @@ -980,6 +968,67 @@ def expand_libdeps_with_flags(source, target, env, for_signature): return libdeps_with_flags +def generate_libdeps_graph(env): + if env.get('SYMBOLDEPSSUFFIX', None): + import glob + from buildscripts.libdeps.graph_analyzer import EdgeProps + find_symbols = env.Dir("$BUILD_DIR").path + "/libdeps/find_symbols" + symbol_deps = [] + for target, source in env.get('LIBDEPS_SYMBOL_DEP_FILES', []): + direct_libdeps = [] + for direct_libdep in __get_sorted_direct_libdeps(source): + env.GetLibdepsGraph().add_edges_from([( + str(direct_libdep.target_node.abspath), + str(source.abspath), + { + EdgeProps.direct.name: 1, + EdgeProps.visibility.name: int(direct_libdep.dependency_type) + })]) + direct_libdeps.append(direct_libdep.target_node.abspath) + for libdep in __get_libdeps(source): + if libdep.abspath not in direct_libdeps: + env.GetLibdepsGraph().add_edges_from([( + str(libdep.abspath), + str(source.abspath), + { + EdgeProps.direct.name: 0, + EdgeProps.visibility.name: 0 + })]) + + ld_path = ":".join([os.path.dirname(str(libdep)) for libdep in __get_libdeps(source)]) + symbol_deps.append(env.Command( + target=target, + source=source, + action=SCons.Action.Action( + f'{find_symbols} $SOURCE "{ld_path}" $TARGET', + "Generating $SOURCE symbol dependencies"))) + + def write_graph_hash(env, target, source): + import networkx + import hashlib + import json + with open(target[0].path, 'w') as f: + json_str = json.dumps(networkx.readwrite.json_graph.node_link_data(env.GetLibdepsGraph()), sort_keys=True).encode('utf-8') + f.write(hashlib.sha256(json_str).hexdigest()) + + graph_hash = env.Command(target="$BUILD_DIR/libdeps/graph_hash.sha256", + source=symbol_deps + [ + env.File("#SConstruct")] + + glob.glob("**/SConscript", recursive=True) + + [os.path.abspath(__file__)], + action=SCons.Action.FunctionAction( + write_graph_hash, + {"cmdstr": None})) + + graph_node = env.Command( + target=env.get('LIBDEPS_GRAPH_FILE', None), + source=symbol_deps, + action=SCons.Action.FunctionAction( + generate_graph, + {"cmdstr": "Generating libdeps graph"})) + + env.Depends(graph_node, graph_hash) + def get_typeinfo_link_command(): if LibdepLinter.skip_linting: return "{ninjalink}" @@ -1040,14 +1089,21 @@ def generate_graph(env, target, source): for symbol_deps_file in source: with open(str(symbol_deps_file)) as f: + symbols = {} for symbol, lib in json.load(f).items(): # ignore symbols from external libraries, # they will just clutter the graph if lib.startswith(env.Dir("$BUILD_DIR").path): - env.GetLibdepsGraph().add_edges_from([( - os.path.abspath(lib).strip(), - os.path.abspath(str(symbol_deps_file)[:-len(env['SYMBOLDEPSSUFFIX'])]), - {symbol.strip(): "1"})]) + if lib not in symbols: + symbols[lib] = [] + symbols[lib].append(symbol) + + for lib in symbols: + env.GetLibdepsGraph().add_edges_from([( + os.path.abspath(lib).strip(), + os.path.abspath(str(symbol_deps_file)[:-len(env['SYMBOLDEPSSUFFIX'])]), + {"symbols": " ".join(symbols[lib]) })]) + libdeps_graph_file = f"{env.Dir('$BUILD_DIR').path}/libdeps/libdeps.graphml" networkx.write_graphml(env.GetLibdepsGraph(), libdeps_graph_file, named_key_ids=True) @@ -1129,14 +1185,15 @@ def setup_environment(env, emitting_shared=False, linting='on', sanitize_typeinf find_symbols_env.VariantDir('${BUILD_DIR}/libdeps', 'buildscripts/libdeps', duplicate = 0) find_symbols_node = find_symbols_env.Program( target='${BUILD_DIR}/libdeps/find_symbols', - source=['${BUILD_DIR}/libdeps/find_symbols.c']) + source=['${BUILD_DIR}/libdeps/find_symbols.c'], + CFLAGS=['-O3']) # Here we are setting up some functions which will return single instance of the # network graph and symbol deps list. We also setup some environment variables # which are used along side the functions. symbol_deps = [] def append_symbol_deps(env, symbol_deps_file): - env.Depends("${BUILD_DIR}/libdeps/libdeps.graphml", symbol_deps_file) + env.Depends(env['LIBDEPS_GRAPH_FILE'], symbol_deps_file[0]) symbol_deps.append(symbol_deps_file) env.AddMethod(append_symbol_deps, "AppendSymbolDeps") @@ -1146,16 +1203,16 @@ def setup_environment(env, emitting_shared=False, linting='on', sanitize_typeinf env.AddMethod(get_libdeps_graph, "GetLibdepsGraph") env['LIBDEPS_SYMBOL_DEP_FILES'] = symbol_deps + env['LIBDEPS_GRAPH_FILE'] = env.File("${BUILD_DIR}/libdeps/libdeps.graphml") env["SYMBOLDEPSSUFFIX"] = '.symbol_deps' # Now we will setup an emitter, and an additional action for several # of the builder involved with dynamic builds. def libdeps_graph_emitter(target, source, env): if "conftest" not in str(target[0]): - symbol_deps_file = target[0].path + env['SYMBOLDEPSSUFFIX'] - env.Depends(target, '${BUILD_DIR}/libdeps/find_symbols') - env.SideEffect(symbol_deps_file, target) - env.AppendSymbolDeps(symbol_deps_file) + symbol_deps_file = env.File(str(target[0]) + env['SYMBOLDEPSSUFFIX']) + env.Depends(symbol_deps_file, '${BUILD_DIR}/libdeps/find_symbols') + env.AppendSymbolDeps((symbol_deps_file,target[0])) return target, source @@ -1165,15 +1222,6 @@ def setup_environment(env, emitting_shared=False, linting='on', sanitize_typeinf new_emitter = SCons.Builder.ListEmitter([base_emitter, libdeps_graph_emitter]) builder.emitter = new_emitter - base_action = builder.action - if not isinstance(base_action, SCons.Action.ListAction): - base_action = SCons.Action.ListAction([base_action]) - find_symbols = env.Dir("$BUILD_DIR").path + "/libdeps/find_symbols" - base_action.list.extend([ - SCons.Action.Action(f'if [ -e {find_symbols} ]; then {find_symbols} $TARGET "$_LIBDEPS_LD_PATH" ${{TARGET}}.symbol_deps; fi', None) - ]) - builder.action = base_action - # We need a way for environments to alter just which libdeps # emitter they want, without altering the overall program or # library emitter which may have important effects. The |