/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*      Copyright (c) 1988 AT&T */
/*        All Rights Reserved   */

/* Copyright 2011 Nexenta Systems, Inc. All rights reserved. */


/* ------------------------------------------------------------------------ */
/* include headers */
/* ------------------------------------------------------------------------ */

#include "static_prof.h"

/* ========== elf_hash ==================================================== */
/*
 * DESCRIPTION:
 * The hash function copied from libelf.so.1
 */
/* ======================================================================== */

static unsigned long
my_elf_hash(const char *name)
{
        unsigned long g, h = 0;
        const unsigned char *nm = (unsigned char *) name;

        while (*nm != '\0') {
                h = (h << 4) + *nm++;
                if ((g = h & MASK) != 0)
                        h ^= g >> 24;
                h &= ~MASK;
        }
        return (h);
}

/* ========== output_dtneeded ============================================= */
/*
 * DESCRIPTION:
 * Outputs all the dt_needed entries if any.
 */
/* ======================================================================== */

static void
output_dtneeded(dt_list * list)
{

        dt_list         *p = list;

        (void) fprintf(OUTPUT_FD, "#dtneeded:");
        if (!p) {
                (void) fprintf(OUTPUT_FD, "\n");
                return;
        } else {
                while (p != NULL) {
                        (void) fprintf(OUTPUT_FD,
                            " %s",
                            p->libname);
                        p = p->next;
                }
                (void) fprintf(OUTPUT_FD, "\n");
        }
}

/* ========== store_binding =============================================== */
/*
 * DESCRIPTION:
 * Read in the symbol binding information from the symbol table and
 * store them into the hash table of buckets.
 */
/* ======================================================================== */

static void
store_binding(binding_bucket * bind)
{
        unsigned long   bktno;
        unsigned long   orig_bktno;

        bktno = my_elf_hash(bind->sym) % DEFBKTS;
        orig_bktno = bktno;

        while (bkts[bktno].sym != NULL) {
                bktno = (bktno + 1) % DEFBKTS;

                if (bktno == orig_bktno)
                        exit(1);
        }

        bkts[bktno].sym = bind->sym;
        bkts[bktno].obj = bind->obj;
        bkts[bktno].ref_lib = bind->ref_lib;
        bkts[bktno].def_lib = bind->def_lib;
        bkts[bktno].section = bind->section;
        bkts[bktno].stbind = bind->stbind;
        bkts[bktno].sttype = bind->sttype;
}


/* ========== check_store_binding ========================================= */
/*
 * DESCRIPTION:
 * Check what's already on the hash table with the new symbol binding
 * information from the dependencies and record it into the bucket.
 */
/* ======================================================================== */

static void
check_store_binding(binding_bucket * bind)
{
        unsigned long   bktno;
        unsigned long   orig_bktno;
        unsigned long   i;

        bktno = my_elf_hash(bind->sym) % DEFBKTS;
        orig_bktno = bktno;

        if (!bkts[bktno].sym)
                return;
        if (bkts[bktno].sym && (strcmp(bkts[bktno].sym, bind->sym)) == 0) {
                if (strcmp(bkts[bktno].ref_lib, "<Unknown>") == 0)
                        if (strcmp(bkts[bktno].obj, bind->obj))
                                bkts[bktno].ref_lib = bind->obj;
        } else {
                bktno = (bktno + 1) % DEFBKTS;
                for (i = bktno; i < DEFBKTS; i = (i + 1) % DEFBKTS) {
                        if (i == orig_bktno)
                                break;
                        if (!bkts[i].sym)
                                continue;
                        if (bkts[i].sym &&
                            (strcmp(bkts[i].sym, bind->sym)) == 0) {
                                if (strcmp(bkts[i].ref_lib, "<Unknown>") == 0)
                                        if (strcmp(bkts[i].obj, bind->obj))
                                                bkts[i].ref_lib = bind->obj;
                                break;
                        }
                }
        }
}

/* ========== stringcompare =============================================== */
/*
 * DESCRIPTION:
 * Compares two strings for qsort().
 */
/* ======================================================================== */

static int
stringcompare(binding_bucket * a,
    binding_bucket * b)
{
        char            *x = "\0";
        char            *y = "\0";
        int             retcode;

        if (a->sym)
                x = a->sym;

        if (b->sym)
                y = b->sym;

        retcode = strcoll(x, y);
        return (retcode);
}

/* ========== profile_binding ============================================= */
/*
 * DESCRIPTION:
 * Output the bindings directly to stdout or a file.
 */
/* ======================================================================== */

static void
profile_binding(binding_bucket * bind)
{
        char            *ref_lib_ptr;

        if (bind->sym && strcmp(bind->ref_lib, "<Unknown>")) {
                if (ref_lib_ptr = strrchr(bind->ref_lib, (int)'/')) {
                        ref_lib_ptr++;
                        if (bind->stbind)
                                (void) fprintf(OUTPUT_FD,
                                    "%s|%s|%s|%s|%s|%s|%s\n",
                                    ref_lib_ptr,
                                    bind->section,
                                    bind->stbind,
                                    bind->sttype,
                                    bind->sym,
                                    bind->def_lib,
                                    bind->obj);
                } else if (bind->stbind)
                        (void) fprintf(OUTPUT_FD,
                            "%s|%s|%s|%s|%s|%s|%s\n",
                            bind->ref_lib,
                            bind->section,
                            bind->stbind,
                            bind->sttype,
                            bind->sym,
                            bind->def_lib,
                            bind->obj);
        } else if (bind->sym && bind->stbind)
                (void) fprintf(OUTPUT_FD,
                    "%s|%s|%s|%s|%s\n",
                    bind->obj,
                    bind->section,
                    bind->stbind,
                    bind->sttype,
                    bind->sym);
}

/* ========== output_binding ============================================== */
/*
 * DESCRIPTION:
 * Output the hash table to either stdout or a file.
 */
/* ======================================================================== */

