xref: /illumos-gate/usr/src/cmd/sgs/libld/common/syms.c (revision c524b4fe)

/*
 * 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 (c) 1988 AT&T
 *	  All Rights Reserved
 *
 *
 * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * Symbol table management routines
 */

#define	ELF_TARGET_AMD64

#include	<stdio.h>
#include	<string.h>
#include	<debug.h>
#include	"msg.h"
#include	"_libld.h"

/*
 * AVL tree comparator function:
 *
 * The primary key is the symbol name hash with a secondary key of the symbol
 * name itself.
 */
int
ld_sym_avl_comp(const void *elem1, const void *elem2)
{
	Sym_avlnode	*sav1 = (Sym_avlnode *)elem1;
	Sym_avlnode	*sav2 = (Sym_avlnode *)elem2;
	int		res;

	res = sav1->sav_hash - sav2->sav_hash;

	if (res < 0)
		return (-1);
	if (res > 0)
		return (1);

	/*
	 * Hash is equal - now compare name
	 */
	res = strcmp(sav1->sav_name, sav2->sav_name);
	if (res == 0)
		return (0);
	if (res > 0)
		return (1);
	return (-1);
}

/*
 * Focal point for verifying symbol names.
 */
inline static const char *
string(Ofl_desc *ofl, Ifl_desc *ifl, Sym *sym, const char *strs, size_t strsize,
    int symndx, Word shndx, Word symsecndx, const char *symsecname,
    const char *strsecname, sd_flag_t *flags)
{
	Word	name = sym->st_name;

	if (name) {
		if ((ifl->ifl_flags & FLG_IF_HSTRTAB) == 0) {
			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_NOSTRTABLE),
			    ifl->ifl_name, EC_WORD(symsecndx), symsecname,
			    symndx, EC_XWORD(name));
			return (NULL);
		}
		if (name >= (Word)strsize) {
			ld_eprintf(ofl, ERR_FATAL,
			    MSG_INTL(MSG_FIL_EXCSTRTABLE), ifl->ifl_name,
			    EC_WORD(symsecndx), symsecname, symndx,
			    EC_XWORD(name), strsecname, EC_XWORD(strsize));
			return (NULL);
		}
	}

	/*
	 * Determine if we're dealing with a register and if so validate it.
	 * If it's a scratch register, a fabricated name will be returned.
	 */
	if (ld_targ.t_ms.ms_is_regsym != NULL) {
		const char *regname = (*ld_targ.t_ms.ms_is_regsym)(ofl, ifl,
		    sym, strs, symndx, shndx, symsecname, flags);

		if (regname == (const char *)S_ERROR) {
			return (NULL);
		}
		if (regname)
			return (regname);
	}

	/*
	 * If this isn't a register, but we have a global symbol with a null
	 * name, we're not going to be able to hash this, search for it, or
	 * do anything interesting.  However, we've been accepting a symbol of
	 * this kind for ages now, so give the user a warning (rather than a
	 * fatal error), just in case this instance exists somewhere in the
	 * world and hasn't, as yet, been a problem.
	 */
	if ((name == 0) && (ELF_ST_BIND(sym->st_info) != STB_LOCAL)) {
		ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_FIL_NONAMESYM),
		    ifl->ifl_name, EC_WORD(symsecndx), symsecname, symndx,
		    EC_XWORD(name));
	}
	return (strs + name);
}

/*
 * For producing symbol names strings to use in error messages.
 * If the symbol has a non-null name, then the string returned by
 * this function is the output from demangle(), surrounded by
 * single quotes. For null names, a descriptive string giving
 * the symbol section and index is generated.
 *
 * This function uses an internal static buffer to hold the resulting
 * string. The value returned is usable by the caller until the next
 * call, at which point it is overwritten.
 */
static const char *
demangle_symname(const char *name, const char *symtab_name, Word symndx)
{
#define	INIT_BUFSIZE 256

	static char	*buf;
	static size_t	bufsize = 0;
	size_t		len;
	int		use_name;

	use_name = (name != NULL) && (*name != '\0');

	if (use_name) {
		name = demangle(name);
		len = strlen(name) + 2;   /* Include room for quotes */
	} else {
		name = MSG_ORIG(MSG_STR_EMPTY);
		len = strlen(symtab_name) + 2 + CONV_INV_BUFSIZE;
	}
	len++;			/* Null termination */

	/* If our buffer is too small, double it until it is big enough */
	if (len > bufsize) {
		size_t	new_bufsize = bufsize;
		char	*new_buf;

		if (new_bufsize == 0)
			new_bufsize = INIT_BUFSIZE;
		while (len > new_bufsize)
			new_bufsize *= 2;
		if ((new_buf = libld_malloc(new_bufsize)) == NULL)
			return (name);
		buf = new_buf;
		bufsize = new_bufsize;
	}

	if (use_name) {
		(void) snprintf(buf, bufsize, MSG_ORIG(MSG_FMT_SYMNAM), name);
	} else {
		(void) snprintf(buf, bufsize, MSG_ORIG(MSG_FMT_NULLSYMNAM),
		    symtab_name, EC_WORD(symndx));
	}

	return (buf);

#undef INIT_BUFSIZE
}

/*
 * Shared objects can be built that define specific symbols that can not be
 * directly bound to.  These objects have a syminfo section (and an associated
 * DF_1_NODIRECT dynamic flags entry).  Scan this table looking for symbols
 * that can't be bound to directly, and if this files symbol is presently
 * referenced, mark it so that we don't directly bind to it.
 */
uintptr_t
ld_sym_nodirect(Is_desc *isp, Ifl_desc *ifl, Ofl_desc *ofl)
{
	Shdr		*sifshdr, *symshdr;
	Syminfo		*sifdata;
	Sym		*symdata;
	char		*strdata;
	ulong_t		cnt, _cnt;

	/*
	 * Get the syminfo data, and determine the number of entries.
	 */
	sifshdr = isp->is_shdr;
	sifdata = (Syminfo *)isp->is_indata->d_buf;
	cnt =  sifshdr->sh_size / sifshdr->sh_entsize;

	/*
	 * Get the associated symbol table.
	 */
	if ((sifshdr->sh_link == 0) || (sifshdr->sh_link >= ifl->ifl_shnum)) {
		/*
		 * Broken input file
		 */
		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_INVSHINFO),
		    ifl->ifl_name, isp->is_name, EC_XWORD(sifshdr->sh_link));
		return (0);
	}
	symshdr = ifl->ifl_isdesc[sifshdr->sh_link]->is_shdr;
	symdata = ifl->ifl_isdesc[sifshdr->sh_link]->is_indata->d_buf;

	/*
	 * Get the string table associated with the symbol table.
	 */
	strdata = ifl->ifl_isdesc[symshdr->sh_link]->is_indata->d_buf;

	/*
	 * Traverse the syminfo data for symbols that can't be directly
	 * bound to.
	 */
	for (_cnt = 1, sifdata++; _cnt < cnt; _cnt++, sifdata++) {
		Sym		*sym;
		char		*str;
		Sym_desc	*sdp;

		if ((sifdata->si_flags & SYMINFO_FLG_NOEXTDIRECT) == 0)
			continue;

		sym = (Sym *)(symdata + _cnt);
		str = (char *)(strdata + sym->st_name);

		if ((sdp = ld_sym_find(str, SYM_NOHASH, NULL, ofl)) != NULL) {
			if (ifl != sdp->sd_file)
				continue;

			sdp->sd_flags &= ~FLG_SY_DIR;
			sdp->sd_flags |= FLG_SY_NDIR;
		}
	}
	return (0);
}

/*
 * If, during symbol processing, it is necessary to update a local symbols
 * contents before we have generated the symbol tables in the output image,
 * create a new symbol structure and copy the original symbol contents.  While
 * we are processing the input files, their local symbols are part of the
 * read-only mapped image.  Commonly, these symbols are copied to the new output
 * file image and then updated to reflect their new address and any change in
 * attributes.  However, sometimes during relocation counting, it is necessary
 * to adjust the symbols information.  This routine provides for the generation
 * of a new symbol image so that this update can be performed.
 * All global symbols are copied to an internal symbol table to improve locality
 * of reference and hence performance, and thus this copying is not necessary.
 */
uintptr_t
ld_sym_copy(Sym_desc *sdp)
{
	Sym	*nsym;

	if (sdp->sd_flags & FLG_SY_CLEAN) {
		if ((nsym = libld_malloc(sizeof (Sym))) == NULL)
			return (S_ERROR);
		*nsym = *(sdp->sd_sym);
		sdp->sd_sym = nsym;
		sdp->sd_flags &= ~FLG_SY_CLEAN;
	}
	return (1);
}

/*
 * Finds a given name in the link editors internal symbol table.  If no
 * hash value is specified it is calculated.  A pointer to the located
 * Sym_desc entry is returned, or NULL if the symbol is not found.
 */
Sym_desc *
ld_sym_find(const char *name, Word hash, avl_index_t *where, Ofl_desc *ofl)
{
	Sym_avlnode	qsav, *sav;

	if (hash == SYM_NOHASH)
		/* LINTED */
		hash = (Word)elf_hash((const char *)name);
	qsav.sav_hash = hash;
	qsav.sav_name = name;

	/*
	 * Perform search for symbol in AVL tree.  Note that the 'where' field
	 * is passed in from the caller.  If a 'where' is present, it can be
	 * used in subsequent 'ld_sym_enter()' calls if required.
	 */
	sav = avl_find(&ofl->ofl_symavl, &qsav, where);

	/*
	 * If symbol was not found in the avl tree, return null to show that.
	 */
	if (sav == NULL)
		return (NULL);

	/*
	 * Return symbol found.
	 */
	return (sav->sav_sdp);
}

/*
 * Enter a new symbol into the link editors internal symbol table.
 * If the symbol is from an input file, information regarding the input file
 * and input section is also recorded.  Otherwise (file == NULL) the symbol
 * has been internally generated (ie. _etext, _edata, etc.).
 */
Sym_desc *
ld_sym_enter(const char *name, Sym *osym, Word hash, Ifl_desc *ifl,
    Ofl_desc *ofl, Word ndx, Word shndx, sd_flag_t sdflags, avl_index_t *where)
{
	Sym_desc	*sdp;
	Sym_aux		*sap;
	Sym_avlnode	*savl;
	char		*_name;
	Sym		*nsym;
	Half		etype;
	uchar_t		vis;
	avl_index_t	_where;

	/*
	 * Establish the file type.
	 */
	if (ifl)
		etype = ifl->ifl_ehdr->e_type;
	else
		etype = ET_NONE;

	ofl->ofl_entercnt++;

	/*
	 * Allocate a Sym Descriptor, Auxiliary Descriptor, and a Sym AVLNode -
	 * contiguously.
	 */
	if ((savl = libld_calloc(S_DROUND(sizeof (Sym_avlnode)) +
	    S_DROUND(sizeof (Sym_desc)) +
	    S_DROUND(sizeof (Sym_aux)), 1)) == NULL)
		return ((Sym_desc *)S_ERROR);
	sdp = (Sym_desc *)((uintptr_t)savl +
	    S_DROUND(sizeof (Sym_avlnode)));
	sap = (Sym_aux *)((uintptr_t)sdp +
	    S_DROUND(sizeof (Sym_desc)));

	savl->sav_sdp = sdp;
	sdp->sd_file = ifl;
	sdp->sd_aux = sap;
	savl->sav_hash = sap->sa_hash = hash;

	/*
	 * Copy the symbol table entry from the input file into the internal
	 * entry and have the symbol descriptor use it.
	 */
	sdp->sd_sym = nsym = &sap->sa_sym;
	*nsym = *osym;
	sdp->sd_shndx = shndx;
	sdp->sd_flags |= sdflags;

	if ((_name = libld_malloc(strlen(name) + 1)) == NULL)
		return ((Sym_desc *)S_ERROR);
	savl->sav_name = sdp->sd_name = (const char *)strcpy(_name, name);

	/*
	 * Enter Symbol in AVL tree.
	 */
	if (where == 0) {
		/* LINTED */
		Sym_avlnode	*_savl;
		/*
		 * If a previous ld_sym_find() hasn't initialized 'where' do it
		 * now.
		 */
		where = &_where;
		_savl = avl_find(&ofl->ofl_symavl, savl, where);
		assert(_savl == NULL);
	}
	avl_insert(&ofl->ofl_symavl, savl, *where);

	/*
	 * Record the section index.  This is possible because the
	 * `ifl_isdesc' table is filled before we start symbol processing.
	 */
	if ((sdflags & FLG_SY_SPECSEC) || (nsym->st_shndx == SHN_UNDEF))
		sdp->sd_isc = NULL;
	else {
		sdp->sd_isc = ifl->ifl_isdesc[shndx];

		/*
		 * If this symbol is from a relocatable object, make sure that
		 * it is still associated with a section.  For example, an
		 * unknown section type (SHT_NULL) would have been rejected on
		 * input with a warning.  Here, we make the use of the symbol
		 * fatal.  A symbol descriptor is still returned, so that the
		 * caller can continue processing all symbols, and hence flush
		 * out as many error conditions as possible.
		 */
		if ((etype == ET_REL) && (sdp->sd_isc == NULL)) {
			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYM_INVSEC),
			    name, ifl->ifl_name, EC_XWORD(shndx));
			return (sdp);
		}
	}

	/*
	 * Mark any COMMON symbols as 'tentative'.
	 */
	if (sdflags & FLG_SY_SPECSEC) {
		if (nsym->st_shndx == SHN_COMMON)
			sdp->sd_flags |= FLG_SY_TENTSYM;
#if	defined(_ELF64)
		else if ((ld_targ.t_m.m_mach == EM_AMD64) &&
		    (nsym->st_shndx == SHN_X86_64_LCOMMON))
			sdp->sd_flags |= FLG_SY_TENTSYM;
#endif
	}

	/*
	 * Establish the symbols visibility and reference.
	 */
	vis = ELF_ST_VISIBILITY(nsym->st_other);

	if ((etype == ET_NONE) || (etype == ET_REL)) {
		switch (vis) {
		case STV_DEFAULT:
			sdp->sd_flags |= FLG_SY_DEFAULT;
			break;
		case STV_INTERNAL:
		case STV_HIDDEN:
			sdp->sd_flags |= FLG_SY_HIDDEN;
			break;
		case STV_PROTECTED:
			sdp->sd_flags |= FLG_SY_PROTECT;
			break;
		case STV_EXPORTED:
			sdp->sd_flags |= FLG_SY_EXPORT;
			break;
		case STV_SINGLETON:
			sdp->sd_flags |= (FLG_SY_SINGLE | FLG_SY_NDIR);
			ofl->ofl_flags1 |= (FLG_OF1_NDIRECT | FLG_OF1_NGLBDIR);
			break;
		case STV_ELIMINATE:
			sdp->sd_flags |= (FLG_SY_HIDDEN | FLG_SY_ELIM);
			break;
		default:
			assert(vis <= STV_ELIMINATE);
		}

		sdp->sd_ref = REF_REL_NEED;

		/*
		 * Under -Bnodirect, all exported interfaces that have not
		 * explicitly been defined protected or directly bound to, are
		 * tagged to prevent direct binding.
		 */
		if ((ofl->ofl_flags1 & FLG_OF1_ALNODIR) &&
		    ((sdp->sd_flags & (FLG_SY_PROTECT | FLG_SY_DIR)) == 0) &&
		    (nsym->st_shndx != SHN_UNDEF)) {
			sdp->sd_flags |= FLG_SY_NDIR;
		}
	} else {
		sdp->sd_ref = REF_DYN_SEEN;

		/*
		 * If this is a protected symbol, remember this.  Note, this
		 * state is different from the FLG_SY_PROTECT used to establish
		 * a symbol definitions visibility.  This state is used to warn
		 * against possible copy relocations against this referenced
		 * symbol.
		 */
		if (vis == STV_PROTECTED)
			sdp->sd_flags |= FLG_SY_PROT;

		/*
		 * If this is a SINGLETON definition, then indicate the symbol
		 * can not be directly bound to, and retain the visibility.
		 * This visibility will be inherited by any references made to
		 * this symbol.
		 */
		if ((vis == STV_SINGLETON) && (nsym->st_shndx != SHN_UNDEF))
			sdp->sd_flags |= (FLG_SY_SINGLE | FLG_SY_NDIR);

		/*
		 * If the new symbol is from a shared library and is associated
		 * with a SHT_NOBITS section then this symbol originated from a
		 * tentative symbol.
		 */
		if (sdp->sd_isc &&
		    (sdp->sd_isc->is_shdr->sh_type == SHT_NOBITS))
			sdp->sd_flags |= FLG_SY_TENTSYM;
	}

	/*
	 * Reclassify any SHN_SUNW_IGNORE symbols to SHN_UNDEF so as to
	 * simplify future processing.
	 */
	if (nsym->st_shndx == SHN_SUNW_IGNORE) {
		sdp->sd_shndx = shndx = SHN_UNDEF;
		sdp->sd_flags |= (FLG_SY_REDUCED |
		    FLG_SY_HIDDEN | FLG_SY_IGNORE | FLG_SY_ELIM);
	}

	/*
	 * If this is an undefined, or common symbol from a relocatable object
	 * determine whether it is a global or weak reference (see build_osym(),
	 * where REF_DYN_NEED definitions are returned back to undefines).
	 */
	if ((etype == ET_REL) &&
	    (ELF_ST_BIND(nsym->st_info) == STB_GLOBAL) &&
	    ((nsym->st_shndx == SHN_UNDEF) || ((sdflags & FLG_SY_SPECSEC) &&
#if	defined(_ELF64)
	    ((nsym->st_shndx == SHN_COMMON) ||
	    ((ld_targ.t_m.m_mach == EM_AMD64) &&
	    (nsym->st_shndx == SHN_X86_64_LCOMMON))))))
