dmake: do not set MAKEFLAGS=k

[unleashed/tickless.git] / usr / src / cmd / sgs / pvs / common / pvs.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 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Analyze the versioning information within a file.
 *
 *   -C         demangle C++ symbol names.
 *
 *   -d         dump version definitions.
 *
 *   -l         print reduced (local) symbols. Implies -s.
 *
 *   -n         normalize any version definitions.
 *
 *   -o         dump output in one-line fashion (more suitable for grep'ing
 *              and diff'ing).
 *
 *   -r         dump the version requirements on library dependencies
 *
 *   -s         display the symbols associated with each version definition.
 *
 *   -v         verbose output.  With the -r and -d options any WEAK attribute
 *              is displayed.  With the -d option, any version inheritance,
 *              and the base version are displayed.  With the -r option,
 *              WEAK and INFO attributes are displayed. With the -s option
 *              the version symbol is displayed.
 *
 *   -I index   only print the specifed version index, or index range.
 *
 *   -N name    only print the specifed `name'.
 */
#include        <fcntl.h>
#include        <stdio.h>
#include        <libelf.h>
#include        <link.h>
#include        <stdlib.h>
#include        <string.h>
#include        <unistd.h>
#include        <locale.h>
#include        <errno.h>
#include        <sgs.h>
#include        <conv.h>
#include        <gelf.h>
#include        <debug.h>
#include        <ctype.h>
#include        <alist.h>
#include        "msg.h"

/*
 * Define Alist initialization sizes.
 */
#define AL_CNT_MATCH_LIST       5       /* match_list initial alist count */
#define AL_CNT_GVER_DESC        25      /* version tracking descriptors */

typedef struct cache {
        Elf_Scn         *c_scn;
        Elf_Data        *c_data;
        char            *c_name;
} Cache;

typedef struct gver_desc {
        const char      *vd_name;
        unsigned long   vd_hash;
        GElf_Half       vd_ndx;
        GElf_Half       vd_flags;
        APlist          *vd_deps;
} GVer_desc;

/* Versym related data used by gvers_syms() */
typedef struct {
        GElf_Versym     *vsd_vsp;       /* ptr to versym data */
        Elf_Data        *vsd_sym_data;  /* ptr to symtab data */
        Word            vsd_symn;       /* # of symbols in symtab */
        const char      *vsd_strs;      /* string table data */
} Gver_sym_data;

/*
 * Type used to manage -I and -N options:
 *
 * The -I option specifies a VERSYM index, or index range. The
 * result is to select the VERDEF or VERNEED records with
 * indexes that match those given.
 *
 * -N options come in two forms:
 *
 *      1) name
 *      2) needobj (version)
 *
 * The meaning of the first case depends on the type of
 * version record being matched:
 *
 *      VERDEF - name is the name of a version defined
 *              by the object being processed (i.e. SUNW_1.1).
 *
 *      VERNEED - name is the name of the object file
 *              on which the dependency exists (i.e. libc.so.1).
 *
 * -N options of the second form only apply to VERNEED records.
 * They are used to specify a version from a needed object.
 */
/* match_opt_t is  used to note which match option was used */
typedef enum {
        MATCH_OPT_NAME,         /* Record contains a name */
        MATCH_OPT_NEED_VER,     /* Record contains needed object and version */
        MATCH_OPT_NDX,          /* Record contains a single index */
        MATCH_OPT_RANGE,        /* Record contains an index range */
} match_opt_t;

typedef struct {
        match_opt_t     opt_type;
        union {
                struct {
                        const char *version;    /* MATCH_OPT_{NAME|NEED_VER} */
                        const char *needobj;    /* MATCH_OPT_NEED_VER only */
                } name;
                struct {
                        int start;              /* MATCH_OPT_{NDX|RANGE} */
                        int end;                /* MATCH_OPT_RANGE only) */
                } ndx;
        } value;
} match_rec_t;



static const char       *cname;
static int              Cflag, dflag, lflag, nflag, oflag, rflag, sflag, vflag;
static Alist            *match_list;

/* Used to track whether an option defaulted to on, or was explicitly set */
#define DEF_DEFINED     1
#define USR_DEFINED     2

/*
 * Determine whether a symbol name should be demangled.
 */
static const char *
demangle(const char *name)
{
        if (Cflag)
                return (Elf_demangle_name(name));
        else
                return (name);
}

/*
 * Append an item to the specified list, and return a pointer to the list
 * node created.
 *
 * exit:
 *      On success, a new list node is created and the item is
 *      added to the list. On failure, a fatal error is issued
 *      and the process exits.
 */
static void
pvs_aplist_append(APlist **lst, const void *item, const char *file)
{
        if (aplist_append(lst, item, AL_CNT_GVER_DESC) == NULL) {
                int err = errno;
                (void) fprintf(stderr, MSG_INTL(MSG_SYS_MALLOC), cname, file,
                    strerror(err));
                exit(1);
        }
}

/*
 * Add an entry to match_list for use by match(). This routine is for
 * use during getopt() processing.
 *
 * entry:
 *      opt - One of 'N' or 'I', indicating the option
 *      str - Value string corresponding to opt
 *
 * exit:
 *      The new match record has been added. On error, a fatal
 *      error is issued and and the process exits.
 */
static void
add_match_record(int opt, const char *str)
{
        /*
         * Macros for removing leading and trailing whitespace:
         *      WS_SKIP - Advance _str without passing the NULL termination,
         *              until the first character is not whitespace.
         *      WS_SKIP_LIMIT - Advance _str without passing _limit,
         *              until the first character is not whitespace.
         *      WS_RSKIP_LIMIT - Move _tail back without passing _str,
         *              until the character before it is not whitespace.
         *              Write a NULL termination at that point.
         */
#define WS_SKIP(_str) for (; *(_str) && isspace(*(_str)); (_str)++)
#define WS_SKIP_LIMIT(_str, _limit) \
        while (((_str) < s2) && isspace(*(_str))) \
                (_str)++
#define WS_RSKIP_LIMIT(_str, _tail) \
        while (((_tail) > (_str)) && isspace(*((_tail) - 1)))   \
                (_tail)--;                                      \
        *(_tail) = '\0'


        match_rec_t     *rec;
        char            *lstr, *s1, *s2;

        rec = alist_append(&match_list, NULL, sizeof (match_rec_t),
            AL_CNT_MATCH_LIST);
        if (rec == NULL) {
                int err = errno;
                (void) fprintf(stderr, MSG_INTL(MSG_SYS_MALLOC), cname,
                    MSG_INTL(MSG_STR_MATCH_RECORD), strerror(err));
                exit(1);
        }

        if (opt == 'N') {
                if ((lstr = strdup(str)) == NULL) {
                        int err = errno;
                        (void) fprintf(stderr, MSG_INTL(MSG_SYS_MALLOC),
                            cname, MSG_INTL(MSG_STR_MATCH_RECORD),
                            strerror(err));
                        exit(1);
                }

                /* Strip leading/trailing whitespace */
                s2 = lstr + strlen(lstr);
                WS_SKIP_LIMIT(lstr, s2);
                WS_RSKIP_LIMIT(lstr, s2);

                /* Assume this is a plain string */
                rec->opt_type = MATCH_OPT_NAME;
                rec->value.name.version = lstr;

                /*
                 * If s2 points at a closing paren, then this might
                 * be a MATCH_OPT_NEED_VER case. Otherwise we're done.
                 */
                if ((s2 == lstr) || (*(s2 - 1) != ')'))
                        return;

                /* We have a closing paren. Locate the opening one. */
                for (s1 = lstr; *s1 && (*s1 != '('); s1++)
                        ;
                if (*s1 != '(')
                        return;

                rec->opt_type = MATCH_OPT_NEED_VER;
                rec->value.name.needobj = lstr;
                rec->value.name.version = s1 + 1;
                s2--;           /* Points at closing paren */

                /* Remove whitespace from head/tail of version */
                WS_SKIP_LIMIT(rec->value.name.version, s2);
                WS_RSKIP_LIMIT(rec->value.name.version, s2);

                /* Terminate needobj, skipping trailing whitespace */
                WS_RSKIP_LIMIT(rec->value.name.needobj, s1);

                return;
        }


        /* If we get here, we are looking at a -I index option */
        rec->value.ndx.start = strtol(str, &s2, 10);
        /* Value must use some of the input, and be positive */
        if ((str == s2) || (rec->value.ndx.start < 1))
                goto syntax_error;
        str = s2;

        WS_SKIP(str);
        if (*str != ':') {
                rec->opt_type = MATCH_OPT_NDX;
        } else {
                str++;                                  /* Skip the ':' */
                rec->opt_type = MATCH_OPT_RANGE;
                WS_SKIP(str);
                if (*str == '\0') {
                        rec->value.ndx.end = -1;        /* Indicates "to end" */
                } else {
                        rec->value.ndx.end = strtol(str, &s2, 10);
                        if ((str == s2) || (rec->value.ndx.end < 0))
                                goto syntax_error;
                        str = s2;
                        WS_SKIP(str);
                }
        }

        /* If we are successful, there is nothing left to parse */
        if (*str == '\0')
                return;

        /*
         * If we get here, there is leftover input. Fall through
         * to issue a syntax error.
         */
syntax_error:
        (void) fprintf(stderr, MSG_INTL(MSG_USAGE_BRIEF), cname);
        exit(1);

#undef  WS_SKIP
#undef  WS_SKIP_LIMIT
#undef  WS_RSKIP_LIMIT
}

/*
 * Returns True (1) if the version with the given name or index should
 * be displayed, and False (0) if it should not be.
 *
 * entry:
 *      needobj - NULL for VERDEF records, the name of the
 *              needed object for VERNEED.
 *      version - NULL, or needed version
 *      ndx - Versym index of version under consideration, or a value less
 *              than 1 to indicate that no valid index is given.
 *
 * exit:
 *      True will be returned if the given name/index matches those given
 *      by one of the -I or -N command line options, or if no such option
 *      was used in the command invocation.
 */
int
match(const char *needobj, const char *version, int ndx)
{
        Aliste          _idx;
        match_rec_t     *rec;
        const char      *str;

        /* If there is no match list, then we approve everything */
        if (alist_nitems(match_list) == 0)
                return (1);

        /* Run through the match records and check for a hit */
        for (ALIST_TRAVERSE(match_list, _idx, rec)) {
                switch (rec->opt_type) {
                case MATCH_OPT_NAME:
                        if (needobj)
                                str = needobj;
                        else if (version)
                                str = version;
                        else
                                break;
                        if (strcmp(rec->value.name.version, str) == 0)
                                return (1);
                        break;
                case MATCH_OPT_NEED_VER:
                        if (needobj && version &&
                            (strcmp(rec->value.name.needobj, needobj) == 0) &&
                            (strcmp(rec->value.name.version, version) == 0))
                                return (1);
                        break;
                case MATCH_OPT_NDX:
                        if ((ndx > 0) && (ndx == rec->value.ndx.start))
                                return (1);
                        break;
                case MATCH_OPT_RANGE:
                        /*
                         * A range end value less than 0 means that any value
                         * above the start is acceptible.
                         */
                        if ((ndx > 0) &&
                            (ndx >= rec->value.ndx.start) &&
                            ((rec->value.ndx.end < 0) ||
                            (ndx <= rec->value.ndx.end)))
                                return (1);
                        break;
                }
        }

        /* Nothing matched */
        return (0);
}

/*
 * List the symbols that belong to a specified version
 *
 * entry:
 *      vsdata - VERSYM related data from the object
 *      vd_ndx - The VERSYM index for symbols to display
 *      vd_name - Version name
 *      needobj - NULL for symbols corresponding to a VERDEF
 *              record. Name of the needed object in the case
 *              of a VERNEED record.
 *      file - Object file
 */
static void
gvers_syms(const Gver_sym_data *vsdata, GElf_Half vd_ndx,
    const char *vd_name, const char *needobj, const char *file)
{
        GElf_Sym        sym;
        int             _symn;

        for (_symn = 0; _symn < vsdata->vsd_symn; _symn++) {
                size_t          size =  0;
                const char      *name;

                if (vsdata->vsd_vsp[_symn] != vd_ndx)
                        continue;

                (void) gelf_getsym(vsdata->vsd_sym_data, _symn, &sym);
                name = demangle(vsdata->vsd_strs + sym.st_name);

                /*
                 * Symbols that reference a VERDEF record
                 * have some extra details to handle.
                 */
                if (needobj == NULL) {
                        /*
                         * For data symbols defined by this object,
                         * determine the size.
                         */
                        if ((GELF_ST_TYPE(sym.st_info) == STT_OBJECT) ||
                            (GELF_ST_TYPE(sym.st_info) == STT_COMMON) ||
                            (GELF_ST_TYPE(sym.st_info) == STT_TLS))
                                size = (size_t)sym.st_size;

                        /*
                         * Only output the version symbol when the verbose
                         * flag is used.
                         */
                        if (!vflag && (sym.st_shndx == SHN_ABS) &&
                            (strcmp(name, vd_name) == 0))
                                continue;
                }

                if (oflag) {
                        if (needobj == NULL)
                                (void) printf(MSG_ORIG(MSG_FMT_SYM_OFIL),
                                    file, vd_name);
                        else
                                (void) printf(MSG_ORIG(MSG_FMT_SYM_NEED_OFIL),
                                    file, needobj, vd_name);

                        if (size)
                                (void) printf(MSG_ORIG(MSG_FMT_SYM_SZ_OFLG),
                                    name, (ulong_t)size);
                        else
                                (void) printf(MSG_ORIG(MSG_FMT_SYM_OFLG), name);
                } else {
                        if (size)
                                (void) printf(MSG_ORIG(MSG_FMT_SYM_SZ), name,
                                    (ulong_t)size);
                        else
                                (void) printf(MSG_ORIG(MSG_FMT_SYM), name);
                }
        }
}

/*
 * Print any reduced symbols.  The convention is that reduced symbols exist as
 * LOCL entries in the .symtab, between the FILE symbol for the output file and
 * the first FILE symbol for any input file used to build the output file.
 */
static void
sym_local(Cache *cache, Cache *csym, const char *file)
{
        int             symn, _symn, found = 0;
        GElf_Shdr       shdr;
        GElf_Sym        sym;
        char            *strs;

        (void) gelf_getshdr(csym->c_scn, &shdr);
        strs = (char *)cache[shdr.sh_link].c_data->d_buf;
        /* LINTED */
        symn = shdr.sh_info;

        /*
         * Verify symtab[1] is the output file symbol.
         */
        (void) gelf_getsym(csym->c_data, 1, &sym);
        if (GELF_ST_TYPE(sym.st_info) != STT_FILE) {
                (void) fprintf(stderr, MSG_INTL(MSG_VER_UNREDSYMS), cname,
                    file);
                (void) fprintf(stderr, MSG_INTL(MSG_VER_NOTSTTFILE),
                    csym->c_name);
                return;
        }

        /*
         * Scan the remaining symbols until the next file symbol is found.
         */
        for (_symn = 2; _symn < symn; _symn++) {
                const char      *name;

                (void) gelf_getsym(csym->c_data, _symn, &sym);
                if (GELF_ST_TYPE(sym.st_info) == STT_SECTION)
                        continue;
                if (GELF_ST_TYPE(sym.st_info) == STT_FILE)
                        break;

                /*
                 * Its possible that section symbols are followed immediately
                 * by globals.  This is the case if an object (filter) is
                 * generated exclusively from mapfile symbol definitions.
                 */
                if (GELF_ST_BIND(sym.st_info) != STB_LOCAL)
                        break;

                name = demangle(strs + sym.st_name);

                if (oflag) {
                        (void) printf(MSG_ORIG(MSG_FMT_LOCSYM_OFLG),
                            file, name);
                } else {
                        if (found == 0) {
                                found = 1;
                                (void) printf(MSG_ORIG(MSG_FMT_LOCSYM_HDR));
                        }
                        (void) printf(MSG_ORIG(MSG_FMT_LOCSYM), name);
                }
        }
}

/*
 * Print data from the files VERNEED section.
 *
 * If we have been asked to display symbols, then the
 * output format follows that used for verdef sections,
 * with each version displayed separately. For instance:
 *
 *      libc.so.1 (SUNW_1.7):
 *              sym1;
 *              sym2;
 *      libc.so.1 (SUNW_1.9):
 *              sym3;
 *
 * If we are not displaying symbols, then a terse format
 * is used, which combines all the needed versions from
 * a given object into a single line. In this case, the
 * versions are shown whether or not they contribute symbols.
 *
 *      libc.so.1 (SUNW_1.7, SUNW_1.9);
 */
static int
gvers_need(Cache *cache, Cache *need, const Gver_sym_data *vsdata,
    const char *file)
{
        unsigned int    num, _num;
        char            *strs;
        GElf_Verneed    *vnd = need->c_data->d_buf;
        GElf_Shdr       shdr;
        int             error = 0;
        int             show = vflag || (vsdata == NULL) || !oflag;


        (void) gelf_getshdr(need->c_scn, &shdr);

        /*
         * Verify the version revision.  We only check the first version
         * structure as it is assumed all other version structures in this
         * data section will be of the same revision.
         */
        if (vnd->vn_version > VER_DEF_CURRENT)
                (void) fprintf(stderr, MSG_INTL(MSG_VER_HIGHREV), cname, file,
                    vnd->vn_version, VER_DEF_CURRENT);

        /*
         * Get the data buffer for the associated string table.
         */
        strs = (char *)cache[shdr.sh_link].c_data->d_buf;
        num = shdr.sh_info;

        for (_num = 1; _num <= num; _num++,
            vnd = (GElf_Verneed *)((uintptr_t)vnd + vnd->vn_next)) {
                GElf_Vernaux    *vnap;
                Word            ndx;
                const char      *needobj, *dep;
                int             started = 0, listcnt = 0;

                vnap = (GElf_Vernaux *) ((uintptr_t)vnd + vnd->vn_aux);

                /* Obtain the needed object file name */
                needobj = (char *)(strs + vnd->vn_file);

                error = 1;

                /* Process the versions needed from this object */
                for (ndx = 0; ndx < vnd->vn_cnt; ndx++,
                    vnap = (GElf_Vernaux *)((uintptr_t)vnap + vnap->vna_next)) {
                        Conv_ver_flags_buf_t    ver_flags_buf;

                        dep = (char *)(strs + vnap->vna_name);

                        if (!match(needobj, dep, vnap->vna_other))
                                continue;

                        if (show) {
                                if ((started == 0) || (vsdata != NULL))  {
                                        /*
                                         * If one-line ouput is called for
                                         * display the filename being processed.
                                         */
                                        if (oflag && show)
                                                (void) printf(
                                                    MSG_ORIG(MSG_FMT_OFIL),
                                                    file);

                                        (void) printf(
                                            MSG_ORIG(MSG_FMT_LIST_BEGIN),
                                            needobj);
                                        started = 1;
                                }

                                /*
                                 * If not showing symbols, only show INFO
                                 * versions in verbose mode. They don't
                                 * actually contribute to the version
                                 * interface as seen by rtld, so listing them
                                 * without qualification can be misleading.
                                 */
                                if (vflag || (vsdata != NULL) ||
                                    (alist_nitems(match_list) != 0) ||
                                    !(vnap->vna_flags & VER_FLG_INFO)) {
                                        const char *fmt = (listcnt == 0) ?
                                            MSG_ORIG(MSG_FMT_LIST_FIRST) :
                                            MSG_ORIG(MSG_FMT_LIST_NEXT);

                                        if (vsdata == NULL)
                                                listcnt++;
                                        (void) printf(fmt, dep);

                                        /* Show non-zero flags */
                                        if (vflag && (vnap->vna_flags != 0))
                                                (void) printf(
                                                    MSG_ORIG(MSG_FMT_VER_FLG),
                                                    conv_ver_flags(
                                                    vnap->vna_flags,
                                                    CONV_FMT_NOBKT,
                                                    &ver_flags_buf));
                                }
                                if (vsdata != NULL)
                                        (void) printf(oflag ?
                                            MSG_ORIG(MSG_FMT_LIST_END_SEM) :
                                            MSG_ORIG(MSG_FMT_LIST_END_COL));
                        }

                        /*
                         * If we are showing symbols, and vna_other is
                         * non-zero, list them here.
                         *
                         * A value of 0 means that this object uses
                         * traditional Solaris versioning rules, under
                         * which VERSYM does not contain indexes to VERNEED
                         * records. In this case, there is nothing to show.
                         */
                        if (vsdata && (vnap->vna_other > 0))
                                gvers_syms(vsdata, vnap->vna_other,
                                    dep, needobj, file);
                }
                if (show && started && (vsdata == NULL))
                        (void) printf(MSG_ORIG(MSG_FMT_LIST_END_SEM));
        }
        return (error);
}

/*
 * Return a GVer_desc descriptor for the given version if one
 * exists.
 *
 * entry:
 *      name - Version name
 *      hash - ELF hash of name
 *      lst - APlist of existing descriptors.
 *      file - Object file containing the version
 *
 * exit:
 *      Return the corresponding GVer_desc struct if it
 *      exists, and NULL otherwise.
 */
static GVer_desc *
gvers_find(const char *name, unsigned long hash, APlist *lst)
{
        Aliste          idx;
        GVer_desc       *vdp;

        for (APLIST_TRAVERSE(lst, idx, vdp))
                if ((vdp->vd_hash == hash) &&
                    (strcmp(vdp->vd_name, name) == 0))
                        return (vdp);

        return (NULL);
}

/*
 * Return a GVer_desc descriptor for the given version.
 *
 * entry:
 *      name - Version name
 *      hash - ELF hash of name
 *      lst - List of existing descriptors.
 *      file - Object file containing the version
 *
 * exit:
 *      Return the corresponding GVer_desc struct. If the
 *      descriptor does not already exist, it is created.
 *      On error, a fatal error is issued and the process exits.
 */
static GVer_desc *
gvers_desc(const char *name, unsigned long hash, APlist **lst, const char *file)
{
        GVer_desc       *vdp;

        if ((vdp = gvers_find(name, hash, *lst)) == NULL) {
                if ((vdp = calloc(sizeof (GVer_desc), 1)) == NULL) {
                        int err = errno;
                        (void) fprintf(stderr, MSG_INTL(MSG_SYS_MALLOC), cname,
                            file, strerror(err));
                        exit(1);
                }

                vdp->vd_name = name;
                vdp->vd_hash = hash;

                pvs_aplist_append(lst, vdp, file);
        }
        return (vdp);
}

/*
 * Insert a version dependency for the given GVer_desc descriptor.
 *
 * entry:
 *      name - Dependency version name
 *      hash - ELF hash of name
 *      lst - List of existing descriptors.
 *      vdp - Existing version descriptor to which the dependency
 *              is to be added.
 *      file - Object file containing the version
 *
 * exit:
 *      A descriptor for the dependency version is looked up
 *      (created if necessary), and then added to the dependency
 *      list for vdp. Returns the dependency descriptor. On error,
 *      a fatal error is issued and the process exits.
 */
static GVer_desc *
gvers_depend(const char *name, unsigned long hash, GVer_desc *vdp, APlist **lst,
    const char *file)
{
        GVer_desc       *_vdp;

        _vdp = gvers_desc(name, hash, lst, file);
        pvs_aplist_append(&vdp->vd_deps, _vdp, file);
        return (vdp);
}

static void
gvers_derefer(GVer_desc *vdp, int weak)
{
        Aliste          idx;
        GVer_desc       *_vdp;

        /*
         * If the head of the list was a weak then we only clear out
         * weak dependencies, but if the head of the list was 'strong'
         * we clear the REFER bit on all dependencies.
         */
        if ((weak && (vdp->vd_flags & VER_FLG_WEAK)) || (!weak))
                vdp->vd_flags &= ~FLG_VER_AVAIL;

        for (APLIST_TRAVERSE(vdp->vd_deps, idx, _vdp))
                gvers_derefer(_vdp, weak);
}


static void
recurse_syms(const Gver_sym_data *vsdata, GVer_desc *vdp, const char *file)
{
        Aliste          idx;
        GVer_desc       *_vdp;

        for (APLIST_TRAVERSE(vdp->vd_deps, idx, _vdp)) {
                if (!oflag)
                        (void) printf(MSG_ORIG(MSG_FMT_TNCO), _vdp->vd_name);
                gvers_syms(vsdata, _vdp->vd_ndx, _vdp->vd_name, NULL, file);
                if (aplist_nitems(_vdp->vd_deps) != 0)
                        recurse_syms(vsdata, _vdp, file);
        }
}


/*
 * Print the files version definition sections.
 */
static int
gvers_def(Cache *cache, Cache *def, const Gver_sym_data *vsdata,
    const char *file)
{
        unsigned int    num, _num;
        char            *strs;
        GElf_Verdef     *vdf = def->c_data->d_buf;
        GElf_Shdr       shdr;
        GVer_desc       *vdp, *bvdp = NULL;
        Aliste          idx1;
        APlist          *verdefs = NULL;
        int             error = 0;

        /*
         * Verify the version revision.  We only check the first version
         * structure as it is assumed all other version structures in this
         * data section will be of the same revision.
         */
        if (vdf->vd_version > VER_DEF_CURRENT) {
                (void) fprintf(stderr, MSG_INTL(MSG_VER_HIGHREV), cname, file,
                    vdf->vd_version, VER_DEF_CURRENT);
        }

        /*
         * Get the data buffer for the associated string table.
         */
        (void) gelf_getshdr(def->c_scn, &shdr);
        strs = (char *)cache[shdr.sh_link].c_data->d_buf;
        num = shdr.sh_info;

        /*
         * Process the version definitions placing each on a version dependency
         * list.
         */
        for (_num = 1; _num <= num; _num++,
            vdf = (GElf_Verdef *)((uintptr_t)vdf + vdf->vd_next)) {
                GElf_Half       cnt = vdf->vd_cnt;
                GElf_Half       ndx = vdf->vd_ndx;
                GElf_Verdaux    *vdap;
                const char      *_name;

                vdap = (GElf_Verdaux *)((uintptr_t)vdf + vdf->vd_aux);

                /*
                 * Determine the version name and any dependencies.
                 */
                _name = (char *)(strs + vdap->vda_name);

                vdp = gvers_desc(_name, elf_hash(_name), &verdefs, file);
                vdp->vd_ndx = ndx;
                vdp->vd_flags = vdf->vd_flags | FLG_VER_AVAIL;

                vdap = (GElf_Verdaux *)((uintptr_t)vdap + vdap->vda_next);
                for (cnt--; cnt; cnt--,
                    vdap = (GElf_Verdaux *)((uintptr_t)vdap + vdap->vda_next)) {
                        _name = (char *)(strs + vdap->vda_name);
                        if (gvers_depend(_name, elf_hash(_name), vdp,
                            &verdefs, file) == NULL)
                                return (0);
                }

                /*
                 * Remember the base version for possible later use.
                 */
                if (ndx == VER_NDX_GLOBAL)
                        bvdp = vdp;
        }

        /*
         * Normalize the dependency list if required.
         */
        if (nflag) {
                for (APLIST_TRAVERSE(verdefs, idx1, vdp)) {
                        Aliste          idx2;
                        GVer_desc       *_vdp;
                        int             type = vdp->vd_flags & VER_FLG_WEAK;

                        for (APLIST_TRAVERSE(vdp->vd_deps, idx2, _vdp))
                                gvers_derefer(_vdp, type);
                }

                /*
                 * Always dereference the base version.
                 */
                if (bvdp)
                        bvdp->vd_flags &= ~FLG_VER_AVAIL;
        }


        /*
         * Traverse the dependency list and print out the appropriate
         * information.
         */
        for (APLIST_TRAVERSE(verdefs, idx1, vdp)) {
                Aliste          idx2;
                GVer_desc       *_vdp;
                int             count;

                if (!match(NULL, vdp->vd_name, vdp->vd_ndx))
                        continue;
                if ((alist_nitems(match_list) == 0) &&
                    !(vdp->vd_flags & FLG_VER_AVAIL))
                        continue;

                error = 1;

                if (vflag) {
                        /*
                         * If the verbose flag is set determine if this version
                         * has a `weak' attribute, and print any version
                         * dependencies this version inherits.
                         */
                        if (oflag)
                                (void) printf(MSG_ORIG(MSG_FMT_OFIL), file);
                        (void) printf(MSG_ORIG(MSG_FMT_VER_NAME), vdp->vd_name);
                        if ((vdp->vd_flags & MSK_VER_USER) != 0) {
                                Conv_ver_flags_buf_t    ver_flags_buf;

                                (void) printf(MSG_ORIG(MSG_FMT_VER_FLG),
                                    conv_ver_flags(
                                    vdp->vd_flags & MSK_VER_USER,
                                    CONV_FMT_NOBKT, &ver_flags_buf));
                        }

                        count = 1;
                        for (APLIST_TRAVERSE(vdp->vd_deps, idx2, _vdp)) {
                                const char      *_name = _vdp->vd_name;

                                if (count++ == 1) {

                                        if (oflag)
                                                (void) printf(
                                                    MSG_ORIG(MSG_FMT_IN_OFLG),
                                                    _name);
                                        else if (vdp->vd_flags & VER_FLG_WEAK)
                                                (void) printf(
                                                    MSG_ORIG(MSG_FMT_IN_WEAK),
                                                    _name);
                                        else
                                                (void) printf(
                                                    MSG_ORIG(MSG_FMT_IN),
                                                    _name);
                                } else
                                        (void) printf(
                                            MSG_ORIG(MSG_FMT_LIST_NEXT), _name);
                        }

                        if (count != 1)
                                (void) printf(MSG_ORIG(MSG_FMT_IN_END));

                        if (vsdata && !oflag)
                                (void) printf(MSG_ORIG(MSG_FMT_COL_NL));
                        else
                                (void) printf(MSG_ORIG(MSG_FMT_SEM_NL));
                } else {
                        if (vsdata && !oflag)
                                (void) printf(MSG_ORIG(MSG_FMT_TNCO),
                                    vdp->vd_name);
                        else if (!vsdata) {
                                if (oflag)
                                        (void) printf(MSG_ORIG(MSG_FMT_OFIL),
                                            file);
                                (void) printf(MSG_ORIG(MSG_FMT_TNSE),
                                    vdp->vd_name);
                        }
                }

                /* If we are not printing symbols, we're done */
                if (vsdata == NULL)
                        continue;

                /*
                 * If a specific version to match has been specified then
                 * display any of its own symbols plus any inherited from
                 * other versions. Otherwise simply print out the symbols
                 * for this version.
                 */
                gvers_syms(vsdata, vdp->vd_ndx, vdp->vd_name, NULL, file);
                if (alist_nitems(match_list) != 0) {
                        recurse_syms(vsdata, vdp, file);

                        /*
                         * If the verbose flag is set, and this is not
                         * the base version, then add the base version as a
                         * dependency.
                         */
                        if (vflag && bvdp &&
                            !match(NULL, bvdp->vd_name, bvdp->vd_ndx)) {
                                if (!oflag)
                                        (void) printf(MSG_ORIG(MSG_FMT_TNCO),
                                            bvdp->vd_name);
                                gvers_syms(vsdata, bvdp->vd_ndx,
                                    bvdp->vd_name, NULL, file);
                        }
                }
        }
        return (error);
}