static void
output_binding(char *prog_name,
    char *target)
{
        int             i;
        char            *ref_lib_ptr;

        qsort(bkts,
            DEFBKTS,
            sizeof (binding_bucket),
            (int (*) (const void *, const void *)) stringcompare);

        if (oflag) {
                if ((OUTPUT_FD = fopen(outputfile, "w")) == NULL) {
                        if (sflag)
                                (void) fprintf(stderr,
                                    "\nfopen failed to open <%s>...\n\n",
                                    outputfile);
                        exit(1);
                }
        }
        /* generates profile report */
        (void) fprintf(OUTPUT_FD,
            "#generated by %s\n",
            prog_name);
        (void) fprintf(OUTPUT_FD,
            "#profiling symbols in .text section of %s\n",
            target);
        output_dtneeded(dt_needed);

        for (i = 0; i < DEFBKTS; i++) {
                if (bkts[i].sym && strcmp(bkts[i].ref_lib, "<Unknown>")) {
                        if (ref_lib_ptr = strrchr(bkts[i].ref_lib, (int)'/')) {
                                ref_lib_ptr++;
                                if (bkts[i].stbind)
                                        (void) fprintf(OUTPUT_FD,
                                            "%s|%s|%s|%s|%s|%s|%s\n",
                                            ref_lib_ptr,
                                            bkts[i].section,
                                            bkts[i].stbind,
                                            bkts[i].sttype,
                                            bkts[i].sym,
                                            bkts[i].def_lib,
                                            bkts[i].obj);
                        } else if (bkts[i].stbind)
                                (void) fprintf(OUTPUT_FD,
                                    "%s|%s|%s|%s|%s|%s|%s\n",
                                    bkts[i].ref_lib,
                                    bkts[i].section,
                                    bkts[i].stbind,
                                    bkts[i].sttype,
                                    bkts[i].sym,
                                    bkts[i].def_lib,
                                    bkts[i].obj);
                } else if (bkts[i].sym && bkts[i].stbind)
                        (void) fprintf(OUTPUT_FD,
                            "%s|%s|%s|%s|%s\n",
                            bkts[i].obj,
                            bkts[i].section,
                            bkts[i].stbind,
                            bkts[i].sttype,
                            bkts[i].sym);
        }
}

/* ========== obj_init ==================================================== */
/*
 * DESCRIPTION:
 * Open (object) file, get ELF descriptor, and verify that the file is
 * an ELF file.
 */
/* ======================================================================== */

static int
obj_init(obj_list * c)
{
        int             mode = O_RDONLY;

        /* open the file */
        if ((c->obj->fd = open(c->obj->ename, mode)) < 0) {
                if (sflag) {
                        if (errno == ENOENT)
                                (void) fprintf(stderr,
                                    "Cannot open <<%s>> : \
                                    No such file or directory.\n",
                                    c->obj->ename);
                        else if (errno == EMFILE)
                                (void) fprintf(stderr,
                                    "File <<%s>> : Already opened.\n",
                                    c->obj->ename);
                }
                c->obj->fd = 0;
                return (FAIL);
        }
        /*
         * queries the ELF library's internal version.
         * Passing ver equal to EV_NONE causes elf_version() to return
         * the library's internal version, without altering the working
         * version.  If ver is a version known to the library,
         * elf_version() returns the previous or initial working
         * version number.  Otherwise, the working version remains
         * unchanged and elf_version() returns EV_NONE.
         */

        /* check if libelf.so is at the right level */
        if (elf_version(EV_CURRENT) == EV_NONE) {
                if (sflag)
                        (void) fprintf(stderr,
                            "Library out of date in ELF access routines.\n");
                return (FAIL);
        }
        /*
         * Before the first call to elf_begin(), it must call
         * elf_version() to coordinate versions.
         */

        /*
         * get elf descriptor just to examine the contents of an existing
         * file
         */
        if ((c->obj->elf = elf_begin(c->obj->fd, ELF_C_READ, (Elf *) 0))
            == (Elf *) 0) {
                if (sflag)
                        (void) fprintf(stderr,
                            "File is not in executable and \
                            linking format(ELF).\n");
                return (FAIL);
        }
        /* Rule out COFF, a.out and shell script files */
        if (elf_kind(c->obj->elf) == ELF_K_COFF) {
                if (sflag) {
                        (void) fprintf(stderr,
                            "File is not in executable \
                            and linking format(ELF) or archive.\n");
                }
                return (FAIL);
        }
        if (elf_kind(c->obj->elf) != ELF_K_AR &&
            elf_kind(c->obj->elf) != ELF_K_ELF) {
                if (sflag) {
                        (void) fprintf(stderr,
                            "File is not in executable and linking \
                            format(ELF) or archive.\n");
                }
                return (FAIL);
        }
        return (SUCCEED);
}

/* ========== obj_elf_hdr ================================================= */
/*
 * DESCRIPTION:
 * Obtain the elf header, verify elf header information
 */
/* ======================================================================== */