#else
	/* BEGIN CSTYLED */
	    (nsym->st_shndx == SHN_COMMON))))
	/* END CSTYLED */
#endif
		sdp->sd_flags |= FLG_SY_GLOBREF;

	/*
	 * Record the input filename on the referenced or defined files list
	 * for possible later diagnostics.  The `sa_rfile' pointer contains the
	 * name of the file that first referenced this symbol and is used to
	 * generate undefined symbol diagnostics (refer to sym_undef_entry()).
	 * Note that this entry can be overridden if a reference from a
	 * relocatable object is found after a reference from a shared object
	 * (refer to sym_override()).
	 * The `sa_dfiles' list is used to maintain the list of files that
	 * define the same symbol.  This list can be used for two reasons:
	 *
	 *  -	To save the first definition of a symbol that is not available
	 *	for this link-edit.
	 *
	 *  -	To save all definitions of a symbol when the -m option is in
	 *	effect.  This is optional as it is used to list multiple
	 *	(interposed) definitions of a symbol (refer to ldmap_out()),
	 *	and can be quite expensive.
	 */
	if (nsym->st_shndx == SHN_UNDEF) {
		sap->sa_rfile = ifl->ifl_name;
	} else {
		if (sdp->sd_ref == REF_DYN_SEEN) {
			/*
			 * A symbol is determined to be unavailable if it
			 * belongs to a version of a shared object that this
			 * user does not wish to use, or if it belongs to an
			 * implicit shared object.
			 */
			if (ifl->ifl_vercnt) {
				Ver_index	*vip;
				Half		vndx = ifl->ifl_versym[ndx];

				sap->sa_dverndx = vndx;
				vip = &ifl->ifl_verndx[vndx];
				if (!(vip->vi_flags & FLG_VER_AVAIL)) {
					sdp->sd_flags |= FLG_SY_NOTAVAIL;
					sap->sa_vfile = ifl->ifl_name;
				}
			}
			if (!(ifl->ifl_flags & FLG_IF_NEEDED))
				sdp->sd_flags |= FLG_SY_NOTAVAIL;

		} else if (etype == ET_REL) {
			/*
			 * If this symbol has been obtained from a versioned
			 * input relocatable object then the new symbol must be
			 * promoted to the versioning of the output file.
			 */
			if (ifl->ifl_versym)
				ld_vers_promote(sdp, ndx, ifl, ofl);
		}

		if ((ofl->ofl_flags & FLG_OF_GENMAP) &&
		    ((sdflags & FLG_SY_SPECSEC) == 0))
			if (aplist_append(&sap->sa_dfiles, ifl->ifl_name,
			    AL_CNT_SDP_DFILES) == NULL)
				return ((Sym_desc *)S_ERROR);
	}

	/*
	 * Provided we're not processing a mapfile, diagnose the entered symbol.
	 * Mapfile processing requires the symbol to be updated with additional
	 * information, therefore the diagnosing of the symbol is deferred until
	 * later (see Dbg_map_symbol()).
	 */
	if ((ifl == NULL) || ((ifl->ifl_flags & FLG_IF_MAPFILE) == 0))
		DBG_CALL(Dbg_syms_entered(ofl, nsym, sdp));

	return (sdp);
}

/*
 * Add a special symbol to the symbol table.  Takes special symbol name with
 * and without underscores.  This routine is called, after all other symbol
 * resolution has completed, to generate a reserved absolute symbol (the
 * underscore version).  Special symbols are updated with the appropriate
 * values in update_osym().  If the user has already defined this symbol
 * issue a warning and leave the symbol as is.  If the non-underscore symbol
 * is referenced then turn it into a weak alias of the underscored symbol.
 *
 * The bits in sdflags_u are OR'd into the flags field of the symbol for the
 * underscored symbol.
 *
 * If this is a global symbol, and it hasn't explicitly been defined as being
 * directly bound to, indicate that it can't be directly bound to.
 * Historically, most special symbols only have meaning to the object in which
 * they exist, however, they've always been global.  To ensure compatibility
 * with any unexpected use presently in effect, ensure these symbols don't get
 * directly bound to.  Note, that establishing this state here isn't sufficient
 * to create a syminfo table, only if a syminfo table is being created by some
 * other symbol directives will the nodirect binding be recorded.  This ensures
 * we don't create syminfo sections for all objects we create, as this might add
 * unnecessary bloat to users who haven't explicitly requested extra symbol
 * information.
 */
static uintptr_t
sym_add_spec(const char *name, const char *uname, Word sdaux_id,
    sd_flag_t sdflags_u, sd_flag_t sdflags, Ofl_desc *ofl)
{
	Sym_desc	*sdp;
	Sym_desc	*usdp;
	Sym		*sym;
	Word		hash;
	avl_index_t	where;

	/* LINTED */
	hash = (Word)elf_hash(uname);
	if (usdp = ld_sym_find(uname, hash, &where, ofl)) {
		/*
		 * If the underscore symbol exists and is undefined, or was
		 * defined in a shared library, convert it to a local symbol.
		 * Otherwise leave it as is and warn the user.
		 */
		if ((usdp->sd_shndx == SHN_UNDEF) ||
		    (usdp->sd_ref != REF_REL_NEED)) {
			usdp->sd_ref = REF_REL_NEED;
			usdp->sd_shndx = usdp->sd_sym->st_shndx = SHN_ABS;
			usdp->sd_flags |= FLG_SY_SPECSEC | sdflags_u;
			usdp->sd_sym->st_info =
			    ELF_ST_INFO(STB_GLOBAL, STT_OBJECT);
			usdp->sd_isc = NULL;
			usdp->sd_sym->st_size = 0;
			usdp->sd_sym->st_value = 0;
			/* LINTED */
			usdp->sd_aux->sa_symspec = (Half)sdaux_id;

			/*
			 * If a user hasn't specifically indicated that the
			 * scope of this symbol be made local, then leave it
			 * as global (ie. prevent automatic scoping).  The GOT
			 * should be defined protected, whereas all other
			 * special symbols are tagged as no-direct.
			 */
			if (!SYM_IS_HIDDEN(usdp) &&
			    (sdflags & FLG_SY_DEFAULT)) {
				usdp->sd_aux->sa_overndx = VER_NDX_GLOBAL;
				if (sdaux_id == SDAUX_ID_GOT) {
					usdp->sd_flags &= ~FLG_SY_NDIR;
					usdp->sd_flags |= FLG_SY_PROTECT;
					usdp->sd_sym->st_other = STV_PROTECTED;
				} else if (
				    ((usdp->sd_flags & FLG_SY_DIR) == 0) &&
				    ((ofl->ofl_flags & FLG_OF_SYMBOLIC) == 0)) {
					usdp->sd_flags |= FLG_SY_NDIR;
				}
			}
			usdp->sd_flags |= sdflags;

			/*
			 * If the reference originated from a mapfile ensure
			 * we mark the symbol as used.
			 */
			if (usdp->sd_flags & FLG_SY_MAPREF)
				usdp->sd_flags |= FLG_SY_MAPUSED;

			DBG_CALL(Dbg_syms_updated(ofl, usdp, uname));
		} else
			ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SYM_RESERVE),
			    uname, usdp->sd_file->ifl_name);
	} else {
		/*
		 * If the symbol does not exist create it.
		 */
		if ((sym = libld_calloc(sizeof (Sym), 1)) == NULL)
			return (S_ERROR);
		sym->st_shndx = SHN_ABS;
		sym->st_info = ELF_ST_INFO(STB_GLOBAL, STT_OBJECT);
		sym->st_size = 0;
		sym->st_value = 0;
		DBG_CALL(Dbg_syms_created(ofl->ofl_lml, uname));
		if ((usdp = ld_sym_enter(uname, sym, hash, (Ifl_desc *)NULL,
		    ofl, 0, SHN_ABS, (FLG_SY_SPECSEC | sdflags_u), &where)) ==
		    (Sym_desc *)S_ERROR)
			return (S_ERROR);
		usdp->sd_ref = REF_REL_NEED;
		/* LINTED */
		usdp->sd_aux->sa_symspec = (Half)sdaux_id;

		usdp->sd_aux->sa_overndx = VER_NDX_GLOBAL;

		if (sdaux_id == SDAUX_ID_GOT) {
			usdp->sd_flags |= FLG_SY_PROTECT;
			usdp->sd_sym->st_other = STV_PROTECTED;
		} else if ((sdflags & FLG_SY_DEFAULT) &&
		    ((ofl->ofl_flags & FLG_OF_SYMBOLIC) == 0)) {
			usdp->sd_flags |= FLG_SY_NDIR;
		}
		usdp->sd_flags |= sdflags;
	}

	if (name && (sdp = ld_sym_find(name, SYM_NOHASH, NULL, ofl)) &&
	    (sdp->sd_sym->st_shndx == SHN_UNDEF)) {
		uchar_t	bind;

		/*
		 * If the non-underscore symbol exists and is undefined
		 * convert it to be a local.  If the underscore has
		 * sa_symspec set (ie. it was created above) then simulate this
		 * as a weak alias.
		 */
		sdp->sd_ref = REF_REL_NEED;
		sdp->sd_shndx = sdp->sd_sym->st_shndx = SHN_ABS;
		sdp->sd_flags |= FLG_SY_SPECSEC;
		sdp->sd_isc = NULL;
		sdp->sd_sym->st_size = 0;
		sdp->sd_sym->st_value = 0;
		/* LINTED */
		sdp->sd_aux->sa_symspec = (Half)sdaux_id;
		if (usdp->sd_aux->sa_symspec) {
			usdp->sd_aux->sa_linkndx = 0;
			sdp->sd_aux->sa_linkndx = 0;
			bind = STB_WEAK;
		} else
			bind = STB_GLOBAL;
		sdp->sd_sym->st_info = ELF_ST_INFO(bind, STT_OBJECT);

		/*
		 * If a user hasn't specifically indicated the scope of this
		 * symbol be made local then leave it as global (ie. prevent
		 * automatic scoping).  The GOT should be defined protected,
		 * whereas all other special symbols are tagged as no-direct.
		 */
		if (!SYM_IS_HIDDEN(sdp) &&
		    (sdflags & FLG_SY_DEFAULT)) {
			sdp->sd_aux->sa_overndx = VER_NDX_GLOBAL;
			if (sdaux_id == SDAUX_ID_GOT) {
				sdp->sd_flags &= ~FLG_SY_NDIR;
				sdp->sd_flags |= FLG_SY_PROTECT;
				sdp->sd_sym->st_other = STV_PROTECTED;
			} else if (((sdp->sd_flags & FLG_SY_DIR) == 0) &&
			    ((ofl->ofl_flags & FLG_OF_SYMBOLIC) == 0)) {
				sdp->sd_flags |= FLG_SY_NDIR;
			}
		}
		sdp->sd_flags |= sdflags;

		/*
		 * If the reference originated from a mapfile ensure
		 * we mark the symbol as used.
		 */
		if (sdp->sd_flags & FLG_SY_MAPREF)
			sdp->sd_flags |= FLG_SY_MAPUSED;

		DBG_CALL(Dbg_syms_updated(ofl, sdp, name));
	}
	return (1);
}


/*
 * Undefined symbols can fall into one of four types:
 *
 *  -	the symbol is really undefined (SHN_UNDEF).
 *
 *  -	versioning has been enabled, however this symbol has not been assigned
 *	to one of the defined versions.
 *
 *  -	the symbol has been defined by an implicitly supplied library, ie. one
 *	which was encounted because it was NEEDED by another library, rather
 *	than from a command line supplied library which would become the only
 *	dependency of the output file being produced.
 *
 *  -	the symbol has been defined by a version of a shared object that is
 *	not permitted for this link-edit.
 *
 * In all cases the file who made the first reference to this symbol will have
 * been recorded via the `sa_rfile' pointer.
 */
