X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftimevar.c;h=d0aa15b5ca16269ae523f7cf421a07961e6b21b5;hb=7cb6f9266435ff3d7d479dc5f5301eb2d4604984;hp=7a10fe78b4780815d67ff7089e27c7aa95785344;hpb=f5f20bad70b0e91fc7146deef28af14deffc9e52;p=pf3gnuchains%2Fgcc-fork.git

diff --git a/gcc/timevar.c b/gcc/timevar.c
index 7a10fe78b47..d0aa15b5ca1 100644
--- a/gcc/timevar.c
+++ b/gcc/timevar.c
@@ -1,12 +1,12 @@
 /* Timing variables for measuring compiler performance.
-   Copyright (C) 2000 Free Software Foundation, Inc.
+   Copyright (C) 2000, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
    Contributed by Alex Samuel <samuel@codesourcery.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 2, or (at your option) any later
+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
@@ -15,21 +15,22 @@ 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 COPYING.  If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA.  */
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
 
 #include "config.h"
 #include "system.h"
-#include "intl.h"
-#include "rtl.h"
-
 #ifdef HAVE_SYS_TIMES_H
 # include <sys/times.h>
 #endif
 #ifdef HAVE_SYS_RESOURCE_H
 #include <sys/resource.h>
 #endif
+#include "coretypes.h"
+#include "tm.h"
+#include "intl.h"
+#include "rtl.h"
+#include "toplev.h"
 
 #ifndef HAVE_CLOCK_T
 typedef int clock_t;
@@ -45,16 +46,6 @@ struct tms
 };
 #endif
 
-#if defined HAVE_DECL_GETRUSAGE && !HAVE_DECL_GETRUSAGE
-extern int getrusage PARAMS ((int, struct rusage *));
-#endif
-#if defined HAVE_DECL_TIMES && !HAVE_DECL_TIMES
-extern clock_t times PARAMS ((struct tms *));
-#endif
-#if defined HAVE_DECL_CLOCK && !HAVE_DECL_CLOCK
-extern clock_t clock PARAMS ((void));
-#endif
-
 #ifndef RUSAGE_SELF
 # define RUSAGE_SELF 0
 #endif
@@ -78,17 +69,26 @@ extern clock_t clock PARAMS ((void));
 /* Prefer times to getrusage to clock (each gives successively less
    information).  */
 #ifdef HAVE_TIMES
+# if defined HAVE_DECL_TIMES && !HAVE_DECL_TIMES
+  extern clock_t times (struct tms *);
+# endif
 # define USE_TIMES
 # define HAVE_USER_TIME
 # define HAVE_SYS_TIME
 # define HAVE_WALL_TIME
 #else
 #ifdef HAVE_GETRUSAGE
+# if defined HAVE_DECL_GETRUSAGE && !HAVE_DECL_GETRUSAGE
+  extern int getrusage (int, struct rusage *);
+# endif
 # define USE_GETRUSAGE
 # define HAVE_USER_TIME
 # define HAVE_SYS_TIME
 #else
 #ifdef HAVE_CLOCK
+# if defined HAVE_DECL_CLOCK && !HAVE_DECL_CLOCK
+  extern clock_t clock (void);
+# endif
 # define USE_CLOCK
 # define HAVE_USER_TIME
 #endif
@@ -100,22 +100,30 @@ extern clock_t clock PARAMS ((void));
    precompute them.  Whose wonderful idea was it to make all those
    _constants_ variable at run time, anyway?  */
 #ifdef USE_TIMES
-static float ticks_to_msec;
-#define TICKS_TO_MSEC (1 / (float)TICKS_PER_SECOND)
+static double ticks_to_msec;
+#define TICKS_TO_MSEC (1 / (double)TICKS_PER_SECOND)
 #endif
 
 #ifdef USE_CLOCK
-static float clocks_to_msec;
-#define CLOCKS_TO_MSEC (1 / (float)CLOCKS_PER_SEC)
+static double clocks_to_msec;
+#define CLOCKS_TO_MSEC (1 / (double)CLOCKS_PER_SEC)
 #endif
 
 #include "flags.h"
 #include "timevar.h"
 
-/* See timevar.h for an explanation of timing variables.  */
+bool timevar_enable;
+
+/* Total amount of memory allocated by garbage collector.  */
+
+size_t timevar_ggc_mem_total;
 
-/* This macro evaluates to nonzero if timing variables are enabled.  */
-#define TIMEVAR_ENABLE (time_report)
+/* The amount of memory that will cause us to report the timevar even
+   if the time spent is not significant.  */
+
+#define GGC_MEM_BOUND (1 << 20)
+
+/* See timevar.h for an explanation of timing variables.  */
 
 /* A timing variable.  */
 