static int
obj_elf_hdr(obj_list * c)
{
#if     defined(_LP64)
        Elf64_Ehdr      *ptr;
#else
        Elf32_Ehdr      *ptr;
#endif

        /*
         * get the elf header if one is available for the ELF descriptor
         * c->elf
         */
#if     defined(_LP64)
        if ((ptr = elf64_getehdr(c->obj->elf)) == (Elf64_Ehdr *) 0) {
                if (sflag)
                        (void) fprintf(stderr,
                            "File is not in 64-bit format.\n");
                return (FAIL);
        }
#else
        if ((ptr = elf32_getehdr(c->obj->elf)) == (Elf32_Ehdr *) 0) {
                if (sflag)
                        (void) fprintf(stderr,
                            "File is not in 32-bit format.\n");
                return (FAIL);
        }
#endif

        /* if there is elf header, save the pointer */
#if defined(_LP64)
        c->obj->ehdr = (Elf64_Ehdr *) ptr;
#else
        c->obj->ehdr = (Elf32_Ehdr *) ptr;
#endif

        /* e_ident[] is identification index which holds values */
        /*
         * we could also use elf_getident() to retrieve file identification
         * data.
         */

        /*
         * e_ident[EI_CLASS] identifies the file's class:
         * ELFCLASSNONE - invalid class
         * ELFCLASS32   - 32-bit objects
         * ELFCLASS64   - 64-bit objects
         */

#if     defined(_LP64)
        if (ptr->e_ident[EI_CLASS] != ELFCLASS64) {
                if (sflag)
                        (void) fprintf(stderr,
                            "File is not in 64-bit format.\n");
                return (FAIL);
        }
#else
        if (ptr->e_ident[EI_CLASS] != ELFCLASS32) {
                if (sflag)
                        (void) fprintf(stderr,
                            "File is not in 32-bit format.\n");
                return (FAIL);
        }
#endif
        /*
         * e_ident[EI_DATA] specifies the data encoding of the
         * processor-specific data in the object file:
         * ELFDATANONE - invalid data encoding
         * ELFDATA2LSB - specifies 2's complement values, with the least
         * significant byte occupying the lowest address
         * ELFDATA2MSB - specifies 2's complement values, with the most
         * significant byte occupying the lowest address
         */

        /*
         * e_ident[EI_VERSION] specifies the ELF header version number.
         * Currently, this value must be EV_CURRENT.
         */

        if (!(ptr->e_ident[EI_VERSION] == EV_CURRENT) &&
            (ptr->e_version == EV_CURRENT)) {
                if (sflag)
                        (void) fprintf(stderr,
                            "File is recorded in an \
                            incompatible ELF version.\n");
                return (FAIL);
        }
        /* only interested in relocatable, shared object, or executable file */
        switch (ptr->e_type) {
        case ET_REL:
        case ET_EXEC:
        case ET_DYN:
                break;
        default:
                if (sflag) {
                        (void) fprintf(stderr,
                            "File is not relocatable, ");
                        (void) fprintf(stderr,
                            "executable, or shared object.\n");
                }
                return (FAIL);
        }

        /*
         * e_machine's value specifies the required architecture for an
         * individual file
         */

#if defined(__sparcv9)
        if (ptr->e_machine != EM_SPARCV9) {
                if (sflag)
                        (void) fprintf(stderr,
                            "File is not for 64-bit \
                            SPARC machine architecture.\n");
                return (FAIL);
        }
#elif defined(__amd64)
        if (ptr->e_machine != EM_AMD64) {
                if (sflag)
                        (void) fprintf(stderr,
                            "File is not for 64-bit \
                            amd64 machine architecture.\n");
                return (FAIL);
        }
#elif defined(__i386)
        if (ptr->e_machine != EM_386) {
                if (sflag)
                        (void) fprintf(stderr,
                            "File is not for 32-bit \
                            i386 machine architecture.\n");
                return (FAIL);
        }
#else
        if (ptr->e_machine != EM_SPARC) {
                if (sflag)
                        (void) fprintf(stderr,
                            "File is not for 32-bit \
                            SPARC machine architecture.\n");
                return (FAIL);
        }
#endif
        return (SUCCEED);
}

/* ========== obj_prog_hdr ============================================= */
/*
 * DESCRIPTION:
 * For executable files and shared objects only, check if it has
 * a program header table.
 */
/* ===================================================================== */

static int
obj_prog_hdr(obj_list * c)
{
        /*
         * Assume:  the elf header has already been read, and the file
         * has already been determined to be
         * executable, shared object, or relocatable
         */

        /*
         * Program headers are meaningful only for executable and shared
         * object files.  It is an array of structures, each describing a
         * segment or other information needs to prepare the program for
         * execution.
         */

        /* skip if file is not executable or shared object */
        /* e_type == ET_REL meaning Relocatable file */
        if (c->obj->ehdr->e_type == ET_REL)
                return (SUCCEED);

        /*
         * ehdr->e_phoff holds the program header table's file offset in
         * bytes.
         */
        /* If the file has no program header table, this member holds zero. */
        /*
         * ehdr->e_phnum holds the number of entries in the program header
         * table.
         */
        /*
         * If a file has no program header table, e_phnum holds the value
         * zero.
         */

        /* make sure there's a program header table */
        if ((c->obj->ehdr->e_phoff == 0) ||
            (c->obj->ehdr->e_phnum == 0)) {
                if (sflag)
                        (void) fprintf(stderr,
                            "File has no program header table.\n");
                return (FAIL);
        }
        return (SUCCEED);
}

/* ========== find_dynamic_sect ========================================== */
/*
 * DESCRIPTION:
 * Find the dynamic section.
 */
/* ======================================================================= */

static int
find_dynamic_sect(obj_list * c)
{
#if     defined(_LP64)
        Elf64_Shdr      *scurrent;      /* temp 64 bit section pointer */
#else
        Elf32_Shdr      *scurrent;      /* temp 32 bit section pointer */
#endif
        Elf_Scn         *scn;   /* temp section header pointer */
        Elf_Data        *ddata; /* temp data header pointer */
        size_t          index;  /* temp section header table index */

        c->obj->dynnames = NULL; /* init of dynamic string table ptr */
        c->obj->dynsect = NULL; /* init of dynamic section ptr */
        c->obj->ddata = NULL;   /* init of dynamic strtab data ptr */

        /* only process executables and shared objects */
        if (c->obj->ehdr->e_type != ET_EXEC && c->obj->ehdr->e_type != ET_DYN)
                return (SUCCEED);

        if ((c->obj->ehdr->e_shoff == 0) || (c->obj->ehdr->e_shnum == 0)) {
                /* there are no sections */
                return (SUCCEED);
        }
        /* search the section header table for dynamic section */

        /* start with null section; section index = 0 */
        scn = 0;

        while ((scn = elf_nextscn(c->obj->elf, scn)) != 0) {
                /* retrieve the section header */
#if     defined(_LP64)
                scurrent = elf64_getshdr(scn);
#else
                scurrent = elf32_getshdr(scn);
#endif

                /* check for dynamic section; (i.e., .dynamic) */
                if (scurrent->sh_type == SHT_DYNAMIC) {
                        ddata = 0;
                        if ((ddata = elf_getdata(scn, ddata)) == 0 ||
                            (ddata->d_size == 0))
                                return (SUCCEED);

                        /* now, we got data of dynamic section */
                        c->obj->dynsect = ddata->d_buf;

                        /* index to section header for dynamic string table */
                        index = scurrent->sh_link;
                        /* get scn descriptor of dynamic string table */
                        scn = elf_getscn(c->obj->elf, index);
                        /* get dynamic string table section header */
#if     defined(_LP64)
                        scurrent = elf64_getshdr(scn);
#else
                        scurrent = elf32_getshdr(scn);
#endif
                        /* get the dynamic string table data descriptor */
                        c->obj->ddata = elf_getdata(scn, (c->obj->ddata));
                        /* save the pointer to dynamic string table data */
                        c->obj->dynnames = c->obj->ddata->d_buf;
                        /*
                         * now, we got dynamic strtab and dynamic section
                         * information
                         */
                        break;
                }
        }
        return (SUCCEED);
}