typedef enum {
	UNDEF,		NOVERSION,	IMPLICIT,	NOTAVAIL,
	BNDLOCAL
} Type;

static const Msg format[] = {
	MSG_SYM_UND_UNDEF,		/* MSG_INTL(MSG_SYM_UND_UNDEF) */
	MSG_SYM_UND_NOVER,		/* MSG_INTL(MSG_SYM_UND_NOVER) */
	MSG_SYM_UND_IMPL,		/* MSG_INTL(MSG_SYM_UND_IMPL) */
	MSG_SYM_UND_NOTA,		/* MSG_INTL(MSG_SYM_UND_NOTA) */
	MSG_SYM_UND_BNDLOCAL		/* MSG_INTL(MSG_SYM_UND_BNDLOCAL) */
};

/*
 * Issue an undefined symbol message for the given symbol.
 *
 * entry:
 *	ofl - Output descriptor
 *	sdp - Undefined symbol to report
 *	type - Type of undefined symbol
 *	ofl_flag - One of 0, FLG_OF_FATAL, or FLG_OF_WARN.
 *	undef_state - Address of variable to be initialized to 0
 *		before the first call to sym_undef_entry, and passed
 *		to each subsequent call. A non-zero value for *undef_state
 *		indicates that this is not the first call in the series.
 *
 * exit:
 *	If *undef_state is 0, a title is issued.
 *
 *	A message for the undefined symbol is issued.
 *
 *	If ofl_flag is non-zero, its value is OR'd into *undef_state. Otherwise,
 *	all bits other than FLG_OF_FATAL and FLG_OF_WARN are set, in order to
 *	provide *undef_state with a non-zero value. These other bits have
 *	no meaning beyond that, and serve to ensure that *undef_state is
 *	non-zero if sym_undef_entry() has been called.
 */
static void
sym_undef_entry(Ofl_desc *ofl, Sym_desc *sdp, Type type, ofl_flag_t ofl_flag,
    ofl_flag_t *undef_state)
{
	const char	*name1, *name2, *name3;
	Ifl_desc	*ifl = sdp->sd_file;
	Sym_aux		*sap = sdp->sd_aux;

	if (*undef_state == 0)
		ld_eprintf(ofl, ERR_NONE, MSG_INTL(MSG_SYM_FMT_UNDEF),
		    MSG_INTL(MSG_SYM_UNDEF_ITM_11),
		    MSG_INTL(MSG_SYM_UNDEF_ITM_21),
		    MSG_INTL(MSG_SYM_UNDEF_ITM_12),
		    MSG_INTL(MSG_SYM_UNDEF_ITM_22));

	ofl->ofl_flags |= ofl_flag;
	*undef_state |= ofl_flag ? ofl_flag : ~(FLG_OF_FATAL | FLG_OF_WARN);

	switch (type) {
	case UNDEF:
	case BNDLOCAL:
		name1 = sap->sa_rfile;
		break;
	case NOVERSION:
		name1 = ifl->ifl_name;
		break;
	case IMPLICIT:
		name1 = sap->sa_rfile;
		name2 = ifl->ifl_name;
		break;
	case NOTAVAIL:
		name1 = sap->sa_rfile;
		name2 = sap->sa_vfile;
		name3 = ifl->ifl_verndx[sap->sa_dverndx].vi_name;
		break;
	default:
		return;
	}

	ld_eprintf(ofl, ERR_NONE, MSG_INTL(format[type]),
	    demangle(sdp->sd_name), name1, name2, name3);
}

/*
 * At this point all symbol input processing has been completed, therefore
 * complete the symbol table entries by generating any necessary internal
 * symbols.
 */
uintptr_t
ld_sym_spec(Ofl_desc *ofl)
{
	Sym_desc	*sdp;

	if (ofl->ofl_flags & FLG_OF_RELOBJ)
		return (1);

	DBG_CALL(Dbg_syms_spec_title(ofl->ofl_lml));

	if (sym_add_spec(MSG_ORIG(MSG_SYM_ETEXT), MSG_ORIG(MSG_SYM_ETEXT_U),
	    SDAUX_ID_ETEXT, 0, (FLG_SY_DEFAULT | FLG_SY_EXPDEF),
	    ofl) == S_ERROR)
		return (S_ERROR);
	if (sym_add_spec(MSG_ORIG(MSG_SYM_EDATA), MSG_ORIG(MSG_SYM_EDATA_U),
	    SDAUX_ID_EDATA, 0, (FLG_SY_DEFAULT | FLG_SY_EXPDEF),
	    ofl) == S_ERROR)
		return (S_ERROR);
	if (sym_add_spec(MSG_ORIG(MSG_SYM_END), MSG_ORIG(MSG_SYM_END_U),
	    SDAUX_ID_END, FLG_SY_DYNSORT, (FLG_SY_DEFAULT | FLG_SY_EXPDEF),
	    ofl) == S_ERROR)
		return (S_ERROR);
	if (sym_add_spec(MSG_ORIG(MSG_SYM_L_END), MSG_ORIG(MSG_SYM_L_END_U),
	    SDAUX_ID_END, 0, FLG_SY_HIDDEN, ofl) == S_ERROR)
		return (S_ERROR);
	if (sym_add_spec(MSG_ORIG(MSG_SYM_L_START), MSG_ORIG(MSG_SYM_L_START_U),
	    SDAUX_ID_START, 0, FLG_SY_HIDDEN, ofl) == S_ERROR)
		return (S_ERROR);

	/*
	 * Historically we've always produced a _DYNAMIC symbol, even for
	 * static executables (in which case its value will be 0).
	 */
	if (sym_add_spec(MSG_ORIG(MSG_SYM_DYNAMIC), MSG_ORIG(MSG_SYM_DYNAMIC_U),
	    SDAUX_ID_DYN, FLG_SY_DYNSORT, (FLG_SY_DEFAULT | FLG_SY_EXPDEF),
	    ofl) == S_ERROR)
		return (S_ERROR);

	if (OFL_ALLOW_DYNSYM(ofl))
		if (sym_add_spec(MSG_ORIG(MSG_SYM_PLKTBL),
		    MSG_ORIG(MSG_SYM_PLKTBL_U), SDAUX_ID_PLT,
		    FLG_SY_DYNSORT, (FLG_SY_DEFAULT | FLG_SY_EXPDEF),
		    ofl) == S_ERROR)
			return (S_ERROR);

	/*
	 * A GOT reference will be accompanied by the associated GOT symbol.
	 * Make sure it gets assigned the appropriate special attributes.
	 */
	if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_GOFTBL_U),
	    SYM_NOHASH, NULL, ofl)) != NULL) && (sdp->sd_ref != REF_DYN_SEEN)) {
		if (sym_add_spec(MSG_ORIG(MSG_SYM_GOFTBL),
		    MSG_ORIG(MSG_SYM_GOFTBL_U), SDAUX_ID_GOT, FLG_SY_DYNSORT,
		    (FLG_SY_DEFAULT | FLG_SY_EXPDEF), ofl) == S_ERROR)
			return (S_ERROR);
	}

	return (1);
}

/*
 * Determine a potential capability symbol's visibility.
 *
 * The -z symbolcap option transforms an object capabilities relocatable object
 * into a symbol capabilities relocatable object.  Any global function symbols,
 * or initialized global data symbols are candidates for transforming into local
 * symbol capabilities definitions.  However, if a user indicates that a symbol
 * should be demoted to local using a mapfile, then there is no need to
 * transform the associated global symbol.
 *
 * Normally, a symbol's visibility is determined after the symbol resolution
 * process, after all symbol state has been gathered and resolved.  However,
 * for -z symbolcap, this determination is too late.  When a global symbol is
 * read from an input file we need to determine it's visibility so as to decide
 * whether to create a local or not.
 *
 * If a user has explicitly defined this symbol as having local scope within a
 * mapfile, then a symbol of the same name already exists.  However, explicit
 * local definitions are uncommon, as most mapfiles define the global symbol
 * requirements together with an auto-reduction directive '*'.  If this state
 * has been defined, then we must make sure that the new symbol isn't a type
 * that can not be demoted to local.
 */
static int
sym_cap_vis(const char *name, Word hash, Sym *sym, Ofl_desc *ofl)
{
	Sym_desc	*sdp;
	uchar_t		vis;
	avl_index_t	where;
	sd_flag_t	sdflags = 0;

	/*
	 * Determine the visibility of the new symbol.
	 */
	vis = ELF_ST_VISIBILITY(sym->st_other);
	switch (vis) {
	case STV_EXPORTED:
		sdflags |= FLG_SY_EXPORT;
		break;
	case STV_SINGLETON:
		sdflags |= FLG_SY_SINGLE;
		break;
	case STV_HIDDEN:
		sdflags |= FLG_SY_HIDDEN;
		break;
	}

	/*
	 * Determine whether a symbol definition already exists, and if so
	 * obtain the visibility.
	 */
	if ((sdp = ld_sym_find(name, hash, &where, ofl)) != NULL)
		sdflags |= sdp->sd_flags;

	/*
	 * Determine whether the symbol flags indicate this symbol should be
	 * hidden.
	 */
	if ((ofl->ofl_flags & (FLG_OF_AUTOLCL | FLG_OF_AUTOELM)) &&
	    ((sdflags & MSK_SY_NOAUTO) == 0))
		sdflags |= FLG_SY_HIDDEN;

	return ((sdflags & FLG_SY_HIDDEN) == 0);
}

/*
 * This routine checks to see if a symbols visibility needs to be reduced to
 * either SYMBOLIC or LOCAL.  This routine can be called from either
 * reloc_init() or sym_validate().
 */
void
ld_sym_adjust_vis(Sym_desc *sdp, Ofl_desc *ofl)
{
	ofl_flag_t	oflags = ofl->ofl_flags;
	Sym		*sym = sdp->sd_sym;

	if ((sdp->sd_ref == REF_REL_NEED) &&
	    (sdp->sd_sym->st_shndx != SHN_UNDEF)) {
		/*
		 * If auto-reduction/elimination is enabled, reduce any
		 * non-versioned, and non-local capabilities global symbols.
		 * A symbol is a candidate for auto-reduction/elimination if:
		 *
		 *  -	the symbol wasn't explicitly defined within a mapfile
		 *	(in which case all the necessary state has been applied
		 *	to the symbol), or
		 *  -	the symbol isn't one of the family of reserved
		 *	special symbols (ie. _end, _etext, etc.), or
		 *  -	the symbol isn't a SINGLETON, or
		 *  -	the symbol wasn't explicitly defined within a version
		 *	definition associated with an input relocatable object.
		 *
		 * Indicate that the symbol has been reduced as it may be
		 * necessary to print these symbols later.
		 */
		if ((oflags & (FLG_OF_AUTOLCL | FLG_OF_AUTOELM)) &&
		    ((sdp->sd_flags & MSK_SY_NOAUTO) == 0)) {
			if ((sdp->sd_flags & FLG_SY_HIDDEN) == 0) {
				sdp->sd_flags |=
				    (FLG_SY_REDUCED | FLG_SY_HIDDEN);
			}

			if (oflags & (FLG_OF_REDLSYM | FLG_OF_AUTOELM)) {
				sdp->sd_flags |= FLG_SY_ELIM;
				sym->st_other = STV_ELIMINATE |
				    (sym->st_other & ~MSK_SYM_VISIBILITY);
			} else if (ELF_ST_VISIBILITY(sym->st_other) !=
			    STV_INTERNAL)
				sym->st_other = STV_HIDDEN |
				    (sym->st_other & ~MSK_SYM_VISIBILITY);
		}

		/*
		 * If -Bsymbolic is in effect, and the symbol hasn't explicitly
		 * been defined nodirect (via a mapfile), then bind the global
		 * symbol symbolically and assign the STV_PROTECTED visibility
		 * attribute.
		 */
		if ((oflags & FLG_OF_SYMBOLIC) &&
		    ((sdp->sd_flags & (FLG_SY_HIDDEN | FLG_SY_NDIR)) == 0)) {
			sdp->sd_flags |= FLG_SY_PROTECT;
			if (ELF_ST_VISIBILITY(sym->st_other) == STV_DEFAULT)
				sym->st_other = STV_PROTECTED |
				    (sym->st_other & ~MSK_SYM_VISIBILITY);
		}
	}

	/*
	 * Indicate that this symbol has had it's visibility checked so that
	 * we don't need to do this investigation again.
	 */
	sdp->sd_flags |= FLG_SY_VISIBLE;
}

/*
 * Make sure a symbol definition is local to the object being built.
 */
inline static int
ensure_sym_local(Ofl_desc *ofl, Sym_desc *sdp, const char *str)
{
	if (sdp->sd_sym->st_shndx == SHN_UNDEF) {
		if (str) {
			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYM_UNDEF),
			    str, demangle((char *)sdp->sd_name));
		}
		return (1);
	}
	if (sdp->sd_ref != REF_REL_NEED) {
		if (str) {
			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYM_EXTERN),
			    str, demangle((char *)sdp->sd_name),
			    sdp->sd_file->ifl_name);
		}
		return (1);
	}

	sdp->sd_flags |= FLG_SY_UPREQD;
	if (sdp->sd_isc) {
		sdp->sd_isc->is_flags |= FLG_IS_SECTREF;
		sdp->sd_isc->is_file->ifl_flags |= FLG_IF_FILEREF;
	}
	return (0);
}

/*
 * Make sure all the symbol definitions required for initarray, finiarray, or
 * preinitarray's are local to the object being built.
 */
static int
ensure_array_local(Ofl_desc *ofl, APlist *apl, const char *str)
{
	Aliste		idx;
	Sym_desc	*sdp;
	int		ret = 0;

	for (APLIST_TRAVERSE(apl, idx, sdp))
		ret += ensure_sym_local(ofl, sdp, str);

	return (ret);
}

/*
 * After all symbol table input processing has been finished, and all relocation
 * counting has been carried out (ie. no more symbols will be read, generated,
 * or modified), validate and count the relevant entries:
 *
 *  -	check and print any undefined symbols remaining.  Note that if a symbol
 *	has been defined by virtue of the inclusion of	an implicit shared
 *	library, it is still classed as undefined.
 *
 *  -	count the number of global needed symbols together with the size of
 *	their associated name strings (if scoping has been indicated these
 *	symbols may be reduced to locals).
 *
 *  -	establish the size and alignment requirements for the global .bss
 *	section (the alignment of this section is based on the	first symbol
 *	that it will contain).
 */
