/usr/src/usr.bin/gprof/printgprof.c

Bug Summary

File:	src/usr.bin/gprof/printgprof.c
Warning:	line 679, column 24 Array access (from variable 'namesortnlp') results in a null pointer dereference

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name printgprof.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/usr.bin/gprof/obj -resource-dir /usr/local/lib/clang/13.0.0 -I . -D MD_INCLUDE="amd64.h" -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/usr.bin/gprof/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/usr.bin/gprof/printgprof.c

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 $	*/

4/*
* Copyright (c) 1983, 1993
*	The Regents of the University of California.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

33#include <string.h>

35#include "gprof.h"
36#include "pathnames.h"

38int namecmp(const void *, const void *);

40void
41printprof()
42{
  nltype		*np;
  nltype		**sortednlp;
  int			index;

  actime = 0.0;
  printf( "\f\n" );
  flatprofheader();
/*
*	Sort the symbol table in by time
*/
  sortednlp = calloc( nname , sizeof(nltype *) );
  if ( sortednlp == (nltype **) 0 )
warnx("[printprof] ran out of memory for time sorting");
  for ( index = 0 ; index < nname ; index += 1 ) {
sortednlp[ index ] = &nl[ index ];
  }
  qsort( sortednlp , nname , sizeof(nltype *) , timecmp );
  for ( index = 0 ; index < nname ; index += 1 ) {
np = sortednlp[ index ];
flatprofline( np );
  }
  actime = 0.0;
  free( sortednlp );
66}

68int
69timecmp(const void *v1, const void *v2)
70{
  const nltype * const *npp1 = v1;
  const nltype * const *npp2 = v2;

  if ((*npp2) -> time < (*npp1) -> time)
return -1;
  if ((*npp2) -> time > (*npp1) -> time)
return 1 ;
  if ((*npp2) -> ncall < (*npp1) -> ncall)
return -1;
  if ((*npp2) -> ncall > (*npp1) -> ncall)
return 1;
  return( strcmp( (*npp1) -> name , (*npp2) -> name ) );
83}

  /*
   *	header for flatprofline
   */
88void
89flatprofheader()
90{
  
  if (bflag)
printblurb( _PATH_FLAT_BLURB"/usr/share/misc/gprof.flat" );
  printf("\ngranularity: each sample hit covers %ld byte(s)",
   (long) scale * sizeof(UNIT));
  if (totime > 0.0)
printf(" for %.2f%% of %.2f seconds\n\n" , 100.0/totime, totime / hz);
  else {
printf( " no time accumulated\n\n" );
   /*
    *	this doesn't hurt sinc eall the numerators will be zero.
    */
totime = 1.0;
  }
  printf("%5.5s %10.10s %8.8s %8.8s %8.8s %8.8s  %-8.8s\n" ,
"%  " , "cumulative" , "self  " , "" , "self  " , "total " , "" );
  printf("%5.5s %10.10s %8.8s %8.8s %8.8s %8.8s  %-8.8s\n" ,
"time" , "seconds " , "seconds" , "calls" ,
"ms/call" , "ms/call" , "name" );
110}

112void
113flatprofline(nltype *np)
114{

  if ( zflag == 0 && np -> ncall == 0 && np -> time == 0 ) {
return;
  }
  actime += np -> time;
  printf( "%5.1f %10.2f %8.2f" ,
100 * np -> time / totime , actime / hz , np -> time / hz );
  if ( np -> ncall != 0 ) {
printf( " %8ld %8.2f %8.2f  " , np -> ncall ,
   1000 * np -> time / hz / np -> ncall ,
   1000 * ( np -> time + np -> childtime ) / hz / np -> ncall );
  } else {
printf( " %8.8s %8.8s %8.8s  " , "" , "" , "" );
  }
  printname( np );
  printf( "\n" );
131}

