1 files changed, 380 insertions, 5 deletions

diff --git a/ld/ldmain.c b/ld/ldmain.c
index 54a834e..91237a4 100644
--- a/ld/ldmain.c
+++ b/ld/ldmain.c
@@ -21,6 +21,7 @@
 
 #include "sysdep.h"
 #include "bfd.h"
+#include "bfdver.h"
 #include "safe-ctype.h"
 #include "libiberty.h"
 #include "bfdlink.h"
@@ -51,6 +52,10 @@
 
 #include <string.h>
 
+#if defined (HAVE_GETRUSAGE)
+#include <sys/resource.h>
+#endif
+
 #ifndef TARGET_SYSTEM_ROOT
 #define TARGET_SYSTEM_ROOT ""
 #endif
@@ -224,6 +229,10 @@ ld_cleanup (void)
       bfd_close_all_done (ibfd);
     }
 #if BFD_SUPPORTS_PLUGINS
+  /* Note - we do not call ld_plugin_start (PHASE_PLUGINS) here as this
+     function is only called when the linker is exiting - ie after any
+     stats may have been reported, and potentially in the middle of a
+     phase where we have already started recording plugin stats.  */
   plugin_call_cleanup ();
 #endif
   if (output_filename && delete_output_file_on_failure)
@@ -270,11 +279,305 @@ display_external_script (void)
   free (buf);
 }
 