uintptr_t
ld_sym_validate(Ofl_desc *ofl)
{
	Sym_avlnode	*sav;
	Sym_desc	*sdp;
	Sym		*sym;
	ofl_flag_t	oflags = ofl->ofl_flags;
	ofl_flag_t	undef = 0, needed = 0, verdesc = 0;
	Xword		bssalign = 0, tlsalign = 0;
	Boolean		need_bss, need_tlsbss;
	Xword		bsssize = 0, tlssize = 0;
#if	defined(_ELF64)
	Xword		lbssalign = 0, lbsssize = 0;
	Boolean		need_lbss;
#endif
	int		ret, allow_ldynsym;
	uchar_t		type;
	ofl_flag_t	undef_state = 0;

	DBG_CALL(Dbg_basic_validate(ofl->ofl_lml));

	/*
	 * The need_XXX booleans are used to determine whether we need to
	 * create each type of bss section. We used to create these sections
	 * if the sum of the required sizes for each type were non-zero.
	 * However, it is possible for a compiler to generate COMMON variables
	 * of zero-length and this tricks that logic --- even zero-length
	 * symbols need an output section.
	 */
	need_bss = need_tlsbss = FALSE;
#if	defined(_ELF64)
	need_lbss = FALSE;
#endif

	/*
	 * Determine how undefined symbols are handled:
	 *
	 * fatal:
	 *	If this link-edit calls for no undefined symbols to remain
	 *	(this is the default case when generating an executable but
	 *	can be enforced for any object using -z defs), a fatal error
	 *	condition will be indicated.
	 *
	 * warning:
	 *	If we're creating a shared object, and either the -Bsymbolic
	 *	flag is set, or the user has turned on the -z guidance feature,
	 *	then a non-fatal warning is issued for each symbol.
	 *
	 * ignore:
	 *	In all other cases, undefined symbols are quietly allowed.
	 */
	if (oflags & FLG_OF_NOUNDEF) {
		undef = FLG_OF_FATAL;
	} else if (oflags & FLG_OF_SHAROBJ) {
		if ((oflags & FLG_OF_SYMBOLIC) ||
		    OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS))
			undef = FLG_OF_WARN;
	}

	/*
	 * If the symbol is referenced from an implicitly included shared object
	 * (ie. it's not on the NEEDED list) then the symbol is also classified
	 * as undefined and a fatal error condition will be indicated.
	 */
	if ((oflags & FLG_OF_NOUNDEF) || !(oflags & FLG_OF_SHAROBJ))
		needed = FLG_OF_FATAL;
	else if ((oflags & FLG_OF_SHAROBJ) &&
	    OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS))
		needed = FLG_OF_WARN;

	/*
	 * If the output image is being versioned, then all symbol definitions
	 * must be associated with a version.  Any symbol that isn't associated
	 * with a version is classified as undefined, and a fatal error
	 * condition is indicated.
	 */
	if ((oflags & FLG_OF_VERDEF) && (ofl->ofl_vercnt > VER_NDX_GLOBAL))
		verdesc = FLG_OF_FATAL;

	allow_ldynsym = OFL_ALLOW_LDYNSYM(ofl);

	if (allow_ldynsym) {
		/*
		 * Normally, we disallow symbols with 0 size from appearing
		 * in a dyn[sym|tls]sort section. However, there are some
		 * symbols that serve special purposes that we want to exempt
		 * from this rule. Look them up, and set their
		 * FLG_SY_DYNSORT flag.
		 */
		static const char *special[] = {
			MSG_ORIG(MSG_SYM_INIT_U),	/* _init */
			MSG_ORIG(MSG_SYM_FINI_U),	/* _fini */
			MSG_ORIG(MSG_SYM_START),	/* _start */
			NULL
		};
		int i;

		for (i = 0; special[i] != NULL; i++) {
			if (((sdp = ld_sym_find(special[i],
			    SYM_NOHASH, NULL, ofl)) != NULL) &&
			    (sdp->sd_sym->st_size == 0)) {
				if (ld_sym_copy(sdp) == S_ERROR)
					return (S_ERROR);
				sdp->sd_flags |= FLG_SY_DYNSORT;
			}
		}
	}

	/*
	 * Collect and validate the globals from the internal symbol table.
	 */
	for (sav = avl_first(&ofl->ofl_symavl); sav;
	    sav = AVL_NEXT(&ofl->ofl_symavl, sav)) {
		Is_desc		*isp;
		int		undeferr = 0;
		uchar_t		vis;

		sdp = sav->sav_sdp;

		/*
		 * If undefined symbols are allowed, and we're not being
		 * asked to supply guidance, ignore any symbols that are
		 * not needed.
		 */
		if (!(oflags & FLG_OF_NOUNDEF) &&
		    !OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS) &&
		    (sdp->sd_ref == REF_DYN_SEEN))
			continue;

		/*
		 * If the symbol originates from an external or parent mapfile
		 * reference and hasn't been matched to a reference from a
		 * relocatable object, ignore it.
		 */
		if ((sdp->sd_flags & (FLG_SY_EXTERN | FLG_SY_PARENT)) &&
		    ((sdp->sd_flags & FLG_SY_MAPUSED) == 0)) {
			sdp->sd_flags |= FLG_SY_INVALID;
			continue;
		}

		sym = sdp->sd_sym;
		type = ELF_ST_TYPE(sym->st_info);

		/*
		 * Sanity check TLS.
		 */
		if ((type == STT_TLS) && (sym->st_size != 0) &&
		    (sym->st_shndx != SHN_UNDEF) &&
		    (sym->st_shndx != SHN_COMMON)) {
			Is_desc		*isp = sdp->sd_isc;
			Ifl_desc	*ifl = sdp->sd_file;

			if ((isp == NULL) || (isp->is_shdr == NULL) ||
			    ((isp->is_shdr->sh_flags & SHF_TLS) == 0)) {
				ld_eprintf(ofl, ERR_FATAL,
				    MSG_INTL(MSG_SYM_TLS),
				    demangle(sdp->sd_name), ifl->ifl_name);
				continue;
			}
		}

		if ((sdp->sd_flags & FLG_SY_VISIBLE) == 0)
			ld_sym_adjust_vis(sdp, ofl);

		if ((sdp->sd_flags & FLG_SY_REDUCED) &&
		    (oflags & FLG_OF_PROCRED)) {
			DBG_CALL(Dbg_syms_reduce(ofl, DBG_SYM_REDUCE_GLOBAL,
			    sdp, 0, 0));
		}

		/*
		 * Record any STV_SINGLETON existence.
		 */
		if ((vis = ELF_ST_VISIBILITY(sym->st_other)) == STV_SINGLETON)
			ofl->ofl_dtflags_1 |= DF_1_SINGLETON;

		/*
		 * If building a shared object or executable, and this is a
		 * non-weak UNDEF symbol with reduced visibility (STV_*), then
		 * give a fatal error.
		 */
		if (((oflags & FLG_OF_RELOBJ) == 0) &&
		    (sym->st_shndx == SHN_UNDEF) &&
		    (ELF_ST_BIND(sym->st_info) != STB_WEAK)) {
			if (vis && (vis != STV_SINGLETON)) {
				sym_undef_entry(ofl, sdp, BNDLOCAL,
				    FLG_OF_FATAL, &undef_state);
				continue;
			}
		}

		/*
		 * If this symbol is defined in a non-allocatable section,
		 * reduce it to local symbol.
		 */
		if (((isp = sdp->sd_isc) != 0) && isp->is_shdr &&
		    ((isp->is_shdr->sh_flags & SHF_ALLOC) == 0)) {
			sdp->sd_flags |= (FLG_SY_REDUCED | FLG_SY_HIDDEN);
		}

		/*
		 * If this symbol originated as a SHN_SUNW_IGNORE, it will have
		 * been processed as an SHN_UNDEF.  Return the symbol to its
		 * original index for validation, and propagation to the output
		 * file.
		 */
		if (sdp->sd_flags & FLG_SY_IGNORE)
			sdp->sd_shndx = SHN_SUNW_IGNORE;

		if (undef) {
			/*
			 * If a non-weak reference remains undefined, or if a
			 * mapfile reference is not bound to the relocatable
			 * objects that make up the object being built, we have
			 * a fatal error.
			 *
			 * The exceptions are symbols which are defined to be
			 * found in the parent (FLG_SY_PARENT), which is really
			 * only meaningful for direct binding, or are defined
			 * external (FLG_SY_EXTERN) so as to suppress -zdefs
			 * errors.
			 *
			 * Register symbols are always allowed to be UNDEF.
			 *
			 * Note that we don't include references created via -u
			 * in the same shared object binding test.  This is for
			 * backward compatibility, in that a number of archive
			 * makefile rules used -u to cause archive extraction.
			 * These same rules have been cut and pasted to apply
			 * to shared objects, and thus although the -u reference
			 * is redundant, flagging it as fatal could cause some
			 * build to fail.  Also we have documented the use of
			 * -u as a mechanism to cause binding to weak version
			 * definitions, thus giving users an error condition
			 * would be incorrect.
			 */
			if (!(sdp->sd_flags & FLG_SY_REGSYM) &&
			    ((sym->st_shndx == SHN_UNDEF) &&
			    ((ELF_ST_BIND(sym->st_info) != STB_WEAK) &&
			    ((sdp->sd_flags &
			    (FLG_SY_PARENT | FLG_SY_EXTERN)) == 0)) ||
			    ((sdp->sd_flags &
			    (FLG_SY_MAPREF | FLG_SY_MAPUSED | FLG_SY_HIDDEN |
			    FLG_SY_PROTECT)) == FLG_SY_MAPREF))) {
				sym_undef_entry(ofl, sdp, UNDEF, undef,
				    &undef_state);
				undeferr = 1;
			}

		} else {
			/*
			 * For building things like shared objects (or anything
			 * -znodefs), undefined symbols are allowed.
			 *
			 * If a mapfile reference remains undefined the user
			 * would probably like a warning at least (they've
			 * usually mis-spelt the reference).  Refer to the above
			 * comments for discussion on -u references, which
			 * are not tested for in the same manner.
			 */
			if ((sdp->sd_flags &
			    (FLG_SY_MAPREF | FLG_SY_MAPUSED)) ==
			    FLG_SY_MAPREF) {
				sym_undef_entry(ofl, sdp, UNDEF, FLG_OF_WARN,
				    &undef_state);
				undeferr = 1;
			}
		}

		/*
		 * If this symbol comes from a dependency mark the dependency
		 * as required (-z ignore can result in unused dependencies
		 * being dropped).  If we need to record dependency versioning
		 * information indicate what version of the needed shared object
		 * this symbol is part of.  Flag the symbol as undefined if it
		 * has not been made available to us.
		 */
		if ((sdp->sd_ref == REF_DYN_NEED) &&
		    (!(sdp->sd_flags & FLG_SY_REFRSD))) {
			sdp->sd_file->ifl_flags |= FLG_IF_DEPREQD;

			/*
			 * Capture that we've bound to a symbol that doesn't
			 * allow being directly bound to.
			 */
			if (sdp->sd_flags & FLG_SY_NDIR)
				ofl->ofl_flags1 |= FLG_OF1_NGLBDIR;

			if (sdp->sd_file->ifl_vercnt) {
				int		vndx;
				Ver_index	*vip;

				vndx = sdp->sd_aux->sa_dverndx;
				vip = &sdp->sd_file->ifl_verndx[vndx];
				if (vip->vi_flags & FLG_VER_AVAIL) {
					vip->vi_flags |= FLG_VER_REFER;
				} else {
					sym_undef_entry(ofl, sdp, NOTAVAIL,
					    FLG_OF_FATAL, &undef_state);
					continue;
				}
			}
		}

		/*
		 * Test that we do not bind to symbol supplied from an implicit
		 * shared object.  If a binding is from a weak reference it can
		 * be ignored.
		 */
		if (needed && !undeferr && (sdp->sd_flags & FLG_SY_GLOBREF) &&
		    (sdp->sd_ref == REF_DYN_NEED) &&
		    (sdp->sd_flags & FLG_SY_NOTAVAIL)) {
			sym_undef_entry(ofl, sdp, IMPLICIT, needed,
			    &undef_state);
			if (needed == FLG_OF_FATAL)
				continue;
		}

		/*
		 * Test that a symbol isn't going to be reduced to local scope
		 * which actually wants to bind to a shared object - if so it's
		 * a fatal error.
		 */
		if ((sdp->sd_ref == REF_DYN_NEED) &&
		    (sdp->sd_flags & (FLG_SY_HIDDEN | FLG_SY_PROTECT))) {
			sym_undef_entry(ofl, sdp, BNDLOCAL, FLG_OF_FATAL,
			    &undef_state);
			continue;
		}

		/*
		 * If the output image is to be versioned then all symbol
		 * definitions must be associated with a version.  Remove any
		 * versioning that might be left associated with an undefined
		 * symbol.
		 */
		if (verdesc && (sdp->sd_ref == REF_REL_NEED)) {
			if (sym->st_shndx == SHN_UNDEF) {
				if (sdp->sd_aux && sdp->sd_aux->sa_overndx)
					sdp->sd_aux->sa_overndx = 0;
			} else {
				if (!SYM_IS_HIDDEN(sdp) && sdp->sd_aux &&
				    (sdp->sd_aux->sa_overndx == 0)) {
					sym_undef_entry(ofl, sdp, NOVERSION,
					    verdesc, &undef_state);
					continue;
				}
			}
		}

		/*
		 * If we don't need the symbol there's no need to process it
		 * any further.
		 */
		if (sdp->sd_ref == REF_DYN_SEEN)
			continue;

		/*
		 * Calculate the size and alignment requirements for the global
		 * .bss and .tls sections.  If we're building a relocatable
		 * object only account for scoped COMMON symbols (these will
		 * be converted to .bss references).
		 *
		 * When -z nopartial is in effect, partially initialized
		 * symbols are directed to the special .data section
		 * created for that purpose (ofl->ofl_isparexpn).
		 * Otherwise, partially initialized symbols go to .bss.
		 *
		 * Also refer to make_mvsections() in sunwmove.c
		 */
		if ((sym->st_shndx == SHN_COMMON) &&
		    (((oflags & FLG_OF_RELOBJ) == 0) ||
		    ld_sym_reducable(ofl, sdp))) {
			if ((sdp->sd_move == NULL) ||
			    ((sdp->sd_flags & FLG_SY_PAREXPN) == 0)) {
				if (type != STT_TLS) {
					need_bss = TRUE;
					bsssize = (Xword)S_ROUND(bsssize,
					    sym->st_value) + sym->st_size;
					if (sym->st_value > bssalign)
						bssalign = sym->st_value;
				} else {
					need_tlsbss = TRUE;
					tlssize = (Xword)S_ROUND(tlssize,
					    sym->st_value) + sym->st_size;
					if (sym->st_value > tlsalign)
						tlsalign = sym->st_value;
				}
			}
		}