133void
134gprofheader()
135{

  if ( bflag ) {
printblurb( _PATH_CALLG_BLURB"/usr/share/misc/gprof.callg" );
  }
  printf( "\ngranularity: each sample hit covers %ld byte(s)" ,
   (long) scale * sizeof(UNIT) );
  if ( printtime > 0.0 ) {
printf( " for %.2f%% of %.2f seconds\n\n" ,
100.0/printtime , printtime / hz );
  } else {
printf( " no time propagated\n\n" );
   /*
    *	this doesn't hurt, since all the numerators will be 0.0
    */
printtime = 1.0;
  }
  printf( "%6.6s %5.5s %7.7s %11.11s %7.7s/%-7.7s     %-8.8s\n" ,
"" , "" , "" , "" , "called" , "total" , "parents");
  printf( "%-6.6s %5.5s %7.7s %11.11s %7.7s+%-7.7s %-8.8s\t%5.5s\n" ,
"index" , "%time" , "self" , "descendents" ,
"called" , "self" , "name" , "index" );
  printf( "%6.6s %5.5s %7.7s %11.11s %7.7s/%-7.7s     %-8.8s\n" ,
"" , "" , "" , "" , "called" , "total" , "children");
  printf( "\n" );
160}

162void
163gprofline(nltype *np)
164{
  char	kirkbuffer[ BUFSIZ1024 ];

  snprintf(kirkbuffer, sizeof kirkbuffer, "[%d]" , np -> index );
  printf( "%-6.6s %5.1f %7.2f %11.2f" , kirkbuffer ,
   100 * ( np -> propself + np -> propchild ) / printtime ,
   np -> propself / hz , np -> propchild / hz );
  if ( ( np -> ncall + np -> selfcalls ) != 0 ) {
printf( " %7ld" , np -> npropcall );
if ( np -> selfcalls != 0 ) {
   printf( "+%-7ld " , np -> selfcalls );
} else {
   printf( " %7.7s " , "" );
}
  } else {
printf( " %7.7s %7.7s " , "" , "" );
  }
  printname( np );
  printf( "\n" );
183}

185void
186printgprof(nltype **timesortnlp)
187{
  int		index;
  nltype	*parentp;

/*
*	Print out the structured profiling list
*/
  gprofheader();
  for ( index = 0 ; index < nname + ncycle ; index ++ ) {
parentp = timesortnlp[ index ];
if ( zflag == 0 &&
    parentp -> ncall == 0 &&
    parentp -> selfcalls == 0 &&
    parentp -> propself == 0 &&
    parentp -> propchild == 0 ) {
   continue;
}
if ( ! parentp -> printflag ) {
   continue;
}
if ( parentp -> name == 0 && parentp -> cycleno != 0 ) {
/*
 *	cycle header
 */
   printcycle( parentp );
   printmembers( parentp );
} else {
   printparents( parentp );
   gprofline( parentp );
   printchildren( parentp );
}
printf( "\n" );
printf( "-----------------------------------------------\n" );
printf( "\n" );
  }
  free( timesortnlp );
223}

  /*
   *	sort by decreasing propagated time
   *	if times are equal, but one is a cycle header,
   *		say that's first (e.g. less, i.e. -1).
   *	if one's name doesn't have an underscore and the other does,
   *		say the one is first.
   *	all else being equal, sort by names.
   */
