dmake: do not set MAKEFLAGS=k

[unleashed/tickless.git] / usr / src / cmd / sgs / gprof / common / gprof.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I%     %E% SMI"

#include        <sysexits.h>
#include        <stdlib.h>
#include        <stdio.h>
#include        <unistd.h>
#include        "gprof.h"
#include        "profile.h"

char            *whoami = "gprof";
static pctype   lowpc, highpc;          /* range profiled, in UNIT's */

/*
 *      things which get -E excluded by default.
 */
static char *defaultEs[] = {
        "mcount",
        "__mcleanup",
        NULL
};

#ifdef DEBUG

static char *objname[] = {
        "<invalid object>",
        "PROF_BUFFER_T",
        "PROF_CALLGRAPH_T",
        "PROF_MODULES_T",
        NULL
};
#define MAX_OBJTYPES    3

#endif /* DEBUG */

void
done(void)
{

        exit(EX_OK);
}

static pctype
max(pctype a, pctype b)
{
        if (a > b)
                return (a);
        return (b);
}

static pctype
min(pctype a, pctype b)
{
        if (a < b)
                return (a);
        return (b);
}

/*
 *      calculate scaled entry point addresses (to save time in asgnsamples),
 *      and possibly push the scaled entry points over the entry mask,
 *      if it turns out that the entry point is in one bucket and the code
 *      for a routine is in the next bucket.
 *
 */
static void
alignentries(void)
{
        struct nl *nlp;
#ifdef DEBUG
        pctype                  bucket_of_entry;
        pctype                  bucket_of_code;
#endif /* DEBUG */

        /* for old-style gmon.out, nameslist is only in modules.nl */

        for (nlp = modules.nl; nlp < modules.npe; nlp++) {
                nlp->svalue = nlp->value / sizeof (UNIT);
#ifdef DEBUG
                bucket_of_entry = (nlp->svalue - lowpc) / scale;
                bucket_of_code = (nlp->svalue + UNITS_TO_CODE - lowpc) / scale;
                if (bucket_of_entry < bucket_of_code) {
                        if (debug & SAMPLEDEBUG) {
                                (void) printf(
                                    "[alignentries] pushing svalue 0x%llx "
                                    "to 0x%llx\n", nlp->svalue,
                                    nlp->svalue + UNITS_TO_CODE);
                        }
                }
#endif /* DEBUG */
        }
}

/*
 *      old-style gmon.out
 *      ------------------
 *
 *      Assign samples to the procedures to which they belong.
 *
 *      There are three cases as to where pcl and pch can be
 *      with respect to the routine entry addresses svalue0 and svalue1
 *      as shown in the following diagram.  overlap computes the
 *      distance between the arrows, the fraction of the sample
 *      that is to be credited to the routine which starts at svalue0.
 *
 *          svalue0                                         svalue1
 *             |                                               |
 *             v                                               v
 *
 *             +-----------------------------------------------+
 *             |                                               |
 *        |  ->|    |<-         ->|         |<-         ->|    |<-  |
 *        |         |             |         |             |         |
 *        +---------+             +---------+             +---------+
 *
 *        ^         ^             ^         ^             ^         ^
 *        |         |             |         |             |         |
 *       pcl       pch           pcl       pch           pcl       pch
 *
 *      For the vax we assert that samples will never fall in the first
 *      two bytes of any routine, since that is the entry mask,
 *      thus we give call alignentries() to adjust the entry points if
 *      the entry mask falls in one bucket but the code for the routine
 *      doesn't start until the next bucket.  In conjunction with the
 *      alignment of routine addresses, this should allow us to have
 *      only one sample for every four bytes of text space and never
 *      have any overlap (the two end cases, above).
 */
static void
asgnsamples(void)
{
        sztype          i, j;
        unsigned_UNIT   ccnt;
        double          time;
        pctype          pcl, pch;
        pctype          overlap;
        pctype          svalue0, svalue1;

        extern mod_info_t       modules;
        nltype          *nl = modules.nl;
        sztype          nname = modules.nname;

        /* read samples and assign to namelist symbols */
        scale = highpc - lowpc;
        scale /= nsamples;
        alignentries();
        for (i = 0, j = 1; i < nsamples; i++) {
                ccnt = samples[i];
                if (ccnt == 0)
                        continue;
                /*LINTED: E_ASSIGMENT_CAUSE_LOSS_PREC*/
                pcl = lowpc + scale * i;
                /*LINTED: E_ASSIGMENT_CAUSE_LOSS_PREC*/
                pch = lowpc + scale * (i + 1);
                time = ccnt;
#ifdef DEBUG
                if (debug & SAMPLEDEBUG) {
                        (void) printf(
                            "[asgnsamples] pcl 0x%llx pch 0x%llx ccnt %d\n",
                            pcl, pch, ccnt);
                }
#endif /* DEBUG */
                totime += time;
                for (j = (j ? j - 1 : 0); j < nname; j++) {
                        svalue0 = nl[j].svalue;
                        svalue1 = nl[j+1].svalue;
                        /*
                         *      if high end of tick is below entry address,
                         *      go for next tick.
                         */
                        if (pch < svalue0)
                                break;
                        /*
                         *      if low end of tick into next routine,
                         *      go for next routine.
                         */
                        if (pcl >= svalue1)
                                continue;
                        overlap = min(pch, svalue1) - max(pcl, svalue0);
                        if (overlap != 0) {
#ifdef DEBUG
                                if (debug & SAMPLEDEBUG) {
                                        (void) printf("[asgnsamples] "
                                            "(0x%llx->0x%llx-0x%llx) %s gets "
                                            "%f ticks %lld overlap\n",
                                            nl[j].value/sizeof (UNIT), svalue0,
                                            svalue1, nl[j].name,
                                            overlap * time / scale, overlap);
                                }
#endif /* DEBUG */
                                nl[j].time += overlap * time / scale;
                        }
                }
        }
#ifdef DEBUG
        if (debug & SAMPLEDEBUG) {
                (void) printf("[asgnsamples] totime %f\n", totime);
        }
#endif /* DEBUG */
}


