+2012-06-18 Lawrence Crowl <crowl@google.com>
+
+ * timevar.def (TV_PHASE_GENERATE): Rename to TV_PHASE_LATE_ASM.
+ (TV_PHASE_CGRAPH): Rename to TV_PHASE_OPT_GEN.
+ (TV_PHASE_STREAM_IN): New.
+ (TV_PHASE_STREAM_OUT): New.
+ * timevar.c (validate_phases): New.
+ (timevar_print): Call validate_phases.
+ * c-decl.c (c_write_global_declarations): Rename use of TV_PHASE_CGRAPH
+ to TV_PHASE_OPT_GEN.
+ * langhooks.c (write_global_declarations): Rename use of
+ TV_PHASE_CGRAPH to TV_PHASE_OPT_GEN. Use TV_PHASE_DBGINFO instead of
+ TV_PHASE_CHECK_DBGINFO.
+ * toplev.c (compile_file): Rename use of TV_PHASE_GENERATE to
+ TV_PHASE_LATE_ASM. Move start of TV_PHASE_LATE_ASM to after call to
+ lang_hooks.decls.final_write_globals.
+
2012-06-18 David Edelshn <dje.gcc@gmail.com>
* config/rs6000/aix52.h (TARGET_EXTRA_BUILTINS): Define as 0.
c_write_global_declarations_1 (BLOCK_VARS (ext_block));
timevar_stop (TV_PHASE_DEFERRED);
- timevar_start (TV_PHASE_CGRAPH);
+ timevar_start (TV_PHASE_OPT_GEN);
/* We're done parsing; proceed to optimize and emit assembly.
FIXME: shouldn't be the front end's responsibility to call this. */
finalize_compilation_unit ();
- timevar_stop (TV_PHASE_CGRAPH);
+ timevar_stop (TV_PHASE_OPT_GEN);
timevar_start (TV_PHASE_DBGINFO);
/* After cgraph has had a chance to emit everything that's going to
+2012-06-18 Lawrence Crowl <crowl@google.com>
+
+ * decl2.c (cp_write_global_declarations): Rename use of TV_PHASE_CGRAPH
+ to TV_PHASE_OPT_GEN.
+
2012-06-18 Steven Bosscher <steven@gcc.gnu.org>
* decl.c (finish_function): Remove code conditional on VMS_TARGET.
candidates = collect_candidates_for_java_method_aliases ();
timevar_stop (TV_PHASE_DEFERRED);
- timevar_start (TV_PHASE_CGRAPH);
+ timevar_start (TV_PHASE_OPT_GEN);
finalize_compilation_unit ();
- timevar_stop (TV_PHASE_CGRAPH);
+ timevar_stop (TV_PHASE_OPT_GEN);
timevar_start (TV_PHASE_CHECK_DBGINFO);
/* Now, issue warnings about static, but not defined, functions,
check_global_declarations (vec, len);
timevar_stop (TV_PHASE_DEFERRED);
- timevar_start (TV_PHASE_CGRAPH);
+ timevar_start (TV_PHASE_OPT_GEN);
/* This lang hook is dual-purposed, and also finalizes the
compilation unit. */
finalize_compilation_unit ();
- timevar_stop (TV_PHASE_CGRAPH);
+ timevar_stop (TV_PHASE_OPT_GEN);
- timevar_start (TV_PHASE_CHECK_DBGINFO);
+ timevar_start (TV_PHASE_DBGINFO);
emit_debug_global_declarations (vec, len);
- timevar_stop (TV_PHASE_CHECK_DBGINFO);
+ timevar_stop (TV_PHASE_DBGINFO);
/* Clean up. */
free (vec);
+2012-06-18 Lawrence Crowl <crowl@google.com>
+
+ * lto.c (do_whole_program_analysis): Rename use of TV_PHASE_CGRAPH to
+ TV_PHASE_OPT_GEN. Use new timevar TV_PHASE_STREAM_OUT around the call
+ to lto_wpa_write_files.
+ (lto_main): Rename use of TV_PHASE_CGRAPH to TV_PHASE_OPT_GEN. Move
+ start of TV_PHASE_OPT_GEN to include call to materialize_cgraph. Use
+ TV_PHASE_SETUP for the call to lto_init. Use new timevar
+ TV_PHASE_STREAM_IN around the call to read_cgraph_and_symbols.
+ Turn TV_PHASE_PARSING off then back on again, because LTO is pretending
+ to be a front end, but is not one.
+
2012-05-18 Jan Hubicka <jh@suse.cz>
* lto.c (lto_materialize_constructors_and_inits): Remove.
static void
do_whole_program_analysis (void)
{
- timevar_start (TV_PHASE_CGRAPH);
+ timevar_start (TV_PHASE_OPT_GEN);
+
/* Note that since we are in WPA mode, materialize_cgraph will not
actually read in all the function bodies. It only materializes
the decls and cgraph nodes so that analysis can be performed. */
else
lto_balanced_map ();
+ timevar_stop (TV_PHASE_OPT_GEN);
+ timevar_start (TV_PHASE_STREAM_OUT);
+
if (!quiet_flag)
{
fprintf (stderr, "\nStreaming out");
fflush (stderr);
}
lto_wpa_write_files ();
- ggc_collect ();
if (!quiet_flag)
fprintf (stderr, "\n");
+ timevar_stop (TV_PHASE_STREAM_OUT);
+
+ ggc_collect ();
if (post_ipa_mem_report)
{
fprintf (stderr, "Memory consumption after IPA\n");
dump_memory_report (false);
}
- timevar_stop (TV_PHASE_CGRAPH);
/* Show the LTO report before launching LTRANS. */
if (flag_lto_report)
print_lto_report ();
void
lto_main (void)
{
+ /* LTO is called as a front end, even though it is not a front end.
+ Because it is called as a front end, TV_PHASE_PARSING and
+ TV_PARSE_GLOBAL are active, and we need to turn them off while
+ doing LTO. Later we turn them back on so they are active up in
+ toplev.c. */
+ timevar_pop (TV_PARSE_GLOBAL);
+ timevar_stop (TV_PHASE_PARSING);
+
+ timevar_start (TV_PHASE_SETUP);
+
/* Initialize the LTO front end. */
lto_init ();
+ timevar_stop (TV_PHASE_SETUP);
+ timevar_start (TV_PHASE_STREAM_IN);
+
/* Read all the symbols and call graph from all the files in the
command line. */
read_cgraph_and_symbols (num_in_fnames, in_fnames);
+ timevar_stop (TV_PHASE_STREAM_IN);
+
if (!seen_error ())
{
/* If WPA is enabled analyze the whole call graph and create an
do_whole_program_analysis ();
else
{
+ timevar_start (TV_PHASE_OPT_GEN);
+
materialize_cgraph ();
/* Let the middle end know that we have read and merged all of
the input files. */
- timevar_start (TV_PHASE_CGRAPH);
compile ();
- timevar_stop (TV_PHASE_CGRAPH);
+
+ timevar_stop (TV_PHASE_OPT_GEN);
/* FIXME lto, if the processes spawned by WPA fail, we miss
the chance to print WPA's report, so WPA will call
print_lto_report ();
}
}
+
+ /* Here we make LTO pretend to be a parser. */
+ timevar_start (TV_PHASE_PARSING);
+ timevar_push (TV_PARSE_GLOBAL);
}
#include "gt-lto-lto.h"
}
+/* Validate that phase times are consistent. */
+
+static void
+validate_phases (FILE *fp)
+{
+ unsigned int /* timevar_id_t */ id;
+ struct timevar_time_def *total = &timevars[TV_TOTAL].elapsed;
+ double phase_user = 0.0;
+ double phase_sys = 0.0;
+ double phase_wall = 0.0;
+ unsigned phase_ggc_mem = 0;
+ static char phase_prefix[] = "phase ";
+ const double tolerance = 1.000001; /* One part in a million. */
+
+ for (id = 0; id < (unsigned int) TIMEVAR_LAST; ++id)
+ {
+ struct timevar_def *tv = &timevars[(timevar_id_t) id];
+
+ /* Don't evaluate timing variables that were never used. */
+ if (!tv->used)
+ continue;
+
+ if (strncmp (tv->name, phase_prefix, sizeof phase_prefix - 1) == 0)
+ {
+ phase_user += tv->elapsed.user;
+ phase_sys += tv->elapsed.sys;
+ phase_wall += tv->elapsed.wall;
+ phase_ggc_mem += tv->elapsed.ggc_mem;
+ }
+ }
+
+ if (phase_user > total->user * tolerance
+ || phase_sys > total->sys * tolerance
+ || phase_wall > total->wall * tolerance
+ || phase_ggc_mem > total->ggc_mem * tolerance)
+ {
+
+ fprintf (fp, "Timing error: total of phase timers exceeds total time.\n");
+ if (phase_user > total->user)
+ fprintf (fp, "user %24.18e > %24.18e\n", phase_user, total->user);
+ if (phase_sys > total->sys)
+ fprintf (fp, "sys %24.18e > %24.18e\n", phase_sys, total->sys);
+ if (phase_wall > total->wall)
+ fprintf (fp, "wall %24.18e > %24.18e\n", phase_wall, total->wall);
+ if (phase_ggc_mem > total->ggc_mem)
+ fprintf (fp, "ggc_mem %24u > %24u\n", phase_ggc_mem, total->ggc_mem);
+ gcc_unreachable ();
+ }
+}
+
+
/* Summarize timing variables to FP. The timing variable TV_TOTAL has
a special meaning -- it's considered to be the total elapsed time,
for normalizing the others, and is displayed last. */
#endif /* defined (HAVE_USER_TIME) || defined (HAVE_SYS_TIME)
|| defined (HAVE_WALL_TIME) */
+
+ validate_phases (fp);
}
/* Prints a message to stderr stating that time elapsed in STR is
/* The total execution time. */
DEFTIMEVAR (TV_TOTAL , "total time")
+/* The compiler phases. These must be mutually exclusive.
+ Ideally, they would sum to near the total time. */
DEFTIMEVAR (TV_PHASE_SETUP , "phase setup")
DEFTIMEVAR (TV_PHASE_PARSING , "phase parsing")
DEFTIMEVAR (TV_PHASE_DEFERRED , "phase lang. deferred")
-DEFTIMEVAR (TV_PHASE_CGRAPH , "phase cgraph")
+DEFTIMEVAR (TV_PHASE_OPT_GEN , "phase opt and generate")
DEFTIMEVAR (TV_PHASE_DBGINFO , "phase debug info")
DEFTIMEVAR (TV_PHASE_CHECK_DBGINFO , "phase check & debug info")
-DEFTIMEVAR (TV_PHASE_GENERATE , "phase generate")
+DEFTIMEVAR (TV_PHASE_LATE_ASM , "phase last asm")
+DEFTIMEVAR (TV_PHASE_STREAM_IN , "phase stream in")
+DEFTIMEVAR (TV_PHASE_STREAM_OUT , "phase stream out")
DEFTIMEVAR (TV_PHASE_FINALIZE , "phase finalize")
/* Concurrent timers, indicated by "|". */
if (flag_syntax_only || flag_wpa)
return;
- timevar_start (TV_PHASE_GENERATE);
-
ggc_protect_identifiers = false;
/* This must also call finalize_compilation_unit. */
lang_hooks.decls.final_write_globals ();
if (seen_error ())
- {
- timevar_stop (TV_PHASE_GENERATE);
- return;
- }
+ return;
+
+ timevar_start (TV_PHASE_LATE_ASM);
/* Compilation unit is finalized. When producing non-fat LTO object, we are
basically finished. */
assembly file after this point. */
targetm.asm_out.file_end ();
- timevar_stop (TV_PHASE_GENERATE);
+ timevar_stop (TV_PHASE_LATE_ASM);
}
/* Print version information to FILE.
projects / gcc.git / commitdiff