/* ========== find_symtabs ================================================ */
/*
 * DESCRIPTION:
 * Find and check symbol tables for an application file
 */
/* ======================================================================== */

static int
find_symtabs(obj_list * c)
{
#if     defined(_LP64)
        Elf64_Shdr      *shdr;
#else
        Elf32_Shdr      *shdr;
#endif
        Elf_Scn         *scn, *scn2;
        Elf_Data        *data;

        c->obj->sym_tab = NULL;
        c->obj->sym_num = 0;
        c->obj->sym_names = NULL;
        c->obj->dsym_tab = NULL;
        c->obj->dsym_num = 0;
        c->obj->dsym_names = NULL;
        c->obj->sym_data = NULL;
        c->obj->dsym_data = NULL;
        scn = 0;

        /*
         * loop through the section header table looking for symbol tables.
         * There must be one or two:  .symtab and .dynsym
         * upon finding a symbol table, save its pointer in obj_com.
         */

        /* get section descriptor */
        while ((scn = elf_nextscn(c->obj->elf, scn)) != 0) {
#if     defined(_LP64)
                Elf64_Sym       *syms;
#else
                Elf32_Sym       *syms;
#endif
                int             symn;
                char            *strs;

                /* point to section header */
#if     defined(_LP64)
                shdr = elf64_getshdr(scn);
#else
                shdr = elf32_getshdr(scn);
#endif

                if (shdr == 0)
                        return (FAIL);

                /* skip if this section is not a symbol table */
                if ((shdr->sh_type != SHT_DYNSYM) &&
                    (shdr->sh_type != SHT_SYMTAB))
                        continue;

                /* get data descriptor for the symbol table itself */
                data = elf_getdata(scn, NULL);
                if (data == NULL)
                        continue;

                /* save pointer to symbol table */
#if     defined(_LP64)
                syms = (Elf64_Sym *) data->d_buf;
#else
                syms = (Elf32_Sym *) data->d_buf;
#endif

                /*
                 * now start looking for the string table associated with
                 * this symbol table section
                 */

                /* get section descriptor first */
                scn2 = elf_getscn(c->obj->elf, shdr->sh_link);
                if (scn2 == NULL)
                        continue;

                /* get data descriptor for the string table section */
                data = elf_getdata(scn2, NULL);
                if (data == NULL)
                        continue;

                /* save pointer to name string table */
                strs = data->d_buf;
                symn = shdr->sh_size / shdr->sh_entsize;

                /* save information in obj_com */
                if (shdr->sh_type == SHT_SYMTAB) {
                        c->obj->sym_tab = syms;
                        c->obj->sym_num = symn;
                        c->obj->sym_names = strs;
                        c->obj->sym_data = data;
                } else {        /* must be the dynamic linking symbol table */
                        c->obj->dsym_tab = syms;
                        c->obj->dsym_num = symn;
                        c->obj->dsym_names = strs;
                        c->obj->dsym_data = data;
                }               /* end if */
        }                       /* end while */
        return (SUCCEED);
}

/* ========== obj_app_symtab ============================================== */
/*
 * DESCRIPTION:
 * Check existence of application's symbol tables.
 */
/* ======================================================================== */

static int
obj_app_symtab(obj_list * c)
{
        /* issue error if a relocatable file has no symbol table */
        if (c->obj->sym_tab == NULL) {
                if (c->obj->ehdr->e_type == ET_REL) {
                        if (sflag)
                                (void) fprintf(stderr,
                                    "ELF error: no symbol \
                                    table in object file.\n");
                        return (FAIL);
                } else {
                        if (c->obj->dsym_tab == NULL) {
                                if (sflag) {
                                        (void) fprintf(stderr,
                                            "Warning: Binary is \
                                            completely statically \
                                            linked and stripped.\n");
                                }
                                return (FAIL);
                        }
                        if (sflag)
                                (void) fprintf(stderr,
                                    "Binary is stripped.\n");
                }
        }
        return (SUCCEED);
}

/* ========== obj_finis =================================================== */
/*
 * DESCRIPTION:
 * It checks the c->fd and c->elf pointers.  If they are not NULL,
 * close the file descriptor and ELF descriptor.
 */
/* ======================================================================== */

static void
obj_finis(obj_list * c)
{
        obj_list        *p;

        if (c) {
                while (c) {
                        if (c->obj->elf != (Elf *) 0)
                                (void) elf_end(c->obj->elf);
                        if (c->obj->fd != 0)
                                (void) close(c->obj->fd);
                        p = c;
                        c = c->next;
                        free(p->obj);
                        free(p);
                }
        }
}

/* ========= is_text_section ============================================== */
/*
 * DESCRIPTION:
 * Scan through every section and returns TRUE(1) if the given section
 * is ".text", otherwise, returns FALSE(0).
 * INPUTS:        shndx - section header index
 * elf_file - ELF descriptor of the object file under test
 * ehdr - ELF header of the object file under test
 */
/* ======================================================================== */

static int
is_text_section(int shndx,
    Elf * elf_file,
#if     defined(_LP64)
    Elf64_Ehdr * ehdr)
#else
    Elf32_Ehdr * ehdr)
#endif
{
        char            *sym_name;
        Elf_Scn         *scn = elf_getscn(elf_file, shndx);

        if (scn != NULL) {
#if     defined(_LP64)
                Elf64_Shdr      *shdr;
                shdr = elf64_getshdr(scn);
#else
                Elf32_Shdr      *shdr;
                shdr = elf32_getshdr(scn);
#endif
                sym_name = elf_strptr(elf_file,
                                    ehdr->e_shstrndx,
                                    shdr->sh_name);
                if (strcmp(sym_name, ".text") == 0)
                        return (1);
        }
        return (0);
}

