elf/sprof.c

   1 /* Read and display shared object profiling data.
   2    Copyright (C) 1997, 1998 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Library General Public License as
   8    published by the Free Software Foundation; either version 2 of the
   9    License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Library General Public License for more details.
  15
  16    You should have received a copy of the GNU Library General Public
  17    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  18    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #include <argp.h>
  22 #include <dlfcn.h>
  23 #include <elf.h>
  24 #include <error.h>
  25 #include <fcntl.h>
  26 #include <inttypes.h>
  27 #include <libintl.h>
  28 #include <locale.h>
  29 #include <obstack.h>
  30 #include <search.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <unistd.h>
  35 #include <elf/ldsodefs.h>
  36 #include <sys/gmon.h>
  37 #include <sys/gmon_out.h>
  38 #include <sys/mman.h>
  39 #include <sys/param.h>
  40 #include <sys/stat.h>
  41
  42 /* Undefine the following line line in the production version.  */
  43 /* #define _NDEBUG 1 */
  44 #include <assert.h>
  45
  46 /* Get libc version number.  */
  47 #include "../version.h"
  48
  49 #define PACKAGE _libc_intl_domainname
  50
  51
  52 #include <endian.h>
  53 #if BYTE_ORDER == BIG_ENDIAN
  54 #define byteorder ELFDATA2MSB
  55 #define byteorder_name "big-endian"
  56 #elif BYTE_ORDER == LITTLE_ENDIAN
  57 #define byteorder ELFDATA2LSB
  58 #define byteorder_name "little-endian"
  59 #else
  60 #error "Unknown BYTE_ORDER " BYTE_ORDER
  61 #define byteorder ELFDATANONE
  62 #endif
  63
  64
  65 extern int __profile_frequency __P ((void));
  66
  67 /* Name and version of program.  */
  68 static void print_version (FILE *stream, struct argp_state *state);
  69 void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version;
  70
  71 #define OPT_TEST        1
  72
  73 /* Definitions of arguments for argp functions.  */
  74 static const struct argp_option options[] =
  75 {
  76   { NULL, 0, NULL, 0, N_("Output selection:") },
  77   { "flat-profile", 'p', NULL, 0,
  78     N_("generate flat profile with counts and ticks") },
  79   { "graph", 'q', NULL, 0, N_("generate call graph") },
  80
  81   { "test", OPT_TEST, NULL, OPTION_HIDDEN, NULL },
  82   { NULL, 0, NULL, 0, NULL }
  83 };
  84
  85 /* Short description of program.  */
  86 static const char doc[] = N_("Read and display shared object profiling data");
  87
  88 /* Strings for arguments in help texts.  */
  89 static const char args_doc[] = N_("SHOBJ [PROFDATA]");
  90
  91 /* Prototype for option handler.  */
  92 static error_t parse_opt (int key, char *arg, struct argp_state *state);
  93
  94 /* Data structure to communicate with argp functions.  */
  95 static struct argp argp =
  96 {
  97   options, parse_opt, args_doc, doc, NULL, NULL
  98 };
  99
 100
 101 /* Operation modes.  */
 102 static enum
 103 {
 104   NONE = 0,
 105   FLAT_MODE = 1 << 0,
 106   CALL_GRAPH_MODE = 1 << 1,
 107
 108   DEFAULT_MODE = FLAT_MODE | CALL_GRAPH_MODE
 109 } mode;
 110
 111 /* If nonzero the total number of invocations of a function is emitted.  */
 112 int count_total;
 113
 114 /* Nozero for testing.  */
 115 int do_test;
 116
 117 /* Strcuture describing calls.  */
 118 struct here_fromstruct
 119 {
 120   struct here_cg_arc_record volatile *here;
 121   uint16_t link;
 122 };
 123
 124 /* We define a special type to address the elements of the arc table.
 125    This is basically the `gmon_cg_arc_record' format but it includes
 126    the room for the tag and it uses real types.  */
 127 struct here_cg_arc_record
 128 {
 129   uintptr_t from_pc;
 130   uintptr_t self_pc;
 131   uint32_t count;
 132 } __attribute__ ((packed));
 133
 134
 135 struct known_symbol;
 136 struct arc_list
 137 {
 138   size_t idx;
 139   uintmax_t count;
 140
 141   struct arc_list *next;
 142 };
 143
 144 static struct obstack ob_list;
 145
 146
 147 struct known_symbol
 148 {
 149   const char *name;
 150   uintptr_t addr;
 151   size_t size;
 152
 153   uintmax_t ticks;
 154   uintmax_t calls;
 155
 156   struct arc_list *froms;
 157   struct arc_list *tos;
 158 };
 159
 160
 161 struct shobj
 162 {
 163   const char *name;             /* User-provided name.  */
 164
 165   struct link_map *map;
 166   const char *dynstrtab;        /* Dynamic string table of shared object.  */
 167   const char *soname;           /* Soname of shared object.  */
 168
 169   uintptr_t lowpc;
 170   uintptr_t highpc;
 171   unsigned long int kcountsize;
 172   size_t expected_size;         /* Expected size of profiling file.  */
 173   size_t tossize;
 174   size_t fromssize;
 175   size_t fromlimit;
 176   unsigned int hashfraction;
 177   int s_scale;
 178
 179   void *symbol_map;
 180   size_t symbol_mapsize;
 181   const ElfW(Sym) *symtab;
 182   size_t symtab_size;
 183   const char *strtab;
 184
 185   struct obstack ob_str;
 186   struct obstack ob_sym;
 187 };
 188
 189
 190 struct profdata
 191 {
 192   void *addr;
 193   off_t size;
 194
 195   char *hist;
 196   struct gmon_hist_hdr *hist_hdr;
 197   uint16_t *kcount;
 198   uint32_t narcs;               /* Number of arcs in toset.  */
 199   struct here_cg_arc_record *data;
 200   uint16_t *tos;
 201   struct here_fromstruct *froms;
 202 };
 203
 204 /* Search tree for symbols.  */
 205 void *symroot;
 206 static struct known_symbol **sortsym;
 207 static size_t symidx;
 208 static uintmax_t total_ticks;
 209
 210 /* Prototypes for local functions.  */
 211 static struct shobj *load_shobj (const char *name);
 212 static void unload_shobj (struct shobj *shobj);
 213 static struct profdata *load_profdata (const char *name, struct shobj *shobj);
 214 static void unload_profdata (struct profdata *profdata);
 215 static void count_total_ticks (struct shobj *shobj, struct profdata *profdata);
 216 static void count_calls (struct shobj *shobj, struct profdata *profdata);
 217 static void read_symbols (struct shobj *shobj);
 218 static void add_arcs (struct profdata *profdata);
 219 static void generate_flat_profile (struct profdata *profdata);
 220 static void generate_call_graph (struct profdata *profdata);
 221
 222
 223 int
 224 main (int argc, char *argv[])
 225 {
 226   const char *shobj;
 227   const char *profdata;
 228   struct shobj *shobj_handle;
 229   struct profdata *profdata_handle;
 230   int remaining;
 231
 232   setlocale (LC_ALL, "");
 233
 234   /* Initialize the message catalog.  */
 235   textdomain (_libc_intl_domainname);
 236
 237   /* Parse and process arguments.  */
 238   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
 239
 240   if (argc - remaining == 0 || argc - remaining > 2)
 241     {
 242       /* We need exactly two non-option parameter.  */
 243       argp_help (&argp, stdout, ARGP_HELP_SEE | ARGP_HELP_EXIT_ERR,
 244                  program_invocation_short_name);
 245       exit (1);
 246     }
 247
 248   /* Get parameters.  */
 249   shobj = argv[remaining];
 250   if (argc - remaining == 2)
 251     profdata = argv[remaining + 1];
 252   else
 253     /* No filename for the profiling data given.  We will determine it
 254        from the soname of the shobj, later.  */
 255     profdata = NULL;
 256
 257   /* First see whether we can load the shared object.  */
 258   shobj_handle = load_shobj (shobj);
 259   if (shobj_handle == NULL)
 260     exit (1);
 261
 262   /* We can now determine the filename for the profiling data, if
 263      nececessary.  */
 264   if (profdata == NULL)
 265     {
 266       char *newp;
 267
 268       if (shobj_handle->soname == NULL)
 269         {
 270           unload_shobj (shobj_handle);
 271
 272           error (EXIT_FAILURE, 0, _("\
 273 no filename for profiling data given and shared object `%s' has no soname"),
 274                  shobj);
 275         }
 276
 277       newp = (char *) alloca (strlen (shobj_handle->soname)
 278                               + sizeof ".profile");
 279       stpcpy (stpcpy (newp, shobj_handle->soname), ".profile");
 280       profdata = newp;
 281     }
 282
 283   /* Now see whether the profiling data file matches the given object.   */
 284   profdata_handle = load_profdata (profdata, shobj_handle);
 285   if (profdata_handle == NULL)
 286     {
 287       unload_shobj (shobj_handle);
 288
 289       exit (1);
 290     }
 291
 292   read_symbols (shobj_handle);
 293
 294   /* Count the ticks.  */
 295   count_total_ticks (shobj_handle, profdata_handle);
 296
 297   /* Count the calls.  */
 298   count_calls (shobj_handle, profdata_handle);
 299
 300   /* Add the arc information.  */
 301   add_arcs (profdata_handle);
 302
 303   /* If no mode is specified fall back to the default mode.  */
 304   if (mode == NONE)
 305     mode = DEFAULT_MODE;
 306
 307   /* Do some work.  */
 308   if (mode & FLAT_MODE)
 309     generate_flat_profile (profdata_handle);
 310
 311   if (mode & CALL_GRAPH_MODE)
 312     generate_call_graph (profdata_handle);
 313
 314   /* Free the resources.  */
 315   unload_shobj (shobj_handle);
 316   unload_profdata (profdata_handle);
 317
 318   return 0;
 319 }
 320
 321
 322 /* Handle program arguments.  */
 323 static error_t
 324 parse_opt (int key, char *arg, struct argp_state *state)
 325 {
 326   switch (key)
 327     {
 328     case 'p':
 329       mode |= FLAT_MODE;
 330       break;
 331     case 'q':
 332       mode |= CALL_GRAPH_MODE;
 333       break;
 334     case OPT_TEST:
 335       do_test = 1;
 336       break;
 337     default:
 338       return ARGP_ERR_UNKNOWN;
 339     }
 340   return 0;
 341 }
 342
 343
 344 /* Print the version information.  */
 345 static void
 346 print_version (FILE *stream, struct argp_state *state)
 347 {
 348   fprintf (stream, "sprof (GNU %s) %s\n", PACKAGE, VERSION);
 349   fprintf (stream, gettext ("\
 350 Copyright (C) %s Free Software Foundation, Inc.\n\
 351 This is free software; see the source for copying conditions.  There is NO\n\
 352 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
 353 "),
 354            "1997, 1998");
 355   fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
 356 }
 357
 358
 359 /* Note that we must not use `dlopen' etc.  The shobj object must not
 360    be loaded for use.  */
 361 static struct shobj *
 362 load_shobj (const char *name)
 363 {
 364   struct link_map *map = NULL;
 365   struct shobj *result;
 366   ElfW(Addr) mapstart = ~((ElfW(Addr)) 0);
 367   ElfW(Addr) mapend = 0;
 368   const ElfW(Phdr) *ph;
 369   size_t textsize;
 370   unsigned int log_hashfraction;
 371   ElfW(Ehdr) *ehdr;
 372   int fd;
 373   ElfW(Shdr) *shdr;
 374   void *ptr;
 375   size_t pagesize = getpagesize ();
 376   const char *shstrtab;
 377   int idx;
 378   ElfW(Shdr) *symtab_entry;
 379
 380   /* Since we use dlopen() we must be prepared to work around the sometimes
 381      strange lookup rules for the shared objects.  If we have a file foo.so
 382      in the current directory and the user specfies foo.so on the command
 383      line (without specifying a directory) we should load the file in the
 384      current directory even if a normal dlopen() call would read the other
 385      file.  We do this by adding a directory portion to the name.  */
 386   if (strchr (name, '/') == NULL)
 387     {
 388       char *load_name = (char *) alloca (strlen (name) + 3);
 389       stpcpy (stpcpy (load_name, "./"), name);
 390
 391       map = (struct link_map *) dlopen (load_name, RTLD_LAZY);
 392     }
 393   if (map == NULL)
 394     {
 395       map = (struct link_map *) dlopen (name, RTLD_LAZY);
 396       if (map == NULL)
 397         {
 398           error (0, errno, _("failed to load shared object `%s'"), name);
 399           return NULL;
 400         }
 401     }
 402
 403   /* Prepare the result.  */
 404   result = (struct shobj *) calloc (1, sizeof (struct shobj));
 405   if (result == NULL)
 406     {
 407       error (0, errno, _("cannot create internal descriptors"));
 408       dlclose (map);
 409       return NULL;
 410     }
 411   result->name = name;
 412   result->map = map;
 413
 414   /* Compute the size of the sections which contain program code.
 415      This must match the code in dl-profile.c (_dl_start_profile).  */
 416   for (ph = map->l_phdr; ph < &map->l_phdr[map->l_phnum]; ++ph)
 417     if (ph->p_type == PT_LOAD && (ph->p_flags & PF_X))
 418       {
 419         ElfW(Addr) start = (ph->p_vaddr & ~(pagesize - 1));
 420         ElfW(Addr) end = ((ph->p_vaddr + ph->p_memsz + pagesize - 1)
 421                           & ~(pagesize - 1));
 422
 423         if (start < mapstart)
 424           mapstart = start;
 425         if (end > mapend)
 426           mapend = end;
 427       }
 428
 429   result->lowpc = ROUNDDOWN ((uintptr_t) (mapstart + map->l_addr),
 430                              HISTFRACTION * sizeof (HISTCOUNTER));
 431   result->highpc = ROUNDUP ((uintptr_t) (mapend + map->l_addr),
 432                             HISTFRACTION * sizeof (HISTCOUNTER));
 433   if (do_test)
 434     printf ("load addr: %0#*" PRIxPTR "\n"
 435             "lower bound PC: %0#*" PRIxPTR "\n"
 436             "upper bound PC: %0#*" PRIxPTR "\n",
 437             __ELF_NATIVE_CLASS == 32 ? 10 : 18, map->l_addr,
 438             __ELF_NATIVE_CLASS == 32 ? 10 : 18, result->lowpc,
 439             __ELF_NATIVE_CLASS == 32 ? 10 : 18, result->highpc);
 440
 441   textsize = result->highpc - result->lowpc;
 442   result->kcountsize = textsize / HISTFRACTION;
 443   result->hashfraction = HASHFRACTION;
 444   if ((HASHFRACTION & (HASHFRACTION - 1)) == 0)
 445     /* If HASHFRACTION is a power of two, mcount can use shifting
 446        instead of integer division.  Precompute shift amount.  */
 447     log_hashfraction = __builtin_ffs (result->hashfraction
 448                                       * sizeof (struct here_fromstruct)) - 1;
 449   else
 450     log_hashfraction = -1;
 451   if (do_test)
 452     printf ("hashfraction = %d\ndivider = %d\n",
 453             result->hashfraction,
 454             result->hashfraction * sizeof (struct here_fromstruct));
 455   result->tossize = textsize / HASHFRACTION;
 456   result->fromlimit = textsize * ARCDENSITY / 100;
 457   if (result->fromlimit < MINARCS)
 458     result->fromlimit = MINARCS;
 459   if (result->fromlimit > MAXARCS)
 460     result->fromlimit = MAXARCS;
 461   result->fromssize = result->fromlimit * sizeof (struct here_fromstruct);
 462
 463   result->expected_size = (sizeof (struct gmon_hdr)
 464                            + 4 + sizeof (struct gmon_hist_hdr)
 465                            + result->kcountsize
 466                            + 4 + 4
 467                            + (result->fromssize
 468                               * sizeof (struct here_cg_arc_record)));
 469
 470   if (do_test)
 471     printf ("expected size: %Zd\n", result->expected_size);
 472
 473 #define SCALE_1_TO_1    0x10000L
 474
 475   if (result->kcountsize < result->highpc - result->lowpc)
 476     {
 477       size_t range = result->highpc - result->lowpc;
 478       size_t quot = range / result->kcountsize;
 479
 480       if (quot >= SCALE_1_TO_1)
 481         result->s_scale = 1;
 482       else if (quot >= SCALE_1_TO_1 / 256)
 483         result->s_scale = SCALE_1_TO_1 / quot;
 484       else if (range > ULONG_MAX / 256)
 485         result->s_scale = ((SCALE_1_TO_1 * 256)
 486                            / (range / (result->kcountsize / 256)));
 487       else
 488         result->s_scale = ((SCALE_1_TO_1 * 256)
 489                            / ((range * 256) / result->kcountsize));
 490     }
 491   else
 492     result->s_scale = SCALE_1_TO_1;
 493
 494   if (do_test)
 495     printf ("s_scale: %d\n", result->s_scale);
 496
 497   /* Determine the dynamic string table.  */
 498   if (map->l_info[DT_STRTAB] == NULL)
 499     result->dynstrtab = NULL;
 500   else
 501     result->dynstrtab = (const char *) (map->l_addr
 502                                         + map->l_info[DT_STRTAB]->d_un.d_ptr);
 503   if (do_test)
 504     printf ("string table: %p\n", result->dynstrtab);
 505
 506   /* Determine the soname.  */
 507   if (map->l_info[DT_SONAME] == NULL)
 508     result->soname = NULL;
 509   else
 510     result->soname = result->dynstrtab + map->l_info[DT_SONAME]->d_un.d_val;
 511   if (do_test)
 512     printf ("soname: %s\n", result->soname);
 513
 514   /* Now we have to load the symbol table.
 515
 516      First load the section header table.  */
 517   ehdr = (ElfW(Ehdr) *) map->l_addr;
 518
 519   /* Make sure we are on the right party.  */
 520   if (ehdr->e_shentsize != sizeof (ElfW(Shdr)))
 521     abort ();
 522
 523   /* And we need the shared object file descriptor again.  */
 524   fd = open (map->l_name, O_RDONLY);
 525   if (fd == -1)
 526     /* Dooh, this really shouldn't happen.  We know the file is available.  */
 527     error (EXIT_FAILURE, errno, _("Reopening shared object `%s' failed"));
 528
 529   /* Now map the section header.  */
 530   ptr = mmap (NULL, (ehdr->e_shnum * sizeof (ElfW(Shdr))
 531                      + (ehdr->e_shoff & (pagesize - 1))), PROT_READ,
 532               MAP_SHARED|MAP_FILE, fd, ehdr->e_shoff & ~(pagesize - 1));
 533   if (ptr == MAP_FAILED)
 534     error (EXIT_FAILURE, errno, _("mapping of section headers failed"));
 535   shdr = (ElfW(Shdr) *) ((char *) ptr + (ehdr->e_shoff & (pagesize - 1)));
 536
 537   /* Get the section header string table.  */
 538   ptr = mmap (NULL, (shdr[ehdr->e_shstrndx].sh_size
 539                      + (shdr[ehdr->e_shstrndx].sh_offset & (pagesize - 1))),
 540               PROT_READ, MAP_SHARED|MAP_FILE, fd,
 541               shdr[ehdr->e_shstrndx].sh_offset & ~(pagesize - 1));
 542   if (ptr == MAP_FAILED)
 543     error (EXIT_FAILURE, errno,
 544            _("mapping of section header string table failed"));
 545   shstrtab = ((const char *) ptr
 546               + (shdr[ehdr->e_shstrndx].sh_offset & (pagesize - 1)));
 547
 548   /* Search for the ".symtab" section.  */
 549   symtab_entry = NULL;
 550   for (idx = 0; idx < ehdr->e_shnum; ++idx)
 551     if (shdr[idx].sh_type == SHT_SYMTAB
 552         && strcmp (shstrtab + shdr[idx].sh_name, ".symtab") == 0)
 553       {
 554         symtab_entry = &shdr[idx];
 555         break;
 556       }
 557
 558   /* We don't need the section header string table anymore.  */
 559   munmap (ptr, (shdr[ehdr->e_shstrndx].sh_size
 560                 + (shdr[ehdr->e_shstrndx].sh_offset & (pagesize - 1))));
 561
 562   if (symtab_entry == NULL)
 563     {
 564       fprintf (stderr, _("\
 565 *** The file `%s' is stripped: no detailed analysis possible\n"),
 566               name);
 567       result->symtab = NULL;
 568       result->strtab = NULL;
 569     }
 570   else
 571     {
 572       ElfW(Off) min_offset, max_offset;
 573       ElfW(Shdr) *strtab_entry;
 574
 575       strtab_entry = &shdr[symtab_entry->sh_link];
 576
 577       /* Find the minimum and maximum offsets that include both the symbol
 578          table and the string table.  */
 579       if (symtab_entry->sh_offset < strtab_entry->sh_offset)
 580         {
 581           min_offset = symtab_entry->sh_offset & ~(pagesize - 1);
 582           max_offset = strtab_entry->sh_offset + strtab_entry->sh_size;
 583         }
 584       else
 585         {
 586           min_offset = strtab_entry->sh_offset & ~(pagesize - 1);
 587           max_offset = symtab_entry->sh_offset + symtab_entry->sh_size;
 588         }
 589
 590       result->symbol_map = mmap (NULL, max_offset - min_offset,
 591                                  PROT_READ, MAP_SHARED|MAP_FILE, fd,
 592                                  min_offset);
 593       if (result->symbol_map == NULL)
 594         error (EXIT_FAILURE, errno, _("failed to load symbol data"));
 595
 596       result->symtab
 597         = (const ElfW(Sym) *) ((const char *) result->symbol_map
 598                                + (symtab_entry->sh_offset - min_offset));
 599       result->symtab_size = symtab_entry->sh_size;
 600       result->strtab = ((const char *) result->symbol_map
 601                         + (strtab_entry->sh_offset - min_offset));
 602       result->symbol_mapsize = max_offset - min_offset;
 603     }
 604
 605   /* Now we also don't need the section header table anymore.  */
 606   munmap ((char *) shdr - (ehdr->e_shoff & (pagesize - 1)),
 607           (ehdr->e_phnum * sizeof (ElfW(Shdr))
 608            + (ehdr->e_shoff & (pagesize - 1))));
 609
 610   /* Free the descriptor for the shared object.  */
 611   close (fd);
 612
 613   return result;
 614 }
 615
 616
 617 static void
 618 unload_shobj (struct shobj *shobj)
 619 {
 620   munmap (shobj->symbol_map, shobj->symbol_mapsize);
 621   dlclose (shobj->map);
 622 }
 623
 624
 625 static struct profdata *
 626 load_profdata (const char *name, struct shobj *shobj)
 627 {
 628   struct profdata *result;
 629   int fd;
 630   struct stat st;
 631   void *addr;
 632   struct gmon_hdr gmon_hdr;
 633   struct gmon_hist_hdr hist_hdr;
 634   uint32_t *narcsp;
 635   size_t fromlimit;
 636   struct here_cg_arc_record *data;
 637   struct here_fromstruct *froms;
 638   uint16_t *tos;
 639   size_t fromidx;
 640   size_t idx;
 641
 642   fd = open (name, O_RDONLY);
 643   if (fd == -1)
 644     {
 645       char *ext_name;
 646
 647       if (errno != ENOENT || strchr (name, '/') != NULL)
 648         /* The file exists but we are not allowed to read it or the
 649            file does not exist and the name includes a path
 650            specification..  */
 651         return NULL;
 652
 653       /* A file with the given name does not exist in the current
 654          directory, try it in the default location where the profiling
 655          files are created.  */
 656       ext_name = (char *) alloca (strlen (name) + sizeof "/var/tmp/");
 657       stpcpy (stpcpy (ext_name, "/var/tmp/"), name);
 658       name = ext_name;
 659
 660       fd = open (ext_name, O_RDONLY);
 661       if (fd == -1)
 662         {
 663           /* Even this file does not exist.  */
 664           error (0, errno, _("cannot load profiling data"));
 665           return NULL;
 666         }
 667     }
 668
 669   /* We have found the file, now make sure it is the right one for the
 670      data file.  */
 671   if (fstat (fd, &st) < 0)
 672     {
 673       error (0, errno, _("while stat'ing profiling data file"));
 674       close (fd);
 675       return NULL;
 676     }
 677
 678   if (st.st_size != shobj->expected_size)
 679     {
 680       error (0, 0, _("profiling data file `%s' does match shared object `%s'"),
 681              name, shobj->name);
 682       close (fd);
 683       return NULL;
 684     }
 685
 686   /* The data file is most probably the right one for our shared
 687      object.  Map it now.  */
 688   addr = mmap (NULL, st.st_size, PROT_READ, MAP_SHARED|MAP_FILE, fd, 0);
 689   if (addr == MAP_FAILED)
 690     {
 691       error (0, errno, _("failed to mmap the profiling data file"));
 692       close (fd);
 693       return NULL;
 694     }
 695
 696   /* We don't need the file desriptor anymore.  */
 697   if (close (fd) < 0)
 698     {
 699       error (0, errno, _("error while closing the profiling data file"));
 700       munmap (addr, st.st_size);
 701       return NULL;
 702     }
 703
 704   /* Prepare the result.  */
 705   result = (struct profdata *) calloc (1, sizeof (struct profdata));
 706   if (result == NULL)
 707     {
 708       error (0, errno, _("cannot create internal descriptor"));
 709       munmap (addr, st.st_size);
 710       return NULL;
 711     }
 712
 713   /* Store the address and size so that we can later free the resources.  */
 714   result->addr = addr;
 715   result->size = st.st_size;
 716
 717   /* Pointer to data after the header.  */
 718   result->hist = (char *) ((struct gmon_hdr *) addr + 1);
 719   result->hist_hdr = (struct gmon_hist_hdr *) ((char *) result->hist
 720                                                + sizeof (uint32_t));
 721   result->kcount = (uint16_t *) ((char *) result->hist + sizeof (uint32_t)
 722                                  + sizeof (struct gmon_hist_hdr));
 723
 724   /* Compute pointer to array of the arc information.  */
 725   narcsp = (uint32_t *) ((char *) result->kcount + shobj->kcountsize
 726                          + sizeof (uint32_t));
 727   result->narcs = *narcsp;
 728   result->data = (struct here_cg_arc_record *) ((char *) narcsp
 729                                                 + sizeof (uint32_t));
 730
 731   /* Create the gmon_hdr we expect or write.  */
 732   memset (&gmon_hdr, '\0', sizeof (struct gmon_hdr));
 733   memcpy (&gmon_hdr.cookie[0], GMON_MAGIC, sizeof (gmon_hdr.cookie));
 734   *(int32_t *) gmon_hdr.version = GMON_SHOBJ_VERSION;
 735
 736   /* Create the hist_hdr we expect or write.  */
 737   *(char **) hist_hdr.low_pc = (char *) shobj->lowpc - shobj->map->l_addr;
 738   *(char **) hist_hdr.high_pc = (char *) shobj->highpc - shobj->map->l_addr;
 739   if (do_test)
 740     printf ("low_pc = %p\nhigh_pc = %p\n",
 741             *(char **) hist_hdr.low_pc, *(char **) hist_hdr.high_pc);
 742   *(int32_t *) hist_hdr.hist_size = shobj->kcountsize / sizeof (HISTCOUNTER);
 743   *(int32_t *) hist_hdr.prof_rate = __profile_frequency ();
 744   strncpy (hist_hdr.dimen, "seconds", sizeof (hist_hdr.dimen));
 745   hist_hdr.dimen_abbrev = 's';
 746
 747   /* Test whether the header of the profiling data is ok.  */
 748   if (memcmp (addr, &gmon_hdr, sizeof (struct gmon_hdr)) != 0
 749       || *(uint32_t *) result->hist != GMON_TAG_TIME_HIST
 750       || memcmp (result->hist_hdr, &hist_hdr,
 751                  sizeof (struct gmon_hist_hdr)) != 0
 752       || narcsp[-1] != GMON_TAG_CG_ARC)
 753     {
 754       free (result);
 755       error (0, 0, _("`%s' is no correct profile data file for `%s'"),
 756              name, shobj->name);
 757       munmap (addr, st.st_size);
 758       return NULL;
 759     }
 760
 761   /* We are pretty sure now that this is a correct input file.  Set up
 762      the remaining information in the result structure and return.  */
 763   result->tos = (uint16_t *) calloc (shobj->tossize + shobj->fromssize, 1);
 764   if (result->tos == NULL)
 765     {
 766       error (0, errno, _("cannot create internal descriptor"));
 767       munmap (addr, st.st_size);
 768       free (result);
 769       return NULL;
 770     }
 771
 772   result->froms = (struct here_fromstruct *) ((char *) result->tos
 773                                               + shobj->tossize);
 774   fromidx = 0;
 775
 776   /* Now we have to process all the arc count entries.  */
 777   fromlimit = shobj->fromlimit;
 778   data = result->data;
 779   froms = result->froms;
 780   tos = result->tos;
 781   for (idx = 0; idx < MIN (*narcsp, fromlimit); ++idx)
 782     {
 783       size_t to_index;
 784       size_t newfromidx;
 785       to_index = (data[idx].self_pc / (shobj->hashfraction * sizeof (*tos)));
 786       newfromidx = fromidx++;
 787       froms[newfromidx].here = &data[idx];
 788       froms[newfromidx].link = tos[to_index];
 789       tos[to_index] = newfromidx;
 790     }
 791
 792   return result;
 793 }
 794
 795
 796 static void
 797 unload_profdata (struct profdata *profdata)
 798 {
 799   free (profdata->tos);
 800   munmap (profdata->addr, profdata->size);
 801   free (profdata);
 802 }
 803
 804
 805 static void
 806 count_total_ticks (struct shobj *shobj, struct profdata *profdata)
 807 {
 808   volatile uint16_t *kcount = profdata->kcount;
 809   size_t maxkidx = shobj->kcountsize;
 810   size_t factor = 2 * (65536 / shobj->s_scale);
 811   size_t kidx = 0;
 812   size_t sidx = 0;
 813
 814   while (sidx < symidx)
 815     {
 816       uintptr_t start = sortsym[sidx]->addr;
 817       uintptr_t end = start + sortsym[sidx]->size;
 818
 819       while (kidx < maxkidx && factor * kidx < start)
 820         ++kidx;
 821       if (kidx == maxkidx)
 822         break;
 823
 824       while (kidx < maxkidx && factor * kidx < end)
 825         sortsym[sidx]->ticks += kcount[kidx++];
 826       if (kidx == maxkidx)
 827         break;
 828
 829       total_ticks += sortsym[sidx++]->ticks;
 830     }
 831 }
 832
 833
 834 static size_t
 835 find_symbol (uintptr_t addr)
 836 {
 837   size_t sidx = 0;
 838
 839   while (sidx < symidx)
 840     {
 841       uintptr_t start = sortsym[sidx]->addr;
 842       uintptr_t end = start + sortsym[sidx]->size;
 843
 844       if (addr >= start && addr < end)
 845         return sidx;
 846
 847       if (addr < start)
 848         break;
 849
 850       ++sidx;
 851     }
 852
 853   return (size_t) -1l;
 854 }
 855
 856
 857 static void
 858 count_calls (struct shobj *shobj, struct profdata *profdata)
 859 {
 860   struct here_cg_arc_record *data = profdata->data;
 861   uint32_t narcs = profdata->narcs;
 862   uint32_t cnt;
 863
 864   for (cnt = 0; cnt < narcs; ++cnt)
 865     {
 866       uintptr_t here = data[cnt].self_pc;
 867       size_t symbol_idx;
 868
 869       /* Find the symbol for this address.  */
 870       symbol_idx = find_symbol (here);
 871       if (symbol_idx != (size_t) -1l)
 872         sortsym[symbol_idx]->calls += data[cnt].count;
 873     }
 874 }
 875
 876
 877 static int
 878 symorder (const void *o1, const void *o2)
 879 {
 880   const struct known_symbol *p1 = (const struct known_symbol *) o1;
 881   const struct known_symbol *p2 = (const struct known_symbol *) o2;
 882
 883   return p1->addr - p2->addr;
 884 }
 885
 886
 887 static void
 888 printsym (const void *node, VISIT value, int level)
 889 {
 890   if (value == leaf || value == postorder)
 891     sortsym[symidx++] = *(struct known_symbol **) node;
 892 }
 893
 894
 895 static void
 896 read_symbols (struct shobj *shobj)
 897 {
 898   void *load_addr = (void *) shobj->map->l_addr;
 899   int n = 0;
 900
 901   /* Initialize the obstacks.  */
 902 #define obstack_chunk_alloc malloc
 903 #define obstack_chunk_free free
 904   obstack_init (&shobj->ob_str);
 905   obstack_init (&shobj->ob_sym);
 906   obstack_init (&ob_list);
 907
 908   /* Process the symbols.  */
 909   if (shobj->symtab)
 910     {
 911       const ElfW(Sym) *sym = shobj->symtab;
 912       const ElfW(Sym) *sym_end
 913         = (const ElfW(Sym) *) ((const char *) sym + shobj->symtab_size);
 914       for (; sym < sym_end; sym++)
 915         if ((ELFW(ST_TYPE) (sym->st_info) == STT_FUNC
 916              || ELFW(ST_TYPE) (sym->st_info) == STT_NOTYPE)
 917             && sym->st_size != 0)
 918           {
 919             struct known_symbol **existp;
 920             struct known_symbol *newsym
 921               = (struct known_symbol *) obstack_alloc (&shobj->ob_sym,
 922                                                        sizeof (*newsym));
 923             if (newsym == NULL)
 924               error (EXIT_FAILURE, errno, _("cannot allocate symbol data"));
 925
 926             newsym->name = &shobj->strtab[sym->st_name];
 927             newsym->addr = sym->st_value;
 928             newsym->size = sym->st_size;
 929             newsym->ticks = 0;
 930             newsym->calls = 0;
 931
 932             existp = tfind (newsym, &symroot, symorder);
 933             if (existp == NULL)
 934               {
 935                 /* New function.  */
 936                 tsearch (newsym, &symroot, symorder);
 937                 ++n;
 938               }
 939             else
 940               {
 941                 /* The function is already defined.  See whether we have
 942                    a better name here.  */
 943                 if ((*existp)->name[0] == '_' && newsym->name[0] != '_')
 944                   *existp = newsym;
 945                 else
 946                   /* We don't need the allocated memory.  */
 947                   obstack_free (&shobj->ob_sym, newsym);
 948               }
 949           }
 950     }
 951   else
 952     {
 953       /* Blarg, the binary is stripped.  We have to rely on the
 954          information contained in the dynamic section of the object.  */
 955       const ElfW(Sym) *symtab = (load_addr
 956                                  + shobj->map->l_info[DT_SYMTAB]->d_un.d_ptr);
 957       const char *strtab = (load_addr
 958                             + shobj->map->l_info[DT_STRTAB]->d_un.d_ptr);
 959
 960       /* We assume that the string table follows the symbol table,
 961          because there is no way in ELF to know the size of the
 962          dynamic symbol table!!  */
 963       while ((void *) symtab < (void *) strtab)
 964         {
 965           if ((ELFW(ST_TYPE)(symtab->st_info) == STT_FUNC
 966                || ELFW(ST_TYPE)(symtab->st_info) == STT_NOTYPE)
 967               && symtab->st_size != 0)
 968             {
 969               struct known_symbol *newsym;
 970               struct known_symbol **existp;
 971
 972               newsym =
 973                 (struct known_symbol *) obstack_alloc (&shobj->ob_sym,
 974                                                        sizeof (*newsym));
 975               if (newsym == NULL)
 976                 error (EXIT_FAILURE, errno, _("cannot allocate symbol data"));
 977
 978               newsym->name = &strtab[symtab->st_name];
 979               newsym->addr = symtab->st_value;
 980               newsym->size = symtab->st_size;
 981               newsym->ticks = 0;
 982               newsym->froms = NULL;
 983               newsym->tos = NULL;
 984
 985               existp = tfind (newsym, &symroot, symorder);
 986               if (existp == NULL)
 987                 {
 988                   /* New function.  */
 989                   tsearch (newsym, &symroot, symorder);
 990                   ++n;
 991                 }
 992               else
 993                 {
 994                   /* The function is already defined.  See whether we have
 995                      a better name here.  */
 996                   if ((*existp)->name[0] == '_' && newsym->name[0] != '_')
 997                     *existp = newsym;
 998                   else
 999                     /* We don't need the allocated memory.  */
1000                     obstack_free (&shobj->ob_sym, newsym);
1001                 }
1002             }
1003         }
1004
1005       ++symtab;
1006     }
1007
1008   sortsym = malloc (n * sizeof (struct known_symbol *));
1009   if (sortsym == NULL)
1010     abort ();
1011
1012   twalk (symroot, printsym);
1013 }
1014
1015
1016 static void
1017 add_arcs (struct profdata *profdata)
1018 {
1019   uint32_t narcs = profdata->narcs;
1020   struct here_cg_arc_record *data = profdata->data;
1021   uint32_t cnt;
1022
1023   for (cnt = 0; cnt < narcs; ++cnt)
1024     {
1025       /* First add the incoming arc.  */
1026       size_t sym_idx = find_symbol (data[cnt].self_pc);
1027
1028       if (sym_idx != (size_t) -1l)
1029         {
1030           struct known_symbol *sym = sortsym[sym_idx];
1031           struct arc_list *runp = sym->froms;
1032
1033           while (runp != NULL
1034                  && ((data[cnt].from_pc == 0 && runp->idx != (size_t) -1l)
1035                      || (data[cnt].from_pc != 0
1036                          && (runp->idx == (size_t) -1l
1037                              || data[cnt].from_pc < sortsym[runp->idx]->addr
1038                              || (data[cnt].from_pc
1039                                  >= (sortsym[runp->idx]->addr
1040                                      + sortsym[runp->idx]->size))))))
1041             runp = runp->next;
1042
1043           if (runp == NULL)
1044             {
1045               /* We need a new entry.  */
1046               struct arc_list *newp = (struct arc_list *)
1047                 obstack_alloc (&ob_list, sizeof (struct arc_list));
1048
1049               if (data[cnt].from_pc == 0)
1050                 newp->idx = (size_t) -1l;
1051               else
1052                 newp->idx = find_symbol (data[cnt].from_pc);
1053               newp->count = data[cnt].count;
1054               newp->next = sym->froms;
1055               sym->froms = newp;
1056             }
1057           else
1058             /* Increment the counter for the found entry.  */
1059             runp->count += data[cnt].count;
1060         }
1061
1062       /* Now add it to the appropriate outgoing list.  */
1063       sym_idx = find_symbol (data[cnt].from_pc);
1064       if (sym_idx != (size_t) -1l)
1065         {
1066           struct known_symbol *sym = sortsym[sym_idx];
1067           struct arc_list *runp = sym->tos;
1068
1069           while (runp != NULL
1070                  && (runp->idx == (size_t) -1l
1071                      || data[cnt].self_pc < sortsym[runp->idx]->addr
1072                      || data[cnt].self_pc >= (sortsym[runp->idx]->addr
1073                                               + sortsym[runp->idx]->size)))
1074             runp = runp->next;
1075
1076           if (runp == NULL)
1077             {
1078               /* We need a new entry.  */
1079               struct arc_list *newp = (struct arc_list *)
1080                 obstack_alloc (&ob_list, sizeof (struct arc_list));
1081
1082               newp->idx = find_symbol (data[cnt].self_pc);
1083               newp->count = data[cnt].count;
1084               newp->next = sym->tos;
1085               sym->tos = newp;
1086             }
1087           else
1088             /* Increment the counter for the found entry.  */
1089             runp->count += data[cnt].count;
1090         }
1091     }
1092 }
1093
1094
1095 static int
1096 countorder (const void *p1, const void *p2)
1097 {
1098   struct known_symbol *s1 = (struct known_symbol *) p1;
1099   struct known_symbol *s2 = (struct known_symbol *) p2;
1100
1101   if (s1->ticks != s2->ticks)
1102     return (int) (s2->ticks - s1->ticks);
1103
1104   if (s1->calls != s2->calls)
1105     return (int) (s2->calls - s1->calls);
1106
1107   return strcmp (s1->name, s2->name);
1108 }
1109
1110
1111 static double tick_unit;
1112 static uintmax_t cumu_ticks;
1113
1114 static void
1115 printflat (const void *node, VISIT value, int level)
1116 {
1117   if (value == leaf || value == postorder)
1118     {
1119       struct known_symbol *s = *(struct known_symbol **) node;
1120
1121       cumu_ticks += s->ticks;
1122
1123       printf ("%6.2f%10.2f%9.2f%9" PRIdMAX "%9.2f           %s\n",
1124               total_ticks ? (100.0 * s->ticks) / total_ticks : 0.0,
1125               tick_unit * cumu_ticks,
1126               tick_unit * s->ticks,
1127               s->calls,
1128               s->calls ? (s->ticks * 1000000) * tick_unit / s->calls : 0,
1129               /* FIXME: don't know about called functions.  */
1130               s->name);
1131     }
1132 }
1133
1134
1135 /* ARGUSED */
1136 static void
1137 freenoop (void *p)
1138 {
1139 }
1140
1141
1142 static void
1143 generate_flat_profile (struct profdata *profdata)
1144 {
1145   size_t n;
1146   void *data = NULL;
1147
1148   tick_unit = 1.0 / *(uint32_t *) profdata->hist_hdr->prof_rate;
1149
1150   printf ("Flat profile:\n\n"
1151           "Each sample counts as %g %s.\n",
1152           tick_unit, profdata->hist_hdr->dimen);
1153   fputs ("  %   cumulative   self              self     total\n"
1154          " time   seconds   seconds    calls  us/call  us/call  name\n",
1155          stdout);
1156
1157   for (n = 0; n < symidx; ++n)
1158     if (sortsym[n]->calls != 0 || sortsym[n]->ticks != 0)
1159       tsearch (sortsym[n], &data, countorder);
1160
1161   twalk (data, printflat);
1162
1163   tdestroy (data, freenoop);
1164 }
1165
1166
1167 static void
1168 generate_call_graph (struct profdata *profdata)
1169 {
1170   size_t cnt;
1171
1172   puts ("\nindex % time    self  children    called     name\n");
1173
1174   for (cnt = 0; cnt < symidx; ++cnt)
1175     if (sortsym[cnt]->froms != NULL || sortsym[cnt]->tos != NULL)
1176       {
1177         struct arc_list *runp;
1178         size_t n;
1179
1180         /* First print the from-information.  */
1181         runp = sortsym[cnt]->froms;
1182         while (runp != NULL)
1183           {
1184             printf ("            %8.2f%8.2f%9" PRIdMAX "/%-9" PRIdMAX "   %s",
1185                     (runp->idx != (size_t) -1l
1186                      ? sortsym[runp->idx]->ticks * tick_unit : 0.0),
1187                     0.0, /* FIXME: what's time for the childern, recursive */
1188                     runp->count, sortsym[cnt]->calls,
1189                     (runp->idx != (size_t) -1l ?
1190                      sortsym[runp->idx]->name : "<UNKNOWN>"));
1191
1192             if (runp->idx != (size_t) -1l)
1193               printf (" [%Zd]", runp->idx);
1194             putchar_unlocked ('\n');
1195
1196             runp = runp->next;
1197           }
1198
1199         /* Info abount the function itself.  */
1200         n = printf ("[%d]", cnt);
1201         printf ("%*s%5.1f%8.2f%8.2f%9" PRIdMAX "         %s [%Zd]\n",
1202                 7 - n, " ",
1203                 total_ticks ? (100.0 * sortsym[cnt]->ticks) / total_ticks : 0,
1204                 sortsym[cnt]->ticks * tick_unit,
1205                 0.0, /* FIXME: what's time for the childern, recursive */
1206                 sortsym[cnt]->calls,
1207                 sortsym[cnt]->name, cnt);
1208
1209         /* Info about the functions this function calls.  */
1210         runp = sortsym[cnt]->tos;
1211         while (runp != NULL)
1212           {
1213             printf ("            %8.2f%8.2f%9" PRIdMAX "/",
1214                     (runp->idx != (size_t) -1l
1215                      ? sortsym[runp->idx]->ticks * tick_unit : 0.0),
1216                     0.0, /* FIXME: what's time for the childern, recursive */
1217                     runp->count);
1218
1219             if (runp->idx != (size_t) -1l)
1220               printf ("%-9" PRIdMAX "   %s [%Zd]\n",
1221                       sortsym[runp->idx]->calls,
1222                       sortsym[runp->idx]->name,
1223                       runp->idx);
1224             else
1225               fputs ("???         <UNKNOWN>\n\n", stdout);
1226
1227             runp = runp->next;
1228           }
1229
1230         fputs ("-----------------------------------------------\n", stdout);
1231       }
1232 }