static void
dump_callgraph(FILE *fp, char *filename, unsigned long tarcs,
    unsigned long ncallees)
{
        ProfCallGraph           prof_cgraph;
        ProfFunction            prof_func;
        arctype *arcp;
        mod_info_t              *mi;
        nltype                  *nlp;
        size_t                  cur_offset;
        unsigned long           caller_id = 0, callee_id = 0;

        /*
         * Write the callgraph header
         */
        prof_cgraph.type = PROF_CALLGRAPH_T;
        prof_cgraph.version = PROF_CALLGRAPH_VER;
        prof_cgraph.functions = PROFCGRAPH_SZ;
        prof_cgraph.size = PROFCGRAPH_SZ + tarcs * PROFFUNC_SZ;
        if (fwrite(&prof_cgraph, sizeof (ProfCallGraph), 1, fp) != 1) {
                perror(filename);
                exit(EX_IOERR);
        }
        /* CONSTCOND */
        if (CGRAPH_FILLER)
                (void) fseek(fp, CGRAPH_FILLER, SEEK_CUR);

        /* Current offset inside the callgraph object */
        cur_offset = prof_cgraph.functions;

        for (mi = &modules; mi; mi = mi->next) {
                for (nlp = mi->nl; nlp < mi->npe; nlp++) {
                        if (nlp->ncallers == 0)
                                continue;

                        /* If this is the last callee, set next_to to 0 */
                        callee_id++;
                        if (callee_id == ncallees)
                                prof_func.next_to = 0;
                        else {
                                prof_func.next_to = cur_offset +
                                    nlp->ncallers * PROFFUNC_SZ;
                        }

                        /*
                         * Dump this callee's raw arc information with all
                         * its callers
                         */
                        caller_id = 1;
                        for (arcp = nlp->parents; arcp;
                            arcp = arcp->arc_parentlist) {
                                /*
                                 * If no more callers for this callee, set
                                 * next_from to 0
                                 */
                                if (caller_id == nlp->ncallers)
                                        prof_func.next_from = 0;
                                else {
                                        prof_func.next_from = cur_offset +
                                            PROFFUNC_SZ;
                                }

                                prof_func.frompc =
                                    arcp->arc_parentp->module->load_base +
                                    (arcp->arc_parentp->value -
                                    arcp->arc_parentp->module->txt_origin);
                                prof_func.topc = mi->load_base +
                                    (nlp->value - mi->txt_origin);
                                prof_func.count = arcp->arc_count;


                                if (fwrite(&prof_func, sizeof (ProfFunction),
                                    1, fp) != 1) {
                                        perror(filename);
                                        exit(EX_IOERR);
                                }
                                /* CONSTCOND */
                                if (FUNC_FILLER)
                                        (void) fseek(fp, FUNC_FILLER, SEEK_CUR);

                                cur_offset += PROFFUNC_SZ;
                                caller_id++;
                        }
                } /* for nlp... */
        } /* for mi... */
}

/*
 * To save all pc-hits in all the gmon.out's is infeasible, as this
 * may become quite huge even with a small number of files to sum.
 * Instead, we'll dump *fictitious hits* to correct functions
 * by scanning module namelists. Again, since this is summing
 * pc-hits, we may have to dump the pcsamples out in chunks if the
 * number of pc-hits is high.
 */
static void
dump_hits(FILE *fp, char *filename, nltype *nlp)
{
        Address         *p, hitpc;
        size_t          i, nelem, ntowrite;

        if ((nelem = nlp->nticks) > PROF_BUFFER_SIZE)
                nelem = PROF_BUFFER_SIZE;

        if ((p = (Address *) calloc(nelem, sizeof (Address))) == NULL) {
                (void) fprintf(stderr, "%s: no room for %d pcsamples\n",
                    whoami, nelem);
                exit(EX_OSERR);
        }

        /*
         * Set up *fictitious* hits (to function entry) buffer
         */
        hitpc = nlp->module->load_base + (nlp->value - nlp->module->txt_origin);
        for (i = 0; i < nelem; i++)
                p[i] = hitpc;

        for (ntowrite = nlp->nticks; ntowrite >= nelem; ntowrite -= nelem) {
                if (fwrite(p, nelem * sizeof (Address), 1, fp) != 1) {
                        perror(filename);
                        exit(EX_IOERR);
                }
        }

        if (ntowrite) {
                if (fwrite(p, ntowrite * sizeof (Address), 1, fp) != 1) {
                        perror(filename);
                        exit(EX_IOERR);
                }
        }

        free(p);
}

static void
dump_pcsamples(FILE *fp, char *filename, unsigned long *tarcs,
    unsigned long *ncallees)
{
        ProfBuffer              prof_buffer;
        arctype *arcp;
        mod_info_t              *mi;
        nltype                  *nlp;

        prof_buffer.type = PROF_BUFFER_T;
        prof_buffer.version = PROF_BUFFER_VER;
        prof_buffer.buffer = PROFBUF_SZ;
        prof_buffer.bufsize = n_pcsamples;
        prof_buffer.size = PROFBUF_SZ + n_pcsamples * sizeof (Address);
        if (fwrite(&prof_buffer, sizeof (ProfBuffer), 1, fp) != 1) {
                perror(filename);
                exit(EX_IOERR);
        }
        /* CONSTCOND */
        if (BUF_FILLER)
                (void) fseek(fp, BUF_FILLER, SEEK_CUR);

        *tarcs = 0;
        *ncallees = 0;
        for (mi = &modules; mi; mi = mi->next) {
                for (nlp = mi->nl; nlp < mi->npe; nlp++) {
                        if (nlp->nticks)
                                dump_hits(fp, filename, nlp);

                        nlp->ncallers = 0;
                        for (arcp = nlp->parents; arcp;
                            arcp = arcp->arc_parentlist) {
                                (nlp->ncallers)++;
                        }

                        if (nlp->ncallers) {
                                (*tarcs) += nlp->ncallers;
                                (*ncallees)++;
                        }
                }
        }
}

static void
dump_modules(FILE *fp, char *filename, size_t pbuf_sz)
{
        char            *pbuf, *p;
        size_t          namelen;
        Index           off_nxt, off_path;
        mod_info_t      *mi;

        ProfModuleList  prof_modlist;
        ProfModule      prof_mod;

        /* Allocate for path strings buffer */
        pbuf_sz = CEIL(pbuf_sz, STRUCT_ALIGN);
        if ((p = pbuf = calloc(pbuf_sz, sizeof (char))) == NULL) {
                (void) fprintf(stderr, "%s: no room for %d bytes\n",
                    whoami, pbuf_sz * sizeof (char));
                exit(EX_OSERR);
        }

        /* Dump out PROF_MODULE_T info for all non-aout modules */
        prof_modlist.type = PROF_MODULES_T;
        prof_modlist.version = PROF_MODULES_VER;
        prof_modlist.modules = PROFMODLIST_SZ;
        prof_modlist.size = PROFMODLIST_SZ + (n_modules - 1) * PROFMOD_SZ +
            pbuf_sz;
        if (fwrite(&prof_modlist, sizeof (ProfModuleList), 1, fp) != 1) {
                perror(filename);
                exit(EX_IOERR);
        }
        /* CONSTCOND */
        if (MODLIST_FILLER)
                (void) fseek(fp, MODLIST_FILLER, SEEK_CUR);

        /*
         * Initialize offsets for ProfModule elements.
         */
        off_nxt = PROFMODLIST_SZ + PROFMOD_SZ;
        off_path = PROFMODLIST_SZ + (n_modules - 1) * PROFMOD_SZ;

        for (mi = modules.next; mi; mi = mi->next) {
                if (mi->next)
                        prof_mod.next = off_nxt;
                else
                        prof_mod.next = 0;
                prof_mod.path = off_path;
                prof_mod.startaddr = mi->load_base;
                prof_mod.endaddr = mi->load_end;

                if (fwrite(&prof_mod, sizeof (ProfModule), 1, fp) != 1) {
                        perror(filename);
                        exit(EX_IOERR);
                }

                /* CONSTCOND */
                if (MOD_FILLER)
                        (void) fseek(fp, MOD_FILLER, SEEK_CUR);

                (void) strcpy(p, mi->name);
                namelen = strlen(mi->name);
                p += namelen + 1;

                /* Note that offset to every path str need not be aligned */
                off_nxt += PROFMOD_SZ;
                off_path += namelen + 1;
        }

        /* Write out the module path strings */
        if (pbuf_sz) {
                if (fwrite(pbuf, pbuf_sz, 1, fp) != 1) {
                        perror(filename);
                        exit(EX_IOERR);
                }

                free(pbuf);
        }
}