/* ========== scan_archive_symbols ======================================= */
/*
 * DESCRIPTION:
 * Scan through the archive symbol tables and write them out.
 * INPUTS:        syms - pointer to application symbol table
 * symn - number of entries in application symbol table
 * buf  - first byte of application string table
 */
/* ======================================================================= */

static void
scan_archive_symbols(obj_list * c,
#if     defined(_LP64)
    Elf64_Sym * syms,
#else
    Elf32_Sym * syms,
#endif
    int symn,
    char *buf,
    Elf * elf_file,
#if     defined(_LP64)
    Elf64_Ehdr * ehdr)
#else
    Elf32_Ehdr * ehdr)
#endif
{
#if     defined(_LP64)
        Elf64_Sym       *symtab_entry;
#else
        Elf32_Sym       *symtab_entry;
#endif
        int             i;
        char            *sym_name;
        int             sttype;
        int             stbind;

        symtab_entry = syms;
        for (i = 0; i < symn; i++, symtab_entry++) {
                binding_bucket *binding;
                /* look only at .text section symbols */
                if (!is_text_section(symtab_entry->st_shndx, elf_file, ehdr))
                        continue;

                /* look only at weak and global symbols */
#if     defined(_LP64)
                stbind = ELF64_ST_BIND(symtab_entry->st_info);
#else
                stbind = ELF32_ST_BIND(symtab_entry->st_info);
#endif
                if (stbind != STB_GLOBAL) {
                        if (stbind != STB_WEAK)
                                continue;
                }
                /* look only at functions and objects */
#if     defined(_LP64)
                sttype = ELF64_ST_TYPE(symtab_entry->st_info);
#else
                sttype = ELF32_ST_TYPE(symtab_entry->st_info);
#endif
                if (sttype != STT_FUNC) {
                        if (sttype != STT_OBJECT)
                                continue;
                }
                sym_name = buf + symtab_entry->st_name;
                binding = (struct binding_bucket *)
                            malloc(sizeof (binding_bucket));
                binding->sym = sym_name;
                binding->obj = c->obj->ename;
                binding->section = "TEXT";
                binding->ref_lib = "<Unknown>";
                binding->def_lib = "*DIRECT*";
                if (stbind == STB_GLOBAL)
                        binding->stbind = "GLOB";
                else if (stbind == STB_WEAK)
                        binding->stbind = "WEAK";
                if (sttype == STT_FUNC)
                        binding->sttype = "FUNC";
                else if (sttype == STT_OBJECT)
                        binding->sttype = "OBJT";
                if (pflag)
                        profile_binding(binding);
                else
                        store_binding(binding);
        }                       /* end for */
}

/* ========== scan_symbols ================================================ */
/*
 * DESCRIPTION:
 * Scan through the symbol table and write them out.
 * INPUTS:        syms - pointer to application symbol table
 * symn - number of entries in application symbol table
 * buf  - first byte of application string table
 */
/* ======================================================================== */

static void
scan_symbols(obj_list * c,
#if     defined(_LP64)
    Elf64_Sym * syms,
#else
    Elf32_Sym * syms,
#endif
    int symn,
    char *buf)
{
#if     defined(_LP64)
        Elf64_Sym       *symtab_entry;
#else
        Elf32_Sym       *symtab_entry;
#endif
        int             i;
        char            *sym_name;
        int             sttype;
        int             stbind;

        symtab_entry = syms;
        if (pflag) {
                (void) fprintf(OUTPUT_FD,
                    "#profiling symbols in .text section of %s\n",
                    c->obj->ename);
                output_dtneeded(dt_needed);
        }
        for (i = 0; i < symn; i++, symtab_entry++) {
                binding_bucket *binding;
                /* look only at .text section symbols */
                if (!is_text_section(symtab_entry->st_shndx,
                    c->obj->elf, c->obj->ehdr))
                        continue;

                /* look only at weak and global symbols */
#if     defined(_LP64)
                stbind = ELF64_ST_BIND(symtab_entry->st_info);
#else
                stbind = ELF32_ST_BIND(symtab_entry->st_info);
#endif
                if (stbind != STB_GLOBAL) {
                        if (stbind != STB_WEAK)
                                continue;
                }
                /* look only at functions and objects */
#if     defined(_LP64)
                sttype = ELF64_ST_TYPE(symtab_entry->st_info);
#else
                sttype = ELF32_ST_TYPE(symtab_entry->st_info);
#endif
                if (sttype != STT_FUNC) {
                        if (sttype != STT_OBJECT)
                                continue;
                }
                sym_name = buf + symtab_entry->st_name;
                binding = (struct binding_bucket *)
                    malloc(sizeof (binding_bucket));
                binding->sym = sym_name;
                binding->obj = c->obj->ename;
                binding->section = "TEXT";
                binding->ref_lib = "<Unknown>";
                binding->def_lib = "*DIRECT*";
                if (stbind == STB_GLOBAL)
                        binding->stbind = "GLOB";
                else if (stbind == STB_WEAK)
                        binding->stbind = "WEAK";
                if (sttype == STT_FUNC)
                        binding->sttype = "FUNC";
                else if (sttype == STT_OBJECT)
                        binding->sttype = "OBJT";
                if (pflag)
                        profile_binding(binding);
                else
                        store_binding(binding);
        }                       /* end for */
}

/* ========= bind_symbols ================================================= */
/*
 * DESCRIPTION:
 * Scan through the dynamic symbol table and write them out.
 * INPUTS:        syms - pointer to application symbol table
 * symn - number of entries in application symbol table
 * buf  - first byte of application string table
 */
/* ======================================================================== */

