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 }