/*
 * If we have inactive modules, their current load addresses may overlap with
 * active ones, and so we've to assign fictitious, non-overlapping addresses
 * to all modules before we dump them.
 */
static void
fixup_maps(size_t *pathsz)
{
        unsigned int    n_inactive = 0;
        Address         lbase = 0, lend;
        mod_info_t      *mi;

        /* Pick the lowest load address among modules */
        *pathsz = 0;
        for (mi = &modules; mi; mi = mi->next) {

                if (mi->active == FALSE)
                        n_inactive++;

                if (mi == &modules || mi->load_base < lbase)
                        lbase = mi->load_base;

                /*
                 * Return total path size of non-aout modules only
                 */
                if (mi != &modules)
                        *pathsz = (*pathsz) + strlen(mi->name) + 1;
        }

        /*
         * All module info is in fine shape already if there are no
         * inactive modules
         */
        if (n_inactive == 0)
                return;

        /*
         * Assign fictitious load addresses to all (non-aout) modules so
         * that sum info can be dumped out.
         */
        for (mi = modules.next; mi; mi = mi->next) {
                lend = lbase + (mi->data_end - mi->txt_origin);
                if ((lbase < modules.load_base && lend < modules.load_base) ||
                    (lbase > modules.load_end && lend > modules.load_end)) {

                        mi->load_base = lbase;
                        mi->load_end = lend;

                        /* just to give an appearance of reality */
                        lbase = CEIL(lend + PGSZ, PGSZ);
                } else {
                        /*
                         * can't use this lbase & lend pair, as it
                         * overlaps with aout's addresses
                         */
                        mi->load_base = CEIL(modules.load_end + PGSZ, PGSZ);
                        mi->load_end = mi->load_base + (lend - lbase);

                        lbase = CEIL(mi->load_end + PGSZ, PGSZ);
                }
        }
}

static void
dump_gprofhdr(FILE *fp, char *filename)
{
        ProfHeader      prof_hdr;

        prof_hdr.h_magic = PROF_MAGIC;
        prof_hdr.h_major_ver = PROF_MAJOR_VERSION;
        prof_hdr.h_minor_ver = PROF_MINOR_VERSION;
        prof_hdr.size = PROFHDR_SZ;
        if (fwrite(&prof_hdr, sizeof (prof_hdr), 1, fp) != 1) {
                perror(filename);
                exit(EX_IOERR);
        }

        /* CONSTCOND */
        if (HDR_FILLER)
                (void) fseek(fp, HDR_FILLER, SEEK_CUR);
}

static void
dumpsum_ostyle(char *sumfile)
{
        nltype *nlp;
        arctype *arcp;
        struct rawarc arc;
        struct rawarc32 arc32;
        FILE *sfile;

        if ((sfile = fopen(sumfile, "w")) == NULL) {
                perror(sumfile);
                exit(EX_IOERR);
        }
        /*
         * dump the header; use the last header read in
         */
        if (Bflag) {
                if (fwrite(&h, sizeof (h), 1, sfile) != 1) {
                        perror(sumfile);
                        exit(EX_IOERR);
                }
        } else {
                struct hdr32 hdr;
                hdr.lowpc  = (pctype32)h.lowpc;
                hdr.highpc = (pctype32)h.highpc;
                hdr.ncnt   = (pctype32)h.ncnt;
                if (fwrite(&hdr, sizeof (hdr), 1, sfile) != 1) {
                        perror(sumfile);
                        exit(EX_IOERR);
                }
        }
        /*
         * dump the samples
         */
        if (fwrite(samples, sizeof (unsigned_UNIT), nsamples, sfile) !=
            nsamples) {
                perror(sumfile);
                exit(EX_IOERR);
        }
        /*
         * dump the normalized raw arc information. For old-style dumping,
         * the only namelist is in modules.nl
         */
        for (nlp = modules.nl; nlp < modules.npe; nlp++) {
                for (arcp = nlp->children; arcp;
                    arcp = arcp->arc_childlist) {
                        if (Bflag) {
                                arc.raw_frompc = arcp->arc_parentp->value;
                                arc.raw_selfpc = arcp->arc_childp->value;
                                arc.raw_count = arcp->arc_count;
                                if (fwrite(&arc, sizeof (arc), 1, sfile) != 1) {
                                        perror(sumfile);
                                        exit(EX_IOERR);
                                }
                        } else {
                                arc32.raw_frompc =
                                    (pctype32)arcp->arc_parentp->value;
                                arc32.raw_selfpc =
                                    (pctype32)arcp->arc_childp->value;
                                arc32.raw_count = (actype32)arcp->arc_count;
                                if (fwrite(&arc32, sizeof (arc32), 1, sfile) !=
                                    1) {
                                        perror(sumfile);
                                        exit(EX_IOERR);
                                }
                        }
#ifdef DEBUG
                        if (debug & SAMPLEDEBUG) {
                                (void) printf(
                                    "[dumpsum_ostyle] frompc 0x%llx selfpc "
                                    "0x%llx count %lld\n", arc.raw_frompc,
                                    arc.raw_selfpc, arc.raw_count);
                        }
#endif /* DEBUG */
                }
        }
        (void) fclose(sfile);
}

/*
 * dump out the gmon.sum file
 */
static void
dumpsum(char *sumfile)
{
        FILE            *sfile;
        size_t          pathbuf_sz;
        unsigned long   total_arcs;     /* total number of arcs in all */
        unsigned long   ncallees;       /* no. of callees with parents */

        if (old_style) {
                dumpsum_ostyle(sumfile);
                return;
        }

        if ((sfile = fopen(sumfile, "w")) == NULL) {
                perror(sumfile);
                exit(EX_IOERR);
        }

        /*
         * Dump the new-style gprof header. Even if one of the original
         * profiled-files was of a older version, the summed file is of
         * current version only.
         */
        dump_gprofhdr(sfile, sumfile);

        /*
         * Fix up load-maps and dump out modules info
         *
         * Fix up module load maps so inactive modules get *some* address
         * (and btw, could you get the total size of non-aout module path
         * strings please ?)
         */
        fixup_maps(&pathbuf_sz);
        dump_modules(sfile, sumfile, pathbuf_sz);


        /*
         * Dump out the summ'd pcsamples
         *
         * For dumping call graph information later, we need certain
         * statistics (like total arcs, number of callers for each node);
         * collect these also while we are at it.
         */
        dump_pcsamples(sfile, sumfile, &total_arcs, &ncallees);

        /*
         * Dump out the summ'd call graph information
         */
        dump_callgraph(sfile, sumfile, total_arcs, ncallees);


        (void) fclose(sfile);
}

