blob: 1cfcdfe8948be57e86602175082b498640368270 [file] [log] [blame]
/* Emit optimization information as JSON files.
Copyright (C) 2018-2019 Free Software Foundation, Inc.
Contributed by David Malcolm <dmalcolm@redhat.com>.
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/>. */
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "backend.h"
#include "tree.h"
#include "gimple.h"
#include "diagnostic-core.h"
#include "profile.h"
#include "output.h"
#include "tree-pass.h"
#include "optinfo.h"
#include "optinfo-emit-json.h"
#include "json.h"
#include "pretty-print.h"
#include "tree-pretty-print.h"
#include "gimple-pretty-print.h"
#include "cgraph.h"
#include "langhooks.h"
#include "version.h"
#include "context.h"
#include "pass_manager.h"
#include "selftest.h"
#include "dump-context.h"
#include <zlib.h>
/* optrecord_json_writer's ctor. Populate the top-level parts of the
in-memory JSON representation. */
optrecord_json_writer::optrecord_json_writer ()
: m_root_tuple (NULL), m_scopes ()
{
m_root_tuple = new json::array ();
/* Populate with metadata; compare with toplev.c: print_version. */
json::object *metadata = new json::object ();
m_root_tuple->append (metadata);
metadata->set ("format", new json::string ("1"));
json::object *generator = new json::object ();
metadata->set ("generator", generator);
generator->set ("name", new json::string (lang_hooks.name));
generator->set ("pkgversion", new json::string (pkgversion_string));
generator->set ("version", new json::string (version_string));
/* TARGET_NAME is passed in by the Makefile. */
generator->set ("target", new json::string (TARGET_NAME));
/* TODO: capture command-line?
see gen_producer_string in dwarf2out.c (currently static). */
/* TODO: capture "any plugins?" flag (or the plugins themselves). */
json::array *passes = new json::array ();
m_root_tuple->append (passes);
/* Call add_pass_list for all of the pass lists. */
{
#define DEF_PASS_LIST(LIST) \
add_pass_list (passes, g->get_passes ()->LIST);
GCC_PASS_LISTS
#undef DEF_PASS_LIST
}
json::array *records = new json::array ();
m_root_tuple->append (records);
m_scopes.safe_push (records);
}
/* optrecord_json_writer's ctor.
Delete the in-memory JSON representation. */
optrecord_json_writer::~optrecord_json_writer ()
{
delete m_root_tuple;
}
/* Choose an appropriate filename, and write the saved records to it. */
void
optrecord_json_writer::write () const
{
pretty_printer pp;
m_root_tuple->print (&pp);
bool emitted_error = false;
char *filename = concat (dump_base_name, ".opt-record.json.gz", NULL);
gzFile outfile = gzopen (filename, "w");
if (outfile == NULL)
{
error_at (UNKNOWN_LOCATION, "cannot open file %qs for writing optimization records",
filename); // FIXME: more info?
goto cleanup;
}
if (gzputs (outfile, pp_formatted_text (&pp)) <= 0)
{
int tmp;
error_at (UNKNOWN_LOCATION, "error writing optimization records to %qs: %s",
filename, gzerror (outfile, &tmp));
emitted_error = true;
}
cleanup:
if (outfile)
if (gzclose (outfile) != Z_OK)
if (!emitted_error)
error_at (UNKNOWN_LOCATION, "error closing optimization records %qs",
filename);
free (filename);
}
/* Add a record for OPTINFO to the queue of records to be written. */
void
optrecord_json_writer::add_record (const optinfo *optinfo)
{
json::object *obj = optinfo_to_json (optinfo);
add_record (obj);
/* Potentially push the scope. */
if (optinfo->get_kind () == OPTINFO_KIND_SCOPE)
{
json::array *children = new json::array ();
obj->set ("children", children);
m_scopes.safe_push (children);
}
}
/* Private methods of optrecord_json_writer. */
/* Add record OBJ to the the innermost scope. */
void
optrecord_json_writer::add_record (json::object *obj)
{
/* Add to innermost scope. */
gcc_assert (m_scopes.length () > 0);
m_scopes[m_scopes.length () - 1]->append (obj);
}
/* Pop the innermost scope. */
void
optrecord_json_writer::pop_scope ()
{
m_scopes.pop ();
/* We should never pop the top-level records array. */
gcc_assert (m_scopes.length () > 0);
}
/* Create a JSON object representing LOC. */
json::object *
optrecord_json_writer::impl_location_to_json (dump_impl_location_t loc)
{
json::object *obj = new json::object ();
obj->set ("file", new json::string (loc.m_file));
obj->set ("line", new json::number (loc.m_line));
if (loc.m_function)
obj->set ("function", new json::string (loc.m_function));
return obj;
}
/* Create a JSON object representing LOC. */
json::object *
optrecord_json_writer::location_to_json (location_t loc)
{
gcc_assert (LOCATION_LOCUS (loc) != UNKNOWN_LOCATION);
expanded_location exploc = expand_location (loc);
json::object *obj = new json::object ();
obj->set ("file", new json::string (exploc.file));
obj->set ("line", new json::number (exploc.line));
obj->set ("column", new json::number (exploc.column));
return obj;
}
/* Create a JSON object representing COUNT. */
json::object *
optrecord_json_writer::profile_count_to_json (profile_count count)
{
json::object *obj = new json::object ();
obj->set ("value", new json::number (count.to_gcov_type ()));
obj->set ("quality",
new json::string (profile_quality_as_string (count.quality ())));
return obj;
}
/* Get a string for use when referring to PASS in the saved optimization
records. */
json::string *
optrecord_json_writer::get_id_value_for_pass (opt_pass *pass)
{
pretty_printer pp;
/* this is host-dependent, but will be consistent for a given host. */
pp_pointer (&pp, static_cast<void *> (pass));
return new json::string (pp_formatted_text (&pp));
}
/* Create a JSON object representing PASS. */
json::object *
optrecord_json_writer::pass_to_json (opt_pass *pass)
{
json::object *obj = new json::object ();
const char *type = NULL;
switch (pass->type)
{
default:
gcc_unreachable ();
case GIMPLE_PASS:
type = "gimple";
break;
case RTL_PASS:
type = "rtl";
break;
case SIMPLE_IPA_PASS:
type = "simple_ipa";
break;
case IPA_PASS:
type = "ipa";
break;
}
obj->set ("id", get_id_value_for_pass (pass));
obj->set ("type", new json::string (type));
obj->set ("name", new json::string (pass->name));
/* Represent the optgroup flags as an array. */
{
json::array *optgroups = new json::array ();
obj->set ("optgroups", optgroups);
for (const kv_pair<optgroup_flags_t> *optgroup = optgroup_options;
optgroup->name != NULL; optgroup++)
if (optgroup->value != OPTGROUP_ALL
&& (pass->optinfo_flags & optgroup->value))
optgroups->append (new json::string (optgroup->name));
}
obj->set ("num", new json::number (pass->static_pass_number));
return obj;
}
/* Create a JSON array for LOC representing the chain of inlining
locations.
Compare with lhd_print_error_function and cp_print_error_function. */
json::value *
optrecord_json_writer::inlining_chain_to_json (location_t loc)
{
json::array *array = new json::array ();
tree abstract_origin = LOCATION_BLOCK (loc);
while (abstract_origin)
{
location_t *locus;
tree block = abstract_origin;
locus = &BLOCK_SOURCE_LOCATION (block);
tree fndecl = NULL;
block = BLOCK_SUPERCONTEXT (block);
while (block && TREE_CODE (block) == BLOCK
&& BLOCK_ABSTRACT_ORIGIN (block))
{
tree ao = BLOCK_ABSTRACT_ORIGIN (block);
if (TREE_CODE (ao) == FUNCTION_DECL)
{
fndecl = ao;
break;
}
else if (TREE_CODE (ao) != BLOCK)
break;
block = BLOCK_SUPERCONTEXT (block);
}
if (fndecl)
abstract_origin = block;
else
{
while (block && TREE_CODE (block) == BLOCK)
block = BLOCK_SUPERCONTEXT (block);
if (block && TREE_CODE (block) == FUNCTION_DECL)
fndecl = block;
abstract_origin = NULL;
}
if (fndecl)
{
json::object *obj = new json::object ();
const char *printable_name
= lang_hooks.decl_printable_name (fndecl, 2);
obj->set ("fndecl", new json::string (printable_name));
if (LOCATION_LOCUS (*locus) != UNKNOWN_LOCATION)
obj->set ("site", location_to_json (*locus));
array->append (obj);
}
}
return array;
}
/* Create a JSON object representing OPTINFO. */
json::object *
optrecord_json_writer::optinfo_to_json (const optinfo *optinfo)
{
json::object *obj = new json::object ();
obj->set ("impl_location",
impl_location_to_json (optinfo->get_impl_location ()));
const char *kind_str = optinfo_kind_to_string (optinfo->get_kind ());
obj->set ("kind", new json::string (kind_str));
json::array *message = new json::array ();
obj->set ("message", message);
for (unsigned i = 0; i < optinfo->num_items (); i++)
{
const optinfo_item *item = optinfo->get_item (i);
switch (item->get_kind ())
{
default:
gcc_unreachable ();
case OPTINFO_ITEM_KIND_TEXT:
{
message->append (new json::string (item->get_text ()));
}
break;
case OPTINFO_ITEM_KIND_TREE:
{
json::object *json_item = new json::object ();
json_item->set ("expr", new json::string (item->get_text ()));
/* Capture any location for the node. */
if (LOCATION_LOCUS (item->get_location ()) != UNKNOWN_LOCATION)
json_item->set ("location",
location_to_json (item->get_location ()));
message->append (json_item);
}
break;
case OPTINFO_ITEM_KIND_GIMPLE:
{
json::object *json_item = new json::object ();
json_item->set ("stmt", new json::string (item->get_text ()));
/* Capture any location for the stmt. */
if (LOCATION_LOCUS (item->get_location ()) != UNKNOWN_LOCATION)
json_item->set ("location",
location_to_json (item->get_location ()));
message->append (json_item);
}
break;
case OPTINFO_ITEM_KIND_SYMTAB_NODE:
{
json::object *json_item = new json::object ();
json_item->set ("symtab_node", new json::string (item->get_text ()));
/* Capture any location for the node. */
if (LOCATION_LOCUS (item->get_location ()) != UNKNOWN_LOCATION)
json_item->set ("location",
location_to_json (item->get_location ()));
message->append (json_item);
}
break;
}
}
if (optinfo->get_pass ())
obj->set ("pass", get_id_value_for_pass (optinfo->get_pass ()));
profile_count count = optinfo->get_count ();
if (count.initialized_p ())
obj->set ("count", profile_count_to_json (count));
/* Record any location, handling the case where of an UNKNOWN_LOCATION
within an inlined block. */
location_t loc = optinfo->get_location_t ();
if (get_pure_location (line_table, loc) != UNKNOWN_LOCATION)
{
// TOOD: record the location (just caret for now)
// TODO: start/finish also?
obj->set ("location", location_to_json (loc));
}
if (current_function_decl)
{
const char *fnname
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
obj->set ("function", new json::string (fnname));
}
if (loc != UNKNOWN_LOCATION)
obj->set ("inlining_chain", inlining_chain_to_json (loc));
return obj;
}
/* Add a json description of PASS and its siblings to ARR, recursing into
child passes (adding their descriptions within a "children" array). */
void
optrecord_json_writer::add_pass_list (json::array *arr, opt_pass *pass)
{
do
{
json::object *pass_obj = pass_to_json (pass);
arr->append (pass_obj);
if (pass->sub)
{
json::array *sub = new json::array ();
pass_obj->set ("children", sub);
add_pass_list (sub, pass->sub);
}
pass = pass->next;
}
while (pass);
}
#if CHECKING_P
namespace selftest {
/* Verify that we can build a JSON optimization record from dump_*
calls. */
static void
test_building_json_from_dump_calls ()
{
temp_dump_context tmp (true, true, MSG_NOTE);
dump_user_location_t loc;
dump_printf_loc (MSG_NOTE, loc, "test of tree: ");
dump_generic_expr (MSG_NOTE, TDF_SLIM, integer_zero_node);
optinfo *info = tmp.get_pending_optinfo ();
ASSERT_TRUE (info != NULL);
ASSERT_EQ (info->num_items (), 2);
optrecord_json_writer writer;
json::object *json_obj = writer.optinfo_to_json (info);
ASSERT_TRUE (json_obj != NULL);
/* Verify that the json is sane. */
pretty_printer pp;
json_obj->print (&pp);
const char *json_str = pp_formatted_text (&pp);
ASSERT_STR_CONTAINS (json_str, "impl_location");
ASSERT_STR_CONTAINS (json_str, "\"kind\": \"note\"");
ASSERT_STR_CONTAINS (json_str,
"\"message\": [\"test of tree: \", {\"expr\": \"0\"}]");
delete json_obj;
}
/* Run all of the selftests within this file. */
void
optinfo_emit_json_cc_tests ()
{
test_building_json_from_dump_calls ();
}
} // namespace selftest
#endif /* CHECKING_P */