+struct ld_phase_data
+{
+  const char *    name;
+
+  unsigned long   start;
+  unsigned long   duration;
+
+  bool            started;
+  bool            broken;
+
+#if defined (HAVE_GETRUSAGE)
+  struct rusage   begin;
+  struct rusage   use;
+#endif
+};
+
+static struct ld_phase_data phase_data [NUM_PHASES] =
+{
+  [PHASE_ALL]     = { .name = "ALL" },
+  [PHASE_CTF]     = { .name = "ctf processing" },
+  [PHASE_MERGE]   = { .name = "string merge" },
+  [PHASE_PARSE]   = { .name = "parsing" },
+  [PHASE_PLUGINS] = { .name = "plugins" },
+  [PHASE_PROCESS] = { .name = "processing files" },
+  [PHASE_WRITE]   = { .name = "write" },
+};
+
+void
+ld_start_phase (ld_phase phase)
+{
+  struct ld_phase_data * pd = phase_data + phase;
+
+  /* We record data even if config.stats_file is NULL.  This allows
+     us to record data about phases that start before the command line
+     arguments have been parsed.  ie PHASE_ALL and PHASE_PARSE.  */
+
+  /* Do not overwrite the fields if we have already started recording.  */
+  if (pd->started)
+    {
+      /* Since we do not queue phase starts and stops, if a phase is started
+	 multiple times there is a likelyhood that it will be stopped multiple
+	 times as well.  This is problematic as we will only record the data
+	 for the first time the phase stops and ignore all of the other stops.
+
+	 So let the user know.  Ideally real users will never actually see
+	 this message, and instead only developers who are adding new phase
+	 tracking code will ever encounter it.  */
+      einfo ("%P: --stats: phase %s started twice - data may be unreliable\n",
+	     pd->name);
+      return;
+    }
+
+  /* It is OK if other phases are also active at this point.
+     It just means that the phases overlap or that one phase is a sub-task
+     of another.  Since we record resources on a per-phase basis, this
+     should not matter.  */
+
+  pd->started = true;
+  pd->start = get_run_time ();
+
+#if defined (HAVE_GETRUSAGE)
+  /* Record the resource usage at the start of the phase.  */
+  struct rusage usage;
+
+  if (getrusage (RUSAGE_SELF, & usage) != 0)
+    /* FIXME: Complain ?  */
+    return;
+  
+  memcpy (& pd->begin, & usage, sizeof usage);
+#endif
+}
+
+void
+ld_stop_phase (ld_phase phase)
+{
+  struct ld_phase_data * pd = phase_data + phase;
+
+  if (!pd->started)
+    {
+      /* We set the broken flag to indicate that the data
+	 recorded for this phase is inconsistent.  */
+      pd->broken = true;
+      return;
+    }
+
+  pd->duration += get_run_time () - pd->start;
+  pd->started = false;
+
+#if defined (HAVE_GETRUSAGE)
+  struct rusage usage;
+
+  if (getrusage (RUSAGE_SELF, & usage) != 0)
+    /* FIXME: Complain ?  */
+    return;
+
+  if (phase == PHASE_ALL)
+    memcpy (& pd->use, & usage, sizeof usage);
+  else
+    {
+      struct timeval t;
+
+      /* For sub-phases we record the increase in specific fields.  */
+      /* FIXME: Most rusage{} fields appear to be irrelevent to when considering
+	 linker resource usage.  Currently we record maxrss and user and system
+	 cpu times.  Are there any other fields that might be useful ?  */
+
+#ifndef timeradd /* Macros copied from <sys/time.h>.  */
+#define timeradd(a, b, result)					\
+      do							\
+	{							\
+	  (result)->tv_sec = (a)->tv_sec + (b)->tv_sec;		\
+	  (result)->tv_usec = (a)->tv_usec + (b)->tv_usec;	\
+	  if ((result)->tv_usec >= 1000000)			\
+	    {							\
+	      ++(result)->tv_sec;				\
+	      (result)->tv_usec -= 1000000;			\
+	    }							\
+	}							\
+      while (0)
+#endif
+      
+#ifndef timersub
+#define timersub(a, b, result)					\
+      do							\
+	{							\
+	  (result)->tv_sec = (a)->tv_sec - (b)->tv_sec;		\
+	  (result)->tv_usec = (a)->tv_usec - (b)->tv_usec;	\
+	  if ((result)->tv_usec < 0)				\
+	    {							\
+	      --(result)->tv_sec;				\
+	      (result)->tv_usec += 1000000;			\
+	    }							\
+	}							\
+      while (0)
+#endif
+      
+      timersub (& usage.ru_utime, & pd->begin.ru_utime, & t);
+      timeradd (& pd->use.ru_utime, &t, & pd->use.ru_utime);
+
+      timersub (& usage.ru_stime, & pd->begin.ru_stime, & t);
+      timeradd (& pd->use.ru_stime, &t, & pd->use.ru_stime);
+		
+      if (pd->begin.ru_maxrss < usage.ru_maxrss)
+	pd->use.ru_maxrss += usage.ru_maxrss - pd->begin.ru_maxrss;
+#endif
+    }
+}
+
+static void
+report_phases (FILE * file, time_t * start, char ** argv)
+{
+  unsigned long i;
+
+  if (file == NULL)
+    return;
+
+  /* We might be writing to stdout, so make sure
+     that we do not have any pending error output.  */
+  fflush (stderr);
+
+  /* We do not translate "Stats" as we provide this as a key
+     word that can be searched for by grep and the like.  */
+#define STATS_PREFIX "Stats: "
+
+  fprintf (file, STATS_PREFIX "linker version: %s\n", BFD_VERSION_STRING);
+
+  /* No \n at the end of the string as ctime() provides its own.  */
+  fprintf (file, STATS_PREFIX "linker started: %s", ctime (start));
+
+  /* We include the linker command line arguments since
+     they can be hard to track down by other means.  */
+  if (argv != NULL)
+    {
+      fprintf (file, STATS_PREFIX "args: ");
+      for (i = 0; argv[i] != NULL; i++)
+	fprintf (file, "%s ", argv[i]);
+      fprintf (file, "\n\n");  /* Blank line to separate the args from the stats.  */
+    }
+
+  /* All of this song and dance with the column_info struct and printf
+     formatting is so that we can have a nicely formated table with regular
+     column spacing, whilst allowing for the column headers to be translated,
+     and coping nicely with extra long strings or numbers.  */
+  struct column_info
+  {
+    const char * header;
+    const char * sub_header;
+    int          width;
+    int          pad;
+  } columns[] =
+#define COLUMNS_FIELD(HEADER,SUBHEADER) \
+    { .header = N_( HEADER ), .sub_header = N_( SUBHEADER ) },
+  {
+    COLUMNS_FIELD ("phase", "name")
+    COLUMNS_FIELD ("cpu time", "(microsec)")
+#if defined (HAVE_GETRUSAGE)  
+    /* Note: keep these columns in sync with the
+       information recorded in ld_stop_phase().  */
+    COLUMNS_FIELD ("memory", "(KiB)")
+    COLUMNS_FIELD ("user time", "(seconds)")
+    COLUMNS_FIELD ("system time", "(seconds)")
+#endif
+  };
+
+#ifndef max
+#define max(A,B) ((A) < (B) ? (B) : (A))
+#endif
+
+  size_t maxwidth = 1;
+  for (i = 0; i < NUM_PHASES; i++)
+    maxwidth = max (maxwidth, strlen (phase_data[i].name));
+
+  fprintf (file, "%s", STATS_PREFIX);
+
+  for (i = 0; i < ARRAY_SIZE (columns); i++)
+    {
+      int padding;
+
+      if (i == 0)
+	columns[i].width = fprintf (file, "%-*s", (int) maxwidth, columns[i].header);
+      else
+	columns[i].width = fprintf (file, "%s", columns[i].header);
+      padding = columns[i].width % 8;
+      if (padding < 4)
+	padding = 4;
+      columns[i].pad = fprintf (file, "%*c", padding, ' ');
+    }
+
+  fprintf (file, "\n");
+
+  int bias = 0;
+#define COLUMN_ENTRY(VAL, FORMAT, N)					\
+  do									\
+    {									\
+      int l;								\
+      									\
+      if (N == 0) 							\
+	l = fprintf (file, "%-*" FORMAT, columns[N].width, VAL);	\
+      else								\
+	l = fprintf (file, "%*" FORMAT, columns[N].width - bias, VAL);	\
+      bias = 0;								\
+      if (l < columns[N].width)						\
+	l = columns[N].pad;						\
+      else if (l < columns[N].width + columns[N].pad)			\
+	l = columns[N].pad - (l - columns[N].width);			\
+      else								\
+	{								\
+	  bias = l - (columns[N].width + columns[N].pad);		\
+	  l = 0;							\
+	}								\
+      if (l)								\
+	fprintf (file, "%*c", l, ' ');					\
+    }									\
+  while (0)
+
+  fprintf (file, "%s", STATS_PREFIX);
+
+  for (i = 0; i < ARRAY_SIZE (columns); i++)
+    COLUMN_ENTRY (columns[i].sub_header, "s", i);
+
+  fprintf (file, "\n");
+
+  for (i = 0; i < NUM_PHASES; i++)
+    {
+      struct ld_phase_data * pd = phase_data + i;
+      /* This should not be needed...  */      
+      const char * name = pd->name ? pd->name : "<unnamed>";
+
+      if (pd->broken)
+	{
+	  fprintf (file, "%s %s: %s",
+		   STATS_PREFIX, name, _("WARNING: Data is unreliable!\n"));
+	  continue;
+	}
+
+      fprintf (file, "%s", STATS_PREFIX);
+
+      /* Care must be taken to keep the lines below in sync with
+	 entries in the columns_info array.
+	 FIXME: There ought to be a better way to do this...  */
+      COLUMN_ENTRY (name, "s", 0);
+      COLUMN_ENTRY (pd->duration, "ld", 1);
+#if defined (HAVE_GETRUSAGE)
+      COLUMN_ENTRY (pd->use.ru_maxrss, "ld", 2);
+      COLUMN_ENTRY (pd->use.ru_utime.tv_sec, "ld", 3);
+      COLUMN_ENTRY (pd->use.ru_stime.tv_sec, "ld", 4);
+#endif
+      fprintf (file, "\n");
+    }
+
+  fflush (file);
+}
+
 int
 main (int argc, char **argv)
 {
   char *emulation;
   long start_time = get_run_time ();
+  time_t start_seconds = time (NULL);
 
 #ifdef HAVE_LC_MESSAGES
   setlocale (LC_MESSAGES, "");
@@ -286,7 +589,23 @@ main (int argc, char **argv)
   program_name = argv[0];
   xmalloc_set_program_name (program_name);
 
+  /* Check the LD_STATS environment variable before parsing the command line
+     so that the --stats option, if used, can override the environment variable.  */
+  char * stats_filename;
+  if ((stats_filename = getenv ("LD_STATS")) != NULL)
+    {
+      if (ISPRINT (stats_filename[0]))
+	config.stats_filename = stats_filename;
+      else
+	config.stats_filename = "-";
+      config.stats = true;
+    }
+
+  ld_start_phase (PHASE_ALL);
+  ld_start_phase (PHASE_PARSE);
+  
   expandargv (&argc, &argv);
+  char ** saved_argv = dupargv (argv);
 
   if (bfd_init () != BFD_INIT_MAGIC)
     fatal (_("%P: fatal error: libbfd ABI mismatch\n"));
@@ -404,11 +723,17 @@ main (int argc, char **argv)
   if (config.hash_table_size != 0)
     bfd_hash_set_default_size (config.hash_table_size);
 
+  ld_stop_phase (PHASE_PARSE);
+  
 #if BFD_SUPPORTS_PLUGINS
+  ld_start_phase (PHASE_PLUGINS);
   /* Now all the plugin arguments have been gathered, we can load them.  */
   plugin_load_plugins ();
+  ld_stop_phase (PHASE_PLUGINS);
 #endif /* BFD_SUPPORTS_PLUGINS */
 
+  ld_start_phase (PHASE_PARSE);
+
   ldemul_set_symbols ();
 
   /* If we have not already opened and parsed a linker script,
@@ -531,7 +856,31 @@ main (int argc, char **argv)
       link_info.has_map_file = true;
     }
 
+  if (config.stats_filename != NULL)
+    {
+      if (config.map_filename != NULL
+	  && strcmp (config.stats_filename, config.map_filename) == 0)
+	config.stats_file = NULL;
+      else if (strcmp (config.stats_filename, "-") == 0)
+	config.stats_file = stdout;
+      else
+	{
+	  if (config.stats_filename[0] == '+')
+	    config.stats_file = fopen (config.stats_filename + 1, "a");
+	  else
+	    config.stats_file = fopen (config.stats_filename, "w");
+
+	  if (config.stats_file == NULL)
+	    einfo ("%P: Warning: failed to open resource record file: %s\n",
+		   config.stats_filename);
+	}
+    }
+
+  ld_stop_phase (PHASE_PARSE);
+
+  ld_start_phase (PHASE_PROCESS);
   lang_process ();
+  ld_stop_phase (PHASE_PROCESS);
 
   /* Print error messages for any missing symbols, for any warning
      symbols, and possibly multiple definitions.  */
@@ -558,7 +907,11 @@ main (int argc, char **argv)
   link_info.output_bfd->flags
     |= flags & bfd_applicable_file_flags (link_info.output_bfd);
 
+
+  ld_start_phase (PHASE_WRITE);
   ldwrite ();
+  ld_stop_phase (PHASE_WRITE);
+
 
   if (config.map_file != NULL)
     lang_map ();
@@ -653,19 +1006,38 @@ main (int argc, char **argv)
   if (config.emit_gnu_object_only)
     cmdline_emit_object_only_section ();
 
+  ld_stop_phase (PHASE_ALL);
+
   if (config.stats)
     {
-      long run_time = get_run_time () - start_time;
+      report_phases (config.map_file, & start_seconds, saved_argv);
+
+      if (config.stats_filename)
+	{
+	  report_phases (config.stats_file, & start_seconds, saved_argv);
+
+	  if (config.stats_file != stdout && config.stats_file != stderr)
+	    {
+	      fclose (config.stats_file);
+	      config.stats_file = NULL;
+	    }
+	}
+      else /* This is for backwards compatibility.  */
+	{
+	  long run_time = get_run_time () - start_time;
 
-      fflush (stdout);
-      fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
-	       program_name, run_time / 1000000, run_time % 1000000);
-      fflush (stderr);
+	  fflush (stdout);
+	  fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
+		   program_name, run_time / 1000000, run_time % 1000000);
+	  fflush (stderr);
+	}
     }
 
   /* Prevent ld_cleanup from deleting the output file.  */
   output_filename = NULL;
 
+  freeargv (saved_argv);
+
   xexit (0);
   return 0;
 }
@@ -942,8 +1314,11 @@ add_archive_element (struct bfd_link_info *info,
       && (!no_more_claiming
 	  || bfd_get_lto_type (abfd) != lto_fat_ir_object))
     {
+      ld_start_phase (PHASE_PLUGINS);
       /* We must offer this archive member to the plugins to claim.  */
       plugin_maybe_claim (input);
+      ld_stop_phase (PHASE_PLUGINS);
+
       if (input->flags.claimed)
 	{
 	  if (no_more_claiming)