@@ -131,11 +139,11 @@ struct timevar_def
   /* The name of this timing variable.  */
   const char *name;
 
-  /* Non-zero if this timing variable is running as a standalone
+  /* Nonzero if this timing variable is running as a standalone
      timer.  */
   unsigned standalone : 1;
 
-  /* Non-zero if this timing variable was ever started or pushed onto
+  /* Nonzero if this timing variable was ever started or pushed onto
      the timing stack.  */
   unsigned used : 1;
 };
@@ -168,25 +176,24 @@ static struct timevar_stack_def *unused_stack_instances;
    element.  */
 static struct timevar_time_def start_time;
 
-static void get_time
-  PARAMS ((struct timevar_time_def *));
-static void timevar_accumulate
-  PARAMS ((struct timevar_time_def *, struct timevar_time_def *,
-	   struct timevar_time_def *));
+static void get_time (struct timevar_time_def *);
+static void timevar_accumulate (struct timevar_time_def *,
+				struct timevar_time_def *,
+				struct timevar_time_def *);
 
 /* Fill the current times into TIME.  The definition of this function
    also defines any or all of the HAVE_USER_TIME, HAVE_SYS_TIME, and
    HAVE_WALL_TIME macros.  */
 
 static void
-get_time (now)
-     struct timevar_time_def *now;
+get_time (struct timevar_time_def *now)
 {
   now->user = 0;
   now->sys  = 0;
   now->wall = 0;
+  now->ggc_mem = timevar_ggc_mem_total;
 
-  if (!TIMEVAR_ENABLE)
+  if (!timevar_enable)
     return;
 
   {
@@ -211,26 +218,25 @@ get_time (now)
 /* Add the difference between STOP_TIME and START_TIME to TIMER.  */
 
 static void
-timevar_accumulate (timer, start_time, stop_time)
-     struct timevar_time_def *timer;
-     struct timevar_time_def *start_time;
-     struct timevar_time_def *stop_time;
+timevar_accumulate (struct timevar_time_def *timer,
+		    struct timevar_time_def *start_time,
+		    struct timevar_time_def *stop_time)
 {
   timer->user += stop_time->user - start_time->user;
   timer->sys += stop_time->sys - start_time->sys;
   timer->wall += stop_time->wall - start_time->wall;
+  timer->ggc_mem += stop_time->ggc_mem - start_time->ggc_mem;
 }
 
 /* Initialize timing variables.  */
 
 void
-init_timevar ()
+timevar_init (void)
 {
-  if (!TIMEVAR_ENABLE)
-    return;
+  timevar_enable = true;
 
   /* Zero all elapsed times.  */
-  memset ((void *) timevars, 0, sizeof (timevars));
+  memset (timevars, 0, sizeof (timevars));
 
   /* Initialize the names of timing variables.  */
 #define DEFTIMEVAR(identifier__, name__) \
@@ -254,22 +260,17 @@ init_timevar ()
    TIMEVAR cannot be running as a standalone timer.  */
 
 void
-timevar_push (timevar)
-     timevar_id_t timevar;
+timevar_push_1 (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 ();
+  gcc_assert (!tv->standalone);
 
   /* What time is it?  */
   get_time (&now);
@@ -291,8 +292,7 @@ timevar_push (timevar)
       unused_stack_instances = unused_stack_instances->next;
     }
   else
-    context = (struct timevar_stack_def *)
-      xmalloc (sizeof (struct timevar_stack_def));
+    context = XNEW (struct timevar_stack_def);
 
   /* Fill it in and put it on the stack.  */
   context->timevar = tv;
@@ -307,18 +307,13 @@ timevar_push (timevar)
    timing variable.  */
 
 void
-timevar_pop (timevar)
-     timevar_id_t timevar;
+timevar_pop_1 (timevar_id_t timevar)
 {
   struct timevar_time_def now;
   struct timevar_stack_def *popped = stack;
 
-  if (!TIMEVAR_ENABLE)
-    return;
-
-  if (&timevars[timevar] != stack->timevar)
-    abort ();
-
+  gcc_assert (&timevars[timevar] == stack->timevar);
+  
   /* What time is it?  */
   get_time (&now);
 
@@ -343,12 +338,11 @@ timevar_pop (timevar)
    attributed to TIMEVAR.  */
 
 void
-timevar_start (timevar)
-     timevar_id_t timevar;
+timevar_start (timevar_id_t timevar)
 {
   struct timevar_def *tv = &timevars[timevar];
 
-  if (!TIMEVAR_ENABLE)
+  if (!timevar_enable)
     return;
 
   /* Mark this timing variable as used.  */
@@ -356,8 +350,7 @@ timevar_start (timevar)
 
   /* Don't allow the same timing variable to be started more than
      once.  */
-  if (tv->standalone)
-    abort ();
+  gcc_assert (!tv->standalone);
   tv->standalone = 1;
 
   get_time (&tv->start_time);
@@ -367,57 +360,27 @@ timevar_start (timevar)
    is attributed to it.  */
 
 void
-timevar_stop (timevar)
-     timevar_id_t timevar;
+timevar_stop (timevar_id_t timevar)
 {
   struct timevar_def *tv = &timevars[timevar];
   struct timevar_time_def now;
 
-  if (!TIMEVAR_ENABLE)
+  if (!timevar_enable)
     return;
 
   /* TIMEVAR must have been started via timevar_start.  */
-  if (!tv->standalone)
-    abort ();
+  gcc_assert (tv->standalone);
 
   get_time (&now);
   timevar_accumulate (&tv->elapsed, &tv->start_time, &now);
 }
 
-/* Fill the elapsed time for TIMEVAR into ELAPSED.  Returns
-   update-to-date information even if TIMEVAR is currently running.  */
-
-void
-timevar_get (timevar, elapsed)
-     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);
-    }
-}
-
 /* 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.  */
 
 void
-timevar_print (fp)
-     FILE *fp;
+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)
@@ -425,7 +388,7 @@ timevar_print (fp)
   struct timevar_time_def *total = &timevars[TV_TOTAL].elapsed;
   struct timevar_time_def now;
 
-  if (!TIMEVAR_ENABLE)
+  if (!timevar_enable)
     return;
 
   /* Update timing information in case we're calling this from GDB.  */
@@ -449,7 +412,7 @@ timevar_print (fp)
   for (id = 0; id < (unsigned int) TIMEVAR_LAST; ++id)
     {
       struct timevar_def *tv = &timevars[(timevar_id_t) id];
-      const float tiny = 5e-3;
+      const double tiny = 5e-3;
 
       /* Don't print the total execution time here; that goes at the
 	 end.  */
@@ -464,7 +427,8 @@ timevar_print (fp)
          zeroes.  */
       if (tv->elapsed.user < tiny
 	  && tv->elapsed.sys < tiny
-	  && tv->elapsed.wall < tiny)
+	  && tv->elapsed.wall < tiny
+	  && tv->elapsed.ggc_mem < GGC_MEM_BOUND)
 	continue;
 
       /* The timing variable name.  */
@@ -491,6 +455,13 @@ timevar_print (fp)
 	       (total->wall == 0 ? 0 : tv->elapsed.wall / total->wall) * 100);
 #endif /* HAVE_WALL_TIME */
 