233int
234totalcmp(const void *v1, const void *v2)
235{
  const nltype *np1 = *(const nltype **)v1;
  const nltype *np2 = *(const nltype **)v2;
  double t1, t2;
  int np1noname, np2noname, np1cyclehdr, np2cyclehdr;

  t1 = np1 -> propself + np1 -> propchild;
  t2 = np2 -> propself + np2 -> propchild;
  if ( t2 > t1 )
   return 1;
  if ( t2 < t1 )
   return -1;

  np1noname = ( np1 -> name == 0 );
  np2noname = ( np2 -> name == 0 );
  np1cyclehdr = ( np1noname && np1 -> cycleno != 0 );
  np2cyclehdr = ( np2noname && np2 -> cycleno != 0 );

  if ( np1cyclehdr && !np2cyclehdr )
return -1;
  else if ( !np1cyclehdr && np2cyclehdr )
return 1;

  if ( np1noname && !np2noname )
return -1;
  else if ( !np1noname && np2noname )
return 1;
  else if ( np1noname && np2noname )
return 0;

  if ( *(np1 -> name) != '_' && *(np2 -> name) == '_' )
return -1;
  if ( *(np1 -> name) == '_' && *(np2 -> name) != '_' )
return 1;
  if ( np1 -> ncall > np2 -> ncall )
return -1;
  if ( np1 -> ncall < np2 -> ncall ) 
return 1;
  return strcmp( np1 -> name , np2 -> name );
274}

276void
277printparents(nltype *childp)
278{
  nltype	*parentp;
  arctype	*arcp;
  nltype	*cycleheadp;

  if ( childp -> cyclehead != 0 ) {
cycleheadp = childp -> cyclehead;
  } else {
cycleheadp = childp;
  }
  if ( childp -> parents == 0 ) {
printf( "%6.6s %5.5s %7.7s %11.11s %7.7s %7.7s     <spontaneous>\n" ,
"" , "" , "" , "" , "" , "" );
return;
  }
  sortparents( childp );
  for ( arcp = childp -> parents ; arcp ; arcp = arcp -> arc_parentlist ) {
parentp = arcp -> arc_parentp;
if ( childp == parentp || ( arcp -> arc_flags & DEADARC0x01 ) ||
    ( childp->cycleno != 0 && parentp->cycleno == childp->cycleno ) ) {
/*
 *	selfcall or call among siblings
 */
   printf( "%6.6s %5.5s %7.7s %11.11s %7ld %7.7s     " ,
    "" , "" , "" , "" ,
    arcp -> arc_count , "" );
   printname( parentp );
   printf( "\n" );
} else {
/*
 *	regular parent of child
 */
   printf( "%6.6s %5.5s %7.2f %11.2f %7ld/%-7ld     " ,
    "" , "" ,
    arcp -> arc_time / hz , arcp -> arc_childtime / hz ,
    arcp -> arc_count , cycleheadp -> npropcall );
   printname( parentp );
   printf( "\n" );
}
  }
318}

320void
321printchildren(nltype *parentp)
322{
  nltype	*childp;
  arctype	*arcp;

  sortchildren( parentp );
  arcp = parentp -> children;
  for ( arcp = parentp -> children ; arcp ; arcp = arcp -> arc_childlist ) {
childp = arcp -> arc_childp;
if ( childp == parentp || ( arcp -> arc_flags & DEADARC0x01 ) ||
   ( childp->cycleno != 0 && childp->cycleno == parentp->cycleno ) ) {
/*
 *	self call or call to sibling
 */
   printf( "%6.6s %5.5s %7.7s %11.11s %7ld %7.7s     " ,
    "" , "" , "" , "" , arcp -> arc_count , "" );
   printname( childp );
   printf( "\n" );
} else {
/*
 *	regular child of parent
 */
   printf( "%6.6s %5.5s %7.2f %11.2f %7ld/%-7ld     " ,
    "" , "" ,
    arcp -> arc_time / hz , arcp -> arc_childtime / hz ,
    arcp -> arc_count , childp -> cyclehead -> npropcall );
   printname( childp );
   printf( "\n" );
}
  }
351}

353void
354printname(nltype *selfp)
355{

  if ( selfp -> name != 0 ) {
printf( "%s" , selfp -> name );
359#	ifdef DEBUG
   if ( debug & DFNDEBUG1 ) {
printf( "{%d} " , selfp -> toporder );
   }
   if ( debug & PROPDEBUG512 ) {
printf( "%5.2f%% " , selfp -> propfraction );
   }
366#	endif /* DEBUG */
  }
  if ( selfp -> cycleno != 0 ) {
printf( " <cycle %d>" , selfp -> cycleno );
  }
  if ( selfp -> index != 0 ) {
if ( selfp -> printflag ) {
   printf( " [%d]" , selfp -> index );
} else {
   printf( " (%d)" , selfp -> index );
}
  }
378}

