GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: usr.bin/gprof/printgprof.c Lines: 0 303 0.0 %
Date: 2017-11-13 Branches: 0 210 0.0 %

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