static void
bind_symbols(obj_list * c,
#if     defined(_LP64)
    Elf64_Sym * syms,
#else
    Elf32_Sym * syms,
#endif
    int symn,
    char *buf)
{
#if     defined(_LP64)
        Elf64_Sym       *symtab_entry;
#else
        Elf32_Sym       *symtab_entry;
#endif
        int             i;
        char            *sym_name;
        binding_bucket  *binding;
        int             sttype;
        int             stbind;

        symtab_entry = syms;
        for (i = 0; i < symn; i++, symtab_entry++) {
                /* look only at global symbols */
#if     defined(_LP64)
                stbind = ELF64_ST_BIND(symtab_entry->st_info);
#else
                stbind = ELF32_ST_BIND(symtab_entry->st_info);
#endif
                if (symtab_entry->st_shndx == SHN_UNDEF)
                        continue;
                if (symtab_entry->st_shndx == SHN_ABS)
                        continue;
                if (stbind != STB_GLOBAL) {
                        if (stbind != STB_WEAK)
                                continue;
                }
                /* look only at functions and objects */
#if     defined(_LP64)
                sttype = ELF64_ST_TYPE(symtab_entry->st_info);
#else
                sttype = ELF32_ST_TYPE(symtab_entry->st_info);
#endif
                if (sttype != STT_FUNC) {
                        if (sttype != STT_OBJECT)
                                continue;
                }
                sym_name = buf + symtab_entry->st_name;
                binding = (binding_bucket *) malloc(sizeof (binding_bucket));
                binding->obj = c->obj->ename;
                binding->sym = sym_name;
                if (!pflag)
                        check_store_binding(binding);
        }                       /* end for */
}

/* ========== get_scnfd =================================================== */
/*
 * DESCRIPTION:
 * Gets section descriptor for the associated string table
 * and verifies that the type of the section pointed to is
 * indeed of type STRTAB.  Returns a valid section descriptor
 * or NULL on error.
 */
/* ======================================================================== */

static Elf_Scn *
get_scnfd(Elf * e_file,
    int shstrtab,
    int SCN_TYPE)
{
        Elf_Scn         *scn_fd;
#if     defined(_LP64)
        Elf64_Shdr      *shdr;
#else
        Elf32_Shdr      *shdr;
#endif

        if ((scn_fd = elf_getscn(e_file, shstrtab)) == NULL)
                return (NULL);

#if     defined(_LP64)
        shdr = elf64_getshdr(scn_fd);
#else
        shdr = elf32_getshdr(scn_fd);
#endif

        if (shdr->sh_type != SCN_TYPE)
                return (NULL);
        return (scn_fd);
}

/* ========== print_symtab ================================================ */
/*
 * DESCRIPTION:
 * Outputs symbol bindings from symbol table to hash table.
 */
/* ======================================================================== */

static void
print_symtab(obj_list * com,
    Elf * elf_file,
#if     defined(_LP64)
    Elf64_Ehdr * ehdr,
    Elf64_Shdr * shdr,
#else
    Elf32_Ehdr * ehdr,
    Elf32_Shdr * shdr,
#endif
    Elf_Scn * p_sd,
    char *filename)
{
#if     defined(_LP64)
        Elf64_Sym       *syms;
#else
        Elf32_Sym       *syms;
#endif
        Elf_Data        *data;
        Elf_Scn         *scn;
        int             count = 0;
        char            *strs, *fullname;
        obj_list        *c;

        c = (obj_list *) malloc(sizeof (obj_list));
        c->obj = (obj_com *) malloc(sizeof (obj_com));
        fullname = (char *)malloc(strlen(com->obj->ename)
            + strlen(filename) + 3);
        (void) strcpy(fullname, com->obj->ename);
        (void) strcat(fullname, "(");
        (void) strcat(fullname, filename);
        (void) strcat(fullname, ")");
        c->obj->ename = fullname;

        if ((data = elf_getdata(p_sd, NULL)) == NULL) {
                if (sflag)
                        (void) fprintf(stderr,
                            "%s - No symbol table data\n",
                            c->obj->ename);
                return;
        }
#if     defined(_LP64)
        syms = (Elf64_Sym *) data->d_buf;
#else
        syms = (Elf32_Sym *) data->d_buf;
#endif

        scn = elf_getscn(elf_file, shdr->sh_link);
        if (scn == NULL)
                return;
        data = elf_getdata(scn, NULL);
        if (data == NULL)
                return;
        strs = data->d_buf;
        count = shdr->sh_size / shdr->sh_entsize;
        if (syms == NULL) {
                if (sflag)
                        (void) fprintf(stderr,
                            "%s: Problem reading symbol data\n",
                            c->obj->ename);
                return;
        }
        c->obj->sym_tab = syms;
        c->obj->sym_num = count;
        c->obj->sym_names = strs;

        if (aflag)
                (void) scan_archive_symbols(c,
                    c->obj->sym_tab,
                    c->obj->sym_num,
                    c->obj->sym_names,
                    elf_file,
                    ehdr);
        else
                (void) bind_symbols(c,
                    c->obj->sym_tab,
                    c->obj->sym_num,
                    c->obj->sym_names);
        free(c->obj);
        free(c);
}

/* ========== get_symtab ================================================== */
/*
 * DESCRIPTION:
 * Gets the symbol table.  This function does not output the contents
 * of the symbol table but sets up the parameters and then calls
 * print_symtab() to output the symbol bindings.
 */
/* ======================================================================== */

static void
get_symtab(obj_list * c,
    Elf * elf_file,
#if     defined(_LP64)
    Elf64_Ehdr * ehdr,
#else
    Elf32_Ehdr * ehdr,
#endif
    char *filename)
{
        Elf_Scn         *scn, *scnfd;
        Elf_Data        *data;
#if     defined(_LP64)
        Elf64_Word      symtabtype;
#else
        Elf32_Word      symtabtype;
#endif

        /* get section header string table */
        scnfd = get_scnfd(elf_file, ehdr->e_shstrndx, SHT_STRTAB);
        if (scnfd == NULL) {
                if (sflag)
                        (void) fprintf(stderr,
                            "%s: Could not get string table\n",
                            filename);
                return;
        }
        data = elf_getdata(scnfd, NULL);
        if (data->d_size == 0) {
                if (sflag)
                        (void) fprintf(stderr,
                            "%s: No data in string table\n",
                            filename);
                return;
        }
        symtabtype = SHT_SYMTAB;
        scn = 0;
        while ((scn = elf_nextscn(elf_file, scn)) != 0) {
#if     defined(_LP64)
                Elf64_Shdr      *shdr;
                if ((shdr = elf64_getshdr(scn)) == NULL)
#else
                Elf32_Shdr      *shdr;
                if ((shdr = elf32_getshdr(scn)) == NULL)
#endif
                {
                        if (sflag)
                                (void) fprintf(stderr,
                                    "%s: %s:\n",
                                    filename,
                                    elf_errmsg(-1));
                        return;
                }
                if (shdr->sh_type == symtabtype)
                        print_symtab(c, elf_file, ehdr, shdr, scn, filename);
        }                       /* end while */
}

