[analyzer] exploded-graph-rewriter: Implement a topology-only mode.

[NoQ]

Summary

In this mode the rewriter will only rewrite program points and omit program states. Useful for understanding the rough topology of the graph.

[Charusso]

May you would remove the "Program points:" part as we only have that, but I think we have enough space for that tiny note. Thanks!

[NoQ]

Fxd!

cfe/trunk/test/Analysis/exploded-graph-rewriter/topology.dot

+// RUN: %exploded_graph_rewriter %s \
+// RUN:     | FileCheck -check-prefixes=NORMAL %s
+// RUN: %exploded_graph_rewriter -t %s \
+// RUN:     | FileCheck -check-prefixes=TOPOLOGY %s
+
+// FIXME: Substitution doesn't seem to work on Windows.
+// UNSUPPORTED: system-windows
+
+// NORMAL: Program point
+// TOPOLOGY-NOT: Program point
+// NORMAL: Checker State
+// TOPOLOGY-NOT: Checker State
+Node0x1 [shape=record,label=
+ "{
+    { "node_id": 1,
+      "pointer": "0x1",
+      "has_report": false,
+      "is_sink": false,
+      "state_id": 2,
+      "program_points": [],
+      "program_state": {
+        "environment": null,
+        "constraints": null,
+        "dynamic_types": null,
+        "constructing_objects": null,
+        "checker_messages": [
+          { "checker": "foo", "messages": ["bar"] }
+        ],
+        "store": null
+      }
+    }
+\l}"];

cfe/trunk/utils/analyzer/exploded-graph-rewriter.py

 # Visitors traverse a deserialized ExplodedGraph and do different things
 # with every node and edge.
 #===-----------------------------------------------------------------------===#
 
 
 # A visitor that dumps the ExplodedGraph into a DOT file with fancy HTML-based
 # syntax highlighing.
 class DotDumpVisitor(object):
-    def __init__(self, do_diffs, dark_mode, gray_mode):
+    def __init__(self, do_diffs, dark_mode, gray_mode, topo_mode):
         super(DotDumpVisitor, self).__init__()
         self._do_diffs = do_diffs
         self._dark_mode = dark_mode
         self._gray_mode = gray_mode
+        self._topo_mode = topo_mode
 
     @staticmethod
     def _dump_raw(s):
         print(s, end='')
 
     def _dump(self, s):
         s = s.replace('&', '&') \
              .replace('{', '\\{') \
def visit_node(self, node):
                       node.node_id, node.ptr, node.state.state_id
                       if node.state is not None else 'Unspecified'))
         if node.has_report:
             self._dump('<tr><td><font color="red"><b>Bug Report Attached'
                        '</b></font></td></tr>')
         if node.is_sink:
             self._dump('<tr><td><font color="cornflowerblue"><b>Sink Node'
                        '</b></font></td></tr>')
+        if not self._topo_mode:
             self._dump('<tr><td align="left" width="0">')
             if len(node.points) > 1:
                 self._dump('<b>Program points:</b></td></tr>')
             else:
                 self._dump('<b>Program point:</b></td></tr>')
         self._dump('<tr><td align="left" width="0">'
                    '<table border="0" align="left" width="0">')
         for p in node.points:
             self.visit_program_point(p)
         self._dump('</table></td></tr>')
 
-        if node.state is not None:
+        if node.state is not None and not self._topo_mode:
             prev_s = None
             # Do diffs only when we have a unique predecessor.
             # Don't do diffs on the leaf nodes because they're
             # the important ones.
             if self._do_diffs and len(node.predecessors) == 1 \
                and len(node.successors) > 0:
                 prev_s = self._graph.nodes[node.predecessors[0]].state
             self.visit_state(node.state, prev_s)
def main():
     parser.add_argument('filename', type=str)
     parser.add_argument('-v', '--verbose', action='store_const',
                         dest='loglevel', const=logging.DEBUG,
                         default=logging.WARNING,
                         help='enable info prints')
     parser.add_argument('-d', '--diff', action='store_const', dest='diff',
                         const=True, default=False,
                         help='display differences between states')
+    parser.add_argument('-t', '--topology', action='store_const',
+                        dest='topology', const=True, default=False,
+                        help='only display program points, omit states')
     parser.add_argument('-s', '--single-path', action='store_const',
                         dest='single_path', const=True, default=False,
                         help='only display the leftmost path in the graph '
                              '(useful for trimmed graphs that still '
                              'branch too much)')
     parser.add_argument('--dark', action='store_const', dest='dark',
                         const=True, default=False,
                         help='dark mode')
     parser.add_argument('--gray', action='store_const', dest='gray',
                         const=True, default=False,
                         help='black-and-white mode')
     args = parser.parse_args()
     logging.basicConfig(level=args.loglevel)
 
     graph = ExplodedGraph()
     with open(args.filename) as fd:
         for raw_line in fd:
             raw_line = raw_line.strip()
             graph.add_raw_line(raw_line)
 
     explorer = SinglePathExplorer() if args.single_path else BasicExplorer()
-    visitor = DotDumpVisitor(args.diff, args.dark, args.gray)
+    visitor = DotDumpVisitor(args.diff, args.dark, args.gray, args.topology)
 
     explorer.explore(graph, visitor)
 
 
 if __name__ == '__main__':
     main()