#if	defined(_ELF64)
		/*
		 * Calculate the size and alignment requirement for the global
		 * .lbss. TLS or partially initialized symbols do not need to be
		 * considered yet.
		 */
		if ((ld_targ.t_m.m_mach == EM_AMD64) &&
		    (sym->st_shndx == SHN_X86_64_LCOMMON)) {
			need_lbss = TRUE;
			lbsssize = (Xword)S_ROUND(lbsssize, sym->st_value) +
			    sym->st_size;
			if (sym->st_value > lbssalign)
				lbssalign = sym->st_value;
		}
#endif
		/*
		 * If a symbol was referenced via the command line
		 * (ld -u <>, ...), then this counts as a reference against the
		 * symbol. Mark any section that symbol is defined in.
		 */
		if (((isp = sdp->sd_isc) != 0) &&
		    (sdp->sd_flags & FLG_SY_CMDREF)) {
			isp->is_flags |= FLG_IS_SECTREF;
			isp->is_file->ifl_flags |= FLG_IF_FILEREF;
		}

		/*
		 * Update the symbol count and the associated name string size.
		 * Note, a capabilities symbol must remain as visible as a
		 * global symbol.  However, the runtime linker recognizes the
		 * hidden requirement and ensures the symbol isn't made globally
		 * available at runtime.
		 */
		if (ld_sym_reducable(ofl, sdp)) {
			/*
			 * If any reductions are being processed, keep a count
			 * of eliminated symbols, and if the symbol is being
			 * reduced to local, count it's size for the .symtab.
			 */
			if (sdp->sd_flags & FLG_SY_ELIM) {
				ofl->ofl_elimcnt++;
			} else {
				ofl->ofl_scopecnt++;
				if ((((sdp->sd_flags & FLG_SY_REGSYM) == 0) ||
				    sym->st_name) && (st_insert(ofl->ofl_strtab,
				    sdp->sd_name) == -1))
					return (S_ERROR);
				if (allow_ldynsym && sym->st_name &&
				    ldynsym_symtype[type]) {
					ofl->ofl_dynscopecnt++;
					if (st_insert(ofl->ofl_dynstrtab,
					    sdp->sd_name) == -1)
						return (S_ERROR);
					/* Include it in sort section? */
					DYNSORT_COUNT(sdp, sym, type, ++);
				}
			}
		} else {
			ofl->ofl_globcnt++;

			/*
			 * Check to see if this global variable should go into
			 * a sort section. Sort sections require a
			 * .SUNW_ldynsym section, so, don't check unless a
			 * .SUNW_ldynsym is allowed.
			 */
			if (allow_ldynsym)
				DYNSORT_COUNT(sdp, sym, type, ++);

			/*
			 * If global direct bindings are in effect, or this
			 * symbol has bound to a dependency which was specified
			 * as requiring direct bindings, and it hasn't
			 * explicitly been defined as a non-direct binding
			 * symbol, mark it.
			 */
			if (((ofl->ofl_dtflags_1 & DF_1_DIRECT) || (isp &&
			    (isp->is_file->ifl_flags & FLG_IF_DIRECT))) &&
			    ((sdp->sd_flags & FLG_SY_NDIR) == 0))
				sdp->sd_flags |= FLG_SY_DIR;

			/*
			 * Insert the symbol name.
			 */
			if (((sdp->sd_flags & FLG_SY_REGSYM) == 0) ||
			    sym->st_name) {
				if (st_insert(ofl->ofl_strtab,
				    sdp->sd_name) == -1)
					return (S_ERROR);

				if (!(ofl->ofl_flags & FLG_OF_RELOBJ) &&
				    (st_insert(ofl->ofl_dynstrtab,
				    sdp->sd_name) == -1))
					return (S_ERROR);
			}

			/*
			 * If this section offers a global symbol - record that
			 * fact.
			 */
			if (isp) {
				isp->is_flags |= FLG_IS_SECTREF;
				isp->is_file->ifl_flags |= FLG_IF_FILEREF;
			}
		}
	}

	/*
	 * Guidance: Use -z defs|nodefs when building shared objects.
	 *
	 * Our caller issues this, unless we mask it out here. So we mask it
	 * out unless we've issued at least one warnings or fatal error.
	 */
	if (!((oflags & FLG_OF_SHAROBJ) && OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS) &&
	    (undef_state & (FLG_OF_FATAL | FLG_OF_WARN))))
		ofl->ofl_guideflags |= FLG_OFG_NO_DEFS;

	/*
	 * If we've encountered a fatal error during symbol validation then
	 * return now.
	 */
	if (ofl->ofl_flags & FLG_OF_FATAL)
		return (1);

	/*
	 * Now that symbol resolution is completed, scan any register symbols.
	 * From now on, we're only interested in those that contribute to the
	 * output file.
	 */
	if (ofl->ofl_regsyms) {
		int	ndx;

		for (ndx = 0; ndx < ofl->ofl_regsymsno; ndx++) {
			if ((sdp = ofl->ofl_regsyms[ndx]) == NULL)
				continue;
			if (sdp->sd_ref != REF_REL_NEED) {
				ofl->ofl_regsyms[ndx] = NULL;
				continue;
			}

			ofl->ofl_regsymcnt++;
			if (sdp->sd_sym->st_name == 0)
				sdp->sd_name = MSG_ORIG(MSG_STR_EMPTY);

			if (SYM_IS_HIDDEN(sdp) ||
			    (ELF_ST_BIND(sdp->sd_sym->st_info) == STB_LOCAL))
				ofl->ofl_lregsymcnt++;
		}
	}

	/*
	 * Generate the .bss section now that we know its size and alignment.
	 */
	if (need_bss) {
		if (ld_make_bss(ofl, bsssize, bssalign,
		    ld_targ.t_id.id_bss) == S_ERROR)
			return (S_ERROR);
	}
	if (need_tlsbss) {
		if (ld_make_bss(ofl, tlssize, tlsalign,
		    ld_targ.t_id.id_tlsbss) == S_ERROR)
			return (S_ERROR);
	}
#if	defined(_ELF64)
	if ((ld_targ.t_m.m_mach == EM_AMD64) &&
	    need_lbss && !(oflags & FLG_OF_RELOBJ)) {
		if (ld_make_bss(ofl, lbsssize, lbssalign,
		    ld_targ.t_id.id_lbss) == S_ERROR)
			return (S_ERROR);
	}
#endif
	/*
	 * Determine what entry point symbol we need, and if found save its
	 * symbol descriptor so that we can update the ELF header entry with the
	 * symbols value later (see update_oehdr).  Make sure the symbol is
	 * tagged to ensure its update in case -s is in effect.  Use any -e
	 * option first, or the default entry points `_start' and `main'.
	 */
	ret = 0;
	if (ofl->ofl_entry) {
		if ((sdp = ld_sym_find(ofl->ofl_entry, SYM_NOHASH,
		    NULL, ofl)) == NULL) {
			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_NOENTRY),
			    ofl->ofl_entry);
			ret++;
		} else if (ensure_sym_local(ofl, sdp,
		    MSG_INTL(MSG_SYM_ENTRY)) != 0) {
			ret++;
		} else {
			ofl->ofl_entry = (void *)sdp;
		}
	} else if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_START),
	    SYM_NOHASH, NULL, ofl)) != NULL) && (ensure_sym_local(ofl,
	    sdp, 0) == 0)) {
		ofl->ofl_entry = (void *)sdp;

	} else if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_MAIN),
	    SYM_NOHASH, NULL, ofl)) != NULL) && (ensure_sym_local(ofl,
	    sdp, 0) == 0)) {
		ofl->ofl_entry = (void *)sdp;
	}

	/*
	 * If ld -zdtrace=<sym> was given, then validate that the symbol is
	 * defined within the current object being built.
	 */
	if ((sdp = ofl->ofl_dtracesym) != 0)
		ret += ensure_sym_local(ofl, sdp, MSG_ORIG(MSG_STR_DTRACE));

	/*
	 * If any initarray, finiarray or preinitarray functions have been
	 * requested, make sure they are defined within the current object
	 * being built.
	 */
	if (ofl->ofl_initarray) {
		ret += ensure_array_local(ofl, ofl->ofl_initarray,
		    MSG_ORIG(MSG_SYM_INITARRAY));
	}
	if (ofl->ofl_finiarray) {
		ret += ensure_array_local(ofl, ofl->ofl_finiarray,
		    MSG_ORIG(MSG_SYM_FINIARRAY));
	}
	if (ofl->ofl_preiarray) {
		ret += ensure_array_local(ofl, ofl->ofl_preiarray,
		    MSG_ORIG(MSG_SYM_PREINITARRAY));
	}

	if (ret)
		return (S_ERROR);

	/*
	 * If we're required to record any needed dependencies versioning
	 * information calculate it now that all symbols have been validated.
	 */
	if ((oflags & (FLG_OF_VERNEED | FLG_OF_NOVERSEC)) == FLG_OF_VERNEED)
		return (ld_vers_check_need(ofl));
	else
		return (1);
}

/*
 * qsort(3c) comparison function.  As an optimization for associating weak
 * symbols to their strong counterparts sort global symbols according to their
 * section index, address and binding.
 */
static int
compare(const void *sdpp1, const void *sdpp2)
{
	Sym_desc	*sdp1 = *((Sym_desc **)sdpp1);
	Sym_desc	*sdp2 = *((Sym_desc **)sdpp2);
	Sym		*sym1, *sym2;
	uchar_t		bind1, bind2;

	/*
	 * Symbol descriptors may be zero, move these to the front of the
	 * sorted array.
	 */
	if (sdp1 == NULL)
		return (-1);
	if (sdp2 == NULL)
		return (1);

	sym1 = sdp1->sd_sym;
	sym2 = sdp2->sd_sym;

	/*
	 * Compare the symbols section index.  This is important when sorting
	 * the symbol tables of relocatable objects.  In this case, a symbols
	 * value is the offset within the associated section, and thus many
	 * symbols can have the same value, but are effectively different
	 * addresses.
	 */
	if (sym1->st_shndx > sym2->st_shndx)
		return (1);
	if (sym1->st_shndx < sym2->st_shndx)
		return (-1);

	/*
	 * Compare the symbols value (address).
	 */
	if (sym1->st_value > sym2->st_value)
		return (1);
	if (sym1->st_value < sym2->st_value)
		return (-1);

	bind1 = ELF_ST_BIND(sym1->st_info);
	bind2 = ELF_ST_BIND(sym2->st_info);

	/*
	 * If two symbols have the same address place the weak symbol before
	 * any strong counterpart.
	 */
	if (bind1 > bind2)
		return (-1);
	if (bind1 < bind2)
		return (1);

	return (0);
}

/*
 * Issue a MSG_SYM_BADADDR error from ld_sym_process(). This error
 * is issued when a symbol address/size is not contained by the
 * target section.
 *
 * Such objects are at least partially corrupt, and the user would
 * be well advised to be skeptical of them, and to ask their compiler
 * supplier to fix the problem. However, a distinction needs to be
 * made between symbols that reference readonly text, and those that
 * access writable data. Other than throwing off profiling results,
 * the readonly section case is less serious. We have encountered
 * such objects in the field. In order to allow existing objects
 * to continue working, we issue a warning rather than a fatal error
 * if the symbol is against readonly text. Other cases are fatal.
 */
static void
issue_badaddr_msg(Ifl_desc *ifl, Ofl_desc *ofl, Sym_desc *sdp,
    Sym *sym, Word shndx)
{
	Error		err;
	const char	*msg;

	if ((sdp->sd_isc->is_shdr->sh_flags & (SHF_WRITE | SHF_ALLOC)) ==
	    SHF_ALLOC) {
		msg = MSG_INTL(MSG_SYM_BADADDR_ROTXT);
		err = ERR_WARNING;
	} else {
		msg = MSG_INTL(MSG_SYM_BADADDR);
		err = ERR_FATAL;
	}

	ld_eprintf(ofl, err, msg, demangle(sdp->sd_name),
	    ifl->ifl_name, shndx, sdp->sd_isc->is_name,
	    EC_XWORD(sdp->sd_isc->is_shdr->sh_size),
	    EC_XWORD(sym->st_value), EC_XWORD(sym->st_size));
}

/*
 * Global symbols that are candidates for translation to local capability
 * symbols under -z symbolcap, are maintained on a local symbol list.  Once
 * all symbols of a file are processed, this list is traversed to cull any
 * unnecessary weak symbol aliases.
 */
typedef struct {
	Sym_desc	*c_nsdp;	/* new lead symbol */
	Sym_desc	*c_osdp;	/* original symbol */
	Cap_group	*c_group;	/* symbol capability group */
	Word		c_ndx;		/* symbol index */
} Cap_pair;

/*
 * Process the symbol table for the specified input file.  At this point all
 * input sections from this input file have been assigned an input section
 * descriptor which is saved in the `ifl_isdesc' array.
 *
 *  -	local symbols are saved (as is) if the input file is a relocatable
 *	object
 *
 *  -	global symbols are added to the linkers internal symbol table if they
 *	are not already present, otherwise a symbol resolution function is
 *	called upon to resolve the conflict.
 */