380void
381sortchildren(nltype *parentp)
382{
  arctype	*arcp;
  arctype	*detachedp;
  arctype	sorted;
  arctype	*prevp;

/*
*	unlink children from parent,
*	then insertion sort back on to sorted's children.
*	    *arcp	the arc you have detached and are inserting.
*	    *detachedp	the rest of the arcs to be sorted.
*	    sorted	arc list onto which you insertion sort.
*	    *prevp	arc before the arc you are comparing.
*/
  sorted.arc_childlist = 0;
  for (arcp = parentp -> children; arcp; arcp = detachedp) {
detachedp = arcp -> arc_childlist;
   /*
    *	consider *arcp as disconnected
    *	insert it into sorted
    */
for (   prevp = &sorted ;
prevp -> arc_childlist ;
prevp = prevp -> arc_childlist ) {
   if ( arccmp( arcp , prevp -> arc_childlist ) != LESSTHAN-1 ) {
break;
   }
}
arcp -> arc_childlist = prevp -> arc_childlist;
prevp -> arc_childlist = arcp;
  }
/*
*	reattach sorted children to parent
*/
  parentp -> children = sorted.arc_childlist;
417}

419void
420sortparents(nltype *childp)
421{
  arctype	*arcp;
  arctype	*detachedp;
  arctype	sorted;
  arctype	*prevp;

/*
*	unlink parents from child,
*	then insertion sort back on to sorted's parents.
*	    *arcp	the arc you have detached and are inserting.
*	    *detachedp	the rest of the arcs to be sorted.
*	    sorted	arc list onto which you insertion sort.
*	    *prevp	arc before the arc you are comparing.
*/
  sorted.arc_parentlist = 0;
  for (arcp = childp->parents; arcp; arcp = detachedp) {
detachedp = arcp->arc_parentlist;
   /*
    *	consider *arcp as disconnected
    *	insert it into sorted
    */
for (prevp = &sorted; prevp->arc_parentlist;
    prevp = prevp->arc_parentlist)
   if (arccmp(arcp , prevp->arc_parentlist) != GREATERTHAN1)
break;
arcp->arc_parentlist = prevp->arc_parentlist;
prevp->arc_parentlist = arcp;
  }
/*
*	reattach sorted arcs to child
*/
  childp -> parents = sorted.arc_parentlist;
453}

  /*
   *	print a cycle header
   */
458void
459printcycle(nltype *cyclep)
460{
  char	kirkbuffer[ BUFSIZ1024 ];

  snprintf(kirkbuffer, sizeof kirkbuffer, "[%d]" , cyclep->index);
  printf("%-6.6s %5.1f %7.2f %11.2f %7ld", kirkbuffer,
   100 * (cyclep->propself + cyclep->propchild) / printtime,
   cyclep->propself / hz, cyclep->propchild / hz, cyclep->npropcall);
  if (cyclep -> selfcalls != 0)
printf("+%-7ld" , cyclep->selfcalls);
  else
printf(" %7.7s" , "");
  printf(" <cycle %d as a whole>\t[%d]\n" ,
   cyclep->cycleno , cyclep->index );
473}

  /*
   *	print the members of a cycle
   */
478void
479printmembers(nltype *cyclep)
480{
  nltype	*memberp;

  sortmembers( cyclep );
  for ( memberp = cyclep -> cnext ; memberp ; memberp = memberp -> cnext ) {
printf( "%6.6s %5.5s %7.2f %11.2f %7ld" , "", "",
 memberp->propself / hz, memberp->propchild / hz, memberp->npropcall );
if (memberp -> selfcalls != 0)
   printf("+%-7ld" , memberp -> selfcalls);
else
   printf(" %7.7s", "");
printf("     ");
printname(memberp);
printf("\n");
  }
495}

  /*
   *	sort members of a cycle
   */