/* ========== process ===================================================== */
/*
 * DESCRIPTION:
 * Gets the ELF header and, if it exists, call get_symtab() to begin
 * processing of the file; otherwise, returns with a warning.
 */
/* ======================================================================== */

static void
process(obj_list * c,
    Elf * elf_file,
    char *filename)
{
#if     defined(_LP64)
        Elf64_Ehdr      *ehdr;
#else
        Elf32_Ehdr      *ehdr;
#endif

#if     defined(_LP64)
        if ((ehdr = elf64_getehdr(elf_file)) == NULL)
#else
        if ((ehdr = elf32_getehdr(elf_file)) == NULL)
#endif
        {
                if (sflag)
                        (void) fprintf(stderr,
                            "%s: %s\n",
                            filename, elf_errmsg(-1));
                return;
        }
        get_symtab(c, elf_file, ehdr, filename);
}

/* ========== process_archive ============================================= */
/*
 * DESCRIPTION:
 * Processes member files of an archive.  This function provides
 * a loop through an archive equivalent the processing of each_file
 * for individual object file.
 */
/* ======================================================================== */

static int
process_archive(obj_list * c)
{
        Elf_Arhdr       *p_ar;
        Elf             *arf;
        Elf_Cmd         cmd = ELF_C_READ;

        while ((arf = elf_begin(c->obj->fd, cmd, c->obj->elf)) != 0) {
                p_ar = elf_getarhdr(arf);
                if (p_ar == NULL) {
                        if (sflag)
                                (void) fprintf(stderr,
                                    "%s: %s\n",
                                    c->obj->filename, elf_errmsg(-1));
                        return (FAIL);
                }
                if ((int)strncmp(p_ar->ar_name, "/", 1) == 0) {
                        cmd = elf_next(arf);
                        (void) elf_end(arf);
                        continue;
                }
                if (elf_kind(arf) == ELF_K_ELF) {
                        process(c, arf, p_ar->ar_name);
                } else {
                        cmd = elf_next(arf);
                        (void) elf_end(arf);
                        continue;
                }
                cmd = elf_next(arf);
                (void) elf_end(arf);
        }                       /* end while */
        return (SUCCEED);
}

/* ========== add_dtneeded ================================================ */
/*
 * DESCRIPTION:
 * Inserts a new node into the linked list.  It is basically for
 * generating a simple linked list of DT_NEEDED entries.
 */
/* ======================================================================== */

static dt_list *
add_dtneeded(dt_list * p,
    dt_list * node)
{
        dt_list         *head = p, *tail;

        if (!head)
                head = node;
        else {
                tail = head;
                if (strcmp(tail->libname, node->libname) == 0) {
                        free(node);
                        return (head);
                }
                while (tail->next != NULL) {
                        tail = tail->next;
                        if (strcmp(tail->libname, node->libname) == 0) {
                                free(node);
                                return (head);
                        }
                }
                tail->next = node;
        }
        return (head);
}

/* ========== find_dtneeded =============================================== */
/*
 * DESCRIPTION:
 * Find the DT_NEEDED, DT_FILTER, and DT_AUXILIARY entries, and save
 * them to link list.
 */
/* ======================================================================== */

static void
find_dtneeded(obj_list * c)
{
#if     defined(_LP64)
        Elf64_Dyn       *dcurrent; /* temp 64 bit dynamic table entry ptr */
#else
        Elf32_Dyn       *dcurrent; /* temp 32 bit dynamic table entry ptr */
#endif
        dt_list         *tmp_lib;

        dcurrent = c->obj->dynsect;
        if (!dcurrent)
                return;

        /*
         * If there are any DT_NEEDED
         * entries, add them to the dt_needed list.
         */

        while (dcurrent->d_tag != DT_NULL) {
                if (dcurrent->d_tag == DT_NEEDED) {
                        tmp_lib = (dt_list *) malloc(sizeof (dt_list));
                        tmp_lib->libname = c->obj->dynnames +
                            dcurrent->d_un.d_val;
                        tmp_lib->d_tag = dcurrent->d_tag;
                        tmp_lib->next = NULL;
                        dt_needed = add_dtneeded(dt_needed, tmp_lib);
                }
                dcurrent++;
        }
}

/* ========= obj_elfcheck ================================================= */
/*
 * DESCRIPTION:
 * It checks the elf header and saves its pointer if succeeds.
 * It checks the program header and saves its pointer if succeed.
 * It checks the section header table and saves its pointer to
 * section header table and section header string table if it
 * succeeds.  It finds dynsym symbol table and saves its pointer.
 * It finds symtab and saves its pointers.
 */
/* ======================================================================== */

static int
obj_elfcheck(obj_list * c)
{
        /* open the file and ELF descriptor */
        if (obj_init(c) == FAIL) {
                obj_finis(c);
                return (FAIL);
        }
        /* if it is an archive library */
        if (elf_kind(c->obj->elf) == ELF_K_AR) {
                if (process_archive(c) == SUCCEED)
                        return (SUCCEED);
                else
                        return (FAIL);
        }
        /* get the ELF header information */
        if (obj_elf_hdr(c) == FAIL) {
                obj_finis(c);
                return (FAIL);
        }
        /* get the program header for dynamic, etc. */
        if (obj_prog_hdr(c) == FAIL) {
                obj_finis(c);
                return (FAIL);
        }
        /* find and save pointers to application symbol tables */
        if (find_symtabs(c) == FAIL) {
                obj_finis(c);
                return (FAIL);
        }
        /* check the existence of application's symbol tables */
        if (obj_app_symtab(c) == FAIL) {
                obj_finis(c);
                return (FAIL);
        }
        /* find and save pointers to the dynamic section */
        if (find_dynamic_sect(c) == FAIL) {
                obj_finis(c);
                return (FAIL);
        }
        /*
         * find the DT_NEEDED entries and save the name to dt_needed link
         * list
         */
        (void) find_dtneeded(c);

        return (SUCCEED);
}