static void
tally(mod_info_t *caller_mod, mod_info_t *callee_mod, struct rawarc *rawp)
{
        nltype          *parentp;
        nltype          *childp;

        /*
         * if count == 0 this is a null arc and
         * we don't need to tally it.
         */
        if (rawp->raw_count == 0)
                return;

        /*
         * Lookup the caller and callee pcs in namelists of
         * appropriate modules
         */
        parentp = nllookup(caller_mod, rawp->raw_frompc, NULL);
        childp = nllookup(callee_mod, rawp->raw_selfpc, NULL);
        if (childp && parentp) {
                if (!Dflag)
                        childp->ncall += rawp->raw_count;
                else {
                        if (first_file)
                                childp->ncall += rawp->raw_count;
                        else {
                                childp->ncall -= rawp->raw_count;
                                if (childp->ncall < 0)
                                        childp->ncall = 0;
                        }
                }

#ifdef DEBUG
                if (debug & TALLYDEBUG) {
                        (void) printf("[tally] arc from %s to %s traversed "
                            "%lld times\n", parentp->name,
                            childp->name, rawp->raw_count);
                }
#endif /* DEBUG */
                addarc(parentp, childp, rawp->raw_count);
        }
}

/*
 * Look up a module's base address in a sorted list of pc-hits. Unlike
 * nllookup(), this deals with misses by mapping them to the next *higher*
 * pc-hit. This is so that we get into the module's first pc-hit rightaway,
 * even if the module's entry-point (load_base) itself is not a hit.
 */
static Address *
locate(Address  *pclist, size_t nelem, Address keypc)
{
        size_t  low = 0, middle, high = nelem - 1;

        if (keypc <= pclist[low])
                return (pclist);

        if (keypc > pclist[high])
                return (NULL);

        while (low != high) {
                middle = (high + low) >> 1;

                if ((pclist[middle] < keypc) && (pclist[middle + 1] >= keypc))
                        return (&pclist[middle + 1]);

                if (pclist[middle] >= keypc)
                        high = middle;
                else
                        low = middle + 1;
        }

        /* must never reach here! */
        return (NULL);
}

static void
assign_pcsamples(mod_info_t *module, Address *pcsmpl, size_t n_samples)
{
        Address         *pcptr, *pcse = pcsmpl + n_samples;
        pctype          nxt_func;
        nltype          *fnl;
        size_t          func_nticks;
#ifdef DEBUG
        size_t          n_hits_in_module = 0;
#endif /* DEBUG */

        /* Locate the first pc-hit for this module */
        if ((pcptr = locate(pcsmpl, n_samples, module->load_base)) == NULL) {
#ifdef DEBUG
                if (debug & PCSMPLDEBUG) {
                        (void) printf("[assign_pcsamples] no pc-hits in\n");
                        (void) printf(
                            "                   `%s'\n", module->name);
                }
#endif /* DEBUG */
                return;                 /* no pc-hits in this module */
        }

        /* Assign all pc-hits in this module to appropriate functions */
        while ((pcptr < pcse) && (*pcptr < module->load_end)) {

                /* Update the corresponding function's time */
                if (fnl = nllookup(module, (pctype) *pcptr, &nxt_func)) {
                        /*
                         * Collect all pc-hits in this function. Each
                         * pc-hit counts as 1 tick.
                         */
                        func_nticks = 0;
                        while ((pcptr < pcse) && (*pcptr < nxt_func)) {
                                func_nticks++;
                                pcptr++;
                        }

                        if (func_nticks == 0)
                                pcptr++;
                        else {
                                fnl->nticks += func_nticks;
                                fnl->time += func_nticks;
                                totime += func_nticks;
                        }

#ifdef DEBUG
                        n_hits_in_module += func_nticks;
#endif /* DEBUG */
                } else {
                        /*
                         * pc sample could not be assigned to function;
                         * probably in a PLT
                         */
                        pcptr++;
                }
        }

#ifdef DEBUG
        if (debug & PCSMPLDEBUG) {
                (void) printf(
                    "[assign_pcsamples] %ld hits in\n", n_hits_in_module);
                (void) printf("                   `%s'\n", module->name);
        }
#endif /* DEBUG */
}

int
pc_cmp(const void *arg1, const void *arg2)
{
        Address *pc1 = (Address *)arg1;
        Address *pc2 = (Address *)arg2;

        if (*pc1 > *pc2)
                return (1);

        if (*pc1 < *pc2)
                return (-1);

        return (0);
}

static void
process_pcsamples(ProfBuffer *bufp)
{
        Address         *pc_samples;
        mod_info_t      *mi;
        caddr_t         p;
        size_t          chunk_size, nelem_read, nelem_to_read;

#ifdef DEBUG
        if (debug & PCSMPLDEBUG) {
                (void) printf(
                    "[process_pcsamples] number of pcsamples = %lld\n",
                    bufp->bufsize);
        }
#endif /* DEBUG */

        /* buffer with no pc samples ? */
        if (bufp->bufsize == 0)
                return;

        /*
         * If we're processing pcsamples of a profile sum, we could have
         * more than PROF_BUFFER_SIZE number of samples. In such a case,
         * we must read the pcsamples in chunks.
         */
        if ((chunk_size = bufp->bufsize) > PROF_BUFFER_SIZE)
                chunk_size = PROF_BUFFER_SIZE;

        /* Allocate for the pcsample chunk */
        pc_samples = (Address *) calloc(chunk_size, sizeof (Address));
        if (pc_samples == NULL) {
                (void) fprintf(stderr, "%s: no room for %d sample pc's\n",
                    whoami, chunk_size);
                exit(EX_OSERR);
        }

        /* Copy the current set of pcsamples */
        nelem_read = 0;
        nelem_to_read = bufp->bufsize;
        p = (char *)bufp + bufp->buffer;

        while (nelem_read < nelem_to_read) {
                (void) memcpy((void *) pc_samples, p,
                    chunk_size * sizeof (Address));

                /* Sort the pc samples */
                qsort(pc_samples, chunk_size, sizeof (Address), pc_cmp);

                /*
                 * Assign pcsamples to functions in the currently active
                 * module list
                 */
                for (mi = &modules; mi; mi = mi->next) {
                        if (mi->active == FALSE)
                                continue;
                        assign_pcsamples(mi, pc_samples, chunk_size);
                }

                p += (chunk_size * sizeof (Address));
                nelem_read += chunk_size;

                if ((nelem_to_read - nelem_read) < chunk_size)
                        chunk_size = nelem_to_read - nelem_read;
        }

        free(pc_samples);

        /* Update total number of pcsamples read so far */
        n_pcsamples += bufp->bufsize;
}

static mod_info_t *
find_module(Address addr)
{
        mod_info_t      *mi;

        for (mi = &modules; mi; mi = mi->next) {
                if (mi->active == FALSE)
                        continue;

                if (addr >= mi->load_base && addr < mi->load_end)
                        return (mi);
        }

        return (NULL);
}