int
main(int argc, char **argv, char **envp)
{
        GElf_Shdr       shdr;
        Elf             *elf;
        Elf_Scn         *scn;
        Elf_Data        *data;
        GElf_Ehdr       ehdr;
        int             nfile, var;
        char            *names;
        Cache           *cache, *_cache;
        Cache           *_cache_def, *_cache_need, *_cache_sym, *_cache_loc;
        int             error = 0;
        Gver_sym_data   vsdata_s;
        const Gver_sym_data     *vsdata = NULL;

        /*
         * Check for a binary that better fits this architecture.
         */
        (void) conv_check_native(argv, envp);

        /*
         * Establish locale.
         */
        (void) setlocale(LC_MESSAGES, MSG_ORIG(MSG_STR_EMPTY));
        (void) textdomain(MSG_ORIG(MSG_SUNW_OST_SGS));

        cname = argv[0];
        Cflag = dflag = lflag = nflag = oflag = rflag = sflag = vflag = 0;

        opterr = 0;
        while ((var = getopt(argc, argv, MSG_ORIG(MSG_STR_OPTIONS))) != EOF) {
                switch (var) {
                case 'C':
                        Cflag = USR_DEFINED;
                        break;
                case 'd':
                        dflag = USR_DEFINED;
                        break;
                case 'l':
                        lflag = sflag = USR_DEFINED;
                        break;
                case 'n':
                        nflag = USR_DEFINED;
                        break;
                case 'o':
                        oflag = USR_DEFINED;
                        break;
                case 'r':
                        rflag = USR_DEFINED;
                        break;
                case 's':
                        sflag = USR_DEFINED;
                        break;
                case 'v':
                        vflag = USR_DEFINED;
                        break;
                case 'I':
                case 'N':
                        add_match_record(var, optarg);
                        break;
                case '?':
                        (void) fprintf(stderr, MSG_INTL(MSG_USAGE_BRIEF),
                            cname);
                        (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL));
                        exit(1);
                default:
                        break;
                }
        }

        /*
         * No files specified on the command line?
         */
        if ((nfile = argc - optind) == 0) {
                (void) fprintf(stderr, MSG_INTL(MSG_USAGE_BRIEF), cname);
                exit(1);
        }

        /*
         * By default print both version definitions and needed dependencies.
         */
        if ((dflag == 0) && (rflag == 0) && (lflag == 0))
                dflag = rflag = DEF_DEFINED;

        /*
         * Open the input file and initialize the elf interface.
         */
        for (; optind < argc; optind++) {
                int             derror = 0, nerror = 0, err;
                const char      *file = argv[optind];
                size_t          shnum = 0;

                if ((var = open(file, O_RDONLY)) == -1) {
                        err = errno;
                        (void) fprintf(stderr, MSG_INTL(MSG_SYS_OPEN),
                            cname, file, strerror(err));
                        error = 1;
                        continue;
                }
                (void) elf_version(EV_CURRENT);
                if ((elf = elf_begin(var, ELF_C_READ, NULL)) == NULL) {
                        (void) fprintf(stderr, MSG_ORIG(MSG_ELF_BEGIN), cname,
                            file, elf_errmsg(elf_errno()));
                        error = 1;
                        (void) close(var);
                        continue;
                }
                if (elf_kind(elf) != ELF_K_ELF) {
                        (void) fprintf(stderr, MSG_INTL(MSG_ELF_NOTELF), cname,
                            file);
                        error = 1;
                        (void) close(var);
                        (void) elf_end(elf);
                        continue;
                }
                if (gelf_getehdr(elf, &ehdr) == NULL) {
                        (void) fprintf(stderr, MSG_ORIG(MSG_ELF_GETEHDR), cname,
                            file, elf_errmsg(elf_errno()));
                        error = 1;
                        (void) close(var);
                        (void) elf_end(elf);
                        continue;
                }

                /*
                 *  Obtain the .shstrtab data buffer to provide the required
                 * section name strings.
                 */
                if ((scn = elf_getscn(elf, ehdr.e_shstrndx)) == NULL) {
                        (void) fprintf(stderr, MSG_ORIG(MSG_ELF_GETSCN), cname,
                            file, elf_errmsg(elf_errno()));
                        error = 1;
                        (void) close(var);
                        (void) elf_end(elf);
                        continue;
                }
                if ((data = elf_getdata(scn, NULL)) == NULL) {
                        (void) fprintf(stderr, MSG_ORIG(MSG_ELF_GETDATA), cname,
                            file, elf_errmsg(elf_errno()));
                        error = 1;
                        (void) close(var);
                        (void) elf_end(elf);
                        continue;
                }
                names = data->d_buf;

                /*
                 * Fill in the cache descriptor with information for each
                 * section we might need.   We probably only need to save
                 * read-only allocable sections as this is where the version
                 * structures and their associated symbols and strings live.
                 * However, God knows what someone can do with a mapfile, and
                 * as elf_begin has already gone through all the overhead we
                 * might as well set up the cache for every section.
                 */
                if (elf_getshdrnum(elf, &shnum) == -1) {
                        (void) fprintf(stderr, MSG_ORIG(MSG_ELF_GETSHDRNUM),
                            cname, file, elf_errmsg(elf_errno()));
                        exit(1);
                }

                if ((cache = calloc(shnum, sizeof (Cache))) == NULL) {
                        int err = errno;
                        (void) fprintf(stderr, MSG_INTL(MSG_SYS_MALLOC), cname,
                            file, strerror(err));
                        exit(1);
                }

                _cache_def = _cache_need = _cache_sym = _cache_loc = NULL;
                _cache = cache;
                _cache++;
                for (scn = NULL; scn = elf_nextscn(elf, scn); _cache++) {
                        if (gelf_getshdr(scn, &shdr) == NULL) {
                                (void) fprintf(stderr,
                                    MSG_ORIG(MSG_ELF_GETSHDR), cname, file,
                                    elf_errmsg(elf_errno()));
                                error = 1;
                                continue;
                        }
                        if ((_cache->c_data = elf_getdata(scn, NULL)) ==
                            NULL) {
                                (void) fprintf(stderr,
                                    MSG_ORIG(MSG_ELF_GETDATA), cname, file,
                                    elf_errmsg(elf_errno()));
                                error = 1;
                                continue;
                        }
                        _cache->c_scn = scn;
                        _cache->c_name = names + shdr.sh_name;

                        /*
                         * Remember the version sections and symbol table.
                         */
                        switch (shdr.sh_type) {
                        case SHT_SUNW_verdef:
                                if (dflag)
                                        _cache_def = _cache;
                                break;
                        case SHT_SUNW_verneed:
                                if (rflag)
                                        _cache_need = _cache;
                                break;
                        case SHT_SUNW_versym:
                                if (sflag)
                                        _cache_sym = _cache;
                                break;
                        case SHT_SYMTAB:
                                if (lflag)
                                        _cache_loc = _cache;
                                break;
                        }
                }

                /*
                 * Before printing anything out determine if any warnings are
                 * necessary.
                 */
                if (lflag && (_cache_loc == NULL)) {
                        (void) fprintf(stderr, MSG_INTL(MSG_VER_UNREDSYMS),
                            cname, file);
                        (void) fprintf(stderr, MSG_INTL(MSG_VER_NOSYMTAB));
                }

                /*
                 * If there is more than one input file, and we're not printing
                 * one-line output, display the filename being processed.
                 */
                if ((nfile > 1) && !oflag)
                        (void) printf(MSG_ORIG(MSG_FMT_FILE), file);

                /*
                 * If we're printing symbols, then collect the data
                 * necessary to do that.
                 */
                if (_cache_sym != NULL) {
                        vsdata = &vsdata_s;
                        (void) gelf_getshdr(_cache_sym->c_scn, &shdr);
                        vsdata_s.vsd_vsp =
                            (GElf_Versym *)_cache_sym->c_data->d_buf;
                        vsdata_s.vsd_sym_data = cache[shdr.sh_link].c_data;
                        (void) gelf_getshdr(cache[shdr.sh_link].c_scn, &shdr);
                        vsdata_s.vsd_symn = shdr.sh_size / shdr.sh_entsize;
                        vsdata_s.vsd_strs =
                            (const char *)cache[shdr.sh_link].c_data->d_buf;
                }


                /*
                 * Print the files version needed sections.
                 */
                if (_cache_need)
                        nerror = gvers_need(cache, _cache_need, vsdata, file);

                /*
                 * Print the files version definition sections.
                 */
                if (_cache_def)
                        derror = gvers_def(cache, _cache_def, vsdata, file);

                /*
                 * Print any local symbol reductions.
                 */
                if (_cache_loc)
                        sym_local(cache, _cache_loc, file);

                /*
                 * Determine the error return.  There are three conditions that
                 * may produce an error (a non-zero return):
                 *
                 *  o   if the user specified -d and no version definitions
                 *      were found.
                 *
                 *  o   if the user specified -r and no version requirements
                 *      were found.
                 *
                 *  o   if the user specified neither -d or -r, (thus both are
                 *      enabled by default), and no version definitions or
                 *      version dependencies were found.
                 */
                if (((dflag == USR_DEFINED) && (derror == 0)) ||
                    ((rflag == USR_DEFINED) && (nerror == 0)) ||
                    (rflag && dflag && (derror == 0) && (nerror == 0)))
                        error = 1;

                (void) close(var);
                (void) elf_end(elf);
                free(cache);
        }
        return (error);
}

const char *
_pvs_msg(Msg mid)
{
        return (gettext(MSG_ORIG(mid)));
}