This patch adds a Python 3 module to "contrib" for reading the output of
-fsave-optimization-record.
It can be imported from other Python code, or run standalone as a script,
in which case it prints the saved messages in a form resembling GCC
diagnostics.
OK for trunk?
contrib/ChangeLog:
* optrecord.py: New file.
---
contrib/optrecord.py | 295 +++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 295 insertions(+)
create mode 100755 contrib/optrecord.py
diff --git a/contrib/optrecord.py b/contrib/optrecord.py
new file mode 100755
index 0000000..b07488e
--- /dev/null
+++ b/contrib/optrecord.py
@@ -0,0 +1,295 @@
+#!/usr/bin/env python3
+#
+# Python module for working with the result of -fsave-optimization-record
+# Contributed by David Malcolm <dmalc...@redhat.com>.
+#
+# Copyright (C) 2018 Free Software Foundation, Inc.
+# This file is part of GCC.
+#
+# GCC is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free
+# Software Foundation; either version 3, or (at your option) any later
+# version.
+#
+# GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+# for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with GCC; see the file COPYING3. If not see
+# <http://www.gnu.org/licenses/>. */
+
+import argparse
+import json
+import os
+import sys
+
+class TranslationUnit:
+ """Top-level class for containing optimization records"""
+ @staticmethod
+ def from_filename(filename):
+ with open(filename) as f:
+ root_obj = json.load(f)
+ return TranslationUnit(filename, root_obj)
+
+ def __init__(self, filename, json_obj):
+ self.filename = filename
+ self.pass_by_id = {}
+
+ # Expect a 3-tuple
+ metadata, passes, records = json_obj
+
+ self.format = metadata['format']
+ self.generator = metadata['generator']
+ self.passes = [Pass(obj, self) for obj in passes]
+ self.records = [Record(obj, self) for obj in records]
+
+ def __repr__(self):
+ return ('TranslationUnit(%r, %r, %r, %r)'
+ % (self.filename, self.generator, self.passes, self.records))
+
+class Pass:
+ """An optimization pass"""
+ def __init__(self, json_obj, tu):
+ self.id_ = json_obj['id']
+ self.name = json_obj['name']
+ self.num = json_obj['num']
+ self.optgroups = set(json_obj['optgroups']) # list of strings
+ self.type = json_obj['type']
+ tu.pass_by_id[self.id_] = self
+ self.children = [Pass(child, tu)
+ for child in json_obj.get('children', [])]
+
+ def __repr__(self):
+ return ('Pass(%r, %r, %r, %r)'
+ % (self.name, self.num, self.optgroups, self.type))
+
+def from_optional_json_field(cls, jsonobj, field):
+ if field not in jsonobj:
+ return None
+ return cls(jsonobj[field])
+
+class ImplLocation:
+ """An implementation location (within the compiler itself)"""
+ def __init__(self, json_obj):
+ self.file = json_obj['file']
+ self.line = json_obj['line']
+ self.function = json_obj['function']
+
+ def __repr__(self):
+ return ('ImplLocation(%r, %r, %r)'
+ % (self.file, self.line, self.function))
+
+class Location:
+ """A source location"""
+ def __init__(self, json_obj):
+ self.file = json_obj['file']
+ self.line = json_obj['line']
+ self.column = json_obj['column']
+
+ def __str__(self):
+ return '%s:%i:%i' % (self.file, self.line, self.column)
+
+ def __repr__(self):
+ return ('Location(%r, %r, %r)'
+ % (self.file, self.line, self.column))
+
+class Count:
+ """An execution count"""
+ def __init__(self, json_obj):
+ self.quality = json_obj['quality']
+ self.value = json_obj['value']
+
+ def __repr__(self):
+ return ('Count(%r, %r)'
+ % (self.quality, self.value))
+
+ def is_precise(self):
+ return self.quality in ('precise', 'adjusted')
+
+class Record:
+ """A optimization record: success/failure/note"""
+ def __init__(self, json_obj, tu):
+ self.kind = json_obj['kind']
+ if 'pass' in json_obj:
+ self.pass_ = tu.pass_by_id[json_obj['pass']]
+ else:
+ self.pass_ = None
+ self.function = json_obj.get('function', None)
+ self.impl_location = from_optional_json_field(ImplLocation, json_obj,
+ 'impl_location')
+ self.message = [Item.from_json(obj) for obj in json_obj['message']]
+ self.count = from_optional_json_field(Count, json_obj, 'count')
+ self.location = from_optional_json_field(Location, json_obj,
'location')
+ if 'inlining_chain' in json_obj:
+ self.inlining_chain = [InliningNode(obj)
+ for obj in json_obj['inlining_chain']]
+ else:
+ self.inlining_chain = None
+ self.children = [Record(child, tu)
+ for child in json_obj.get('children', [])]
+
+ def __repr__(self):
+ return ('Record(%r, %r, %r, %r, %r)'
+ % (self.kind, self.message, self.pass_, self.function,
+ self.children))
+
+class InliningNode:
+ """A node within an inlining chain"""
+ def __init__(self, json_obj):
+ self.fndecl = json_obj['fndecl']
+ self.site = from_optional_json_field(Location, json_obj, 'site')
+
+class Item:
+ """Base class for non-string items within a message"""
+ @staticmethod
+ def from_json(json_obj):
+ if isinstance(json_obj, str):
+ return json_obj
+ if 'expr' in json_obj:
+ return Expr(json_obj)
+ elif 'stmt' in json_obj:
+ return Stmt(json_obj)
+ elif 'symtab_node' in json_obj:
+ return SymtabNode(json_obj)
+ else:
+ raise ValueError('unrecognized item: %r' % json_obj)
+
+class Expr(Item):
+ """An expression within a message"""
+ def __init__(self, json_obj):
+ self.expr = json_obj['expr']
+ self.location = from_optional_json_field(Location, json_obj,
'location')
+
+ def __str__(self):
+ return self.expr
+
+ def __repr__(self):
+ return 'Expr(%r)' % self.expr
+
+class Stmt(Item):
+ """A statement within a message"""
+ def __init__(self, json_obj):
+ self.stmt = json_obj['stmt']
+ self.location = from_optional_json_field(Location, json_obj,
'location')
+
+ def __str__(self):
+ return self.stmt
+
+ def __repr__(self):
+ return 'Stmt(%r)' % self.stmt
+
+class SymtabNode(Item):
+ """A symbol table node within a message"""
+ def __init__(self, json_obj):
+ self.node = json_obj['symtab_node']
+ self.location = from_optional_json_field(Location, json_obj,
'location')
+
+ def __str__(self):
+ return self.node
+
+ def __repr__(self):
+ return 'SymtabNode(%r)' % self.node
+
+############################################################################
+
+SGR_START = "\33["
+SGR_END = "m\33[K"
+def SGR_SEQ(text):
+ return SGR_START + text + SGR_END
+SGR_RESET = SGR_SEQ("")
+
+COLOR_SEPARATOR = ";"
+COLOR_BOLD = "01"
+COLOR_FG_RED = "31"
+COLOR_FG_GREEN = "32"
+COLOR_FG_CYAN = "36"
+
+class Printer:
+ def __init__(self, colorize):
+ self.colorize = colorize
+
+ def print_to_str(self, record, indent=0):
+ msg = ''
+ loc = record.location
+ if loc:
+ msg += self.bold('%s: ' % loc)
+ msg += self.color_for_kind('%s: ' % record.kind, record.kind)
+ msg += ' ' * indent
+ for item in record.message:
+ if isinstance(item, str):
+ msg += item
+ elif isinstance(item, (Expr, Stmt, SymtabNode)):
+ msg += "'" + self.bold(str(item)) + "'"
+ else:
+ raise TypeError('unknown message item: %r' % item)
+ # Strip trailing whitespace (including newlines)
+ msg = msg.rstrip()
+ if record.pass_:
+ msg += ' [%s]' % self.bold('pass=%s' % record.pass_.name)
+ if record.count:
+ msg += (' [%s]'
+ % self.bold('count(%s)=%i'
+ % (record.count.quality,
+ record.count.value)))
+ return msg
+
+ def print_record(self, out, record, indent=0):
+ msg = self.print_to_str(record, indent)
+ out.write('%s\n' % msg)
+ for child in record.children:
+ self.print_record(out, child, indent + 1)
+
+ def with_color(self, color, text):
+ if self.colorize:
+ return SGR_SEQ(color) + text + SGR_RESET
+ else:
+ return text
+
+ def bold(self, text):
+ return self.with_color(COLOR_BOLD, text)
+
+ def bold_green(self, text):
+ return self.with_color(COLOR_FG_GREEN + COLOR_SEPARATOR + COLOR_BOLD,
+ text)
+
+ def bold_red(self, text):
+ return self.with_color(COLOR_FG_RED + COLOR_SEPARATOR + COLOR_BOLD,
+ text)
+
+ def bold_cyan(self, text):
+ return self.with_color(COLOR_FG_CYAN + COLOR_SEPARATOR + COLOR_BOLD,
+ text)
+
+ def color_for_kind(self, text, kind):
+ if kind == 'success':
+ return self.bold_green(text)
+ elif kind == 'failure':
+ return self.bold_red(text)
+ else:
+ return self.bold_cyan(text)
+
+def should_colorize(stream):
+ return os.environ['TERM'] != 'dumb' and os.isatty(stream.fileno())
+
+############################################################################
+
+def main():
+ """
+ If run as a script, read one or more files, and print them to stdout in
+ a format similar to GCC diagnostics.
+ """
+ parser = argparse.ArgumentParser(
+ description="Print the results of GCC's -fsave-optimization-record.")
+ parser.add_argument('filenames', metavar='FILENAME', type=str, nargs='+',
+ help='the name of the file(s) to be printed')
+ args = parser.parse_args()
+ p = Printer(should_colorize(sys.stdout))
+ for filename in args.filenames:
+ tu = TranslationUnit.from_filename(filename)
+ for r in tu.records:
+ p.print_record(sys.stdout, r)
+
+if __name__ == '__main__':
+ main()
--
1.8.5.3