static void
process_cgraph(ProfCallGraph *cgp)
{
        struct rawarc   arc;
        mod_info_t      *callee_mi, *caller_mi;
        ProfFunction    *calleep, *callerp;
        Index           caller_off, callee_off;

        /*
         * Note that *callee_off* increment in the for loop below
         * uses *calleep* and *calleep* doesn't get set until the for loop
         * is entered. We don't expect the increment to be executed before
         * the loop body is executed atleast once, so this should be ok.
         */
        for (callee_off = cgp->functions; callee_off;
            callee_off = calleep->next_to) {

                /* LINTED: pointer cast */
                calleep = (ProfFunction *)((char *)cgp + callee_off);

                /*
                 * We could choose either to sort the {caller, callee}
                 * list twice and assign callee/caller to modules or inspect
                 * each callee/caller in the active modules list. Since
                 * the modules list is usually very small, we'l choose the
                 * latter.
                 */

                /*
                 * If we cannot identify a callee with a module, there's
                 * no use worrying about who called it.
                 */
                if ((callee_mi = find_module(calleep->topc)) == NULL) {
#ifdef DEBUG
                        if (debug & CGRAPHDEBUG) {
                                (void) printf(
                                    "[process_cgraph] callee %#llx missed\n",
                                    calleep->topc);
                        }
#endif /* DEBUG */
                        continue;
                } else
                        arc.raw_selfpc = calleep->topc;

                for (caller_off = callee_off; caller_off;
                    caller_off = callerp->next_from)  {

                        /* LINTED: pointer cast */
                        callerp = (ProfFunction *)((char *)cgp + caller_off);
                        if ((caller_mi = find_module(callerp->frompc)) ==
                            NULL) {
#ifdef DEBUG
                                if (debug & CGRAPHDEBUG) {
                                        (void) printf(
                                            "[process_cgraph] caller %#llx "
                                            "missed\n", callerp->frompc);
                                }
#endif /* DEBUG */
                                continue;
                        }

                        arc.raw_frompc = callerp->frompc;
                        arc.raw_count = callerp->count;

#ifdef DEBUG
                        if (debug & CGRAPHDEBUG) {
                                (void) printf(
                                    "[process_cgraph] arc <%#llx, %#llx, "
                                    "%lld>\n", arc.raw_frompc, arc.raw_selfpc,
                                    arc.raw_count);
                        }
#endif /* DEBUG */
                        tally(caller_mi, callee_mi, &arc);
                }
        }

#ifdef DEBUG
        puts("\n");
#endif /* DEBUG */
}

/*
 * Two modules overlap each other if they don't lie completely *outside*
 * each other.
 */
static bool
does_overlap(ProfModule *new, mod_info_t *old)
{
        /* case 1: new module lies completely *before* the old one */
        if (new->startaddr < old->load_base && new->endaddr <= old->load_base)
                return (FALSE);

        /* case 2: new module lies completely *after* the old one */
        if (new->startaddr >= old->load_end && new->endaddr >= old->load_end)
                return (FALSE);

        /* probably a dlopen: the modules overlap each other */
        return (TRUE);
}

static bool
is_same_as_aout(char *modpath, struct stat *buf)
{
        if (stat(modpath, buf) == -1) {
                (void) fprintf(stderr, "%s: can't get info on `%s'\n",
                    whoami, modpath);
                exit(EX_NOINPUT);
        }

        if ((buf->st_dev == aout_info.dev) && (buf->st_ino == aout_info.ino))
                return (TRUE);
        else
                return (FALSE);
}

static void
process_modules(ProfModuleList *modlp)
{
        ProfModule      *newmodp;
        mod_info_t      *mi, *last, *new_module;
        char            *so_path;
        bool            more_modules = TRUE;
        struct stat     so_statbuf;

#ifdef DEBUG
        if (debug & MODULEDEBUG) {
                (void) printf("[process_modules] module obj version %u\n",
                    modlp->version);
        }
#endif /* DEBUG */

        /* Check version of module type object */
        if (modlp->version > PROF_MODULES_VER) {
                (void) fprintf(stderr, "%s: version %d for module type objects"
                    "is not supported\n", whoami, modlp->version);
                exit(EX_SOFTWARE);
        }


        /*
         * Scan the PROF_MODULES_T list and add modules to current list
         * of modules, if they're not present already
         */
        /* LINTED: pointer cast */
        newmodp = (ProfModule *)((char *)modlp + modlp->modules);
        do {
                /*
                 * Since the prog could've been renamed after its run, we
                 * should see if this overlaps a.out. If it does, it is
                 * probably the renamed aout. We should also skip any other
                 * non-sharedobj's that we see (or should we report an error ?)
                 */
                so_path = (caddr_t)modlp + newmodp->path;
                if (does_overlap(newmodp, &modules) ||
                    is_same_as_aout(so_path, &so_statbuf) ||
                    (!is_shared_obj(so_path))) {

                        if (!newmodp->next)
                                more_modules = FALSE;

                        /* LINTED: pointer cast */
                        newmodp = (ProfModule *)
                            ((caddr_t)modlp + newmodp->next);
#ifdef DEBUG
                        if (debug & MODULEDEBUG) {
                                (void) printf(
                                    "[process_modules] `%s'\n", so_path);
                                (void) printf("                  skipped\n");
                        }
#endif /* DEBUG */
                        continue;
                }
#ifdef DEBUG
                if (debug & MODULEDEBUG)
                        (void) printf("[process_modules] `%s'...\n", so_path);
#endif /* DEBUG */

                /*
                 * Check all modules (leave the first one, 'cos that
                 * is the program executable info). If this module is already
                 * there in the list, update the load addresses and proceed.
                 */
                last = &modules;
                while ((mi = last->next) != NULL) {
                        /*
                         * We expect the full pathname for all shared objects
                         * needed by the program executable. In this case, we
                         * simply need to compare the paths to see if they are
                         * the same file.
                         */
                        if (strcmp(mi->name, so_path) == 0)
                                break;

                        /*
                         * Check if this new shared object will overlap
                         * any existing module. If yes, remove the old one
                         * from the linked list (but don't free it, 'cos
                         * there may be symbols referring to this module
                         * still)
                         */
                        if (does_overlap(newmodp, mi)) {
#ifdef DEBUG
                                if (debug & MODULEDEBUG) {
                                        (void) printf(
                                            "[process_modules] `%s'\n",
                                            so_path);
                                        (void) printf(
                                            "                  overlaps\n");
                                        (void) printf(
                                            "                  `%s'\n",
                                            mi->name);
                                }
#endif /* DEBUG */
                                mi->active = FALSE;
                        }

                        last = mi;
                }

                /* Module already there, skip it */
                if (mi != NULL) {
                        mi->load_base = newmodp->startaddr;
                        mi->load_end = newmodp->endaddr;
                        mi->active = TRUE;
                        if (!newmodp->next)
                                more_modules = FALSE;

                        /* LINTED: pointer cast */
                        newmodp = (ProfModule *)
                            ((caddr_t)modlp + newmodp->next);

#ifdef DEBUG
                        if (debug & MODULEDEBUG) {
                                (void) printf("[process_modules] base=%#llx, "
                                    "end=%#llx\n", mi->load_base, mi->load_end);
                        }
#endif /* DEBUG */
                        continue;
                }

                /*
                 * Check if gmon.out is outdated with respect to the new
                 * module we want to add
                 */
                if (gmonout_info.mtime < so_statbuf.st_mtime) {
                        (void) fprintf(stderr,
                            "%s: shared obj outdates prof info\n", whoami);
                        (void) fprintf(stderr, "\t(newer %s)\n", so_path);
                        exit(EX_NOINPUT);
                }

                /* Create a new module element */
                new_module = malloc(sizeof (mod_info_t));
                if (new_module == NULL) {
                        (void) fprintf(stderr, "%s: no room for %d bytes\n",
                            whoami, sizeof (mod_info_t));
                        exit(EX_OSERR);
                }

                /* and fill in info... */
                new_module->id = n_modules + 1;
                new_module->load_base = newmodp->startaddr;
                new_module->load_end = newmodp->endaddr;
                new_module->name = malloc(strlen(so_path) + 1);
                if (new_module->name == NULL) {
                        (void) fprintf(stderr, "%s: no room for %d bytes\n",
                            whoami, strlen(so_path) + 1);
                        exit(EX_OSERR);
                }
                (void) strcpy(new_module->name, so_path);
#ifdef DEBUG
                if (debug & MODULEDEBUG) {
                        (void) printf(
                            "[process_modules] base=%#llx, end=%#llx\n",
                            new_module->load_base, new_module->load_end);
                }
#endif /* DEBUG */

                /* Create this module's nameslist */
                process_namelist(new_module);

                /* Add it to the tail of active module list */
                last->next = new_module;
                n_modules++;

#ifdef DEBUG
                if (debug & MODULEDEBUG) {
                        (void) printf(
                            "[process_modules] total shared objects = %ld\n",
                            n_modules - 1);
                }
#endif /* DEBUG */
                /*
                 * Move to the next module in the PROF_MODULES_T list
                 * (if present)
                 */
                if (!newmodp->next)
                        more_modules = FALSE;

                /* LINTED: pointer cast */
                newmodp = (ProfModule *)((caddr_t)modlp + newmodp->next);

        } while (more_modules);
}