uintptr_t
ld_sym_process(Is_desc *isc, Ifl_desc *ifl, Ofl_desc *ofl)
{
	/*
	 * This macro tests the given symbol to see if it is out of
	 * range relative to the section it references.
	 *
	 * entry:
	 *	- ifl is a relative object (ET_REL)
	 *	_sdp - Symbol descriptor
	 *	_sym - Symbol
	 *	_type - Symbol type
	 *
	 * The following are tested:
	 *	- Symbol length is non-zero
	 *	- Symbol type is a type that references code or data
	 *	- Referenced section is not 0 (indicates an UNDEF symbol)
	 *	  and is not in the range of special values above SHN_LORESERVE
	 *	  (excluding SHN_XINDEX, which is OK).
	 *	- We have a valid section header for the target section
	 *
	 * If the above are all true, and the symbol position is not
	 * contained by the target section, this macro evaluates to
	 * True (1). Otherwise, False(0).
	 */
#define	SYM_LOC_BADADDR(_sdp, _sym, _type) \
	(_sym->st_size && dynsymsort_symtype[_type] && \
	(_sym->st_shndx != SHN_UNDEF) && \
	((_sym->st_shndx < SHN_LORESERVE) || \
		(_sym->st_shndx == SHN_XINDEX)) && \
	_sdp->sd_isc && _sdp->sd_isc->is_shdr && \
	((_sym->st_value + _sym->st_size) > _sdp->sd_isc->is_shdr->sh_size))

	Conv_inv_buf_t	inv_buf;
	Sym		*sym = (Sym *)isc->is_indata->d_buf;
	Word		*symshndx = NULL;
	Shdr		*shdr = isc->is_shdr;
	Sym_desc	*sdp;
	size_t		strsize;
	char		*strs;
	uchar_t		type, bind;
	Word		ndx, hash, local, total;
	uchar_t		osabi = ifl->ifl_ehdr->e_ident[EI_OSABI];
	Half		mach = ifl->ifl_ehdr->e_machine;
	Half		etype = ifl->ifl_ehdr->e_type;
	int		etype_rel;
	const char	*symsecname, *strsecname;
	Word		symsecndx;
	avl_index_t	where;
	int		test_gnu_hidden_bit, weak;
	Cap_desc	*cdp = NULL;
	Alist		*cappairs = NULL;

	/*
	 * Its possible that a file may contain more that one symbol table,
	 * ie. .dynsym and .symtab in a shared library.  Only process the first
	 * table (here, we assume .dynsym comes before .symtab).
	 */
	if (ifl->ifl_symscnt)
		return (1);

	if (isc->is_symshndx)
		symshndx = isc->is_symshndx->is_indata->d_buf;

	DBG_CALL(Dbg_syms_process(ofl->ofl_lml, ifl));

	symsecndx = isc->is_scnndx;
	if (isc->is_name)
		symsecname = isc->is_name;
	else
		symsecname = MSG_ORIG(MSG_STR_EMPTY);

	/*
	 * From the symbol tables section header information determine which
	 * strtab table is needed to locate the actual symbol names.
	 */
	if (ifl->ifl_flags & FLG_IF_HSTRTAB) {
		ndx = shdr->sh_link;
		if ((ndx == 0) || (ndx >= ifl->ifl_shnum)) {
			ld_eprintf(ofl, ERR_FATAL,
			    MSG_INTL(MSG_FIL_INVSHLINK), ifl->ifl_name,
			    EC_WORD(symsecndx), symsecname, EC_XWORD(ndx));
			return (S_ERROR);
		}
		strsize = ifl->ifl_isdesc[ndx]->is_shdr->sh_size;
		strs = ifl->ifl_isdesc[ndx]->is_indata->d_buf;
		if (ifl->ifl_isdesc[ndx]->is_name)
			strsecname = ifl->ifl_isdesc[ndx]->is_name;
		else
			strsecname = MSG_ORIG(MSG_STR_EMPTY);
	} else {
		/*
		 * There is no string table section in this input file
		 * although there are symbols in this symbol table section.
		 * This means that these symbols do not have names.
		 * Currently, only scratch register symbols are allowed
		 * not to have names.
		 */
		strsize = 0;
		strs = (char *)MSG_ORIG(MSG_STR_EMPTY);
		strsecname = MSG_ORIG(MSG_STR_EMPTY);
	}

	/*
	 * Determine the number of local symbols together with the total
	 * number we have to process.
	 */
	total = (Word)(shdr->sh_size / shdr->sh_entsize);
	local = shdr->sh_info;

	/*
	 * Allocate a symbol table index array and a local symbol array
	 * (global symbols are processed and added to the ofl->ofl_symbkt[]
	 * array).  If we are dealing with a relocatable object, allocate the
	 * local symbol descriptors.  If this isn't a relocatable object we
	 * still have to process any shared object locals to determine if any
	 * register symbols exist.  Although these aren't added to the output
	 * image, they are used as part of symbol resolution.
	 */
	if ((ifl->ifl_oldndx = libld_malloc((size_t)(total *
	    sizeof (Sym_desc *)))) == NULL)
		return (S_ERROR);
	etype_rel = (etype == ET_REL);
	if (etype_rel && local) {
		if ((ifl->ifl_locs =
		    libld_calloc(sizeof (Sym_desc), local)) == NULL)
			return (S_ERROR);
		/* LINTED */
		ifl->ifl_locscnt = (Word)local;
	}
	ifl->ifl_symscnt = total;

	/*
	 * If there are local symbols to save add them to the symbol table
	 * index array.
	 */
	if (local) {
		int		allow_ldynsym = OFL_ALLOW_LDYNSYM(ofl);
		Sym_desc	*last_file_sdp = NULL;
		int		last_file_ndx = 0;

		for (sym++, ndx = 1; ndx < local; sym++, ndx++) {
			sd_flag_t	sdflags = FLG_SY_CLEAN;
			Word		shndx;
			const char	*name;
			Sym_desc	*rsdp;
			int		shndx_bad = 0;
			int		symtab_enter = 1;

			/*
			 * Determine and validate the associated section index.
			 */
			if (symshndx && (sym->st_shndx == SHN_XINDEX)) {
				shndx = symshndx[ndx];
			} else if ((shndx = sym->st_shndx) >= SHN_LORESERVE) {
				sdflags |= FLG_SY_SPECSEC;
			} else if (shndx > ifl->ifl_shnum) {
				/* We need the name before we can issue error */
				shndx_bad = 1;
			}

			/*
			 * Check if st_name has a valid value or not.
			 */
			if ((name = string(ofl, ifl, sym, strs, strsize, ndx,
			    shndx, symsecndx, symsecname, strsecname,
			    &sdflags)) == NULL)
				continue;

			/*
			 * Now that we have the name, if the section index
			 * was bad, report it.
			 */
			if (shndx_bad) {
				ld_eprintf(ofl, ERR_WARNING,
				    MSG_INTL(MSG_SYM_INVSHNDX),
				    demangle_symname(name, symsecname, ndx),
				    ifl->ifl_name,
				    conv_sym_shndx(osabi, mach, sym->st_shndx,
				    CONV_FMT_DECIMAL, &inv_buf));
				continue;
			}

			/*
			 * If this local symbol table originates from a shared
			 * object, then we're only interested in recording
			 * register symbols.  As local symbol descriptors aren't
			 * allocated for shared objects, one will be allocated
			 * to associated with the register symbol.  This symbol
			 * won't become part of the output image, but we must
			 * process it to test for register conflicts.
			 */
			rsdp = sdp = NULL;
			if (sdflags & FLG_SY_REGSYM) {
				/*
				 * The presence of FLG_SY_REGSYM means that
				 * the pointers in ld_targ.t_ms are non-NULL.
				 */
				rsdp = (*ld_targ.t_ms.ms_reg_find)(sym, ofl);
				if (rsdp != 0) {
					/*
					 * The fact that another register def-
					 * inition has been found is fatal.
					 * Call the verification routine to get
					 * the error message and move on.
					 */
					(void) (*ld_targ.t_ms.ms_reg_check)
					    (rsdp, sym, name, ifl, ofl);
					continue;
				}

				if (etype == ET_DYN) {
					if ((sdp = libld_calloc(
					    sizeof (Sym_desc), 1)) == NULL)
						return (S_ERROR);
					sdp->sd_ref = REF_DYN_SEEN;

					/* Will not appear in output object */
					symtab_enter = 0;
				}
			} else if (etype == ET_DYN)
				continue;

			/*
			 * Fill in the remaining symbol descriptor information.
			 */
			if (sdp == NULL) {
				sdp = &(ifl->ifl_locs[ndx]);
				sdp->sd_ref = REF_REL_NEED;
				sdp->sd_symndx = ndx;
			}
			if (rsdp == NULL) {
				sdp->sd_name = name;
				sdp->sd_sym = sym;
				sdp->sd_shndx = shndx;
				sdp->sd_flags = sdflags;
				sdp->sd_file = ifl;
				ifl->ifl_oldndx[ndx] = sdp;
			}

			DBG_CALL(Dbg_syms_entry(ofl->ofl_lml, ndx, sdp));

			/*
			 * Reclassify any SHN_SUNW_IGNORE symbols to SHN_UNDEF
			 * so as to simplify future processing.
			 */
			if (sym->st_shndx == SHN_SUNW_IGNORE) {
				sdp->sd_shndx = shndx = SHN_UNDEF;
				sdp->sd_flags |= (FLG_SY_IGNORE | FLG_SY_ELIM);
			}

			/*
			 * Process any register symbols.
			 */
			if (sdp->sd_flags & FLG_SY_REGSYM) {
				/*
				 * Add a diagnostic to indicate we've caught a
				 * register symbol, as this can be useful if a
				 * register conflict is later discovered.
				 */
				DBG_CALL(Dbg_syms_entered(ofl, sym, sdp));

				/*
				 * If this register symbol hasn't already been
				 * recorded, enter it now.
				 *
				 * The presence of FLG_SY_REGSYM means that
				 * the pointers in ld_targ.t_ms are non-NULL.
				 */
				if ((rsdp == NULL) &&
				    ((*ld_targ.t_ms.ms_reg_enter)(sdp, ofl) ==
				    0))
					return (S_ERROR);
			}

			/*
			 * Assign an input section.
			 */
			if ((sym->st_shndx != SHN_UNDEF) &&
			    ((sdp->sd_flags & FLG_SY_SPECSEC) == 0))
				sdp->sd_isc = ifl->ifl_isdesc[shndx];

			/*
			 * If this symbol falls within the range of a section
			 * being discarded, then discard the symbol itself.
			 * There is no reason to keep this local symbol.
			 */
			if (sdp->sd_isc &&
			    (sdp->sd_isc->is_flags & FLG_IS_DISCARD)) {
				sdp->sd_flags |= FLG_SY_ISDISC;
				DBG_CALL(Dbg_syms_discarded(ofl->ofl_lml, sdp));
				continue;
			}

			/*
			 * Skip any section symbols as new versions of these
			 * will be created.
			 */
			if ((type = ELF_ST_TYPE(sym->st_info)) == STT_SECTION) {
				if (sym->st_shndx == SHN_UNDEF) {
					ld_eprintf(ofl, ERR_WARNING,
					    MSG_INTL(MSG_SYM_INVSHNDX),
					    demangle_symname(name, symsecname,
					    ndx), ifl->ifl_name,
					    conv_sym_shndx(osabi, mach,
					    sym->st_shndx, CONV_FMT_DECIMAL,
					    &inv_buf));
				}
				continue;
			}

			/*
			 * For a relocatable object, if this symbol is defined
			 * and has non-zero length and references an address
			 * within an associated section, then check its extents
			 * to make sure the section boundaries encompass it.
			 * If they don't, the ELF file is corrupt.
			 */
			if (etype_rel) {
				if (SYM_LOC_BADADDR(sdp, sym, type)) {
					issue_badaddr_msg(ifl, ofl, sdp,
					    sym, shndx);
					if (ofl->ofl_flags & FLG_OF_FATAL)
						continue;
				}

				/*
				 * We have observed relocatable objects
				 * containing identical adjacent STT_FILE
				 * symbols. Discard any other than the first,
				 * as they are all equivalent and the extras
				 * do not add information.
				 *
				 * For the purpose of this test, we assume
				 * that only the symbol type and the string
				 * table offset (st_name) matter.
				 */
				if (type == STT_FILE) {
					int toss = (last_file_sdp != NULL) &&
					    ((ndx - 1) == last_file_ndx) &&
					    (sym->st_name ==
					    last_file_sdp->sd_sym->st_name);

					last_file_sdp = sdp;
					last_file_ndx = ndx;
					if (toss) {
						sdp->sd_flags |= FLG_SY_INVALID;
						DBG_CALL(Dbg_syms_dup_discarded(
						    ofl->ofl_lml, ndx, sdp));
						continue;
					}
				}
			}


			/*
			 * Sanity check for TLS
			 */
			if ((sym->st_size != 0) && ((type == STT_TLS) &&
			    (sym->st_shndx != SHN_COMMON))) {
				Is_desc	*isp = sdp->sd_isc;

				if ((isp == NULL) || (isp->is_shdr == NULL) ||
				    ((isp->is_shdr->sh_flags & SHF_TLS) == 0)) {
					ld_eprintf(ofl, ERR_FATAL,
					    MSG_INTL(MSG_SYM_TLS),
					    demangle(sdp->sd_name),
					    ifl->ifl_name);
					continue;
				}
			}

			/*
			 * Carry our some basic sanity checks (these are just
			 * some of the erroneous symbol entries we've come
			 * across, there's probably a lot more).  The symbol
			 * will not be carried forward to the output file, which
			 * won't be a problem unless a relocation is required
			 * against it.
			 */
			if (((sdp->sd_flags & FLG_SY_SPECSEC) &&
			    ((sym->st_shndx == SHN_COMMON)) ||
			    ((type == STT_FILE) &&
			    (sym->st_shndx != SHN_ABS))) ||
			    (sdp->sd_isc && (sdp->sd_isc->is_osdesc == NULL))) {
				ld_eprintf(ofl, ERR_WARNING,
				    MSG_INTL(MSG_SYM_INVSHNDX),
				    demangle_symname(name, symsecname, ndx),
				    ifl->ifl_name,
				    conv_sym_shndx(osabi, mach, sym->st_shndx,
				    CONV_FMT_DECIMAL, &inv_buf));
				sdp->sd_isc = NULL;
				sdp->sd_flags |= FLG_SY_INVALID;
				continue;
			}

			/*
			 * As these local symbols will become part of the output
			 * image, record their number and name string size.
			 * Globals are counted after all input file processing
			 * (and hence symbol resolution) is complete during
			 * sym_validate().
			 */
			if (!(ofl->ofl_flags & FLG_OF_REDLSYM) &&
			    symtab_enter) {
				ofl->ofl_locscnt++;

				if ((((sdp->sd_flags & FLG_SY_REGSYM) == 0) ||
				    sym->st_name) && (st_insert(ofl->ofl_strtab,
				    sdp->sd_name) == -1))
					return (S_ERROR);

				if (allow_ldynsym && sym->st_name &&
				    ldynsym_symtype[type]) {
					ofl->ofl_dynlocscnt++;
					if (st_insert(ofl->ofl_dynstrtab,
					    sdp->sd_name) == -1)
						return (S_ERROR);
					/* Include it in sort section? */
					DYNSORT_COUNT(sdp, sym, type, ++);
				}
			}
		}
	}

	/*
	 * The GNU ld interprets the top bit of the 16-bit Versym value
	 * (0x8000) as the "hidden" bit. If this bit is set, the linker
	 * is supposed to act as if that symbol does not exist. The Solaris
	 * linker does not support this mechanism, or the model of interface
	 * evolution that it allows, but we honor it in GNU ld produced
	 * objects in order to interoperate with them.
	 *
	 * Determine if we should honor the GNU hidden bit for this file.
	 */
	test_gnu_hidden_bit = ((ifl->ifl_flags & FLG_IF_GNUVER) != 0) &&
	    (ifl->ifl_versym != NULL);

	/*
	 * Determine whether object capabilities for this file are being
	 * converted into symbol capabilities.  If so, global function symbols,
	 * and initialized global data symbols, need special translation and
	 * processing.
	 */
	if ((etype == ET_REL) && (ifl->ifl_flags & FLG_IF_OTOSCAP))
		cdp = ifl->ifl_caps;

	/*
	 * Now scan the global symbols entering them in the internal symbol
	 * table or resolving them as necessary.
	 */
	sym = (Sym *)isc->is_indata->d_buf;
	sym += local;
	weak = 0;
	/* LINTED */
	for (ndx = (int)local; ndx < total; sym++, ndx++) {
		const char	*name;
		sd_flag_t	sdflags = 0;
		Word		shndx;
		int		shndx_bad = 0;
		Sym		*nsym = sym;
		Cap_pair	*cpp = NULL;
		uchar_t		ntype;

		/*
		 * Determine and validate the associated section index.
		 */
		if (symshndx && (nsym->st_shndx == SHN_XINDEX)) {
			shndx = symshndx[ndx];
		} else if ((shndx = nsym->st_shndx) >= SHN_LORESERVE) {
			sdflags |= FLG_SY_SPECSEC;
		} else if (shndx > ifl->ifl_shnum) {
			/* We need the name before we can issue error */
			shndx_bad = 1;
		}

		/*
		 * Check if st_name has a valid value or not.
		 */
		if ((name = string(ofl, ifl, nsym, strs, strsize, ndx, shndx,
		    symsecndx, symsecname, strsecname, &sdflags)) == NULL)
			continue;

		/*
		 * Now that we have the name, report an erroneous section index.
		 */
		if (shndx_bad) {
			ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SYM_INVSHNDX),
			    demangle_symname(name, symsecname, ndx),
			    ifl->ifl_name,
			    conv_sym_shndx(osabi, mach, nsym->st_shndx,
			    CONV_FMT_DECIMAL, &inv_buf));
			continue;
		}

		/*
		 * Test for the GNU hidden bit, and ignore symbols that
		 * have it set.
		 */
		if (test_gnu_hidden_bit &&
		    ((ifl->ifl_versym[ndx] & 0x8000) != 0))
			continue;

		/*
		 * The linker itself will generate symbols for _end, _etext,
		 * _edata, _DYNAMIC and _PROCEDURE_LINKAGE_TABLE_, so don't
		 * bother entering these symbols from shared objects.  This
		 * results in some wasted resolution processing, which is hard
		 * to feel, but if nothing else, pollutes diagnostic relocation
		 * output.
		 */
		if (name[0] && (etype == ET_DYN) && (nsym->st_size == 0) &&
		    (ELF_ST_TYPE(nsym->st_info) == STT_OBJECT) &&
		    (name[0] == '_') && ((name[1] == 'e') ||
		    (name[1] == 'D') || (name[1] == 'P')) &&
		    ((strcmp(name, MSG_ORIG(MSG_SYM_ETEXT_U)) == 0) ||
		    (strcmp(name, MSG_ORIG(MSG_SYM_EDATA_U)) == 0) ||
		    (strcmp(name, MSG_ORIG(MSG_SYM_END_U)) == 0) ||
		    (strcmp(name, MSG_ORIG(MSG_SYM_DYNAMIC_U)) == 0) ||
		    (strcmp(name, MSG_ORIG(MSG_SYM_PLKTBL_U)) == 0))) {
			ifl->ifl_oldndx[ndx] = 0;
			continue;
		}

		/*
		 * The '-z wrap=XXX' option emulates the GNU ld --wrap=XXX
		 * option. When XXX is the symbol to be wrapped:
		 *
		 *  -	An undefined reference to XXX is converted to __wrap_XXX
		 *  -	An undefined reference to __real_XXX is converted to XXX
		 *
		 * The idea is that the user can supply a wrapper function
		 * __wrap_XXX that does some work, and then uses the name
		 * __real_XXX to pass the call on to the real function. The
		 * wrapper objects are linked with the original unmodified
		 * objects to produce a wrapped version of the output object.
		 */
		if (ofl->ofl_wrap && name[0] && (shndx == SHN_UNDEF)) {
			WrapSymNode wsn, *wsnp;

			/*
			 * If this is the __real_XXX form, advance the
			 * pointer to reference the wrapped name.
			 */
			wsn.wsn_name = name;
			if ((*name == '_') &&
			    (strncmp(name, MSG_ORIG(MSG_STR_UU_REAL_U),
			    MSG_STR_UU_REAL_U_SIZE) == 0))
				wsn.wsn_name += MSG_STR_UU_REAL_U_SIZE;

			/*
			 * Is this symbol in the wrap AVL tree? If so, map
			 * XXX to __wrap_XXX, and __real_XXX to XXX. Note that
			 * wsn.wsn_name will equal the current value of name
			 * if the __real_ prefix is not present.
			 */
			if ((wsnp = avl_find(ofl->ofl_wrap, &wsn, 0)) != NULL) {
				const char *old_name = name;

				name = (wsn.wsn_name == name) ?
				    wsnp->wsn_wrapname : wsn.wsn_name;
				DBG_CALL(Dbg_syms_wrap(ofl->ofl_lml, ndx,
				    old_name, name));
			}
		}

		/*
		 * Determine and validate the symbols binding.
		 */
		bind = ELF_ST_BIND(nsym->st_info);
		if ((bind != STB_GLOBAL) && (bind != STB_WEAK)) {
			ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SYM_NONGLOB),
			    demangle_symname(name, symsecname, ndx),
			    ifl->ifl_name,
			    conv_sym_info_bind(bind, 0, &inv_buf));
			continue;
		}
		if (bind == STB_WEAK)
			weak++;

		/*
		 * If this symbol falls within the range of a section being
		 * discarded, then discard the symbol itself.
		 */
		if (((sdflags & FLG_SY_SPECSEC) == 0) &&
		    (nsym->st_shndx != SHN_UNDEF)) {
			Is_desc	*isp;

			if (shndx >= ifl->ifl_shnum) {
				/*
				 * Carry our some basic sanity checks
				 * The symbol will not be carried forward to
				 * the output file, which won't be a problem
				 * unless a relocation is required against it.
				 */
				ld_eprintf(ofl, ERR_WARNING,
				    MSG_INTL(MSG_SYM_INVSHNDX),
				    demangle_symname(name, symsecname, ndx),
				    ifl->ifl_name,
				    conv_sym_shndx(osabi, mach, nsym->st_shndx,
				    CONV_FMT_DECIMAL, &inv_buf));
				continue;
			}

			isp = ifl->ifl_isdesc[shndx];
			if (isp && (isp->is_flags & FLG_IS_DISCARD)) {
				if ((sdp =
				    libld_calloc(sizeof (Sym_desc), 1)) == NULL)
					return (S_ERROR);

				/*
				 * Create a dummy symbol entry so that if we
				 * find any references to this discarded symbol
				 * we can compensate.
				 */
				sdp->sd_name = name;
				sdp->sd_sym = nsym;
				sdp->sd_file = ifl;
				sdp->sd_isc = isp;
				sdp->sd_flags = FLG_SY_ISDISC;
				ifl->ifl_oldndx[ndx] = sdp;

				DBG_CALL(Dbg_syms_discarded(ofl->ofl_lml, sdp));
				continue;
			}
		}

		/*
		 * If object capabilities for this file are being converted
		 * into symbol capabilities, then:
		 *
		 *  -	Any global function, or initialized global data symbol
		 *	definitions (ie., those that are not associated with
		 *	special symbol types, ie., ABS, COMMON, etc.), and which
		 *	have not been reduced to locals, are converted to symbol
		 *	references (UNDEF).  This ensures that any reference to
		 *	the original symbol, for example from a relocation, get
		 *	associated to a capabilities family lead symbol, ie., a
		 *	generic instance.
		 *
		 *  -	For each global function, or object symbol definition,
		 *	a new local symbol is created.  The function or object
		 *	is renamed using the capabilities CA_SUNW_ID definition
		 *	(which might have been fabricated for this purpose -
		 *	see get_cap_group()).  The new symbol name is:
		 *
		 *	    <original name>%<capability group identifier>
		 *
		 *	This symbol is associated to the same location, and
		 *	becomes a capabilities family member.
		 */
		/* LINTED */
		hash = (Word)elf_hash(name);

		ntype = ELF_ST_TYPE(nsym->st_info);
		if (cdp && (nsym->st_shndx != SHN_UNDEF) &&
		    ((sdflags & FLG_SY_SPECSEC) == 0) &&
		    ((ntype == STT_FUNC) || (ntype == STT_OBJECT))) {
			/*
			 * Determine this symbol's visibility.  If a mapfile has
			 * indicated this symbol should be local, then there's
			 * no point in transforming this global symbol to a
			 * capabilities symbol.  Otherwise, create a symbol
			 * capability pair descriptor to record this symbol as
			 * a candidate for translation.
			 */
			if (sym_cap_vis(name, hash, sym, ofl) &&
			    ((cpp = alist_append(&cappairs, NULL,
			    sizeof (Cap_pair), AL_CNT_CAP_PAIRS)) == NULL))
				return (S_ERROR);
		}

		if (cpp) {
			Sym	*rsym;

			DBG_CALL(Dbg_syms_cap_convert(ofl, ndx, name, nsym));

			/*
			 * Allocate a new symbol descriptor to represent the
			 * transformed global symbol.  The descriptor points
			 * to the original symbol information (which might
			 * indicate a global or weak visibility).  The symbol
			 * information will be transformed into a local symbol
			 * later, after any weak aliases are culled.
			 */
			if ((cpp->c_osdp =
			    libld_malloc(sizeof (Sym_desc))) == NULL)
				return (S_ERROR);

			cpp->c_osdp->sd_name = name;
			cpp->c_osdp->sd_sym = nsym;
			cpp->c_osdp->sd_shndx = shndx;
			cpp->c_osdp->sd_file = ifl;
			cpp->c_osdp->sd_isc = ifl->ifl_isdesc[shndx];
			cpp->c_osdp->sd_ref = REF_REL_NEED;

			/*
			 * Save the capabilities group this symbol belongs to,
			 * and the original symbol index.
			 */
			cpp->c_group = cdp->ca_groups->apl_data[0];
			cpp->c_ndx = ndx;

			/*
			 * Replace the original symbol definition with a symbol
			 * reference.  Make sure this reference isn't left as a
			 * weak.
			 */
			if ((rsym = libld_malloc(sizeof (Sym))) == NULL)
				return (S_ERROR);

			*rsym = *nsym;

			rsym->st_info = ELF_ST_INFO(STB_GLOBAL, ntype);
			rsym->st_shndx = shndx = SHN_UNDEF;
			rsym->st_value = 0;
			rsym->st_size = 0;

			sdflags |= FLG_SY_CAP;

			nsym = rsym;
		}

		/*
		 * If the symbol does not already exist in the internal symbol
		 * table add it, otherwise resolve the conflict.  If the symbol
		 * from this file is kept, retain its symbol table index for
		 * possible use in associating a global alias.
		 */
		if ((sdp = ld_sym_find(name, hash, &where, ofl)) == NULL) {
			DBG_CALL(Dbg_syms_global(ofl->ofl_lml, ndx, name));
			if ((sdp = ld_sym_enter(name, nsym, hash, ifl, ofl, ndx,
			    shndx, sdflags, &where)) == (Sym_desc *)S_ERROR)
				return (S_ERROR);

		} else if (ld_sym_resolve(sdp, nsym, ifl, ofl, ndx, shndx,
		    sdflags) == S_ERROR)
			return (S_ERROR);

		/*
		 * Now that we have a symbol descriptor, retain the descriptor
		 * for later use by symbol capabilities processing.
		 */
		if (cpp)
			cpp->c_nsdp = sdp;

		/*
		 * After we've compared a defined symbol in one shared
		 * object, flag the symbol so we don't compare it again.
		 */
		if ((etype == ET_DYN) && (nsym->st_shndx != SHN_UNDEF) &&
		    ((sdp->sd_flags & FLG_SY_SOFOUND) == 0))
			sdp->sd_flags |= FLG_SY_SOFOUND;

		/*
		 * If the symbol is accepted from this file retain the symbol
		 * index for possible use in aliasing.
		 */
		if (sdp->sd_file == ifl)
			sdp->sd_symndx = ndx;

		ifl->ifl_oldndx[ndx] = sdp;

		/*
		 * If we've accepted a register symbol, continue to validate
		 * it.
		 */
		if (sdp->sd_flags & FLG_SY_REGSYM) {
			Sym_desc	*rsdp;

			/*
			 * The presence of FLG_SY_REGSYM means that
			 * the pointers in ld_targ.t_ms are non-NULL.
			 */
			rsdp = (*ld_targ.t_ms.ms_reg_find)(sdp->sd_sym, ofl);
			if (rsdp == NULL) {
				if ((*ld_targ.t_ms.ms_reg_enter)(sdp, ofl) == 0)
					return (S_ERROR);
			} else if (rsdp != sdp) {
				(void) (*ld_targ.t_ms.ms_reg_check)(rsdp,
				    sdp->sd_sym, sdp->sd_name, ifl, ofl);
			}
		}

		/*
		 * For a relocatable object, if this symbol is defined
		 * and has non-zero length and references an address
		 * within an associated section, then check its extents
		 * to make sure the section boundaries encompass it.
		 * If they don't, the ELF file is corrupt. Note that this
		 * global symbol may have come from another file to satisfy
		 * an UNDEF symbol of the same name from this one. In that
		 * case, we don't check it, because it was already checked
		 * as part of its own file.
		 */
		if (etype_rel && (sdp->sd_file == ifl)) {
			Sym *tsym = sdp->sd_sym;

			if (SYM_LOC_BADADDR(sdp, tsym,
			    ELF_ST_TYPE(tsym->st_info))) {
				issue_badaddr_msg(ifl, ofl, sdp,
				    tsym, tsym->st_shndx);
				continue;
			}
		}
	}
	DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD));

	/*
	 * Associate weak (alias) symbols to their non-weak counterparts by
	 * scanning the global symbols one more time.
	 *
	 * This association is needed when processing the symbols from a shared
	 * object dependency when a a weak definition satisfies a reference:
	 *
	 *  -	When building a dynamic executable, if a referenced symbol is a
	 *	data item, the symbol data is copied to the executables address
	 *	space.  In this copy-relocation case, we must also reassociate
	 *	the alias symbol with its new location in the executable.
	 *
	 *  -	If the referenced symbol is a function then we may need to
	 *	promote the symbols binding from undefined weak to undefined,
	 *	otherwise the run-time linker will not generate the correct
	 *	relocation error should the symbol not be found.
	 *
	 * Weak alias association is also required when a local dynsym table
	 * is being created.  This table should only contain one instance of a
	 * symbol that is associated to a given address.
	 *
	 * The true association between a weak/strong symbol pair is that both
	 * symbol entries are identical, thus first we create a sorted symbol
	 * list keyed off of the symbols section index and value.  If the symbol
	 * belongs to the same section and has the same value, then the chances
	 * are that the rest of the symbols data is the same.  This list is then
	 * scanned for weak symbols, and if one is found then any strong
	 * association will exist in the entries that follow.  Thus we just have
	 * to scan one (typically a single alias) or more (in the uncommon
	 * instance of multiple weak to strong associations) entries to
	 * determine if a match exists.
	 */
	if (weak && (OFL_ALLOW_LDYNSYM(ofl) || (etype == ET_DYN)) &&
	    (total > local)) {
		static Sym_desc	**sort;
		static size_t	osize = 0;
		size_t		nsize = (total - local) * sizeof (Sym_desc *);

		/*
		 * As we might be processing many input files, and many symbols,
		 * try and reuse a static sort buffer.  Note, presently we're
		 * playing the game of never freeing any buffers as there's a
		 * belief this wastes time.
		 */
		if ((osize == 0) || (nsize > osize)) {
			if ((sort = libld_malloc(nsize)) == NULL)
				return (S_ERROR);
			osize = nsize;
		}
		(void) memcpy((void *)sort, &ifl->ifl_oldndx[local], nsize);

		qsort(sort, (total - local), sizeof (Sym_desc *), compare);

		for (ndx = 0; ndx < (total - local); ndx++) {
			Sym_desc	*wsdp = sort[ndx];
			Sym		*wsym;
			int		sndx;

			/*
			 * Ignore any empty symbol descriptor, or the case where
			 * the symbol has been resolved to a different file.
			 */
			if ((wsdp == NULL) || (wsdp->sd_file != ifl))
				continue;

			wsym = wsdp->sd_sym;

			if ((wsym->st_shndx == SHN_UNDEF) ||
			    (wsdp->sd_flags & FLG_SY_SPECSEC) ||
			    (ELF_ST_BIND(wsym->st_info) != STB_WEAK))
				continue;

			/*
			 * We have a weak symbol, if it has a strong alias it
			 * will have been sorted to one of the following sort
			 * table entries.  Note that we could have multiple weak
			 * symbols aliased to one strong (if this occurs then
			 * the strong symbol only maintains one alias back to
			 * the last weak).
			 */
			for (sndx = ndx + 1; sndx < (total - local); sndx++) {
				Sym_desc	*ssdp = sort[sndx];
				Sym		*ssym;
				sd_flag_t	w_dynbits, s_dynbits;

				/*
				 * Ignore any empty symbol descriptor, or the
				 * case where the symbol has been resolved to a
				 * different file.
				 */
				if ((ssdp == NULL) || (ssdp->sd_file != ifl))
					continue;

				ssym = ssdp->sd_sym;

				if (ssym->st_shndx == SHN_UNDEF)
					continue;

				if ((ssym->st_shndx != wsym->st_shndx) ||
				    (ssym->st_value != wsym->st_value))
					break;

				if ((ssym->st_size != wsym->st_size) ||
				    (ssdp->sd_flags & FLG_SY_SPECSEC) ||
				    (ELF_ST_BIND(ssym->st_info) == STB_WEAK))
					continue;

				/*
				 * If a sharable object, set link fields so
				 * that they reference each other.`
				 */
				if (etype == ET_DYN) {
					ssdp->sd_aux->sa_linkndx =
					    (Word)wsdp->sd_symndx;
					wsdp->sd_aux->sa_linkndx =
					    (Word)ssdp->sd_symndx;
				}

				/*
				 * Determine which of these two symbols go into
				 * the sort section.  If a mapfile has made
				 * explicit settings of the FLG_SY_*DYNSORT
				 * flags for both symbols, then we do what they
				 * say.  If one has the DYNSORT flags set, we
				 * set the NODYNSORT bit in the other.  And if
				 * neither has an explicit setting, then we
				 * favor the weak symbol because they usually
				 * lack the leading underscore.
				 */
				w_dynbits = wsdp->sd_flags &
				    (FLG_SY_DYNSORT | FLG_SY_NODYNSORT);
				s_dynbits = ssdp->sd_flags &
				    (FLG_SY_DYNSORT | FLG_SY_NODYNSORT);
				if (!(w_dynbits && s_dynbits)) {
					if (s_dynbits) {
						if (s_dynbits == FLG_SY_DYNSORT)
							wsdp->sd_flags |=
							    FLG_SY_NODYNSORT;
					} else if (w_dynbits !=
					    FLG_SY_NODYNSORT) {
						ssdp->sd_flags |=
						    FLG_SY_NODYNSORT;
					}
				}
				break;
			}
		}
	}

	/*
	 * Having processed all symbols, under -z symbolcap, reprocess any
	 * symbols that are being translated from global to locals.  The symbol
	 * pair that has been collected defines the original symbol (c_osdp),
	 * which will become a local, and the new symbol (c_nsdp), which will
	 * become a reference (UNDEF) for the original.
	 *
	 * Scan these symbol pairs looking for weak symbols, which have non-weak
	 * aliases.  There is no need to translate both of these symbols to
	 * locals, only the global is necessary.
	 */
	if (cappairs) {
		Aliste		idx1;
		Cap_pair	*cpp1;

		for (ALIST_TRAVERSE(cappairs, idx1, cpp1)) {
			Sym_desc	*sdp1 = cpp1->c_osdp;
			Sym		*sym1 = sdp1->sd_sym;
			uchar_t		bind1 = ELF_ST_BIND(sym1->st_info);
			Aliste		idx2;
			Cap_pair	*cpp2;

			/*
			 * If this symbol isn't weak, it's capability member is
			 * retained for the creation of a local symbol.
			 */
			if (bind1 != STB_WEAK)
				continue;

			/*
			 * If this is a weak symbol, traverse the capabilities
			 * list again to determine if a corresponding non-weak
			 * symbol exists.
			 */
			for (ALIST_TRAVERSE(cappairs, idx2, cpp2)) {
				Sym_desc	*sdp2 = cpp2->c_osdp;
				Sym		*sym2 = sdp2->sd_sym;
				uchar_t		bind2 =
				    ELF_ST_BIND(sym2->st_info);

				if ((cpp1 == cpp2) ||
				    (cpp1->c_group != cpp2->c_group) ||
				    (sym1->st_value != sym2->st_value) ||
				    (bind2 == STB_WEAK))
					continue;

				/*
				 * The weak symbol (sym1) has a non-weak (sym2)
				 * counterpart.  There's no point in translating
				 * both of these equivalent symbols to locals.
				 * Add this symbol capability alias to the
				 * capabilities family information, and remove
				 * the weak symbol.
				 */
				if (ld_cap_add_family(ofl, cpp2->c_nsdp,
				    cpp1->c_nsdp, NULL, NULL) == S_ERROR)
					return (S_ERROR);

				free((void *)cpp1->c_osdp);
				(void) alist_delete(cappairs, &idx1);
			}
		}

		DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD));

		/*
		 * The capability pairs information now represents all the
		 * global symbols that need transforming to locals.  These
		 * local symbols are renamed using their group identifiers.
		 */
		for (ALIST_TRAVERSE(cappairs, idx1, cpp1)) {
			Sym_desc	*osdp = cpp1->c_osdp;
			Objcapset	*capset;
			size_t		nsize, tsize;
			const char	*oname;
			char		*cname, *idstr;
			Sym		*csym;

			/*
			 * If the local symbol has not yet been translated
			 * convert it to a local symbol with a name.
			 */
			if ((osdp->sd_flags & FLG_SY_CAP) != 0)
				continue;

			/*
			 * As we're converting object capabilities to symbol
			 * capabilities, obtain the capabilities set for this
			 * object, so as to retrieve the CA_SUNW_ID value.
			 */
			capset = &cpp1->c_group->cg_set;

			/*
			 * Create a new name from the existing symbol and the
			 * capabilities group identifier.  Note, the delimiter
			 * between the symbol name and identifier name is hard-
			 * coded here (%), so that we establish a convention
			 * for transformed symbol names.
			 */
			oname = osdp->sd_name;

			idstr = capset->oc_id.cs_str;
			nsize = strlen(oname);
			tsize = nsize + 1 + strlen(idstr) + 1;
			if ((cname = libld_malloc(tsize)) == 0)
				return (S_ERROR);

			(void) strcpy(cname, oname);
			cname[nsize++] = '%';
			(void) strcpy(&cname[nsize], idstr);

			/*
			 * Allocate a new symbol table entry, transform this
			 * symbol to a local, and assign the new name.
			 */
			if ((csym = libld_malloc(sizeof (Sym))) == NULL)
				return (S_ERROR);

			*csym = *osdp->sd_sym;
			csym->st_info = ELF_ST_INFO(STB_LOCAL,
			    ELF_ST_TYPE(osdp->sd_sym->st_info));

			osdp->sd_name = cname;
			osdp->sd_sym = csym;
			osdp->sd_flags = FLG_SY_CAP;

			/*
			 * Keep track of this new local symbol.  As -z symbolcap
			 * can only be used to create a relocatable object, a
			 * dynamic symbol table can't exist.  Ensure there is
			 * space reserved in the string table.
			 */
			ofl->ofl_caploclcnt++;
			if (st_insert(ofl->ofl_strtab, cname) == -1)
				return (S_ERROR);

			DBG_CALL(Dbg_syms_cap_local(ofl, cpp1->c_ndx,
			    cname, csym, osdp));

			/*
			 * Establish this capability pair as a family.
			 */
			if (ld_cap_add_family(ofl, cpp1->c_nsdp, osdp,
			    cpp1->c_group, &ifl->ifl_caps->ca_syms) == S_ERROR)
				return (S_ERROR);
		}
	}

	return (1);

