xref: /titanic_41/usr/src/cmd/sgs/pvs/common/pvs.c (revision e521049d0fdbd76727f036cb77c99c98d7ee1125)

/*
 * 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)));
}