static void
reset_active_modules(void)
{
        mod_info_t      *mi;

        /* Except the executable, no other module should remain active */
        for (mi = modules.next; mi; mi = mi->next)
                mi->active = FALSE;
}

static void
getpfiledata(caddr_t memp, size_t fsz)
{
        ProfObject      *objp;
        caddr_t         file_end;
        bool            found_pcsamples = FALSE, found_cgraph = FALSE;

        /*
         * Before processing a new gmon.out, all modules except the
         * program executable must be made inactive, so that symbols
         * are searched only in the program executable, if we don't
         * find a MODULES_T object. Don't do it *after* we read a gmon.out,
         * because we need the active module data after we're done with
         * the last gmon.out, if we're doing summing.
         */
        reset_active_modules();

        file_end = memp + fsz;
        /* LINTED: pointer cast */
        objp = (ProfObject *)(memp + ((ProfHeader *)memp)->size);
        while ((caddr_t)objp < file_end) {
#ifdef DEBUG
                {
                        unsigned int    type = 0;

                        if (debug & MONOUTDEBUG) {
                                if (objp->type <= MAX_OBJTYPES)
                                        type = objp->type;

                                (void) printf(
                                    "\n[getpfiledata] object %s [%#lx]\n",
                                    objname[type], objp->type);
                        }
                }
#endif /* DEBUG */
                switch (objp->type) {
                        case PROF_MODULES_T :
                                process_modules((ProfModuleList *) objp);
                                break;

                        case PROF_CALLGRAPH_T :
                                process_cgraph((ProfCallGraph *) objp);
                                found_cgraph = TRUE;
                                break;

                        case PROF_BUFFER_T :
                                process_pcsamples((ProfBuffer *) objp);
                                found_pcsamples = TRUE;
                                break;

                        default :
                                (void) fprintf(stderr,
                                    "%s: unknown prof object type=%d\n",
                                    whoami, objp->type);
                                exit(EX_SOFTWARE);
                }
                /* LINTED: pointer cast */
                objp = (ProfObject *)((caddr_t)objp + objp->size);
        }

        if (!found_cgraph || !found_pcsamples) {
                (void) fprintf(stderr,
                    "%s: missing callgraph/pcsamples object\n", whoami);
                exit(EX_SOFTWARE);
        }

        if ((caddr_t)objp > file_end) {
                (void) fprintf(stderr, "%s: malformed profile file.\n", whoami);
                exit(EX_SOFTWARE);
        }

        if (first_file)
                first_file = FALSE;
}

static void
readarcs(FILE *pfile)
{
        /*
         *      the rest of the file consists of
         *      a bunch of <from,self,count> tuples.
         */
        /* CONSTCOND */
        while (1) {
                struct rawarc   arc;

                if (rflag) {
                        if (Bflag) {
                                L_cgarc64               rtld_arc64;

                                /*
                                 * If rflag is set then this is an profiled
                                 * image generated by rtld.  It needs to be
                                 * 'converted' to the standard data format.
                                 */
                                if (fread(&rtld_arc64,
                                    sizeof (L_cgarc64), 1, pfile) != 1)
                                        break;

                                if (rtld_arc64.cg_from == PRF_OUTADDR64)
                                        arc.raw_frompc = s_highpc + 0x10;
                                else
                                        arc.raw_frompc =
                                            (pctype)rtld_arc64.cg_from;
                                arc.raw_selfpc = (pctype)rtld_arc64.cg_to;
                                arc.raw_count = (actype)rtld_arc64.cg_count;
                        } else {
                                L_cgarc         rtld_arc;

                                /*
                                 * If rflag is set then this is an profiled
                                 * image generated by rtld.  It needs to be
                                 * 'converted' to the standard data format.
                                 */
                                if (fread(&rtld_arc,
                                    sizeof (L_cgarc), 1, pfile) != 1)
                                        break;

                                if (rtld_arc.cg_from == PRF_OUTADDR)
                                        arc.raw_frompc = s_highpc + 0x10;
                                else
                                        arc.raw_frompc = (pctype)
                                            (uintptr_t)rtld_arc.cg_from;
                                arc.raw_selfpc = (pctype)
                                    (uintptr_t)rtld_arc.cg_to;
                                arc.raw_count = (actype)rtld_arc.cg_count;
                        }
                } else {
                        if (Bflag) {
                                if (fread(&arc, sizeof (struct rawarc), 1,
                                    pfile) != 1) {
                                        break;
                                }
                        } else {
                                /*
                                 * If these aren't big %pc's, we need to read
                                 * into the 32-bit raw arc structure, and
                                 * assign the members into the actual arc.
                                 */
                                struct rawarc32 arc32;
                                if (fread(&arc32, sizeof (struct rawarc32),
                                    1, pfile) != 1)
                                        break;
                                arc.raw_frompc = (pctype)arc32.raw_frompc;
                                arc.raw_selfpc = (pctype)arc32.raw_selfpc;
                                arc.raw_count  = (actype)arc32.raw_count;
                        }
                }

#ifdef DEBUG
                if (debug & SAMPLEDEBUG) {
                        (void) printf("[getpfile] frompc 0x%llx selfpc "
                            "0x%llx count %lld\n", arc.raw_frompc,
                            arc.raw_selfpc, arc.raw_count);
                }
#endif /* DEBUG */
                /*
                 *      add this arc
                 */
                tally(&modules, &modules, &arc);
        }
        if (first_file)
                first_file = FALSE;
}

static void
readsamples(FILE *pfile)
{
        sztype          i;
        unsigned_UNIT   sample;

        if (samples == 0) {
                samples = (unsigned_UNIT *) calloc(nsamples,
                    sizeof (unsigned_UNIT));
                if (samples == 0) {
                        (void) fprintf(stderr,
                            "%s: No room for %d sample pc's\n",
                            whoami, sampbytes / sizeof (unsigned_UNIT));
                        exit(EX_OSERR);
                }
        }

        for (i = 0; i < nsamples; i++) {
                (void) fread(&sample, sizeof (unsigned_UNIT), 1, pfile);
                if (feof(pfile))
                        break;
                samples[i] += sample;
        }
        if (i != nsamples) {
                (void) fprintf(stderr,
                    "%s: unexpected EOF after reading %d/%d samples\n",
                    whoami, --i, nsamples);
                exit(EX_IOERR);
        }
}