/* ========= analyze_dependency ========================================== */
/*
 * DESCRIPTION:
 * Read in an dependency object file and analyze it.
 * INPUTS:        dep_file - dependency object file name
 */
/* ======================================================================= */

static int
analyze_dependency(char *dep_file)
{
        obj_list        *dep_obj;

        if (!dep_file)
                return (SUCCEED);

        dep_obj = (obj_list *) malloc(sizeof (obj_list));
        (void) memset(dep_obj, 0, sizeof (obj_list));
        dep_obj->obj = (obj_com *) malloc(sizeof (obj_com));
        (void) memset(dep_obj->obj, 0, sizeof (obj_com));
        dep_obj->next = NULL;
        dep_obj->obj->filename = dep_file;
        dep_obj->obj->ename = dep_obj->obj->filename;

        if (obj_elfcheck(dep_obj) == FAIL)
                return (FAIL);

        if (dep_obj->obj->dsym_names != NULL)
                bind_symbols(dep_obj,
                    dep_obj->obj->dsym_tab,
                    dep_obj->obj->dsym_num,
                    dep_obj->obj->dsym_names);

        if (dep_obj->obj->sym_names != NULL)
                bind_symbols(dep_obj,
                    dep_obj->obj->sym_tab,
                    dep_obj->obj->sym_num,
                    dep_obj->obj->sym_names);
        return (SUCCEED);
}

/* ========= analyze_main =============================================== */
/*
 * DESCRIPTION:
 * Read in an object file and analyze it.
 */
/* ====================================================================== */

static void
analyze_main(obj_list * c)
{
        int     i;

        if (obj_elfcheck(c) == FAIL)
                exit(1);

        aflag = FALSE;

        if (c->obj->sym_names != NULL)
                scan_symbols(c,
                    c->obj->sym_tab,
                    c->obj->sym_num,
                    c->obj->sym_names);
        else if (c->obj->dsym_names != NULL)
                scan_symbols(c,
                    c->obj->dsym_tab,
                    c->obj->dsym_num,
                    c->obj->dsym_names);

        if (c->obj->numfiles == 0)
                return;

        for (i = 0; i < c->obj->numfiles; i++)
                (void) analyze_dependency(c->obj->filenames[i]);
}

/* ========= analyze_args ================================================= */
/*
 * DESCRIPTION:
 * Analyze the command-line options.
 */
/* ======================================================================== */

static int
analyze_args(obj_list * c,
    int argc,
    char *argv[])
{
        extern char     *optarg;
        extern int      optind;
        int             option;
        int             i;
        char            *nameptr;
        char            slash = '/';
        int             errflg = 0;

        if ((nameptr = strrchr(argv[0], slash)) != NULL)
                nameptr++;
        else
                nameptr = argv[0];

        while ((option = getopt(argc, argv, "pso:a")) != EOF) {
                switch (option) {
                case 'p':       /* just do profiling; write to stdout */
                        pflag = 1;
                        break;
                case 's':       /* silent mode to turn off stderr messages */
                        sflag = 0;
                        break;
                case 'o':       /* redirects the output */
                        outputfile = optarg;
                        oflag = 1;
                        break;
                case 'a':       /* processes archive as input */
                        aflag = 1;
                        break;
                case '?':
                default:
                        errflg++;
                }               /* end switch */
        }                       /* end while */

        /* exit if there are no files to process */
        if (optind >= argc)
                errflg++;
        if (errflg) {
                (void) fprintf(stderr,
                    "usage: %s [-p] [-s] [-o outputfile] ", nameptr);
                (void) fprintf(stderr,
                    "<archive>|<binary_executable>\n");
                (void) fprintf(stderr,
                    "\t\t   [<archive>|<dynamic library>...]\n");
                return (FALSE);
        }                       /* end if */
        c->obj->filename = argv[optind++];
        c->obj->ename = c->obj->filename;

        /* compute number of files and save their pointers */
        c->obj->numfiles = argc - optind;

        if (c->obj->numfiles > 0) {
                i = 0;
                c->obj->filenames = (char **)
                    malloc(sizeof (char *) * (c->obj->numfiles + 1));
                for (; optind < argc; i++, optind++)
                        c->obj->filenames[i] = argv[optind];
        }
        return (TRUE);
}

/* ======================================================================= */
/*
 * Here starts the main ()
 */
/* ======================================================================= */

int
main(int argc, char *argv[])
{
        obj_list        *main_obj;
        dt_list         *q;

        main_obj = (obj_list *) malloc(sizeof (obj_list));
        (void) memset(main_obj, 0, sizeof (obj_list));
        main_obj->obj = (obj_com *) malloc(sizeof (obj_com));
        (void) memset(main_obj->obj, 0, sizeof (obj_com));
        main_obj->next = NULL;

        if (!analyze_args(main_obj, argc, argv))
                exit(1);

        if (oflag && pflag) {
                if ((OUTPUT_FD = fopen(outputfile, "w")) == NULL) {
                        if (sflag)
                                (void) fprintf(stderr,
                                    "\nfopen failed to open <%s>...\n\n",
                                    outputfile);
                        exit(1);
                }
        }
        /* generates profile report if pflag is set */
        if (pflag)
                (void) fprintf(OUTPUT_FD,
                    "#generated by %s\n",
                    argv[0]);

        /* analyze the input file */
        analyze_main(main_obj);

        /* generates profile report */
        if (!pflag)
                output_binding(argv[0], main_obj->obj->ename);

        /* close the library .so file descriptor and ELF descriptor */
        obj_finis(main_obj);

        /* de-allocates the dt_needed link list */
        if (dt_needed) {
                while (dt_needed) {
                        q = dt_needed;
                        dt_needed = dt_needed->next;
                        free(q);
                }
        }
        /* close the output redirect file descriptor */
        if (oflag)
                (void) fclose(OUTPUT_FD);

        return (0);
}