1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 1983, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #if 0 33 #ifndef lint 34 static char sccsid[] = "@(#)printgprof.c 8.1 (Berkeley) 6/6/93"; 35 #endif /* not lint */ 36 #endif 37 38 #include <sys/cdefs.h> 39 #include <err.h> 40 #include <string.h> 41 42 #include "gprof.h" 43 #include "pathnames.h" 44 45 int namecmp(const void *, const void *); 46 int timecmp(const void *, const void *); 47 48 void 49 printprof(void) 50 { 51 register nltype *np; 52 nltype **sortednlp; 53 int idx; 54 55 actime = 0.0; 56 printf( "\f\n" ); 57 flatprofheader(); 58 /* 59 * Sort the symbol table in by time 60 */ 61 sortednlp = (nltype **) calloc( nname , sizeof(nltype *) ); 62 if ( sortednlp == (nltype **) 0 ) 63 errx( 1 , "[printprof] ran out of memory for time sorting" ); 64 for ( idx = 0 ; idx < nname ; idx += 1 ) { 65 sortednlp[ idx ] = &nl[ idx ]; 66 } 67 qsort( sortednlp , nname , sizeof(nltype *) , timecmp ); 68 for ( idx = 0 ; idx < nname ; idx += 1 ) { 69 np = sortednlp[ idx ]; 70 flatprofline( np ); 71 } 72 actime = 0.0; 73 free( sortednlp ); 74 } 75 76 int 77 timecmp(const void *v1, const void *v2) 78 { 79 const nltype **npp1 = (const nltype **)v1; 80 const nltype **npp2 = (const nltype **)v2; 81 double timediff; 82 long calldiff; 83 84 timediff = (*npp2) -> time - (*npp1) -> time; 85 if ( timediff > 0.0 ) 86 return 1 ; 87 if ( timediff < 0.0 ) 88 return -1; 89 calldiff = (*npp2) -> ncall - (*npp1) -> ncall; 90 if ( calldiff > 0 ) 91 return 1; 92 if ( calldiff < 0 ) 93 return -1; 94 return( strcmp( (*npp1) -> name , (*npp2) -> name ) ); 95 } 96 97 /* 98 * header for flatprofline 99 */ 100 void 101 flatprofheader(void) 102 { 103 104 if ( bflag ) { 105 printblurb( _PATH_FLAT_BLURB ); 106 } 107 printf( "\ngranularity: each sample hit covers %g byte(s)" , 108 scale * HISTORICAL_SCALE_2 ); 109 if ( totime > 0.0 ) { 110 printf( " for %.2f%% of %.2f seconds\n\n" , 111 100.0/totime , totime / hz ); 112 } else { 113 printf( " no time accumulated\n\n" ); 114 /* 115 * this doesn't hurt since all the numerators will be zero. 116 */ 117 totime = 1.0; 118 } 119 printf( "%5.5s %10.10s %8.8s %8.8s %8.8s %8.8s %-8.8s\n" , 120 "% " , "cumulative" , "self " , "" , "self " , "total " , "" ); 121 printf( "%5.5s %10.10s %8.8s %8.8s %8.8s %8.8s %-8.8s\n" , 122 "time" , "seconds " , "seconds" , "calls" , 123 hz >= 10000000 ? "ns/call" : hz >= 10000 ? "us/call" : "ms/call" , 124 hz >= 10000000 ? "ns/call" : hz >= 10000 ? "us/call" : "ms/call" , 125 "name" ); 126 } 127 128 void 129 flatprofline(register nltype *np) 130 { 131 132 if ( zflag == 0 && np -> ncall == 0 && np -> time == 0 && 133 np -> childtime == 0 ) { 134 return; 135 } 136 actime += np -> time; 137 if (hz >= 10000) 138 printf( "%5.1f %10.3f %8.3f" , 139 100 * np -> time / totime , actime / hz , np -> time / hz ); 140 else 141 printf( "%5.1f %10.2f %8.2f" , 142 100 * np -> time / totime , actime / hz , np -> time / hz ); 143 if ( np -> ncall != 0 ) { 144 if (hz >= 10000000) 145 printf( " %8ld %8.0f %8.0f " , np -> ncall , 146 1e9 * np -> time / hz / np -> ncall , 147 1e9 * ( np -> time + np -> childtime ) / hz / np -> ncall ); 148 else if (hz >= 10000) 149 printf( " %8ld %8.0f %8.0f " , np -> ncall , 150 1e6 * np -> time / hz / np -> ncall , 151 1e6 * ( np -> time + np -> childtime ) / hz / np -> ncall ); 152 else 153 printf( " %8ld %8.2f %8.2f " , np -> ncall , 154 1000 * np -> time / hz / np -> ncall , 155 1000 * ( np -> time + np -> childtime ) / hz / np -> ncall ); 156 } else if ( np -> time != 0 || np -> childtime != 0 ) { 157 printf( " %8ld %7.2f%% %8.8s " , np -> ncall , 158 100 * np -> time / ( np -> time + np -> childtime ) , "" ); 159 } else { 160 printf( " %8.8s %8.8s %8.8s " , "" , "" , "" ); 161 } 162 printname( np ); 163 printf( "\n" ); 164 } 165 166 void 167 gprofheader(void) 168 { 169 170 if ( bflag ) { 171 printblurb( _PATH_CALLG_BLURB ); 172 } 173 printf( "\ngranularity: each sample hit covers %g byte(s)" , 174 scale * HISTORICAL_SCALE_2 ); 175 if ( printtime > 0.0 ) { 176 printf( " for %.2f%% of %.2f seconds\n\n" , 177 100.0/printtime , printtime / hz ); 178 } else { 179 printf( " no time propagated\n\n" ); 180 /* 181 * this doesn't hurt, since all the numerators will be 0.0 182 */ 183 printtime = 1.0; 184 } 185 printf( "%6.6s %5.5s %7.7s %11.11s %7.7s/%-7.7s %-8.8s\n" , 186 "" , "" , "" , "" , "called" , "total" , "parents"); 187 printf( "%-6.6s %5.5s %7.7s %11.11s %7.7s+%-7.7s %-8.8s\t%5.5s\n" , 188 "index" , "%time" , "self" , "descendents" , 189 "called" , "self" , "name" , "index" ); 190 printf( "%6.6s %5.5s %7.7s %11.11s %7.7s/%-7.7s %-8.8s\n" , 191 "" , "" , "" , "" , "called" , "total" , "children"); 192 printf( "\n" ); 193 } 194 195 void 196 gprofline(register nltype *np) 197 { 198 char kirkbuffer[ BUFSIZ ]; 199 200 sprintf( kirkbuffer , "[%d]" , np -> index ); 201 printf( "%-6.6s %5.1f %7.2f %11.2f" , 202 kirkbuffer , 203 100 * ( np -> propself + np -> propchild ) / printtime , 204 np -> propself / hz , 205 np -> propchild / hz ); 206 if ( ( np -> ncall + np -> selfcalls ) != 0 ) { 207 printf( " %7ld" , np -> npropcall ); 208 if ( np -> selfcalls != 0 ) { 209 printf( "+%-7ld " , np -> selfcalls ); 210 } else { 211 printf( " %7.7s " , "" ); 212 } 213 } else { 214 printf( " %7.7s %7.7s " , "" , "" ); 215 } 216 printname( np ); 217 printf( "\n" ); 218 } 219 220 void 221 printgprof(nltype **timesortnlp) 222 { 223 int idx; 224 nltype *parentp; 225 226 /* 227 * Print out the structured profiling list 228 */ 229 gprofheader(); 230 for ( idx = 0 ; idx < nname + ncycle ; idx ++ ) { 231 parentp = timesortnlp[ idx ]; 232 if ( zflag == 0 && 233 parentp -> ncall == 0 && 234 parentp -> selfcalls == 0 && 235 parentp -> propself == 0 && 236 parentp -> propchild == 0 ) { 237 continue; 238 } 239 if ( ! parentp -> printflag ) { 240 continue; 241 } 242 if ( parentp -> name == 0 && parentp -> cycleno != 0 ) { 243 /* 244 * cycle header 245 */ 246 printcycle( parentp ); 247 printmembers( parentp ); 248 } else { 249 printparents( parentp ); 250 gprofline( parentp ); 251 printchildren( parentp ); 252 } 253 printf( "\n" ); 254 printf( "-----------------------------------------------\n" ); 255 printf( "\n" ); 256 } 257 free( timesortnlp ); 258 } 259 260 /* 261 * sort by decreasing propagated time 262 * if times are equal, but one is a cycle header, 263 * say that's first (e.g. less, i.e. -1). 264 * if one's name doesn't have an underscore and the other does, 265 * say the one is first. 266 * all else being equal, sort by names. 267 */ 268 int 269 totalcmp(const void *v1, const void *v2) 270 { 271 const nltype **npp1 = (const nltype **)v1; 272 const nltype **npp2 = (const nltype **)v2; 273 register const nltype *np1 = *npp1; 274 register const nltype *np2 = *npp2; 275 double diff; 276 277 diff = ( np1 -> propself + np1 -> propchild ) 278 - ( np2 -> propself + np2 -> propchild ); 279 if ( diff < 0.0 ) 280 return 1; 281 if ( diff > 0.0 ) 282 return -1; 283 if ( np1 -> name == 0 && np1 -> cycleno != 0 ) 284 return -1; 285 if ( np2 -> name == 0 && np2 -> cycleno != 0 ) 286 return 1; 287 if ( np1 -> name == 0 ) 288 return -1; 289 if ( np2 -> name == 0 ) 290 return 1; 291 if ( *(np1 -> name) != '_' && *(np2 -> name) == '_' ) 292 return -1; 293 if ( *(np1 -> name) == '_' && *(np2 -> name) != '_' ) 294 return 1; 295 if ( np1 -> ncall > np2 -> ncall ) 296 return -1; 297 if ( np1 -> ncall < np2 -> ncall ) 298 return 1; 299 return strcmp( np1 -> name , np2 -> name ); 300 } 301 302 void 303 printparents(nltype *childp) 304 { 305 nltype *parentp; 306 arctype *arcp; 307 nltype *cycleheadp; 308 309 if ( childp -> cyclehead != 0 ) { 310 cycleheadp = childp -> cyclehead; 311 } else { 312 cycleheadp = childp; 313 } 314 if ( childp -> parents == 0 ) { 315 printf( "%6.6s %5.5s %7.7s %11.11s %7.7s %7.7s <spontaneous>\n" , 316 "" , "" , "" , "" , "" , "" ); 317 return; 318 } 319 sortparents( childp ); 320 for ( arcp = childp -> parents ; arcp ; arcp = arcp -> arc_parentlist ) { 321 parentp = arcp -> arc_parentp; 322 if ( childp == parentp || ( arcp -> arc_flags & DEADARC ) || 323 ( childp->cycleno != 0 && parentp->cycleno == childp->cycleno ) ) { 324 /* 325 * selfcall or call among siblings 326 */ 327 printf( "%6.6s %5.5s %7.7s %11.11s %7ld %7.7s " , 328 "" , "" , "" , "" , 329 arcp -> arc_count , "" ); 330 printname( parentp ); 331 printf( "\n" ); 332 } else { 333 /* 334 * regular parent of child 335 */ 336 printf( "%6.6s %5.5s %7.2f %11.2f %7ld/%-7ld " , 337 "" , "" , 338 arcp -> arc_time / hz , arcp -> arc_childtime / hz , 339 arcp -> arc_count , cycleheadp -> npropcall ); 340 printname( parentp ); 341 printf( "\n" ); 342 } 343 } 344 } 345 346 void 347 printchildren(nltype *parentp) 348 { 349 nltype *childp; 350 arctype *arcp; 351 352 sortchildren( parentp ); 353 arcp = parentp -> children; 354 for ( arcp = parentp -> children ; arcp ; arcp = arcp -> arc_childlist ) { 355 childp = arcp -> arc_childp; 356 if ( childp == parentp || ( arcp -> arc_flags & DEADARC ) || 357 ( childp->cycleno != 0 && childp->cycleno == parentp->cycleno ) ) { 358 /* 359 * self call or call to sibling 360 */ 361 printf( "%6.6s %5.5s %7.7s %11.11s %7ld %7.7s " , 362 "" , "" , "" , "" , arcp -> arc_count , "" ); 363 printname( childp ); 364 printf( "\n" ); 365 } else { 366 /* 367 * regular child of parent 368 */ 369 printf( "%6.6s %5.5s %7.2f %11.2f %7ld/%-7ld " , 370 "" , "" , 371 arcp -> arc_time / hz , arcp -> arc_childtime / hz , 372 arcp -> arc_count , childp -> cyclehead -> npropcall ); 373 printname( childp ); 374 printf( "\n" ); 375 } 376 } 377 } 378 379 void 380 printname(nltype *selfp) 381 { 382 383 if ( selfp -> name != 0 ) { 384 printf( "%s" , selfp -> name ); 385 # ifdef DEBUG 386 if ( debug & DFNDEBUG ) { 387 printf( "{%d} " , selfp -> toporder ); 388 } 389 if ( debug & PROPDEBUG ) { 390 printf( "%5.2f%% " , selfp -> propfraction ); 391 } 392 # endif /* DEBUG */ 393 } 394 if ( selfp -> cycleno != 0 ) { 395 printf( " <cycle %d>" , selfp -> cycleno ); 396 } 397 if ( selfp -> index != 0 ) { 398 if ( selfp -> printflag ) { 399 printf( " [%d]" , selfp -> index ); 400 } else { 401 printf( " (%d)" , selfp -> index ); 402 } 403 } 404 } 405 406 void 407 sortchildren(nltype *parentp) 408 { 409 arctype *arcp; 410 arctype *detachedp; 411 arctype sorted; 412 arctype *prevp; 413 414 /* 415 * unlink children from parent, 416 * then insertion sort back on to sorted's children. 417 * *arcp the arc you have detached and are inserting. 418 * *detachedp the rest of the arcs to be sorted. 419 * sorted arc list onto which you insertion sort. 420 * *prevp arc before the arc you are comparing. 421 */ 422 sorted.arc_childlist = 0; 423 for ( (arcp = parentp -> children)&&(detachedp = arcp -> arc_childlist); 424 arcp ; 425 (arcp = detachedp)&&(detachedp = detachedp -> arc_childlist)) { 426 /* 427 * consider *arcp as disconnected 428 * insert it into sorted 429 */ 430 for ( prevp = &sorted ; 431 prevp -> arc_childlist ; 432 prevp = prevp -> arc_childlist ) { 433 if ( arccmp( arcp , prevp -> arc_childlist ) != LESSTHAN ) { 434 break; 435 } 436 } 437 arcp -> arc_childlist = prevp -> arc_childlist; 438 prevp -> arc_childlist = arcp; 439 } 440 /* 441 * reattach sorted children to parent 442 */ 443 parentp -> children = sorted.arc_childlist; 444 } 445 446 void 447 sortparents(nltype *childp) 448 { 449 arctype *arcp; 450 arctype *detachedp; 451 arctype sorted; 452 arctype *prevp; 453 454 /* 455 * unlink parents from child, 456 * then insertion sort back on to sorted's parents. 457 * *arcp the arc you have detached and are inserting. 458 * *detachedp the rest of the arcs to be sorted. 459 * sorted arc list onto which you insertion sort. 460 * *prevp arc before the arc you are comparing. 461 */ 462 sorted.arc_parentlist = 0; 463 for ( (arcp = childp -> parents)&&(detachedp = arcp -> arc_parentlist); 464 arcp ; 465 (arcp = detachedp)&&(detachedp = detachedp -> arc_parentlist)) { 466 /* 467 * consider *arcp as disconnected 468 * insert it into sorted 469 */ 470 for ( prevp = &sorted ; 471 prevp -> arc_parentlist ; 472 prevp = prevp -> arc_parentlist ) { 473 if ( arccmp( arcp , prevp -> arc_parentlist ) != GREATERTHAN ) { 474 break; 475 } 476 } 477 arcp -> arc_parentlist = prevp -> arc_parentlist; 478 prevp -> arc_parentlist = arcp; 479 } 480 /* 481 * reattach sorted arcs to child 482 */ 483 childp -> parents = sorted.arc_parentlist; 484 } 485 486 /* 487 * print a cycle header 488 */ 489 void 490 printcycle(nltype *cyclep) 491 { 492 char kirkbuffer[ BUFSIZ ]; 493 494 sprintf( kirkbuffer , "[%d]" , cyclep -> index ); 495 printf( "%-6.6s %5.1f %7.2f %11.2f %7ld" , 496 kirkbuffer , 497 100 * ( cyclep -> propself + cyclep -> propchild ) / printtime , 498 cyclep -> propself / hz , 499 cyclep -> propchild / hz , 500 cyclep -> npropcall ); 501 if ( cyclep -> selfcalls != 0 ) { 502 printf( "+%-7ld" , cyclep -> selfcalls ); 503 } else { 504 printf( " %7.7s" , "" ); 505 } 506 printf( " <cycle %d as a whole>\t[%d]\n" , 507 cyclep -> cycleno , cyclep -> index ); 508 } 509 510 /* 511 * print the members of a cycle 512 */ 513 void 514 printmembers(nltype *cyclep) 515 { 516 nltype *memberp; 517 518 sortmembers( cyclep ); 519 for ( memberp = cyclep -> cnext ; memberp ; memberp = memberp -> cnext ) { 520 printf( "%6.6s %5.5s %7.2f %11.2f %7ld" , 521 "" , "" , memberp -> propself / hz , memberp -> propchild / hz , 522 memberp -> npropcall ); 523 if ( memberp -> selfcalls != 0 ) { 524 printf( "+%-7ld" , memberp -> selfcalls ); 525 } else { 526 printf( " %7.7s" , "" ); 527 } 528 printf( " " ); 529 printname( memberp ); 530 printf( "\n" ); 531 } 532 } 533 534 /* 535 * sort members of a cycle 536 */ 537 void 538 sortmembers(nltype *cyclep) 539 { 540 nltype *todo; 541 nltype *doing; 542 nltype *prev; 543 544 /* 545 * detach cycle members from cyclehead, 546 * and insertion sort them back on. 547 */ 548 todo = cyclep -> cnext; 549 cyclep -> cnext = 0; 550 for ( (doing = todo)&&(todo = doing -> cnext); 551 doing ; 552 (doing = todo )&&(todo = doing -> cnext )){ 553 for ( prev = cyclep ; prev -> cnext ; prev = prev -> cnext ) { 554 if ( membercmp( doing , prev -> cnext ) == GREATERTHAN ) { 555 break; 556 } 557 } 558 doing -> cnext = prev -> cnext; 559 prev -> cnext = doing; 560 } 561 } 562 563 /* 564 * major sort is on propself + propchild, 565 * next is sort on ncalls + selfcalls. 566 */ 567 int 568 membercmp(nltype *this, nltype *that) 569 { 570 double thistime = this -> propself + this -> propchild; 571 double thattime = that -> propself + that -> propchild; 572 long thiscalls = this -> ncall + this -> selfcalls; 573 long thatcalls = that -> ncall + that -> selfcalls; 574 575 if ( thistime > thattime ) { 576 return GREATERTHAN; 577 } 578 if ( thistime < thattime ) { 579 return LESSTHAN; 580 } 581 if ( thiscalls > thatcalls ) { 582 return GREATERTHAN; 583 } 584 if ( thiscalls < thatcalls ) { 585 return LESSTHAN; 586 } 587 return EQUALTO; 588 } 589 /* 590 * compare two arcs to/from the same child/parent. 591 * - if one arc is a self arc, it's least. 592 * - if one arc is within a cycle, it's less than. 593 * - if both arcs are within a cycle, compare arc counts. 594 * - if neither arc is within a cycle, compare with 595 * arc_time + arc_childtime as major key 596 * arc count as minor key 597 */ 598 int 599 arccmp(arctype *thisp, arctype *thatp) 600 { 601 nltype *thisparentp = thisp -> arc_parentp; 602 nltype *thischildp = thisp -> arc_childp; 603 nltype *thatparentp = thatp -> arc_parentp; 604 nltype *thatchildp = thatp -> arc_childp; 605 double thistime; 606 double thattime; 607 608 # ifdef DEBUG 609 if ( debug & TIMEDEBUG ) { 610 printf( "[arccmp] " ); 611 printname( thisparentp ); 612 printf( " calls " ); 613 printname ( thischildp ); 614 printf( " %f + %f %ld/%ld\n" , 615 thisp -> arc_time , thisp -> arc_childtime , 616 thisp -> arc_count , thischildp -> ncall ); 617 printf( "[arccmp] " ); 618 printname( thatparentp ); 619 printf( " calls " ); 620 printname( thatchildp ); 621 printf( " %f + %f %ld/%ld\n" , 622 thatp -> arc_time , thatp -> arc_childtime , 623 thatp -> arc_count , thatchildp -> ncall ); 624 printf( "\n" ); 625 } 626 # endif /* DEBUG */ 627 if ( thisparentp == thischildp ) { 628 /* this is a self call */ 629 return LESSTHAN; 630 } 631 if ( thatparentp == thatchildp ) { 632 /* that is a self call */ 633 return GREATERTHAN; 634 } 635 if ( thisparentp -> cycleno != 0 && thischildp -> cycleno != 0 && 636 thisparentp -> cycleno == thischildp -> cycleno ) { 637 /* this is a call within a cycle */ 638 if ( thatparentp -> cycleno != 0 && thatchildp -> cycleno != 0 && 639 thatparentp -> cycleno == thatchildp -> cycleno ) { 640 /* that is a call within the cycle, too */ 641 if ( thisp -> arc_count < thatp -> arc_count ) { 642 return LESSTHAN; 643 } 644 if ( thisp -> arc_count > thatp -> arc_count ) { 645 return GREATERTHAN; 646 } 647 return EQUALTO; 648 } else { 649 /* that isn't a call within the cycle */ 650 return LESSTHAN; 651 } 652 } else { 653 /* this isn't a call within a cycle */ 654 if ( thatparentp -> cycleno != 0 && thatchildp -> cycleno != 0 && 655 thatparentp -> cycleno == thatchildp -> cycleno ) { 656 /* that is a call within a cycle */ 657 return GREATERTHAN; 658 } else { 659 /* neither is a call within a cycle */ 660 thistime = thisp -> arc_time + thisp -> arc_childtime; 661 thattime = thatp -> arc_time + thatp -> arc_childtime; 662 if ( thistime < thattime ) 663 return LESSTHAN; 664 if ( thistime > thattime ) 665 return GREATERTHAN; 666 if ( thisp -> arc_count < thatp -> arc_count ) 667 return LESSTHAN; 668 if ( thisp -> arc_count > thatp -> arc_count ) 669 return GREATERTHAN; 670 return EQUALTO; 671 } 672 } 673 } 674 675 void 676 printblurb(const char *blurbname) 677 { 678 FILE *blurbfile; 679 int input; 680 681 blurbfile = fopen( blurbname , "r" ); 682 if ( blurbfile == NULL ) { 683 warn( "%s" , blurbname ); 684 return; 685 } 686 while ( ( input = getc( blurbfile ) ) != EOF ) { 687 putchar( input ); 688 } 689 fclose( blurbfile ); 690 } 691 692 int 693 namecmp(const void *v1, const void *v2) 694 { 695 const nltype **npp1 = (const nltype **)v1; 696 const nltype **npp2 = (const nltype **)v2; 697 698 return( strcmp( (*npp1) -> name , (*npp2) -> name ) ); 699 } 700 701 void 702 printindex(void) 703 { 704 nltype **namesortnlp; 705 register nltype *nlp; 706 int idx, nnames, todo, i, j; 707 char peterbuffer[ BUFSIZ ]; 708 709 /* 710 * Now, sort regular function name alphabetically 711 * to create an index. 712 */ 713 namesortnlp = (nltype **) calloc( nname + ncycle , sizeof(nltype *) ); 714 if ( namesortnlp == (nltype **) 0 ) 715 errx( 1 , "ran out of memory for sorting"); 716 for ( idx = 0 , nnames = 0 ; idx < nname ; idx++ ) { 717 if ( zflag == 0 && nl[idx].ncall == 0 && nl[idx].time == 0 ) 718 continue; 719 namesortnlp[nnames++] = &nl[idx]; 720 } 721 qsort( namesortnlp , nnames , sizeof(nltype *) , namecmp ); 722 for ( idx = 1 , todo = nnames ; idx <= ncycle ; idx++ ) { 723 namesortnlp[todo++] = &cyclenl[idx]; 724 } 725 printf( "\f\nIndex by function name\n\n" ); 726 idx = ( todo + 2 ) / 3; 727 for ( i = 0; i < idx ; i++ ) { 728 for ( j = i; j < todo ; j += idx ) { 729 nlp = namesortnlp[ j ]; 730 if ( nlp -> printflag ) { 731 sprintf( peterbuffer , "[%d]" , nlp -> index ); 732 } else { 733 sprintf( peterbuffer , "(%d)" , nlp -> index ); 734 } 735 if ( j < nnames ) { 736 printf( "%6.6s %-19.19s" , peterbuffer , nlp -> name ); 737 } else { 738 printf( "%6.6s " , peterbuffer ); 739 sprintf( peterbuffer , "<cycle %d>" , nlp -> cycleno ); 740 printf( "%-19.19s" , peterbuffer ); 741 } 742 } 743 printf( "\n" ); 744 } 745 free( namesortnlp ); 746 } 747