#undef SYM_LOC_BADADDR
}

/*
 * Add an undefined symbol to the symbol table.  The reference originates from
 * the location identified by the message id (mid).  These references can
 * originate from command line options such as -e, -u, -initarray, etc.
 * (identified with MSG_INTL(MSG_STR_COMMAND)), or from internally generated
 * TLS relocation references (identified with MSG_INTL(MSG_STR_TLSREL)).
 */
Sym_desc *
ld_sym_add_u(const char *name, Ofl_desc *ofl, Msg mid)
{
	Sym		*sym;
	Ifl_desc	*ifl = NULL, *_ifl;
	Sym_desc	*sdp;
	Word		hash;
	Aliste		idx;
	avl_index_t	where;
	const char	*reference = MSG_INTL(mid);

	/*
	 * As an optimization, determine whether we've already generated this
	 * reference.  If the symbol doesn't already exist we'll create it.
	 * Or if the symbol does exist from a different source, we'll resolve
	 * the conflict.
	 */
	/* LINTED */
	hash = (Word)elf_hash(name);
	if ((sdp = ld_sym_find(name, hash, &where, ofl)) != NULL) {
		if ((sdp->sd_sym->st_shndx == SHN_UNDEF) &&
		    (sdp->sd_file->ifl_name == reference))
			return (sdp);
	}

	/*
	 * Determine whether a pseudo input file descriptor exists to represent
	 * the command line, as any global symbol needs an input file descriptor
	 * during any symbol resolution (refer to map_ifl() which provides a
	 * similar method for adding symbols from mapfiles).
	 */
	for (APLIST_TRAVERSE(ofl->ofl_objs, idx, _ifl))
		if (strcmp(_ifl->ifl_name, reference) == 0) {
			ifl = _ifl;
			break;
		}

	/*
	 * If no descriptor exists create one.
	 */
	if (ifl == NULL) {
		if ((ifl = libld_calloc(sizeof (Ifl_desc), 1)) == NULL)
			return ((Sym_desc *)S_ERROR);
		ifl->ifl_name = reference;
		ifl->ifl_flags = FLG_IF_NEEDED | FLG_IF_FILEREF;
		if ((ifl->ifl_ehdr = libld_calloc(sizeof (Ehdr), 1)) == NULL)
			return ((Sym_desc *)S_ERROR);
		ifl->ifl_ehdr->e_type = ET_REL;

		if (aplist_append(&ofl->ofl_objs, ifl, AL_CNT_OFL_OBJS) == NULL)
			return ((Sym_desc *)S_ERROR);
	}

	/*
	 * Allocate a symbol structure and add it to the global symbol table.
	 */
	if ((sym = libld_calloc(sizeof (Sym), 1)) == NULL)
		return ((Sym_desc *)S_ERROR);
	sym->st_info = ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE);
	sym->st_shndx = SHN_UNDEF;

	DBG_CALL(Dbg_syms_process(ofl->ofl_lml, ifl));
	if (sdp == NULL) {
		DBG_CALL(Dbg_syms_global(ofl->ofl_lml, 0, name));
		if ((sdp = ld_sym_enter(name, sym, hash, ifl, ofl, 0, SHN_UNDEF,
		    0, &where)) == (Sym_desc *)S_ERROR)
			return ((Sym_desc *)S_ERROR);
	} else if (ld_sym_resolve(sdp, sym, ifl, ofl, 0,
	    SHN_UNDEF, 0) == S_ERROR)
		return ((Sym_desc *)S_ERROR);

	sdp->sd_flags &= ~FLG_SY_CLEAN;
	sdp->sd_flags |= FLG_SY_CMDREF;

	return (sdp);
}