static void *
handle_versioned(FILE *pfile, char *filename, size_t *fsz)
{
        int             fd;
        bool            invalid_version;
        caddr_t         fmem;
        struct stat     buf;
        ProfHeader      prof_hdr;
        off_t           lret;

        /*
         * Check versioning info. For now, let's say we provide
         * backward compatibility, so we accept all older versions.
         */
        if (fread(&prof_hdr, sizeof (ProfHeader), 1, pfile) == 0) {
                perror("fread()");
                exit(EX_IOERR);
        }

        invalid_version = FALSE;
        if (prof_hdr.h_major_ver > PROF_MAJOR_VERSION)
                invalid_version = TRUE;
        else if (prof_hdr.h_major_ver == PROF_MAJOR_VERSION) {
                if (prof_hdr.h_minor_ver > PROF_MINOR_VERSION)
                        invalid_version = FALSE;
        }

        if (invalid_version) {
                (void) fprintf(stderr, "%s: version %d.%d not supported\n",
                    whoami, prof_hdr.h_major_ver, prof_hdr.h_minor_ver);
                exit(EX_SOFTWARE);
        }

        /*
         * Map gmon.out onto memory.
         */
        (void) fclose(pfile);
        if ((fd = open(filename, O_RDONLY)) == -1) {
                perror(filename);
                exit(EX_IOERR);
        }

        if ((lret = lseek(fd, 0, SEEK_END)) == -1) {
                perror(filename);
                exit(EX_IOERR);
        }
        *fsz = lret;

        fmem = mmap(NULL, *fsz, PROT_READ, MAP_PRIVATE, fd, 0);
        if (fmem == MAP_FAILED) {
                (void) fprintf(stderr, "%s: can't map %s\n", whoami, filename);
                exit(EX_IOERR);
        }

        /*
         * Before we close this fd, save this gmon.out's info to later verify
         * if the shared objects it references have changed since the time
         * they were used to generate this gmon.out
         */
        if (fstat(fd, &buf) == -1) {
                (void) fprintf(stderr, "%s: can't get info on `%s'\n",
                    whoami, filename);
                exit(EX_NOINPUT);
        }
        gmonout_info.dev = buf.st_dev;
        gmonout_info.ino = buf.st_ino;
        gmonout_info.mtime = buf.st_mtime;
        gmonout_info.size = buf.st_size;

        (void) close(fd);

        return ((void *) fmem);
}

static void *
openpfile(char *filename, size_t *fsz)
{
        struct hdr      tmp;
        FILE            *pfile;
        unsigned long   magic_num;
        size_t          hdrsize;
        static bool     first_time = TRUE;
        extern bool     old_style;

        if ((pfile = fopen(filename, "r")) == NULL) {
                perror(filename);
                exit(EX_IOERR);
        }

        /*
         * Read in the magic. Note that we changed the cast "unsigned long"
         * to "unsigned int" because that's how h_magic is defined in the
         * new format ProfHeader.
         */
        if (fread(&magic_num, sizeof (unsigned int), 1, pfile) == 0) {
                perror("fread()");
                exit(EX_IOERR);
        }

        rewind(pfile);

        /*
         * First check if this is versioned or *old-style* gmon.out
         */
        if (magic_num == (unsigned int)PROF_MAGIC) {
                if ((!first_time) && (old_style == TRUE)) {
                        (void) fprintf(stderr, "%s: can't mix old & new format "
                            "profiled files\n", whoami);
                        exit(EX_SOFTWARE);
                }
                first_time = FALSE;
                old_style = FALSE;
                return (handle_versioned(pfile, filename, fsz));
        }

        if ((!first_time) && (old_style == FALSE)) {
                (void) fprintf(stderr, "%s: can't mix old & new format "
                    "profiled files\n", whoami);
                exit(EX_SOFTWARE);
        }

        first_time = FALSE;
        old_style = TRUE;
        fsz = 0;

        /*
         * Now, we need to determine if this is a run-time linker
         * profiled file or if it is a standard gmon.out.
         *
         * We do this by checking if magic matches PRF_MAGIC. If it
         * does, then this is a run-time linker profiled file, if it
         * doesn't, it must be a gmon.out file.
         */
        if (magic_num == (unsigned long)PRF_MAGIC)
                rflag = TRUE;
        else
                rflag = FALSE;

        hdrsize = Bflag ? sizeof (struct hdr) : sizeof (struct hdr32);

        if (rflag) {
                if (Bflag) {
                        L_hdr64         l_hdr64;

                        /*
                         * If the rflag is set then the input file is
                         * rtld profiled data, we'll read it in and convert
                         * it to the standard format (ie: make it look like
                         * a gmon.out file).
                         */
                        if (fread(&l_hdr64, sizeof (L_hdr64), 1, pfile) == 0) {
                                perror("fread()");
                                exit(EX_IOERR);
                        }
                        if (l_hdr64.hd_version != PRF_VERSION_64) {
                                (void) fprintf(stderr,
                                    "%s: expected version %d, "
                                    "got version %d when processing 64-bit "
                                    "run-time linker profiled file.\n",
                                    whoami, PRF_VERSION_64, l_hdr64.hd_version);
                                exit(EX_SOFTWARE);
                        }
                        tmp.lowpc = 0;
                        tmp.highpc = (pctype)l_hdr64.hd_hpc;
                        tmp.ncnt = hdrsize + l_hdr64.hd_psize;
                } else {
                        L_hdr           l_hdr;

                        /*
                         * If the rflag is set then the input file is
                         * rtld profiled data, we'll read it in and convert
                         * it to the standard format (ie: make it look like
                         * a gmon.out file).
                         */
                        if (fread(&l_hdr, sizeof (L_hdr), 1, pfile) == 0) {
                                perror("fread()");
                                exit(EX_IOERR);
                        }
                        if (l_hdr.hd_version != PRF_VERSION) {
                                (void) fprintf(stderr,
                                    "%s: expected version %d, "
                                    "got version %d when processing "
                                    "run-time linker profiled file.\n",
                                    whoami, PRF_VERSION, l_hdr.hd_version);
                                exit(EX_SOFTWARE);
                        }
                        tmp.lowpc = 0;
                        tmp.highpc = (pctype)(uintptr_t)l_hdr.hd_hpc;
                        tmp.ncnt = hdrsize + l_hdr.hd_psize;
                }
        } else {
                if (Bflag) {
                        if (fread(&tmp, sizeof (struct hdr), 1, pfile) == 0) {
                                perror("fread()");
                                exit(EX_IOERR);
                        }
                } else {
                        /*
                         * If we're not reading big %pc's, we need to read
                         * the 32-bit header, and assign the members to
                         * the actual header.
                         */
                        struct hdr32 hdr32;
                        if (fread(&hdr32, sizeof (hdr32), 1, pfile) == 0) {
                                perror("fread()");
                                exit(EX_IOERR);
                        }
                        tmp.lowpc = hdr32.lowpc;
                        tmp.highpc = hdr32.highpc;
                        tmp.ncnt = hdr32.ncnt;
                }
        }

        /*
         * perform sanity check on profiled file we've opened.
         */
        if (tmp.lowpc >= tmp.highpc) {
                if (rflag)
                        (void) fprintf(stderr,
                            "%s: badly formed profiled data.\n",
                            filename);
                else
                        (void) fprintf(stderr,
                            "%s: badly formed gmon.out file.\n",
                            filename);
                exit(EX_SOFTWARE);
        }

        if (s_highpc != 0 && (tmp.lowpc != h.lowpc ||
            tmp.highpc != h.highpc || tmp.ncnt != h.ncnt)) {
                (void) fprintf(stderr,
                    "%s: incompatible with first gmon file\n",
                    filename);
                exit(EX_IOERR);
        }
        h = tmp;
        s_lowpc = h.lowpc;
        s_highpc = h.highpc;
        lowpc = h.lowpc / sizeof (UNIT);
        highpc = h.highpc / sizeof (UNIT);
        sampbytes = h.ncnt > hdrsize ? h.ncnt - hdrsize : 0;
        nsamples = sampbytes / sizeof (unsigned_UNIT);

#ifdef DEBUG
        if (debug & SAMPLEDEBUG) {
                (void) printf("[openpfile] hdr.lowpc 0x%llx hdr.highpc "
                    "0x%llx hdr.ncnt %lld\n",
                    h.lowpc, h.highpc, h.ncnt);
                (void) printf(
                    "[openpfile]   s_lowpc 0x%llx   s_highpc 0x%llx\n",
                    s_lowpc, s_highpc);
                (void) printf(
                    "[openpfile]     lowpc 0x%llx     highpc 0x%llx\n",
                    lowpc, highpc);
                (void) printf("[openpfile] sampbytes %d nsamples %d\n",
                    sampbytes, nsamples);
        }
#endif /* DEBUG */

        return ((void *) pfile);
}