+      /* Print the amount of ggc memory allocated.  */
+      fprintf (fp, "%8u kB (%2.0f%%) ggc",
+	       (unsigned) (tv->elapsed.ggc_mem >> 10),
+	       (total->ggc_mem == 0
+		? 0
+		: (float) tv->elapsed.ggc_mem / total->ggc_mem) * 100);
+
       putc ('\n', fp);
     }
 
@@ -503,31 +474,28 @@ timevar_print (fp)
   fprintf (fp, "%7.2f          ", total->sys);
 #endif
 #ifdef HAVE_WALL_TIME
-  fprintf (fp, "%7.2f\n", total->wall);
+  fprintf (fp, "%7.2f           ", total->wall);
+#endif
+  fprintf (fp, "%8u kB\n", (unsigned) (total->ggc_mem >> 10));
+
+#ifdef ENABLE_CHECKING
+  fprintf (fp, "Extra diagnostic checks enabled; compiler may run slowly.\n");
+  fprintf (fp, "Configure with --enable-checking=release to disable checks.\n");
+#endif
+#ifndef ENABLE_ASSERT_CHECKING
+  fprintf (fp, "Internal checks disabled; compiler is not suited for release.\n");
+  fprintf (fp, "Configure with --enable-checking=release to enable checks.\n");
 #endif
 
 #endif /* defined (HAVE_USER_TIME) || defined (HAVE_SYS_TIME)
 	  || defined (HAVE_WALL_TIME) */
 }
 
-/* Returns time (user + system) used so far by the compiler process,
-   in microseconds.  */
-
-long
-get_run_time ()
-{
-  struct timevar_time_def total_elapsed;
-  timevar_get (TV_TOTAL, &total_elapsed);
-  return total_elapsed.user + total_elapsed.sys;
-}
-
 /* Prints a message to stderr stating that time elapsed in STR is
    TOTAL (given in microseconds).  */
 
 void
-print_time (str, total)
-     const char *str;
-     long total;
+print_time (const char *str, long total)
 {
   long all_time = get_run_time ();
   fprintf (stderr,