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