void
timevar_pop_1 (timevar_id_t timevar)
{
struct timevar_time_def now;
struct timevar_stack_def *popped = stack;
gcc_assert (&timevars[timevar] == stack->timevar);
/* What time is it? */
get_time (&now);
/* Attribute the elapsed time to the element we're popping. */
timevar_accumulate (&popped->timevar->elapsed, &start_time, &now);
/* Reset the start time; from now on, time is attributed to the
element just exposed on the stack. */
start_time = now;
/* Take the item off the stack. */
stack = stack->next;
/* Don't delete the stack element; instead, add it to the list of
unused elements for later use. */
popped->next = unused_stack_instances;
unused_stack_instances = popped;
}
void
timevar_pop (timevar_id_t timevar)
{
struct timevar_time_def now;
struct timevar_stack_def *popped = stack;
if (!timevar_enable)
return;
if (&timevars[timevar] != stack->timevar)
{
sorry ("cannot timevar_pop '%s' when top of timevars stack is '%s'",
timevars[timevar].name, stack->timevar->name);
abort ();
}
/* What time is it? */
get_time (&now);
/* Attribute the elapsed time to the element we're popping. */
timevar_accumulate (&popped->timevar->elapsed, &start_time, &now);
/* Reset the start time; from now on, time is attributed to the
element just exposed on the stack. */
start_time = now;
/* Take the item off the stack. */
stack = stack->next;
/* Don't delete the stack element; instead, add it to the list of
unused elements for later use. */
popped->next = unused_stack_instances;
unused_stack_instances = popped;
}
void
timevar_get (timevar_id_t timevar, struct timevar_time_def *elapsed)
{
struct timevar_def *tv = &timevars[timevar];
struct timevar_time_def now;
*elapsed = tv->elapsed;
/* Is TIMEVAR currently running as a standalone timer? */
if (tv->standalone)
{
get_time (&now);
timevar_accumulate (elapsed, &tv->start_time, &now);
}
/* Or is TIMEVAR at the top of the timer stack? */
else if (stack->timevar == tv)
{
get_time (&now);
timevar_accumulate (elapsed, &start_time, &now);
}
}
void
timevar_stop (timevar_id_t timevar)
{
struct timevar_def *tv = &timevars[timevar];
struct timevar_time_def now;
if (!timevar_enable)
return;
/* TIMEVAR must have been started via timevar_start. */
gcc_assert (tv->standalone);
get_time (&now);
timevar_accumulate (&tv->elapsed, &tv->start_time, &now);
}
void
timevar_push (timevar_id_t timevar)
{
struct timevar_def *tv = &timevars[timevar];
struct timevar_stack_def *context;
struct timevar_time_def now;
if (!timevar_enable)
return;
/* Mark this timing variable as used. */
tv->used = 1;
/* Can't push a standalone timer. */
if (tv->standalone)
abort ();
/* What time is it? */
get_time (&now);
/* If the stack isn't empty, attribute the current elapsed time to
the old topmost element. */
if (stack)
timevar_accumulate (&stack->timevar->elapsed, &start_time, &now);
/* Reset the start time; from now on, time is attributed to
TIMEVAR. */
start_time = now;
/* See if we have a previously-allocated stack instance. If so,
take it off the list. If not, malloc a new one. */
if (unused_stack_instances != NULL)
{
context = unused_stack_instances;
unused_stack_instances = unused_stack_instances->next;
}
else
context = xmalloc (sizeof (struct timevar_stack_def));
/* Fill it in and put it on the stack. */
context->timevar = tv;
context->next = stack;
stack = context;
}
void
timevar_print (FILE *fp)
{
/* Only print stuff if we have some sort of time information. */
#if defined (HAVE_USER_TIME) || defined (HAVE_SYS_TIME) || defined (HAVE_WALL_TIME)
unsigned int /* timevar_id_t */ id;
struct timevar_time_def *total = &timevars[TV_TOTAL].elapsed;
struct timevar_time_def now;
if (!timevar_enable)
return;
/* Update timing information in case we're calling this from GDB. */
if (fp == 0)
fp = stderr;
/* What time is it? */
get_time (&now);
/* If the stack isn't empty, attribute the current elapsed time to
the old topmost element. */
if (stack)
timevar_accumulate (&stack->timevar->elapsed, &start_time, &now);
/* Reset the start time; from now on, time is attributed to
TIMEVAR. */
start_time = now;
fputs (_("\nExecution times (seconds)\n"), fp);
for (id = 0; id < (unsigned int) TIMEVAR_LAST; ++id)
{
struct timevar_def *tv = &timevars[(timevar_id_t) id];
const double tiny = 5e-3;
/* Don't print the total execution time here; that goes at the
end. */
if ((timevar_id_t) id == TV_TOTAL)
continue;
/* Don't print timing variables that were never used. */
if (!tv->used)
continue;
/* Don't print timing variables if we're going to get a row of
zeroes. */
if (tv->elapsed.user < tiny
&& tv->elapsed.sys < tiny
&& tv->elapsed.wall < tiny)
continue;
/* The timing variable name. */
fprintf (fp, " %-22s:", tv->name);
#ifdef HAVE_USER_TIME
/* Print user-mode time for this process. */
fprintf (fp, "%7.2f (%2.0f%%) usr",
tv->elapsed.user,
(total->user == 0 ? 0 : tv->elapsed.user / total->user) * 100);
#endif /* HAVE_USER_TIME */
#ifdef HAVE_SYS_TIME
/* Print system-mode time for this process. */
fprintf (fp, "%7.2f (%2.0f%%) sys",
tv->elapsed.sys,
(total->sys == 0 ? 0 : tv->elapsed.sys / total->sys) * 100);
#endif /* HAVE_SYS_TIME */
#ifdef HAVE_WALL_TIME
/* Print wall clock time elapsed. */
fprintf (fp, "%7.2f (%2.0f%%) wall",
tv->elapsed.wall,
(total->wall == 0 ? 0 : tv->elapsed.wall / total->wall) * 100);
#endif /* HAVE_WALL_TIME */
putc ('\n', fp);
}
/* Print total time. */
fputs (_(" TOTAL :"), fp);
#ifdef HAVE_USER_TIME
/* APPLE LOCAL time formatting */
fprintf (fp, "%7.2f", total->user);
#endif
#ifdef HAVE_SYS_TIME
/* APPLE LOCAL time formatting */
fprintf (fp, " %7.2f", total->sys);
#endif
#ifdef HAVE_WALL_TIME
/* APPLE LOCAL time formatting */
fprintf (fp, " %7.2f", total->wall);
#endif
/* APPLE LOCAL time formatting */
putc ('\n', fp);
#ifdef ENABLE_CHECKING
fprintf (fp, "Extra diagnostic checks enabled; compiler may run slowly.\n");
fprintf (fp, "Configure with --disable-checking to disable checks.\n");
#endif
#endif /* defined (HAVE_USER_TIME) || defined (HAVE_SYS_TIME)
|| defined (HAVE_WALL_TIME) */
