1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 *
26 * Copyright 2018 Jason King
27 */
28
29 #include <ctype.h>
30 #include <string.h>
31 #include <sys/param.h>
32 #include <stdlib.h>
33 #include "conv.h"
34 #include "gprof.h"
35
36 void print_demangled_name(int, nltype *);
37 void striped_name(char *, nltype **);
38
39 extern long hz;
40
41 /*
42 * Symbols that must never be printed, no matter what.
43 */
44 char *splsym[] = {
45 PRF_ETEXT,
46 PRF_EXTSYM,
47 PRF_MEMTERM,
48 NULL
49 };
50
51 static bool is_special_sym(nltype *nlp);
52
53 const char *
54 demangled_name(nltype *selfp)
55 {
56 if (!Cflag)
57 return (selfp->name);
58
59 return (conv_demangle_name(selfp->name));
60 }
61
62 void
63 printprof(void)
64 {
65 nltype *np;
66 nltype **sortednlp;
67 int i, index;
68 int print_count = number_funcs_toprint;
69 bool print_flag = TRUE;
70 mod_info_t *mi;
71
72 actime = 0.0;
73 (void) printf("\f\n");
74 flatprofheader();
75
76 /*
77 * Sort the symbol table in by time
78 */
79 sortednlp = (nltype **) calloc(total_names, sizeof (nltype *));
80 if (sortednlp == (nltype **) 0) {
81 (void) fprintf(stderr,
82 "[printprof] ran out of memory for time sorting\n");
83 }
84
85 index = 0;
86 for (mi = &modules; mi; mi = mi->next) {
87 for (i = 0; i < mi->nname; i++)
88 sortednlp[index++] = &(mi->nl[i]);
89 }
90
91 qsort(sortednlp, total_names, sizeof (nltype *), timecmp);
92
93 for (index = 0; (index < total_names) && print_flag; index += 1) {
94 np = sortednlp[index];
95 flatprofline(np);
96 if (nflag) {
97 if (--print_count == 0)
98 print_flag = FALSE;
99 }
100 }
101 actime = 0.0;
102 free(sortednlp);
103 }
104
105 int
106 timecmp(const void *arg1, const void *arg2)
107 {
108 nltype **npp1 = (nltype **)arg1;
109 nltype **npp2 = (nltype **)arg2;
110 double timediff;
111 long calldiff;
112
113 timediff = (*npp2)->time - (*npp1)->time;
114
115 if (timediff > 0.0)
116 return (1);
117
118 if (timediff < 0.0)
119 return (-1);
120
121 calldiff = (*npp2)->ncall - (*npp1)->ncall;
122
123 if (calldiff > 0)
124 return (1);
125
126 if (calldiff < 0)
127 return (-1);
128
129 return (strcmp((*npp1)->name, (*npp2)->name));
130 }
131
132 /*
133 * header for flatprofline
134 */
135 void
136 flatprofheader()
137 {
138
139 if (bflag)
140 printblurb(FLAT_BLURB);
141
142 if (old_style) {
143 (void) printf(
144 "\ngranularity: each sample hit covers %d byte(s)",
145 (long)scale * sizeof (UNIT));
146 if (totime > 0.0) {
147 (void) printf(" for %.2f%% of %.2f seconds\n\n",
148 100.0/totime, totime / hz);
149 } else {
150 (void) printf(" no time accumulated\n\n");
151 /*
152 * this doesn't hurt since all the numerators will
153 * be zero.
154 */
155 totime = 1.0;
156 }
157 }
158
159 (void) printf("%5.5s %10.10s %8.8s %8.8s %8.8s %8.8s %-8.8s\n",
160 "% ", "cumulative", "self ", "", "self ", "total ", "");
161 (void) printf("%5.5s %10.10s %8.8s %8.8s %8.8s %8.8s %-8.8s\n",
162 "time", "seconds ", "seconds", "calls",
163 "ms/call", "ms/call", "name");
164 }
165
166 void
167 flatprofline(nltype *np)
168 {
169 if (zflag == 0 && np->ncall == 0 && np->time == 0)
170 return;
171
172 /*
173 * Do not print certain special symbols, like PRF_EXTSYM, etc.
174 * even if zflag was on.
175 */
176 if (is_special_sym(np))
177 return;
178
179 actime += np->time;
180
181 (void) printf("%5.1f %10.2f %8.2f",
182 100 * np->time / totime, actime / hz, np->time / hz);
183
184 if (np->ncall != 0) {
185 (void) printf(" %8lld %8.2f %8.2f ", np->ncall,
186 1000 * np->time / hz / np->ncall,
187 1000 * (np->time + np->childtime) / hz / np->ncall);
188 } else {
189 if (!Cflag)
190 (void) printf(" %8.8s %8.8s %8.8s ", "", "", "");
191 else
192 (void) printf(" %8.8s %8.8s %8.8s ", "", "", "");
193 }
194
195 printname(np);
196
197 if (Cflag)
198 print_demangled_name(55, np);
199
200 (void) printf("\n");
201 }
202
203 void
204 gprofheader()
205 {
206
207 if (bflag)
208 printblurb(CALLG_BLURB);
209
210 if (old_style) {
211
212 (void) printf(
213 "\ngranularity: each sample hit covers %d byte(s)",
214 (long)scale * sizeof (UNIT));
215
216 if (printtime > 0.0) {
217 (void) printf(" for %.2f%% of %.2f seconds\n\n",
218 100.0/printtime, printtime / hz);
219 } else {
220 (void) printf(" no time propagated\n\n");
221 /*
222 * this doesn't hurt, since all the numerators
223 * will be 0.0
224 */
225 printtime = 1.0;
226 }
227 } else {
228 (void) printf(
229 "\ngranularity: each pc-hit is considered 1 tick");
230 if (hz != 1) {
231 (void) printf(" (@ %4.3f seconds per tick)",
232 (double)1.0 / hz);
233 }
234 (void) puts("\n\n");
235 }
236
237 (void) printf("%6.6s %5.5s %7.7s %11.11s %7.7s/%-7.7s %-8.8s\n",
238 "", "", "", "", "called", "total", "parents");
239 (void) printf("%-6.6s %5.5s %7.7s %11.11s %7.7s+%-7.7s %-8.8s\t%5.5s\n",
240 "index", "%time", "self", "descendents",
241 "called", "self", "name", "index");
242 (void) printf("%6.6s %5.5s %7.7s %11.11s %7.7s/%-7.7s %-8.8s\n",
243 "", "", "", "", "called", "total", "children");
244 (void) printf("\n");
245 }
246
247 void
248 gprofline(nltype *np)
249 {
250 char kirkbuffer[BUFSIZ];
251
252 (void) sprintf(kirkbuffer, "[%d]", np->index);
253 (void) printf("%-6.6s %5.1f %7.2f %11.2f", kirkbuffer,
254 100 * (np->propself + np->propchild) / printtime,
255 np->propself / hz, np->propchild / hz);
256
257 if ((np->ncall + np->selfcalls) != 0) {
258 (void) printf(" %7lld", np->ncall);
259
260 if (np->selfcalls != 0)
261 (void) printf("+%-7lld ", np->selfcalls);
262 else
263 (void) printf(" %7.7s ", "");
264 } else {
265 (void) printf(" %7.7s %7.7s ", "", "");
266 }
267
268 printname(np);
269
270 if (Cflag)
271 print_demangled_name(50, np);
272
273 (void) printf("\n");
274 }
275
276 static bool
277 is_special_sym(nltype *nlp)
278 {
279 int i;
280
281 if (nlp->name == NULL)
282 return (FALSE);
283
284 for (i = 0; splsym[i]; i++)
285 if (strcmp(splsym[i], nlp->name) == 0)
286 return (TRUE);
287
288 return (FALSE);
289 }
290
291 void
292 printgprof(nltype **timesortnlp)
293 {
294 int index;
295 nltype *parentp;
296 int print_count = number_funcs_toprint;
297 bool count_flag = TRUE;
298
299 /*
300 * Print out the structured profiling list
301 */
302 gprofheader();
303
304 for (index = 0; index < total_names + ncycle && count_flag; index++) {
305 parentp = timesortnlp[index];
306 if (zflag == 0 && parentp->ncall == 0 &&
307 parentp->selfcalls == 0 && parentp->propself == 0 &&
308 parentp -> propchild == 0)
309 continue;
310
311 if (!parentp->printflag)
312 continue;
313
314 /*
315 * Do not print certain special symbols, like PRF_EXTSYM, etc.
316 * even if zflag was on.
317 */
318 if (is_special_sym(parentp))
319 continue;
320
321 if (parentp->name == 0 && parentp->cycleno != 0) {
322 /*
323 * cycle header
324 */
325 printcycle(parentp);
326 printmembers(parentp);
327 } else {
328 printparents(parentp);
329 gprofline(parentp);
330 printchildren(parentp);
331 }
332
333 (void) printf("\n");
334 (void) printf(
335 "-----------------------------------------------\n");
336 (void) printf("\n");
337
338 if (nflag) {
339 --print_count;
340 if (print_count == 0)
341 count_flag = FALSE;
342 }
343 }
344 free(timesortnlp);
345 }
346
347 /*
348 * sort by decreasing propagated time
349 * if times are equal, but one is a cycle header,
350 * say that's first (e.g. less, i.e. -1).
351 * if one's name doesn't have an underscore and the other does,
352 * say the one is first.
353 * all else being equal, sort by names.
354 */
355 int
356 totalcmp(const void *arg1, const void *arg2)
357 {
358 nltype **npp1 = (nltype **)arg1;
359 nltype **npp2 = (nltype **)arg2;
360 nltype *np1 = *npp1;
361 nltype *np2 = *npp2;
362 double diff;
363
364 diff = (np1->propself + np1->propchild) -
365 (np2->propself + np2->propchild);
366
367 if (diff < 0.0)
368 return (1);
369 if (diff > 0.0)
370 return (-1);
371 if (np1->name == 0 && np1->cycleno != 0)
372 return (-1);
373 if (np2->name == 0 && np2->cycleno != 0)
374 return (1);
375 if (np1->name == 0)
376 return (-1);
377 if (np2->name == 0)
378 return (1);
379
380 if (*(np1->name) != '_' && *(np2->name) == '_')
381 return (-1);
382 if (*(np1->name) == '_' && *(np2->name) != '_')
383 return (1);
384 if (np1->ncall > np2->ncall)
385 return (-1);
386 if (np1->ncall < np2->ncall)
387 return (1);
388 return (strcmp(np1->name, np2->name));
389 }
390
391 void
392 printparents(nltype *childp)
393 {
394 nltype *parentp;
395 arctype *arcp;
396 nltype *cycleheadp;
397
398 if (childp->cyclehead != 0)
399 cycleheadp = childp -> cyclehead;
400 else
401 cycleheadp = childp;
402
403 if (childp->parents == 0) {
404 (void) printf("%6.6s %5.5s %7.7s %11.11s %7.7s %7.7s"
405 " <spontaneous>\n", "", "", "", "", "", "");
406 return;
407 }
408
409 sortparents(childp);
410
411 for (arcp = childp->parents; arcp; arcp = arcp->arc_parentlist) {
412 parentp = arcp -> arc_parentp;
413 if (childp == parentp || (childp->cycleno != 0 &&
414 parentp->cycleno == childp->cycleno)) {
415 /*
416 * selfcall or call among siblings
417 */
418 (void) printf(
419 "%6.6s %5.5s %7.7s %11.11s %7lld %7.7s ",
420 "", "", "", "", arcp->arc_count, "");
421 printname(parentp);
422
423 if (Cflag)
424 print_demangled_name(54, parentp);
425
426 (void) printf("\n");
427 } else {
428 /*
429 * regular parent of child
430 */
431 (void) printf(
432 "%6.6s %5.5s %7.2f %11.2f %7lld/%-7lld ", "",
433 "", arcp->arc_time / hz, arcp->arc_childtime / hz,
434 arcp->arc_count, cycleheadp->ncall);
435 printname(parentp);
436
437 if (Cflag)
438 print_demangled_name(54, parentp);
439
440 (void) printf("\n");
441 }
442 }
443 }
444
445 void
446 printchildren(nltype *parentp)
447 {
448 nltype *childp;
449 arctype *arcp;
450
451 sortchildren(parentp);
452
453 for (arcp = parentp->children; arcp; arcp = arcp->arc_childlist) {
454 childp = arcp->arc_childp;
455 if (childp == parentp || (childp->cycleno != 0 &&
456 childp->cycleno == parentp->cycleno)) {
457 /*
458 * self call or call to sibling
459 */
460 (void) printf(
461 "%6.6s %5.5s %7.7s %11.11s %7lld %7.7s ",
462 "", "", "", "", arcp->arc_count, "");
463 printname(childp);
464
465 if (Cflag)
466 print_demangled_name(54, childp);
467
468 (void) printf("\n");
469 } else {
470 /*
471 * regular child of parent
472 */
473 if (childp->cyclehead)
474 (void) printf("%6.6s %5.5s %7.2f %11.2f "
475 "%7lld/%-7lld ", "", "",
476 arcp->arc_time / hz,
477 arcp->arc_childtime / hz, arcp->arc_count,
478 childp->cyclehead->ncall);
479 else
480 (void) printf("%6.6s %5.5s %7.2f %11.2f "
481 "%7lld %7.7s ",
482 "", "", arcp->arc_time / hz,
483 arcp->arc_childtime / hz, arcp->arc_count,
484 "");
485
486 printname(childp);
487
488 if (Cflag)
489 print_demangled_name(54, childp);
490
491 (void) printf("\n");
492 }
493 }
494 }
495
496 void
497 printname(nltype *selfp)
498 {
499 const char *c;
500 c = demangled_name(selfp);
501
502 if (selfp->name != 0) {
503 (void) printf("%s", c);
504
505 #ifdef DEBUG
506 if (debug & DFNDEBUG)
507 (void) printf("{%d} ", selfp->toporder);
508
509 if (debug & PROPDEBUG)
510 (void) printf("%5.2f%% ", selfp->propfraction);
511 #endif /* DEBUG */
512 }
513
514 if (selfp->cycleno != 0)
515 (void) printf("\t<cycle %d>", selfp->cycleno);
516
517 if (selfp->index != 0) {
518 if (selfp->printflag)
519 (void) printf(" [%d]", selfp->index);
520 else
521 (void) printf(" (%d)", selfp->index);
522 }
523
524 if (c != selfp->name)
525 free((void *)c);
526 }
527
528 void
529 print_demangled_name(int n, nltype *selfp)
530 {
531 char *c = (char *)demangled_name(selfp);
532 int i;
533
534 if (c == selfp->name)
535 return;
536
537 (void) printf("\n");
538 for (i = 1; i < n; i++)
539 (void) printf(" ");
540 (void) printf("[%s]", selfp->name);
541
542 free(c);
543 }
544
545 void
546 sortchildren(nltype *parentp)
547 {
548 arctype *arcp;
549 arctype *detachedp;
550 arctype sorted;
551 arctype *prevp;
552
553 /*
554 * unlink children from parent,
555 * then insertion sort back on to sorted's children.
556 * *arcp the arc you have detached and are inserting.
557 * *detachedp the rest of the arcs to be sorted.
558 * sorted arc list onto which you insertion sort.
559 * *prevp arc before the arc you are comparing.
560 */
561 sorted.arc_childlist = 0;
562
563 /* LINTED: warning: assignment operator */
564 for ((arcp = parentp->children) && (detachedp = arcp->arc_childlist);
565 arcp;
566 /* LINTED: warning: assignment operator */
567 (arcp = detachedp) && (detachedp = detachedp->arc_childlist)) {
568 /*
569 * consider *arcp as disconnected
570 * insert it into sorted
571 */
572 for (prevp = &sorted; prevp->arc_childlist;
573 prevp = prevp->arc_childlist) {
574 if (arccmp(arcp, prevp->arc_childlist) != LESSTHAN)
575 break;
576 }
577
578 arcp->arc_childlist = prevp->arc_childlist;
579 prevp->arc_childlist = arcp;
580 }
581
582 /*
583 * reattach sorted children to parent
584 */
585 parentp->children = sorted.arc_childlist;
586 }
587
588 void
589 sortparents(nltype *childp)
590 {
591 arctype *arcp;
592 arctype *detachedp;
593 arctype sorted;
594 arctype *prevp;
595
596 /*
597 * unlink parents from child,
598 * then insertion sort back on to sorted's parents.
599 * *arcp the arc you have detached and are inserting.
600 * *detachedp the rest of the arcs to be sorted.
601 * sorted arc list onto which you insertion sort.
602 * *prevp arc before the arc you are comparing.
603 */
604 sorted.arc_parentlist = 0;
605
606 /* LINTED: warning: assignment operator */
607 for ((arcp = childp->parents) && (detachedp = arcp->arc_parentlist);
608 arcp;
609 /* LINTED: warning: assignment operator */
610 (arcp = detachedp) && (detachedp = detachedp->arc_parentlist)) {
611 /*
612 * consider *arcp as disconnected
613 * insert it into sorted
614 */
615 for (prevp = &sorted; prevp->arc_parentlist;
616 prevp = prevp->arc_parentlist) {
617 if (arccmp(arcp, prevp->arc_parentlist) != GREATERTHAN)
618 break;
619 }
620 arcp->arc_parentlist = prevp->arc_parentlist;
621 prevp->arc_parentlist = arcp;
622 }
623
624 /*
625 * reattach sorted arcs to child
626 */
627 childp->parents = sorted.arc_parentlist;
628 }
629
630 void
631 printcycle(nltype *cyclep)
632 {
633 char kirkbuffer[BUFSIZ];
634
635 (void) sprintf(kirkbuffer, "[%d]", cyclep->index);
636 (void) printf("%-6.6s %5.1f %7.2f %11.2f %7lld", kirkbuffer,
637 100 * (cyclep->propself + cyclep->propchild) / printtime,
638 cyclep -> propself / hz, cyclep -> propchild / hz,
639 cyclep -> ncall);
640
641 if (cyclep->selfcalls != 0)
642 (void) printf("+%-7lld", cyclep->selfcalls);
643 else
644 (void) printf(" %7.7s", "");
645
646 (void) printf(" <cycle %d as a whole>\t[%d]\n", cyclep->cycleno,
647 cyclep->index);
648 }
649
650 /*
651 * print the members of a cycle
652 */
653 void
654 printmembers(nltype *cyclep)
655 {
656 nltype *memberp;
657
658 sortmembers(cyclep);
659
660 for (memberp = cyclep->cnext; memberp; memberp = memberp->cnext) {
661 (void) printf("%6.6s %5.5s %7.2f %11.2f %7lld", "", "",
662 memberp->propself / hz, memberp->propchild / hz,
663 memberp->ncall);
664
665 if (memberp->selfcalls != 0)
666 (void) printf("+%-7lld", memberp->selfcalls);
667 else
668 (void) printf(" %7.7s", "");
669
670 (void) printf(" ");
671 printname(memberp);
672 if (Cflag)
673 print_demangled_name(54, memberp);
674 (void) printf("\n");
675 }
676 }
677
678 /*
679 * sort members of a cycle
680 */
681 void
682 sortmembers(nltype *cyclep)
683 {
684 nltype *todo;
685 nltype *doing;
686 nltype *prev;
687
688 /*
689 * detach cycle members from cyclehead,
690 * and insertion sort them back on.
691 */
692 todo = cyclep->cnext;
693 cyclep->cnext = 0;
694
695 /* LINTED: warning: assignment operator */
696 for ((doing = todo) && (todo = doing->cnext);
697 doing;
698 /* LINTED: warning: assignment operator */
699 (doing = todo) && (todo = doing->cnext)) {
700 for (prev = cyclep; prev->cnext; prev = prev->cnext) {
701 if (membercmp(doing, prev->cnext) == GREATERTHAN)
702 break;
703 }
704 doing->cnext = prev->cnext;
705 prev->cnext = doing;
706 }
707 }
708
709 /*
710 * major sort is on propself + propchild,
711 * next is sort on ncalls + selfcalls.
712 */
713 int
714 membercmp(nltype *this, nltype *that)
715 {
716 double thistime = this->propself + this->propchild;
717 double thattime = that->propself + that->propchild;
718 actype thiscalls = this->ncall + this->selfcalls;
719 actype thatcalls = that->ncall + that->selfcalls;
720
721 if (thistime > thattime)
722 return (GREATERTHAN);
723
724 if (thistime < thattime)
725 return (LESSTHAN);
726
727 if (thiscalls > thatcalls)
728 return (GREATERTHAN);
729
730 if (thiscalls < thatcalls)
731 return (LESSTHAN);
732
733 return (EQUALTO);
734 }
735
736 /*
737 * compare two arcs to/from the same child/parent.
738 * - if one arc is a self arc, it's least.
739 * - if one arc is within a cycle, it's less than.
740 * - if both arcs are within a cycle, compare arc counts.
741 * - if neither arc is within a cycle, compare with
742 * arc_time + arc_childtime as major key
743 * arc count as minor key
744 */
745 int
746 arccmp(arctype *thisp, arctype *thatp)
747 {
748 nltype *thisparentp = thisp->arc_parentp;
749 nltype *thischildp = thisp->arc_childp;
750 nltype *thatparentp = thatp->arc_parentp;
751 nltype *thatchildp = thatp->arc_childp;
752 double thistime;
753 double thattime;
754
755 #ifdef DEBUG
756 if (debug & TIMEDEBUG) {
757 (void) printf("[arccmp] ");
758 printname(thisparentp);
759 (void) printf(" calls ");
760 printname(thischildp);
761 (void) printf(" %f + %f %lld/%lld\n", thisp->arc_time,
762 thisp->arc_childtime, thisp->arc_count,
763 thischildp->ncall);
764 (void) printf("[arccmp] ");
765 printname(thatparentp);
766 (void) printf(" calls ");
767 printname(thatchildp);
768 (void) printf(" %f + %f %lld/%lld\n", thatp->arc_time,
769 thatp->arc_childtime, thatp->arc_count,
770 thatchildp->ncall);
771 (void) printf("\n");
772 }
773 #endif /* DEBUG */
774
775 if (thisparentp == thischildp) {
776 /*
777 * this is a self call
778 */
779 return (LESSTHAN);
780 }
781
782 if (thatparentp == thatchildp) {
783 /*
784 * that is a self call
785 */
786 return (GREATERTHAN);
787 }
788
789 if (thisparentp->cycleno != 0 && thischildp->cycleno != 0 &&
790 thisparentp->cycleno == thischildp->cycleno) {
791 /*
792 * this is a call within a cycle
793 */
794 if (thatparentp->cycleno != 0 && thatchildp->cycleno != 0 &&
795 thatparentp->cycleno == thatchildp->cycleno) {
796 /*
797 * that is a call within the cycle, too
798 */
799 if (thisp->arc_count < thatp->arc_count)
800 return (LESSTHAN);
801
802 if (thisp->arc_count > thatp->arc_count)
803 return (GREATERTHAN);
804
805 return (EQUALTO);
806 } else {
807 /*
808 * that isn't a call within the cycle
809 */
810 return (LESSTHAN);
811 }
812 } else {
813 /*
814 * this isn't a call within a cycle
815 */
816 if (thatparentp->cycleno != 0 && thatchildp->cycleno != 0 &&
817 thatparentp->cycleno == thatchildp->cycleno) {
818 /*
819 * that is a call within a cycle
820 */
821 return (GREATERTHAN);
822 } else {
823 /*
824 * neither is a call within a cycle
825 */
826 thistime = thisp->arc_time + thisp->arc_childtime;
827 thattime = thatp->arc_time + thatp->arc_childtime;
828
829 if (thistime < thattime)
830 return (LESSTHAN);
831
832 if (thistime > thattime)
833 return (GREATERTHAN);
834
835 if (thisp->arc_count < thatp->arc_count)
836 return (LESSTHAN);
837
838 if (thisp->arc_count > thatp->arc_count)
839 return (GREATERTHAN);
840
841 return (EQUALTO);
842 }
843 }
844 }
845
846 void
847 printblurb(char *blurbname)
848 {
849 FILE *blurbfile;
850 int input;
851
852 blurbfile = fopen(blurbname, "r");
853 if (blurbfile == NULL) {
854 perror(blurbname);
855 return;
856 }
857
858 while ((input = getc(blurbfile)) != EOF)
859 (void) putchar(input);
860
861 (void) fclose(blurbfile);
862 }
863
864 char *s1, *s2;
865
866 static int
867 namecmp(const void *arg1, const void *arg2)
868 {
869 nltype **npp1 = (nltype **)arg1;
870 nltype **npp2 = (nltype **)arg2;
871
872 if (!Cflag)
873 return (strcmp((*npp1)->name, (*npp2)->name));
874 else {
875 striped_name(s1, npp1);
876 striped_name(s2, npp2);
877 return (strcmp(s1, s2));
878 }
879 }
880
881 void
882 striped_name(char *s, nltype **npp)
883 {
884 const char *name, *d;
885 char *c;
886
887 c = (char *)s;
888 name = d = demangled_name(*npp);
889
890 while ((*d != '(') && (*d != '\0')) {
891 if (*d != ':')
892 *c++ = *d++;
893 else
894 d++;
895 }
896 *c = '\0';
897
898 if ((*npp)->name != name)
899 free((void *)name);
900 }
901
902 /*
903 * Checks if the current symbol name is the same as its neighbour and
904 * returns TRUE if it is.
905 */
906 static bool
907 does_clash(nltype **nlp, int ndx, int nnames)
908 {
909 /*
910 * same as previous (if there's one) ?
911 */
912 if (ndx && (strcmp(nlp[ndx]->name, nlp[ndx-1]->name) == 0))
913 return (TRUE);
914
915 /*
916 * same as next (if there's one) ?
917 */
918 if ((ndx < (nnames - 1)) &&
919 (strcmp(nlp[ndx]->name, nlp[ndx+1]->name) == 0)) {
920 return (TRUE);
921 }
922
923 return (FALSE);
924 }
925
926 void
927 printmodules()
928 {
929 mod_info_t *mi;
930
931 (void) printf("\f\nObject modules\n\n");
932 for (mi = &modules; mi; mi = mi->next)
933 (void) printf(" %d: %s\n", mi->id, mi->name);
934 }
935
936 #define IDFMT(id) ((id) < 10 ? 1 : 2)
937 #define NMFMT(id) ((id) < 10 ? 17 : 16)
938
939 void
940 printindex()
941 {
942 nltype **namesortnlp;
943 nltype *nlp;
944 int index, nnames, todo, i, j;
945 char peterbuffer[BUFSIZ];
946 mod_info_t *mi;
947
948 /*
949 * Now, sort regular function name alphabetically
950 * to create an index.
951 */
952 namesortnlp = calloc(total_names + ncycle, sizeof (nltype *));
953
954 if (namesortnlp == NULL)
955 (void) fprintf(stderr, "%s: ran out of memory for sorting\n",
956 whoami);
957
958 nnames = 0;
959 for (mi = &modules; mi; mi = mi->next) {
960 for (index = 0; index < mi->nname; index++) {
961 if (zflag == 0 && (mi->nl[index]).ncall == 0 &&
962 (mi->nl[index]).time == 0) {
963 continue;
964 }
965
966 /*
967 * Do not print certain special symbols, like
968 * PRF_EXTSYM, etc. even if zflag was on.
969 */
970 if (is_special_sym(&(mi->nl[index])))
971 continue;
972
973 namesortnlp[nnames++] = &(mi->nl[index]);
974 }
975 }
976
977 if (Cflag) {
978 s1 = malloc(500 * sizeof (char));
979 s2 = malloc(500 * sizeof (char));
980 }
981
982 qsort(namesortnlp, nnames, sizeof (nltype *), namecmp);
983
984 for (index = 1, todo = nnames; index <= ncycle; index++)
985 namesortnlp[todo++] = &cyclenl[index];
986
987 (void) printf("\f\nIndex by function name\n\n");
988
989 if (!Cflag)
990 index = (todo + 2) / 3;
991 else
992 index = todo;
993
994 for (i = 0; i < index; i++) {
995 if (!Cflag) {
996 for (j = i; j < todo; j += index) {
997 nlp = namesortnlp[j];
998
999 if (nlp->printflag) {
1000 (void) sprintf(peterbuffer,
1001 "[%d]", nlp->index);
1002 } else {
1003 (void) sprintf(peterbuffer,
1004 "(%d)", nlp->index);
1005 }
1006
1007 if (j < nnames) {
1008 if (does_clash(namesortnlp,
1009 j, nnames)) {
1010 (void) printf(
1011 "%6.6s %*d:%-*.*s",
1012 peterbuffer,
1013 IDFMT(nlp->module->id),
1014 nlp->module->id,
1015 NMFMT(nlp->module->id),
1016 NMFMT(nlp->module->id),
1017 nlp->name);
1018 } else {
1019 (void) printf("%6.6s %-19.19s",
1020 peterbuffer, nlp->name);
1021 }
1022 } else {
1023 (void) printf("%6.6s ", peterbuffer);
1024 (void) sprintf(peterbuffer,
1025 "<cycle %d>", nlp->cycleno);
1026 (void) printf("%-19.19s", peterbuffer);
1027 }
1028 }
1029 } else {
1030 nlp = namesortnlp[i];
1031
1032 if (nlp->printflag)
1033 (void) sprintf(peterbuffer, "[%d]", nlp->index);
1034 else
1035 (void) sprintf(peterbuffer, "(%d)", nlp->index);
1036
1037 if (i < nnames) {
1038 const char *d = demangled_name(nlp);
1039
1040 if (does_clash(namesortnlp, i, nnames)) {
1041 (void) printf("%6.6s %d:%s\n",
1042 peterbuffer, nlp->module->id, d);
1043 } else {
1044 (void) printf("%6.6s %s\n", peterbuffer,
1045 d);
1046 }
1047
1048 if (d != nlp->name) {
1049 (void) printf("%6.6s [%s]", "",
1050 nlp->name);
1051 free((void *)d);
1052 }
1053 } else {
1054 (void) printf("%6.6s ", peterbuffer);
1055 (void) sprintf(peterbuffer, "<cycle %d>",
1056 nlp->cycleno);
1057 (void) printf("%-33.33s", peterbuffer);
1058 }
1059 }
1060 (void) printf("\n");
1061 }
1062 free(namesortnlp);
1063 }