/*
 * STT_SECTION symbols have their st_name field set to NULL, and consequently
 * have no name. Generate a name suitable for diagnostic use for such a symbol
 * and store it in the input section descriptor. The resulting name will be
 * of the form:
 *
 *	"XXX (section)"
 *
 * where XXX is the name of the section.
 *
 * entry:
 *	isc - Input section associated with the symbol.
 *	fmt - NULL, or format string to use.
 *
 * exit:
 *	Sets isp->is_sym_name to the allocated string. Returns the
 *	string pointer, or NULL on allocation failure.
 */
const char *
ld_stt_section_sym_name(Is_desc *isp)
{
	const char	*fmt;
	char		*str;
	size_t		len;

	if ((isp == NULL) || (isp->is_name == NULL))
		return (NULL);

	if (isp->is_sym_name == NULL) {
		fmt = (isp->is_flags & FLG_IS_GNSTRMRG) ?
		    MSG_INTL(MSG_STR_SECTION_MSTR) : MSG_INTL(MSG_STR_SECTION);

		len = strlen(fmt) + strlen(isp->is_name) + 1;

		if ((str = libld_malloc(len)) == NULL)
			return (NULL);
		(void) snprintf(str, len, fmt, isp->is_name);
		isp->is_sym_name = str;
	}

	return (isp->is_sym_name);
}

/*
 * If we're producing a relocatable object and the symbol is eligible for
 * COMDAT section, it shouldn't be reduced in scope as that will break the
 * COMDAT matching when the output object is later consumed.  Leave it alone,
 * and any reduction (and COMDAT) processing will occur then.
 *
 * Otherwise, any hidden symbol is reduced when reductions are being processed.
 */
Boolean
ld_sym_reducable(Ofl_desc *ofl, Sym_desc *sdp)
{
	Is_desc *isc = sdp->sd_isc;

	if (((ofl->ofl_flags & FLG_OF_RELOBJ) != 0) &&
	    (isc != NULL) &&
	    ((isc->is_flags & FLG_IS_COMDAT) != 0)) {
		return (FALSE);
	} else {
		return (SYM_IS_HIDDEN(sdp) &&
		    (ofl->ofl_flags & FLG_OF_PROCRED));
	}
}