500void
501sortmembers(nltype *cyclep)
502{
  nltype	*todo;
  nltype	*doing;
  nltype	*prev;

/*
*	detach cycle members from cyclehead,
*	and insertion sort them back on.
*/
  todo = cyclep -> cnext;
  cyclep -> cnext = 0;
  for (doing = todo; doing; doing = todo) {
todo = doing -> cnext;
for (prev = cyclep; prev -> cnext; prev = prev -> cnext)
   if (membercmp(doing, prev->cnext ) == GREATERTHAN1)
break;
doing -> cnext = prev -> cnext;
prev -> cnext = doing;
  }
521}

  /*
   *	major sort is on propself + propchild,
   *	next is sort on ncalls + selfcalls.
   */
527int
528membercmp(nltype *this , nltype *that)
529{
  double	thistime = this -> propself + this -> propchild;
  double	thattime = that -> propself + that -> propchild;
  long	thiscalls = this -> ncall + this -> selfcalls;
  long	thatcalls = that -> ncall + that -> selfcalls;

  if ( thistime > thattime ) {
return GREATERTHAN1;
  }
  if ( thistime < thattime ) {
return LESSTHAN-1;
  }
  if ( thiscalls > thatcalls ) {
return GREATERTHAN1;
  }
  if ( thiscalls < thatcalls ) {
return LESSTHAN-1;
  }
  return EQUALTO0;
548}
  /*
   *	compare two arcs to/from the same child/parent.
   *	- if one arc is a self arc, it's least.
   *	- if one arc is within a cycle, it's less than.
   *	- if both arcs are within a cycle, compare arc counts.
   *	- if neither arc is within a cycle, compare with
   *		arc_time + arc_childtime as major key
   *		arc count as minor key
   */
558int
559arccmp(arctype *thisp, arctype *thatp)
560{
  nltype	*thisparentp = thisp -> arc_parentp;
  nltype	*thischildp = thisp -> arc_childp;
  nltype	*thatparentp = thatp -> arc_parentp;
  nltype	*thatchildp = thatp -> arc_childp;
  double	thistime;
  double	thattime;

568#   ifdef DEBUG
if ( debug & TIMEDEBUG16 ) {
   printf( "[arccmp] " );
   printname( thisparentp );
   printf( " calls " );
   printname ( thischildp );
   printf( " %f + %f %ld/%ld\n" ,
    thisp -> arc_time , thisp -> arc_childtime ,
    thisp -> arc_count , thischildp -> ncall );
   printf( "[arccmp] " );
   printname( thatparentp );
   printf( " calls " );
   printname( thatchildp );
   printf( " %f + %f %ld/%ld\n" ,
    thatp -> arc_time , thatp -> arc_childtime ,
    thatp -> arc_count , thatchildp -> ncall );
   printf( "\n" );
}
586#   endif /* DEBUG */
  if ( thisparentp == thischildp ) {
   /* this is a self call */
return LESSTHAN-1;
  }
  if ( thatparentp == thatchildp ) {
   /* that is a self call */
return GREATERTHAN1;
  }
  if ( thisparentp -> cycleno != 0 && thischildp -> cycleno != 0 &&
thisparentp -> cycleno == thischildp -> cycleno ) {
   /* this is a call within a cycle */
if ( thatparentp -> cycleno != 0 && thatchildp -> cycleno != 0 &&
   thatparentp -> cycleno == thatchildp -> cycleno ) {
/* that is a call within the cycle, too */
   if ( thisp -> arc_count < thatp -> arc_count ) {
return LESSTHAN-1;
   }
   if ( thisp -> arc_count > thatp -> arc_count ) {
return GREATERTHAN1;
   }
   return EQUALTO0;
} else {
/* that isn't a call within the cycle */
   return LESSTHAN-1;
}
  } else {
   /* this isn't a call within a cycle */
if ( thatparentp -> cycleno != 0 && thatchildp -> cycleno != 0 &&
   thatparentp -> cycleno == thatchildp -> cycleno ) {
/* that is a call within a cycle */
   return GREATERTHAN1;
} else {
/* neither is a call within a cycle */
   thistime = thisp -> arc_time + thisp -> arc_childtime;
   thattime = thatp -> arc_time + thatp -> arc_childtime;
   if ( thistime < thattime )
return LESSTHAN-1;
   if ( thistime > thattime )
return GREATERTHAN1;
   if ( thisp -> arc_count < thatp -> arc_count )
return LESSTHAN-1;
   if ( thisp -> arc_count > thatp -> arc_count )
return GREATERTHAN1;
   return EQUALTO0;
}
  }
633}