/*
 * Information from a gmon.out file depends on whether it's versioned
 * or non-versioned, *old style* gmon.out. If old-style, it is in two
 * parts : an array of sampling hits within pc ranges, and the arcs. If
 * versioned, it contains a header, followed by any number of
 * modules/callgraph/pcsample_buffer objects.
 */
static void
getpfile(char *filename)
{
        void            *handle;
        size_t          fsz;

        handle = openpfile(filename, &fsz);

        if (old_style) {
                readsamples((FILE *)handle);
                readarcs((FILE *)handle);
                (void) fclose((FILE *)handle);
                return;
        }

        getpfiledata((caddr_t)handle, fsz);
        (void) munmap(handle, fsz);
}

int
main(int argc, char **argv)
{
        char    **sp;
        nltype  **timesortnlp;
        int             c;
        int             errflg;

        prog_name = *argv;  /* preserve program name */
        debug = 0;
        nflag = FALSE;
        bflag = TRUE;
        lflag = FALSE;
        Cflag = FALSE;
        first_file = TRUE;
        rflag = FALSE;
        Bflag = FALSE;
        errflg = FALSE;

        while ((c = getopt(argc, argv, "abd:CcDE:e:F:f:ln:sz")) != EOF)
                switch (c) {
                case 'a':
                        aflag = TRUE;
                        break;
                case 'b':
                        bflag = FALSE;
                        break;
                case 'c':
                        cflag = TRUE;
                        break;
                case 'C':
                        Cflag = TRUE;
                        break;
                case 'd':
                        dflag = TRUE;
                        debug |= atoi(optarg);
                        (void) printf("[main] debug = 0x%x\n", debug);
                        break;
                case 'D':
                        Dflag = TRUE;
                        break;
                case 'E':
                        addlist(Elist, optarg);
                        Eflag = TRUE;
                        addlist(elist, optarg);
                        eflag = TRUE;
                        break;
                case 'e':
                        addlist(elist, optarg);
                        eflag = TRUE;
                        break;
                case 'F':
                        addlist(Flist, optarg);
                        Fflag = TRUE;
                        addlist(flist, optarg);
                        fflag = TRUE;
                        break;
                case 'f':
                        addlist(flist, optarg);
                        fflag = TRUE;
                        break;
                case 'l':
                        lflag = TRUE;
                        break;
                case 'n':
                        nflag = TRUE;
                        number_funcs_toprint = atoi(optarg);
                        break;
                case 's':
                        sflag = TRUE;
                        break;
                case 'z':
                        zflag = TRUE;
                        break;
                case '?':
                        errflg++;

                }

        if (errflg) {
                (void) fprintf(stderr,
                    "usage: gprof [ -abcCDlsz ] [ -e function-name ] "
                    "[ -E function-name ]\n\t[ -f function-name ] "
                    "[ -F function-name  ]\n\t[  image-file  "
                    "[ profile-file ... ] ]\n");
                exit(EX_USAGE);
        }

        if (optind < argc) {
                a_outname  = argv[optind++];
        } else {
                a_outname  = A_OUTNAME;
        }
        if (optind < argc) {
                gmonname = argv[optind++];
        } else {
                gmonname = GMONNAME;
        }
        /*
         *      turn off default functions
         */
        for (sp = &defaultEs[0]; *sp; sp++) {
                Eflag = TRUE;
                addlist(Elist, *sp);
                eflag = TRUE;
                addlist(elist, *sp);
        }
        /*
         *      how many ticks per second?
         *      if we can't tell, report time in ticks.
         */
        hz = sysconf(_SC_CLK_TCK);
        if (hz == -1) {
                hz = 1;
                (void) fprintf(stderr, "time is in ticks, not seconds\n");
        }

        getnfile(a_outname);

        /*
         *      get information about mon.out file(s).
         */
        do {
                getpfile(gmonname);
                if (optind < argc)
                        gmonname = argv[optind++];
                else
                        optind++;
        } while (optind <= argc);
        /*
         *      dump out a gmon.sum file if requested
         */
        if (sflag || Dflag)
                dumpsum(GMONSUM);

        if (old_style) {
                /*
                 *      assign samples to procedures
                 */
                asgnsamples();
        }

        /*
         *      assemble the dynamic profile
         */
        timesortnlp = doarcs();

        /*
         *      print the dynamic profile
         */
#ifdef DEBUG
        if (debug & ANYDEBUG) {
                /* raw output of all symbols in all their glory */
                int i;
                (void) printf(" Name, pc_entry_pt, svalue, tix_in_routine, "
                    "#calls, selfcalls, index \n");
                for (i = 0; i < modules.nname; i++) {   /* Print each symbol */
                        if (timesortnlp[i]->name)
                                (void) printf(" %s ", timesortnlp[i]->name);
                        else
                                (void) printf(" <cycle> ");
                        (void) printf(" %lld ", timesortnlp[i]->value);
                        (void) printf(" %lld ", timesortnlp[i]->svalue);
                        (void) printf(" %f ", timesortnlp[i]->time);
                        (void) printf(" %lld ", timesortnlp[i]->ncall);
                        (void) printf(" %lld ", timesortnlp[i]->selfcalls);
                        (void) printf(" %d ", timesortnlp[i]->index);
                        (void) printf(" \n");
                }
        }
#endif /* DEBUG */

        printgprof(timesortnlp);
        /*
         *      print the flat profile
         */
        printprof();
        /*
         *      print the index
         */
        printindex();

        /*
         * print the modules
         */
        printmodules();

        done();
        /* NOTREACHED */
        return (0);
}