635void
636printblurb(const char *blurbname)
637{
  FILE	*blurbfile;
  int		input;

  blurbfile = fopen( blurbname , "r" );
  if ( blurbfile == NULL((void *)0) ) {
warn("fopen: %s", blurbname );
return;
  }
  while ( ( input = getc( blurbfile )(!__isthreaded ? (--(blurbfile)->_r < 0 ? __srget(blurbfile
) : (int)(*(blurbfile)->_p++)) : (getc)(blurbfile)) ) != EOF(-1) )
putchar( input )(!__isthreaded ? __sputc(input, (&__sF[1])) : (putc)(input
, (&__sF[1])));

  fclose( blurbfile );
650}

652int
653namecmp(const void *v1, const void *v2)
654{
  const nltype * const *npp1 = v1;
  const nltype * const *npp2 = v2;

  return( strcmp( (*npp1) -> name , (*npp2) -> name ) );
659}

661void
662printindex()
663{
  nltype		**namesortnlp;
  nltype		*nlp;
  int			index, nnames, todo, i, j;
  char		peterbuffer[ BUFSIZ1024 ];

/*
*	Now, sort regular function name alphbetically
*	to create an index.
*/
  namesortnlp = calloc( nname + ncycle , sizeof(nltype *) );
1
Value assigned to 'namesortnlp'→
  if ( namesortnlp == (nltype **) 0 )
2
←
Assuming 'namesortnlp' is equal to null→
3
←
Taking true branch→
warnx("ran out of memory for sorting");
  for ( index = 0 , nnames = 0 ; index < nname ; index++ ) {
4
←
Assuming 'index' is < 'nname'→
5
←
Loop condition is true.  Entering loop body→
if ( zflag == 0 && nl[index].ncall == 0 && nl[index].time == 0 )
6
←
Assuming 'zflag' is not equal to 0→
continue;
namesortnlp[nnames++] = &nl[index];
7
←
Array access (from variable 'namesortnlp') results in a null pointer dereference
  }
  qsort( namesortnlp , nnames , sizeof(nltype *) , namecmp );
  for ( index = 1 , todo = nnames ; index <= ncycle ; index++ ) {
namesortnlp[todo++] = &cyclenl[index];
  }
  printf( "\f\nIndex by function name\n\n" );
  index = ( todo + 2 ) / 3;
  for ( i = 0; i < index ; i++ ) {
for ( j = i; j < todo ; j += index ) {
   nlp = namesortnlp[ j ];
   if ( nlp -> printflag ) {
snprintf(peterbuffer, sizeof peterbuffer, "[%d]" , nlp -> index );
   } else {
snprintf(peterbuffer, sizeof peterbuffer, "(%d)" , nlp -> index );
   }
   if ( j < nnames ) {
printf( "%6.6s %-19.19s" , peterbuffer , nlp -> name );
   } else {
printf( "%6.6s " , peterbuffer );
snprintf(peterbuffer, sizeof peterbuffer, "<cycle %d>"
    , nlp -> cycleno );
printf( "%-19.19s" , peterbuffer );
   }
}
printf( "\n" );
  }
  free( namesortnlp );
707}