xref: /titanic_50/usr/src/cmd/sgs/libld/common/syms.c (revision faac71c002f7c7a98741f991b25937b24f309df0)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  *	Copyright (c) 1988 AT&T
24  *	  All Rights Reserved
25  *
26  *
27  * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
28  */
29 
30 /*
31  * Symbol table management routines
32  */
33 
34 #define	ELF_TARGET_AMD64
35 
36 #include	<stdio.h>
37 #include	<string.h>
38 #include	<debug.h>
39 #include	"msg.h"
40 #include	"_libld.h"
41 
42 /*
43  * AVL tree comparator function:
44  *
45  * The primary key is the symbol name hash with a secondary key of the symbol
46  * name itself.
47  */
48 int
49 ld_sym_avl_comp(const void *elem1, const void *elem2)
50 {
51 	Sym_avlnode	*sav1 = (Sym_avlnode *)elem1;
52 	Sym_avlnode	*sav2 = (Sym_avlnode *)elem2;
53 	int		res;
54 
55 	res = sav1->sav_hash - sav2->sav_hash;
56 
57 	if (res < 0)
58 		return (-1);
59 	if (res > 0)
60 		return (1);
61 
62 	/*
63 	 * Hash is equal - now compare name
64 	 */
65 	res = strcmp(sav1->sav_name, sav2->sav_name);
66 	if (res == 0)
67 		return (0);
68 	if (res > 0)
69 		return (1);
70 	return (-1);
71 }
72 
73 /*
74  * Focal point for verifying symbol names.
75  */
76 inline static const char *
77 string(Ofl_desc *ofl, Ifl_desc *ifl, Sym *sym, const char *strs, size_t strsize,
78     int symndx, Word shndx, Word symsecndx, const char *symsecname,
79     const char *strsecname, sd_flag_t *flags)
80 {
81 	Word	name = sym->st_name;
82 
83 	if (name) {
84 		if ((ifl->ifl_flags & FLG_IF_HSTRTAB) == 0) {
85 			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_NOSTRTABLE),
86 			    ifl->ifl_name, EC_WORD(symsecndx), symsecname,
87 			    symndx, EC_XWORD(name));
88 			return (NULL);
89 		}
90 		if (name >= (Word)strsize) {
91 			ld_eprintf(ofl, ERR_FATAL,
92 			    MSG_INTL(MSG_FIL_EXCSTRTABLE), ifl->ifl_name,
93 			    EC_WORD(symsecndx), symsecname, symndx,
94 			    EC_XWORD(name), strsecname, EC_XWORD(strsize));
95 			return (NULL);
96 		}
97 	}
98 
99 	/*
100 	 * Determine if we're dealing with a register and if so validate it.
101 	 * If it's a scratch register, a fabricated name will be returned.
102 	 */
103 	if (ld_targ.t_ms.ms_is_regsym != NULL) {
104 		const char *regname = (*ld_targ.t_ms.ms_is_regsym)(ofl, ifl,
105 		    sym, strs, symndx, shndx, symsecname, flags);
106 
107 		if (regname == (const char *)S_ERROR) {
108 			return (NULL);
109 		}
110 		if (regname)
111 			return (regname);
112 	}
113 
114 	/*
115 	 * If this isn't a register, but we have a global symbol with a null
116 	 * name, we're not going to be able to hash this, search for it, or
117 	 * do anything interesting.  However, we've been accepting a symbol of
118 	 * this kind for ages now, so give the user a warning (rather than a
119 	 * fatal error), just in case this instance exists somewhere in the
120 	 * world and hasn't, as yet, been a problem.
121 	 */
122 	if ((name == 0) && (ELF_ST_BIND(sym->st_info) != STB_LOCAL)) {
123 		ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_FIL_NONAMESYM),
124 		    ifl->ifl_name, EC_WORD(symsecndx), symsecname, symndx,
125 		    EC_XWORD(name));
126 	}
127 	return (strs + name);
128 }
129 
130 /*
131  * For producing symbol names strings to use in error messages.
132  * If the symbol has a non-null name, then the string returned by
133  * this function is the output from demangle(), surrounded by
134  * single quotes. For null names, a descriptive string giving
135  * the symbol section and index is generated.
136  *
137  * This function uses an internal static buffer to hold the resulting
138  * string. The value returned is usable by the caller until the next
139  * call, at which point it is overwritten.
140  */
141 static const char *
142 demangle_symname(const char *name, const char *symtab_name, Word symndx)
143 {
144 #define	INIT_BUFSIZE 256
145 
146 	static char	*buf;
147 	static size_t	bufsize = 0;
148 	size_t		len;
149 	int		use_name;
150 
151 	use_name = (name != NULL) && (*name != '\0');
152 
153 	if (use_name) {
154 		name = demangle(name);
155 		len = strlen(name) + 2;   /* Include room for quotes */
156 	} else {
157 		name = MSG_ORIG(MSG_STR_EMPTY);
158 		len = strlen(symtab_name) + 2 + CONV_INV_BUFSIZE;
159 	}
160 	len++;			/* Null termination */
161 
162 	/* If our buffer is too small, double it until it is big enough */
163 	if (len > bufsize) {
164 		size_t	new_bufsize = bufsize;
165 		char	*new_buf;
166 
167 		if (new_bufsize == 0)
168 			new_bufsize = INIT_BUFSIZE;
169 		while (len > new_bufsize)
170 			new_bufsize *= 2;
171 		if ((new_buf = libld_malloc(new_bufsize)) == NULL)
172 			return (name);
173 		buf = new_buf;
174 		bufsize = new_bufsize;
175 	}
176 
177 	if (use_name) {
178 		(void) snprintf(buf, bufsize, MSG_ORIG(MSG_FMT_SYMNAM), name);
179 	} else {
180 		(void) snprintf(buf, bufsize, MSG_ORIG(MSG_FMT_NULLSYMNAM),
181 		    symtab_name, EC_WORD(symndx));
182 	}
183 
184 	return (buf);
185 
186 #undef INIT_BUFSIZE
187 }
188 
189 /*
190  * Shared objects can be built that define specific symbols that can not be
191  * directly bound to.  These objects have a syminfo section (and an associated
192  * DF_1_NODIRECT dynamic flags entry).  Scan this table looking for symbols
193  * that can't be bound to directly, and if this files symbol is presently
194  * referenced, mark it so that we don't directly bind to it.
195  */
196 uintptr_t
197 ld_sym_nodirect(Is_desc *isp, Ifl_desc *ifl, Ofl_desc *ofl)
198 {
199 	Shdr		*sifshdr, *symshdr;
200 	Syminfo		*sifdata;
201 	Sym		*symdata;
202 	char		*strdata;
203 	ulong_t		cnt, _cnt;
204 
205 	/*
206 	 * Get the syminfo data, and determine the number of entries.
207 	 */
208 	sifshdr = isp->is_shdr;
209 	sifdata = (Syminfo *)isp->is_indata->d_buf;
210 	cnt =  sifshdr->sh_size / sifshdr->sh_entsize;
211 
212 	/*
213 	 * Get the associated symbol table.
214 	 */
215 	if ((sifshdr->sh_link == 0) || (sifshdr->sh_link >= ifl->ifl_shnum)) {
216 		/*
217 		 * Broken input file
218 		 */
219 		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_INVSHINFO),
220 		    ifl->ifl_name, isp->is_name, EC_XWORD(sifshdr->sh_link));
221 		return (0);
222 	}
223 	symshdr = ifl->ifl_isdesc[sifshdr->sh_link]->is_shdr;
224 	symdata = ifl->ifl_isdesc[sifshdr->sh_link]->is_indata->d_buf;
225 
226 	/*
227 	 * Get the string table associated with the symbol table.
228 	 */
229 	strdata = ifl->ifl_isdesc[symshdr->sh_link]->is_indata->d_buf;
230 
231 	/*
232 	 * Traverse the syminfo data for symbols that can't be directly
233 	 * bound to.
234 	 */
235 	for (_cnt = 1, sifdata++; _cnt < cnt; _cnt++, sifdata++) {
236 		Sym		*sym;
237 		char		*str;
238 		Sym_desc	*sdp;
239 
240 		if ((sifdata->si_flags & SYMINFO_FLG_NOEXTDIRECT) == 0)
241 			continue;
242 
243 		sym = (Sym *)(symdata + _cnt);
244 		str = (char *)(strdata + sym->st_name);
245 
246 		if ((sdp = ld_sym_find(str, SYM_NOHASH, NULL, ofl)) != NULL) {
247 			if (ifl != sdp->sd_file)
248 				continue;
249 
250 			sdp->sd_flags &= ~FLG_SY_DIR;
251 			sdp->sd_flags |= FLG_SY_NDIR;
252 		}
253 	}
254 	return (0);
255 }
256 
257 /*
258  * If, during symbol processing, it is necessary to update a local symbols
259  * contents before we have generated the symbol tables in the output image,
260  * create a new symbol structure and copy the original symbol contents.  While
261  * we are processing the input files, their local symbols are part of the
262  * read-only mapped image.  Commonly, these symbols are copied to the new output
263  * file image and then updated to reflect their new address and any change in
264  * attributes.  However, sometimes during relocation counting, it is necessary
265  * to adjust the symbols information.  This routine provides for the generation
266  * of a new symbol image so that this update can be performed.
267  * All global symbols are copied to an internal symbol table to improve locality
268  * of reference and hence performance, and thus this copying is not necessary.
269  */
270 uintptr_t
271 ld_sym_copy(Sym_desc *sdp)
272 {
273 	Sym	*nsym;
274 
275 	if (sdp->sd_flags & FLG_SY_CLEAN) {
276 		if ((nsym = libld_malloc(sizeof (Sym))) == NULL)
277 			return (S_ERROR);
278 		*nsym = *(sdp->sd_sym);
279 		sdp->sd_sym = nsym;
280 		sdp->sd_flags &= ~FLG_SY_CLEAN;
281 	}
282 	return (1);
283 }
284 
285 /*
286  * Finds a given name in the link editors internal symbol table.  If no
287  * hash value is specified it is calculated.  A pointer to the located
288  * Sym_desc entry is returned, or NULL if the symbol is not found.
289  */
290 Sym_desc *
291 ld_sym_find(const char *name, Word hash, avl_index_t *where, Ofl_desc *ofl)
292 {
293 	Sym_avlnode	qsav, *sav;
294 
295 	if (hash == SYM_NOHASH)
296 		/* LINTED */
297 		hash = (Word)elf_hash((const char *)name);
298 	qsav.sav_hash = hash;
299 	qsav.sav_name = name;
300 
301 	/*
302 	 * Perform search for symbol in AVL tree.  Note that the 'where' field
303 	 * is passed in from the caller.  If a 'where' is present, it can be
304 	 * used in subsequent 'ld_sym_enter()' calls if required.
305 	 */
306 	sav = avl_find(&ofl->ofl_symavl, &qsav, where);
307 
308 	/*
309 	 * If symbol was not found in the avl tree, return null to show that.
310 	 */
311 	if (sav == NULL)
312 		return (NULL);
313 
314 	/*
315 	 * Return symbol found.
316 	 */
317 	return (sav->sav_sdp);
318 }
319 
320 /*
321  * Enter a new symbol into the link editors internal symbol table.
322  * If the symbol is from an input file, information regarding the input file
323  * and input section is also recorded.  Otherwise (file == NULL) the symbol
324  * has been internally generated (ie. _etext, _edata, etc.).
325  */
326 Sym_desc *
327 ld_sym_enter(const char *name, Sym *osym, Word hash, Ifl_desc *ifl,
328     Ofl_desc *ofl, Word ndx, Word shndx, sd_flag_t sdflags, avl_index_t *where)
329 {
330 	Sym_desc	*sdp;
331 	Sym_aux		*sap;
332 	Sym_avlnode	*savl;
333 	char		*_name;
334 	Sym		*nsym;
335 	Half		etype;
336 	uchar_t		vis;
337 	avl_index_t	_where;
338 
339 	/*
340 	 * Establish the file type.
341 	 */
342 	if (ifl)
343 		etype = ifl->ifl_ehdr->e_type;
344 	else
345 		etype = ET_NONE;
346 
347 	ofl->ofl_entercnt++;
348 
349 	/*
350 	 * Allocate a Sym Descriptor, Auxiliary Descriptor, and a Sym AVLNode -
351 	 * contiguously.
352 	 */
353 	if ((savl = libld_calloc(S_DROUND(sizeof (Sym_avlnode)) +
354 	    S_DROUND(sizeof (Sym_desc)) +
355 	    S_DROUND(sizeof (Sym_aux)), 1)) == NULL)
356 		return ((Sym_desc *)S_ERROR);
357 	sdp = (Sym_desc *)((uintptr_t)savl +
358 	    S_DROUND(sizeof (Sym_avlnode)));
359 	sap = (Sym_aux *)((uintptr_t)sdp +
360 	    S_DROUND(sizeof (Sym_desc)));
361 
362 	savl->sav_sdp = sdp;
363 	sdp->sd_file = ifl;
364 	sdp->sd_aux = sap;
365 	savl->sav_hash = sap->sa_hash = hash;
366 
367 	/*
368 	 * Copy the symbol table entry from the input file into the internal
369 	 * entry and have the symbol descriptor use it.
370 	 */
371 	sdp->sd_sym = nsym = &sap->sa_sym;
372 	*nsym = *osym;
373 	sdp->sd_shndx = shndx;
374 	sdp->sd_flags |= sdflags;
375 
376 	if ((_name = libld_malloc(strlen(name) + 1)) == NULL)
377 		return ((Sym_desc *)S_ERROR);
378 	savl->sav_name = sdp->sd_name = (const char *)strcpy(_name, name);
379 
380 	/*
381 	 * Enter Symbol in AVL tree.
382 	 */
383 	if (where == 0) {
384 		/* LINTED */
385 		Sym_avlnode	*_savl;
386 		/*
387 		 * If a previous ld_sym_find() hasn't initialized 'where' do it
388 		 * now.
389 		 */
390 		where = &_where;
391 		_savl = avl_find(&ofl->ofl_symavl, savl, where);
392 		assert(_savl == NULL);
393 	}
394 	avl_insert(&ofl->ofl_symavl, savl, *where);
395 
396 	/*
397 	 * Record the section index.  This is possible because the
398 	 * `ifl_isdesc' table is filled before we start symbol processing.
399 	 */
400 	if ((sdflags & FLG_SY_SPECSEC) || (nsym->st_shndx == SHN_UNDEF))
401 		sdp->sd_isc = NULL;
402 	else {
403 		sdp->sd_isc = ifl->ifl_isdesc[shndx];
404 
405 		/*
406 		 * If this symbol is from a relocatable object, make sure that
407 		 * it is still associated with a section.  For example, an
408 		 * unknown section type (SHT_NULL) would have been rejected on
409 		 * input with a warning.  Here, we make the use of the symbol
410 		 * fatal.  A symbol descriptor is still returned, so that the
411 		 * caller can continue processing all symbols, and hence flush
412 		 * out as many error conditions as possible.
413 		 */
414 		if ((etype == ET_REL) && (sdp->sd_isc == NULL)) {
415 			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYM_INVSEC),
416 			    name, ifl->ifl_name, EC_XWORD(shndx));
417 			return (sdp);
418 		}
419 	}
420 
421 	/*
422 	 * Mark any COMMON symbols as 'tentative'.
423 	 */
424 	if (sdflags & FLG_SY_SPECSEC) {
425 		if (nsym->st_shndx == SHN_COMMON)
426 			sdp->sd_flags |= FLG_SY_TENTSYM;
427 #if	defined(_ELF64)
428 		else if ((ld_targ.t_m.m_mach == EM_AMD64) &&
429 		    (nsym->st_shndx == SHN_X86_64_LCOMMON))
430 			sdp->sd_flags |= FLG_SY_TENTSYM;
431 #endif
432 	}
433 
434 	/*
435 	 * Establish the symbols visibility and reference.
436 	 */
437 	vis = ELF_ST_VISIBILITY(nsym->st_other);
438 
439 	if ((etype == ET_NONE) || (etype == ET_REL)) {
440 		switch (vis) {
441 		case STV_DEFAULT:
442 			sdp->sd_flags |= FLG_SY_DEFAULT;
443 			break;
444 		case STV_INTERNAL:
445 		case STV_HIDDEN:
446 			sdp->sd_flags |= FLG_SY_HIDDEN;
447 			break;
448 		case STV_PROTECTED:
449 			sdp->sd_flags |= FLG_SY_PROTECT;
450 			break;
451 		case STV_EXPORTED:
452 			sdp->sd_flags |= FLG_SY_EXPORT;
453 			break;
454 		case STV_SINGLETON:
455 			sdp->sd_flags |= (FLG_SY_SINGLE | FLG_SY_NDIR);
456 			ofl->ofl_flags1 |= (FLG_OF1_NDIRECT | FLG_OF1_NGLBDIR);
457 			break;
458 		case STV_ELIMINATE:
459 			sdp->sd_flags |= (FLG_SY_HIDDEN | FLG_SY_ELIM);
460 			break;
461 		default:
462 			assert(vis <= STV_ELIMINATE);
463 		}
464 
465 		sdp->sd_ref = REF_REL_NEED;
466 
467 		/*
468 		 * Under -Bnodirect, all exported interfaces that have not
469 		 * explicitly been defined protected or directly bound to, are
470 		 * tagged to prevent direct binding.
471 		 */
472 		if ((ofl->ofl_flags1 & FLG_OF1_ALNODIR) &&
473 		    ((sdp->sd_flags & (FLG_SY_PROTECT | FLG_SY_DIR)) == 0) &&
474 		    (nsym->st_shndx != SHN_UNDEF)) {
475 			sdp->sd_flags |= FLG_SY_NDIR;
476 		}
477 	} else {
478 		sdp->sd_ref = REF_DYN_SEEN;
479 
480 		/*
481 		 * If this is a protected symbol, remember this.  Note, this
482 		 * state is different from the FLG_SY_PROTECT used to establish
483 		 * a symbol definitions visibility.  This state is used to warn
484 		 * against possible copy relocations against this referenced
485 		 * symbol.
486 		 */
487 		if (vis == STV_PROTECTED)
488 			sdp->sd_flags |= FLG_SY_PROT;
489 
490 		/*
491 		 * If this is a SINGLETON definition, then indicate the symbol
492 		 * can not be directly bound to, and retain the visibility.
493 		 * This visibility will be inherited by any references made to
494 		 * this symbol.
495 		 */
496 		if ((vis == STV_SINGLETON) && (nsym->st_shndx != SHN_UNDEF))
497 			sdp->sd_flags |= (FLG_SY_SINGLE | FLG_SY_NDIR);
498 
499 		/*
500 		 * If the new symbol is from a shared library and is associated
501 		 * with a SHT_NOBITS section then this symbol originated from a
502 		 * tentative symbol.
503 		 */
504 		if (sdp->sd_isc &&
505 		    (sdp->sd_isc->is_shdr->sh_type == SHT_NOBITS))
506 			sdp->sd_flags |= FLG_SY_TENTSYM;
507 	}
508 
509 	/*
510 	 * Reclassify any SHN_SUNW_IGNORE symbols to SHN_UNDEF so as to
511 	 * simplify future processing.
512 	 */
513 	if (nsym->st_shndx == SHN_SUNW_IGNORE) {
514 		sdp->sd_shndx = shndx = SHN_UNDEF;
515 		sdp->sd_flags |= (FLG_SY_REDUCED |
516 		    FLG_SY_HIDDEN | FLG_SY_IGNORE | FLG_SY_ELIM);
517 	}
518 
519 	/*
520 	 * If this is an undefined, or common symbol from a relocatable object
521 	 * determine whether it is a global or weak reference (see build_osym(),
522 	 * where REF_DYN_NEED definitions are returned back to undefines).
523 	 */
524 	if ((etype == ET_REL) &&
525 	    (ELF_ST_BIND(nsym->st_info) == STB_GLOBAL) &&
526 	    ((nsym->st_shndx == SHN_UNDEF) || ((sdflags & FLG_SY_SPECSEC) &&
527 #if	defined(_ELF64)
528 	    ((nsym->st_shndx == SHN_COMMON) ||
529 	    ((ld_targ.t_m.m_mach == EM_AMD64) &&
530 	    (nsym->st_shndx == SHN_X86_64_LCOMMON))))))
531 #else
532 	/* BEGIN CSTYLED */
533 	    (nsym->st_shndx == SHN_COMMON))))
534 	/* END CSTYLED */
535 #endif
536 		sdp->sd_flags |= FLG_SY_GLOBREF;
537 
538 	/*
539 	 * Record the input filename on the referenced or defined files list
540 	 * for possible later diagnostics.  The `sa_rfile' pointer contains the
541 	 * name of the file that first referenced this symbol and is used to
542 	 * generate undefined symbol diagnostics (refer to sym_undef_entry()).
543 	 * Note that this entry can be overridden if a reference from a
544 	 * relocatable object is found after a reference from a shared object
545 	 * (refer to sym_override()).
546 	 * The `sa_dfiles' list is used to maintain the list of files that
547 	 * define the same symbol.  This list can be used for two reasons:
548 	 *
549 	 *  -	To save the first definition of a symbol that is not available
550 	 *	for this link-edit.
551 	 *
552 	 *  -	To save all definitions of a symbol when the -m option is in
553 	 *	effect.  This is optional as it is used to list multiple
554 	 *	(interposed) definitions of a symbol (refer to ldmap_out()),
555 	 *	and can be quite expensive.
556 	 */
557 	if (nsym->st_shndx == SHN_UNDEF) {
558 		sap->sa_rfile = ifl->ifl_name;
559 	} else {
560 		if (sdp->sd_ref == REF_DYN_SEEN) {
561 			/*
562 			 * A symbol is determined to be unavailable if it
563 			 * belongs to a version of a shared object that this
564 			 * user does not wish to use, or if it belongs to an
565 			 * implicit shared object.
566 			 */
567 			if (ifl->ifl_vercnt) {
568 				Ver_index	*vip;
569 				Half		vndx = ifl->ifl_versym[ndx];
570 
571 				sap->sa_dverndx = vndx;
572 				vip = &ifl->ifl_verndx[vndx];
573 				if (!(vip->vi_flags & FLG_VER_AVAIL)) {
574 					sdp->sd_flags |= FLG_SY_NOTAVAIL;
575 					sap->sa_vfile = ifl->ifl_name;
576 				}
577 			}
578 			if (!(ifl->ifl_flags & FLG_IF_NEEDED))
579 				sdp->sd_flags |= FLG_SY_NOTAVAIL;
580 
581 		} else if (etype == ET_REL) {
582 			/*
583 			 * If this symbol has been obtained from a versioned
584 			 * input relocatable object then the new symbol must be
585 			 * promoted to the versioning of the output file.
586 			 */
587 			if (ifl->ifl_versym)
588 				ld_vers_promote(sdp, ndx, ifl, ofl);
589 		}
590 
591 		if ((ofl->ofl_flags & FLG_OF_GENMAP) &&
592 		    ((sdflags & FLG_SY_SPECSEC) == 0))
593 			if (aplist_append(&sap->sa_dfiles, ifl->ifl_name,
594 			    AL_CNT_SDP_DFILES) == NULL)
595 				return ((Sym_desc *)S_ERROR);
596 	}
597 
598 	/*
599 	 * Provided we're not processing a mapfile, diagnose the entered symbol.
600 	 * Mapfile processing requires the symbol to be updated with additional
601 	 * information, therefore the diagnosing of the symbol is deferred until
602 	 * later (see Dbg_map_symbol()).
603 	 */
604 	if ((ifl == NULL) || ((ifl->ifl_flags & FLG_IF_MAPFILE) == 0))
605 		DBG_CALL(Dbg_syms_entered(ofl, nsym, sdp));
606 
607 	return (sdp);
608 }
609 
610 /*
611  * Add a special symbol to the symbol table.  Takes special symbol name with
612  * and without underscores.  This routine is called, after all other symbol
613  * resolution has completed, to generate a reserved absolute symbol (the
614  * underscore version).  Special symbols are updated with the appropriate
615  * values in update_osym().  If the user has already defined this symbol
616  * issue a warning and leave the symbol as is.  If the non-underscore symbol
617  * is referenced then turn it into a weak alias of the underscored symbol.
618  *
619  * The bits in sdflags_u are OR'd into the flags field of the symbol for the
620  * underscored symbol.
621  *
622  * If this is a global symbol, and it hasn't explicitly been defined as being
623  * directly bound to, indicate that it can't be directly bound to.
624  * Historically, most special symbols only have meaning to the object in which
625  * they exist, however, they've always been global.  To ensure compatibility
626  * with any unexpected use presently in effect, ensure these symbols don't get
627  * directly bound to.  Note, that establishing this state here isn't sufficient
628  * to create a syminfo table, only if a syminfo table is being created by some
629  * other symbol directives will the nodirect binding be recorded.  This ensures
630  * we don't create syminfo sections for all objects we create, as this might add
631  * unnecessary bloat to users who haven't explicitly requested extra symbol
632  * information.
633  */
634 static uintptr_t
635 sym_add_spec(const char *name, const char *uname, Word sdaux_id,
636     sd_flag_t sdflags_u, sd_flag_t sdflags, Ofl_desc *ofl)
637 {
638 	Sym_desc	*sdp;
639 	Sym_desc 	*usdp;
640 	Sym		*sym;
641 	Word		hash;
642 	avl_index_t	where;
643 
644 	/* LINTED */
645 	hash = (Word)elf_hash(uname);
646 	if (usdp = ld_sym_find(uname, hash, &where, ofl)) {
647 		/*
648 		 * If the underscore symbol exists and is undefined, or was
649 		 * defined in a shared library, convert it to a local symbol.
650 		 * Otherwise leave it as is and warn the user.
651 		 */
652 		if ((usdp->sd_shndx == SHN_UNDEF) ||
653 		    (usdp->sd_ref != REF_REL_NEED)) {
654 			usdp->sd_ref = REF_REL_NEED;
655 			usdp->sd_shndx = usdp->sd_sym->st_shndx = SHN_ABS;
656 			usdp->sd_flags |= FLG_SY_SPECSEC | sdflags_u;
657 			usdp->sd_sym->st_info =
658 			    ELF_ST_INFO(STB_GLOBAL, STT_OBJECT);
659 			usdp->sd_isc = NULL;
660 			usdp->sd_sym->st_size = 0;
661 			usdp->sd_sym->st_value = 0;
662 			/* LINTED */
663 			usdp->sd_aux->sa_symspec = (Half)sdaux_id;
664 
665 			/*
666 			 * If a user hasn't specifically indicated that the
667 			 * scope of this symbol be made local, then leave it
668 			 * as global (ie. prevent automatic scoping).  The GOT
669 			 * should be defined protected, whereas all other
670 			 * special symbols are tagged as no-direct.
671 			 */
672 			if (!SYM_IS_HIDDEN(usdp) &&
673 			    (sdflags & FLG_SY_DEFAULT)) {
674 				usdp->sd_aux->sa_overndx = VER_NDX_GLOBAL;
675 				if (sdaux_id == SDAUX_ID_GOT) {
676 					usdp->sd_flags &= ~FLG_SY_NDIR;
677 					usdp->sd_flags |= FLG_SY_PROTECT;
678 					usdp->sd_sym->st_other = STV_PROTECTED;
679 				} else if (
680 				    ((usdp->sd_flags & FLG_SY_DIR) == 0) &&
681 				    ((ofl->ofl_flags & FLG_OF_SYMBOLIC) == 0)) {
682 					usdp->sd_flags |= FLG_SY_NDIR;
683 				}
684 			}
685 			usdp->sd_flags |= sdflags;
686 
687 			/*
688 			 * If the reference originated from a mapfile ensure
689 			 * we mark the symbol as used.
690 			 */
691 			if (usdp->sd_flags & FLG_SY_MAPREF)
692 				usdp->sd_flags |= FLG_SY_MAPUSED;
693 
694 			DBG_CALL(Dbg_syms_updated(ofl, usdp, uname));
695 		} else
696 			ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SYM_RESERVE),
697 			    uname, usdp->sd_file->ifl_name);
698 	} else {
699 		/*
700 		 * If the symbol does not exist create it.
701 		 */
702 		if ((sym = libld_calloc(sizeof (Sym), 1)) == NULL)
703 			return (S_ERROR);
704 		sym->st_shndx = SHN_ABS;
705 		sym->st_info = ELF_ST_INFO(STB_GLOBAL, STT_OBJECT);
706 		sym->st_size = 0;
707 		sym->st_value = 0;
708 		DBG_CALL(Dbg_syms_created(ofl->ofl_lml, uname));
709 		if ((usdp = ld_sym_enter(uname, sym, hash, (Ifl_desc *)NULL,
710 		    ofl, 0, SHN_ABS, (FLG_SY_SPECSEC | sdflags_u), &where)) ==
711 		    (Sym_desc *)S_ERROR)
712 			return (S_ERROR);
713 		usdp->sd_ref = REF_REL_NEED;
714 		/* LINTED */
715 		usdp->sd_aux->sa_symspec = (Half)sdaux_id;
716 
717 		usdp->sd_aux->sa_overndx = VER_NDX_GLOBAL;
718 
719 		if (sdaux_id == SDAUX_ID_GOT) {
720 			usdp->sd_flags |= FLG_SY_PROTECT;
721 			usdp->sd_sym->st_other = STV_PROTECTED;
722 		} else if ((sdflags & FLG_SY_DEFAULT) &&
723 		    ((ofl->ofl_flags & FLG_OF_SYMBOLIC) == 0)) {
724 			usdp->sd_flags |= FLG_SY_NDIR;
725 		}
726 		usdp->sd_flags |= sdflags;
727 	}
728 
729 	if (name && (sdp = ld_sym_find(name, SYM_NOHASH, NULL, ofl)) &&
730 	    (sdp->sd_sym->st_shndx == SHN_UNDEF)) {
731 		uchar_t	bind;
732 
733 		/*
734 		 * If the non-underscore symbol exists and is undefined
735 		 * convert it to be a local.  If the underscore has
736 		 * sa_symspec set (ie. it was created above) then simulate this
737 		 * as a weak alias.
738 		 */
739 		sdp->sd_ref = REF_REL_NEED;
740 		sdp->sd_shndx = sdp->sd_sym->st_shndx = SHN_ABS;
741 		sdp->sd_flags |= FLG_SY_SPECSEC;
742 		sdp->sd_isc = NULL;
743 		sdp->sd_sym->st_size = 0;
744 		sdp->sd_sym->st_value = 0;
745 		/* LINTED */
746 		sdp->sd_aux->sa_symspec = (Half)sdaux_id;
747 		if (usdp->sd_aux->sa_symspec) {
748 			usdp->sd_aux->sa_linkndx = 0;
749 			sdp->sd_aux->sa_linkndx = 0;
750 			bind = STB_WEAK;
751 		} else
752 			bind = STB_GLOBAL;
753 		sdp->sd_sym->st_info = ELF_ST_INFO(bind, STT_OBJECT);
754 
755 		/*
756 		 * If a user hasn't specifically indicated the scope of this
757 		 * symbol be made local then leave it as global (ie. prevent
758 		 * automatic scoping).  The GOT should be defined protected,
759 		 * whereas all other special symbols are tagged as no-direct.
760 		 */
761 		if (!SYM_IS_HIDDEN(sdp) &&
762 		    (sdflags & FLG_SY_DEFAULT)) {
763 			sdp->sd_aux->sa_overndx = VER_NDX_GLOBAL;
764 			if (sdaux_id == SDAUX_ID_GOT) {
765 				sdp->sd_flags &= ~FLG_SY_NDIR;
766 				sdp->sd_flags |= FLG_SY_PROTECT;
767 				sdp->sd_sym->st_other = STV_PROTECTED;
768 			} else if (((sdp->sd_flags & FLG_SY_DIR) == 0) &&
769 			    ((ofl->ofl_flags & FLG_OF_SYMBOLIC) == 0)) {
770 				sdp->sd_flags |= FLG_SY_NDIR;
771 			}
772 		}
773 		sdp->sd_flags |= sdflags;
774 
775 		/*
776 		 * If the reference originated from a mapfile ensure
777 		 * we mark the symbol as used.
778 		 */
779 		if (sdp->sd_flags & FLG_SY_MAPREF)
780 			sdp->sd_flags |= FLG_SY_MAPUSED;
781 
782 		DBG_CALL(Dbg_syms_updated(ofl, sdp, name));
783 	}
784 	return (1);
785 }
786 
787 
788 /*
789  * Undefined symbols can fall into one of four types:
790  *
791  *  -	the symbol is really undefined (SHN_UNDEF).
792  *
793  *  -	versioning has been enabled, however this symbol has not been assigned
794  *	to one of the defined versions.
795  *
796  *  -	the symbol has been defined by an implicitly supplied library, ie. one
797  *	which was encounted because it was NEEDED by another library, rather
798  * 	than from a command line supplied library which would become the only
799  *	dependency of the output file being produced.
800  *
801  *  -	the symbol has been defined by a version of a shared object that is
802  *	not permitted for this link-edit.
803  *
804  * In all cases the file who made the first reference to this symbol will have
805  * been recorded via the `sa_rfile' pointer.
806  */
807 typedef enum {
808 	UNDEF,		NOVERSION,	IMPLICIT,	NOTAVAIL,
809 	BNDLOCAL
810 } Type;
811 
812 static const Msg format[] = {
813 	MSG_SYM_UND_UNDEF,		/* MSG_INTL(MSG_SYM_UND_UNDEF) */
814 	MSG_SYM_UND_NOVER,		/* MSG_INTL(MSG_SYM_UND_NOVER) */
815 	MSG_SYM_UND_IMPL,		/* MSG_INTL(MSG_SYM_UND_IMPL) */
816 	MSG_SYM_UND_NOTA,		/* MSG_INTL(MSG_SYM_UND_NOTA) */
817 	MSG_SYM_UND_BNDLOCAL		/* MSG_INTL(MSG_SYM_UND_BNDLOCAL) */
818 };
819 
820 /*
821  * Issue an undefined symbol message for the given symbol.
822  *
823  * entry:
824  *	ofl - Output descriptor
825  *	sdp - Undefined symbol to report
826  *	type - Type of undefined symbol
827  *	ofl_flag - One of 0, FLG_OF_FATAL, or FLG_OF_WARN.
828  *	undef_state - Address of variable to be initialized to 0
829  *		before the first call to sym_undef_entry, and passed
830  *		to each subsequent call. A non-zero value for *undef_state
831  *		indicates that this is not the first call in the series.
832  *
833  * exit:
834  *	If *undef_state is 0, a title is issued.
835  *
836  *	A message for the undefined symbol is issued.
837  *
838  *	If ofl_flag is non-zero, its value is OR'd into *undef_state. Otherwise,
839  *	all bits other than FLG_OF_FATAL and FLG_OF_WARN are set, in order to
840  *	provide *undef_state with a non-zero value. These other bits have
841  *	no meaning beyond that, and serve to ensure that *undef_state is
842  *	non-zero if sym_undef_entry() has been called.
843  */
844 static void
845 sym_undef_entry(Ofl_desc *ofl, Sym_desc *sdp, Type type, ofl_flag_t ofl_flag,
846     ofl_flag_t *undef_state)
847 {
848 	const char	*name1, *name2, *name3;
849 	Ifl_desc	*ifl = sdp->sd_file;
850 	Sym_aux		*sap = sdp->sd_aux;
851 
852 	if (*undef_state == 0)
853 		ld_eprintf(ofl, ERR_NONE, MSG_INTL(MSG_SYM_FMT_UNDEF),
854 		    MSG_INTL(MSG_SYM_UNDEF_ITM_11),
855 		    MSG_INTL(MSG_SYM_UNDEF_ITM_21),
856 		    MSG_INTL(MSG_SYM_UNDEF_ITM_12),
857 		    MSG_INTL(MSG_SYM_UNDEF_ITM_22));
858 
859 	ofl->ofl_flags |= ofl_flag;
860 	*undef_state |= ofl_flag ? ofl_flag : ~(FLG_OF_FATAL | FLG_OF_WARN);
861 
862 	switch (type) {
863 	case UNDEF:
864 	case BNDLOCAL:
865 		name1 = sap->sa_rfile;
866 		break;
867 	case NOVERSION:
868 		name1 = ifl->ifl_name;
869 		break;
870 	case IMPLICIT:
871 		name1 = sap->sa_rfile;
872 		name2 = ifl->ifl_name;
873 		break;
874 	case NOTAVAIL:
875 		name1 = sap->sa_rfile;
876 		name2 = sap->sa_vfile;
877 		name3 = ifl->ifl_verndx[sap->sa_dverndx].vi_name;
878 		break;
879 	default:
880 		return;
881 	}
882 
883 	ld_eprintf(ofl, ERR_NONE, MSG_INTL(format[type]),
884 	    demangle(sdp->sd_name), name1, name2, name3);
885 }
886 
887 /*
888  * At this point all symbol input processing has been completed, therefore
889  * complete the symbol table entries by generating any necessary internal
890  * symbols.
891  */
892 uintptr_t
893 ld_sym_spec(Ofl_desc *ofl)
894 {
895 	Sym_desc	*sdp;
896 
897 	if (ofl->ofl_flags & FLG_OF_RELOBJ)
898 		return (1);
899 
900 	DBG_CALL(Dbg_syms_spec_title(ofl->ofl_lml));
901 
902 	if (sym_add_spec(MSG_ORIG(MSG_SYM_ETEXT), MSG_ORIG(MSG_SYM_ETEXT_U),
903 	    SDAUX_ID_ETEXT, 0, (FLG_SY_DEFAULT | FLG_SY_EXPDEF),
904 	    ofl) == S_ERROR)
905 		return (S_ERROR);
906 	if (sym_add_spec(MSG_ORIG(MSG_SYM_EDATA), MSG_ORIG(MSG_SYM_EDATA_U),
907 	    SDAUX_ID_EDATA, 0, (FLG_SY_DEFAULT | FLG_SY_EXPDEF),
908 	    ofl) == S_ERROR)
909 		return (S_ERROR);
910 	if (sym_add_spec(MSG_ORIG(MSG_SYM_END), MSG_ORIG(MSG_SYM_END_U),
911 	    SDAUX_ID_END, FLG_SY_DYNSORT, (FLG_SY_DEFAULT | FLG_SY_EXPDEF),
912 	    ofl) == S_ERROR)
913 		return (S_ERROR);
914 	if (sym_add_spec(MSG_ORIG(MSG_SYM_L_END), MSG_ORIG(MSG_SYM_L_END_U),
915 	    SDAUX_ID_END, 0, FLG_SY_HIDDEN, ofl) == S_ERROR)
916 		return (S_ERROR);
917 	if (sym_add_spec(MSG_ORIG(MSG_SYM_L_START), MSG_ORIG(MSG_SYM_L_START_U),
918 	    SDAUX_ID_START, 0, FLG_SY_HIDDEN, ofl) == S_ERROR)
919 		return (S_ERROR);
920 
921 	/*
922 	 * Historically we've always produced a _DYNAMIC symbol, even for
923 	 * static executables (in which case its value will be 0).
924 	 */
925 	if (sym_add_spec(MSG_ORIG(MSG_SYM_DYNAMIC), MSG_ORIG(MSG_SYM_DYNAMIC_U),
926 	    SDAUX_ID_DYN, FLG_SY_DYNSORT, (FLG_SY_DEFAULT | FLG_SY_EXPDEF),
927 	    ofl) == S_ERROR)
928 		return (S_ERROR);
929 
930 	if (OFL_ALLOW_DYNSYM(ofl))
931 		if (sym_add_spec(MSG_ORIG(MSG_SYM_PLKTBL),
932 		    MSG_ORIG(MSG_SYM_PLKTBL_U), SDAUX_ID_PLT,
933 		    FLG_SY_DYNSORT, (FLG_SY_DEFAULT | FLG_SY_EXPDEF),
934 		    ofl) == S_ERROR)
935 			return (S_ERROR);
936 
937 	/*
938 	 * A GOT reference will be accompanied by the associated GOT symbol.
939 	 * Make sure it gets assigned the appropriate special attributes.
940 	 */
941 	if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_GOFTBL_U),
942 	    SYM_NOHASH, NULL, ofl)) != NULL) && (sdp->sd_ref != REF_DYN_SEEN)) {
943 		if (sym_add_spec(MSG_ORIG(MSG_SYM_GOFTBL),
944 		    MSG_ORIG(MSG_SYM_GOFTBL_U), SDAUX_ID_GOT, FLG_SY_DYNSORT,
945 		    (FLG_SY_DEFAULT | FLG_SY_EXPDEF), ofl) == S_ERROR)
946 			return (S_ERROR);
947 	}
948 
949 	return (1);
950 }
951 
952 /*
953  * Determine a potential capability symbol's visibility.
954  *
955  * The -z symbolcap option transforms an object capabilities relocatable object
956  * into a symbol capabilities relocatable object.  Any global function symbols,
957  * or initialized global data symbols are candidates for transforming into local
958  * symbol capabilities definitions.  However, if a user indicates that a symbol
959  * should be demoted to local using a mapfile, then there is no need to
960  * transform the associated global symbol.
961  *
962  * Normally, a symbol's visibility is determined after the symbol resolution
963  * process, after all symbol state has been gathered and resolved.  However,
964  * for -z symbolcap, this determination is too late.  When a global symbol is
965  * read from an input file we need to determine it's visibility so as to decide
966  * whether to create a local or not.
967  *
968  * If a user has explicitly defined this symbol as having local scope within a
969  * mapfile, then a symbol of the same name already exists.  However, explicit
970  * local definitions are uncommon, as most mapfiles define the global symbol
971  * requirements together with an auto-reduction directive '*'.  If this state
972  * has been defined, then we must make sure that the new symbol isn't a type
973  * that can not be demoted to local.
974  */
975 static int
976 sym_cap_vis(const char *name, Word hash, Sym *sym, Ofl_desc *ofl)
977 {
978 	Sym_desc	*sdp;
979 	uchar_t		vis;
980 	avl_index_t	where;
981 	sd_flag_t	sdflags = 0;
982 
983 	/*
984 	 * Determine the visibility of the new symbol.
985 	 */
986 	vis = ELF_ST_VISIBILITY(sym->st_other);
987 	switch (vis) {
988 	case STV_EXPORTED:
989 		sdflags |= FLG_SY_EXPORT;
990 		break;
991 	case STV_SINGLETON:
992 		sdflags |= FLG_SY_SINGLE;
993 		break;
994 	}
995 
996 	/*
997 	 * Determine whether a symbol definition already exists, and if so
998 	 * obtain the visibility.
999 	 */
1000 	if ((sdp = ld_sym_find(name, hash, &where, ofl)) != NULL)
1001 		sdflags |= sdp->sd_flags;
1002 
1003 	/*
1004 	 * Determine whether the symbol flags indicate this symbol should be
1005 	 * hidden.
1006 	 */
1007 	if ((ofl->ofl_flags & (FLG_OF_AUTOLCL | FLG_OF_AUTOELM)) &&
1008 	    ((sdflags & MSK_SY_NOAUTO) == 0))
1009 		sdflags |= FLG_SY_HIDDEN;
1010 
1011 	return ((sdflags & FLG_SY_HIDDEN) == 0);
1012 }
1013 
1014 /*
1015  * This routine checks to see if a symbols visibility needs to be reduced to
1016  * either SYMBOLIC or LOCAL.  This routine can be called from either
1017  * reloc_init() or sym_validate().
1018  */
1019 void
1020 ld_sym_adjust_vis(Sym_desc *sdp, Ofl_desc *ofl)
1021 {
1022 	ofl_flag_t	oflags = ofl->ofl_flags;
1023 	Sym		*sym = sdp->sd_sym;
1024 
1025 	if ((sdp->sd_ref == REF_REL_NEED) &&
1026 	    (sdp->sd_sym->st_shndx != SHN_UNDEF)) {
1027 		/*
1028 		 * If auto-reduction/elimination is enabled, reduce any
1029 		 * non-versioned, and non-local capabilities global symbols.
1030 		 * A symbol is a candidate for auto-reduction/elimination if:
1031 		 *
1032 		 *  -	the symbol wasn't explicitly defined within a mapfile
1033 		 *	(in which case all the necessary state has been applied
1034 		 *	to the symbol), or
1035 		 *  -	the symbol isn't one of the family of reserved
1036 		 *	special symbols (ie. _end, _etext, etc.), or
1037 		 *  -	the symbol isn't a SINGLETON, or
1038 		 *  -	the symbol wasn't explicitly defined within a version
1039 		 *	definition associated with an input relocatable object.
1040 		 *
1041 		 * Indicate that the symbol has been reduced as it may be
1042 		 * necessary to print these symbols later.
1043 		 */
1044 		if ((oflags & (FLG_OF_AUTOLCL | FLG_OF_AUTOELM)) &&
1045 		    ((sdp->sd_flags & MSK_SY_NOAUTO) == 0)) {
1046 			if ((sdp->sd_flags & FLG_SY_HIDDEN) == 0) {
1047 				sdp->sd_flags |=
1048 				    (FLG_SY_REDUCED | FLG_SY_HIDDEN);
1049 			}
1050 
1051 			if (oflags & (FLG_OF_REDLSYM | FLG_OF_AUTOELM)) {
1052 				sdp->sd_flags |= FLG_SY_ELIM;
1053 				sym->st_other = STV_ELIMINATE |
1054 				    (sym->st_other & ~MSK_SYM_VISIBILITY);
1055 			} else if (ELF_ST_VISIBILITY(sym->st_other) !=
1056 			    STV_INTERNAL)
1057 				sym->st_other = STV_HIDDEN |
1058 				    (sym->st_other & ~MSK_SYM_VISIBILITY);
1059 		}
1060 
1061 		/*
1062 		 * If -Bsymbolic is in effect, and the symbol hasn't explicitly
1063 		 * been defined nodirect (via a mapfile), then bind the global
1064 		 * symbol symbolically and assign the STV_PROTECTED visibility
1065 		 * attribute.
1066 		 */
1067 		if ((oflags & FLG_OF_SYMBOLIC) &&
1068 		    ((sdp->sd_flags & (FLG_SY_HIDDEN | FLG_SY_NDIR)) == 0)) {
1069 			sdp->sd_flags |= FLG_SY_PROTECT;
1070 			if (ELF_ST_VISIBILITY(sym->st_other) == STV_DEFAULT)
1071 				sym->st_other = STV_PROTECTED |
1072 				    (sym->st_other & ~MSK_SYM_VISIBILITY);
1073 		}
1074 	}
1075 
1076 	/*
1077 	 * Indicate that this symbol has had it's visibility checked so that
1078 	 * we don't need to do this investigation again.
1079 	 */
1080 	sdp->sd_flags |= FLG_SY_VISIBLE;
1081 }
1082 
1083 /*
1084  * Make sure a symbol definition is local to the object being built.
1085  */
1086 inline static int
1087 ensure_sym_local(Ofl_desc *ofl, Sym_desc *sdp, const char *str)
1088 {
1089 	if (sdp->sd_sym->st_shndx == SHN_UNDEF) {
1090 		if (str) {
1091 			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYM_UNDEF),
1092 			    str, demangle((char *)sdp->sd_name));
1093 		}
1094 		return (1);
1095 	}
1096 	if (sdp->sd_ref != REF_REL_NEED) {
1097 		if (str) {
1098 			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYM_EXTERN),
1099 			    str, demangle((char *)sdp->sd_name),
1100 			    sdp->sd_file->ifl_name);
1101 		}
1102 		return (1);
1103 	}
1104 
1105 	sdp->sd_flags |= FLG_SY_UPREQD;
1106 	if (sdp->sd_isc) {
1107 		sdp->sd_isc->is_flags |= FLG_IS_SECTREF;
1108 		sdp->sd_isc->is_file->ifl_flags |= FLG_IF_FILEREF;
1109 	}
1110 	return (0);
1111 }
1112 
1113 /*
1114  * Make sure all the symbol definitions required for initarray, finiarray, or
1115  * preinitarray's are local to the object being built.
1116  */
1117 static int
1118 ensure_array_local(Ofl_desc *ofl, APlist *apl, const char *str)
1119 {
1120 	Aliste		idx;
1121 	Sym_desc	*sdp;
1122 	int		ret = 0;
1123 
1124 	for (APLIST_TRAVERSE(apl, idx, sdp))
1125 		ret += ensure_sym_local(ofl, sdp, str);
1126 
1127 	return (ret);
1128 }
1129 
1130 /*
1131  * After all symbol table input processing has been finished, and all relocation
1132  * counting has been carried out (ie. no more symbols will be read, generated,
1133  * or modified), validate and count the relevant entries:
1134  *
1135  *  -	check and print any undefined symbols remaining.  Note that if a symbol
1136  *	has been defined by virtue of the inclusion of 	an implicit shared
1137  *	library, it is still classed as undefined.
1138  *
1139  *  -	count the number of global needed symbols together with the size of
1140  *	their associated name strings (if scoping has been indicated these
1141  *	symbols may be reduced to locals).
1142  *
1143  *  -	establish the size and alignment requirements for the global .bss
1144  *	section (the alignment of this section is based on the 	first symbol
1145  *	that it will contain).
1146  */
1147 uintptr_t
1148 ld_sym_validate(Ofl_desc *ofl)
1149 {
1150 	Sym_avlnode	*sav;
1151 	Sym_desc	*sdp;
1152 	Sym		*sym;
1153 	ofl_flag_t	oflags = ofl->ofl_flags;
1154 	ofl_flag_t	undef = 0, needed = 0, verdesc = 0;
1155 	Xword		bssalign = 0, tlsalign = 0;
1156 	Boolean		need_bss, need_tlsbss;
1157 	Xword		bsssize = 0, tlssize = 0;
1158 #if	defined(_ELF64)
1159 	Xword		lbssalign = 0, lbsssize = 0;
1160 	Boolean		need_lbss;
1161 #endif
1162 	int		ret, allow_ldynsym;
1163 	uchar_t		type;
1164 	ofl_flag_t	undef_state = 0;
1165 
1166 	DBG_CALL(Dbg_basic_validate(ofl->ofl_lml));
1167 
1168 	/*
1169 	 * The need_XXX booleans are used to determine whether we need to
1170 	 * create each type of bss section. We used to create these sections
1171 	 * if the sum of the required sizes for each type were non-zero.
1172 	 * However, it is possible for a compiler to generate COMMON variables
1173 	 * of zero-length and this tricks that logic --- even zero-length
1174 	 * symbols need an output section.
1175 	 */
1176 	need_bss = need_tlsbss = FALSE;
1177 #if	defined(_ELF64)
1178 	need_lbss = FALSE;
1179 #endif
1180 
1181 	/*
1182 	 * Determine how undefined symbols are handled:
1183 	 *
1184 	 * fatal:
1185 	 *	If this link-edit calls for no undefined symbols to remain
1186 	 *	(this is the default case when generating an executable but
1187 	 *	can be enforced for any object using -z defs), a fatal error
1188 	 *	condition will be indicated.
1189 	 *
1190 	 * warning:
1191 	 *	If we're creating a shared object, and either the -Bsymbolic
1192 	 *	flag is set, or the user has turned on the -z guidance feature,
1193 	 *	then a non-fatal warning is issued for each symbol.
1194 	 *
1195 	 * ignore:
1196 	 *	In all other cases, undefined symbols are quietly allowed.
1197 	 */
1198 	if (oflags & FLG_OF_NOUNDEF) {
1199 		undef = FLG_OF_FATAL;
1200 	} else if (oflags & FLG_OF_SHAROBJ) {
1201 		if ((oflags & FLG_OF_SYMBOLIC) ||
1202 		    OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS))
1203 			undef = FLG_OF_WARN;
1204 	}
1205 
1206 	/*
1207 	 * If the symbol is referenced from an implicitly included shared object
1208 	 * (ie. it's not on the NEEDED list) then the symbol is also classified
1209 	 * as undefined and a fatal error condition will be indicated.
1210 	 */
1211 	if ((oflags & FLG_OF_NOUNDEF) || !(oflags & FLG_OF_SHAROBJ))
1212 		needed = FLG_OF_FATAL;
1213 	else if ((oflags & FLG_OF_SHAROBJ) &&
1214 	    OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS))
1215 		needed = FLG_OF_WARN;
1216 
1217 	/*
1218 	 * If the output image is being versioned, then all symbol definitions
1219 	 * must be associated with a version.  Any symbol that isn't associated
1220 	 * with a version is classified as undefined, and a fatal error
1221 	 * condition is indicated.
1222 	 */
1223 	if ((oflags & FLG_OF_VERDEF) && (ofl->ofl_vercnt > VER_NDX_GLOBAL))
1224 		verdesc = FLG_OF_FATAL;
1225 
1226 	allow_ldynsym = OFL_ALLOW_LDYNSYM(ofl);
1227 
1228 	if (allow_ldynsym) {
1229 		/*
1230 		 * Normally, we disallow symbols with 0 size from appearing
1231 		 * in a dyn[sym|tls]sort section. However, there are some
1232 		 * symbols that serve special purposes that we want to exempt
1233 		 * from this rule. Look them up, and set their
1234 		 * FLG_SY_DYNSORT flag.
1235 		 */
1236 		static const char *special[] = {
1237 			MSG_ORIG(MSG_SYM_INIT_U),	/* _init */
1238 			MSG_ORIG(MSG_SYM_FINI_U),	/* _fini */
1239 			MSG_ORIG(MSG_SYM_START),	/* _start */
1240 			NULL
1241 		};
1242 		int i;
1243 
1244 		for (i = 0; special[i] != NULL; i++) {
1245 			if (((sdp = ld_sym_find(special[i],
1246 			    SYM_NOHASH, NULL, ofl)) != NULL) &&
1247 			    (sdp->sd_sym->st_size == 0)) {
1248 				if (ld_sym_copy(sdp) == S_ERROR)
1249 					return (S_ERROR);
1250 				sdp->sd_flags |= FLG_SY_DYNSORT;
1251 			}
1252 		}
1253 	}
1254 
1255 	/*
1256 	 * Collect and validate the globals from the internal symbol table.
1257 	 */
1258 	for (sav = avl_first(&ofl->ofl_symavl); sav;
1259 	    sav = AVL_NEXT(&ofl->ofl_symavl, sav)) {
1260 		Is_desc		*isp;
1261 		int		undeferr = 0;
1262 		uchar_t		vis;
1263 
1264 		sdp = sav->sav_sdp;
1265 
1266 		/*
1267 		 * If undefined symbols are allowed, and we're not being
1268 		 * asked to supply guidance, ignore any symbols that are
1269 		 * not needed.
1270 		 */
1271 		if (!(oflags & FLG_OF_NOUNDEF) &&
1272 		    !OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS) &&
1273 		    (sdp->sd_ref == REF_DYN_SEEN))
1274 			continue;
1275 
1276 		/*
1277 		 * If the symbol originates from an external or parent mapfile
1278 		 * reference and hasn't been matched to a reference from a
1279 		 * relocatable object, ignore it.
1280 		 */
1281 		if ((sdp->sd_flags & (FLG_SY_EXTERN | FLG_SY_PARENT)) &&
1282 		    ((sdp->sd_flags & FLG_SY_MAPUSED) == 0)) {
1283 			sdp->sd_flags |= FLG_SY_INVALID;
1284 			continue;
1285 		}
1286 
1287 		sym = sdp->sd_sym;
1288 		type = ELF_ST_TYPE(sym->st_info);
1289 
1290 		/*
1291 		 * Sanity check TLS.
1292 		 */
1293 		if ((type == STT_TLS) && (sym->st_size != 0) &&
1294 		    (sym->st_shndx != SHN_UNDEF) &&
1295 		    (sym->st_shndx != SHN_COMMON)) {
1296 			Is_desc		*isp = sdp->sd_isc;
1297 			Ifl_desc	*ifl = sdp->sd_file;
1298 
1299 			if ((isp == NULL) || (isp->is_shdr == NULL) ||
1300 			    ((isp->is_shdr->sh_flags & SHF_TLS) == 0)) {
1301 				ld_eprintf(ofl, ERR_FATAL,
1302 				    MSG_INTL(MSG_SYM_TLS),
1303 				    demangle(sdp->sd_name), ifl->ifl_name);
1304 				continue;
1305 			}
1306 		}
1307 
1308 		if ((sdp->sd_flags & FLG_SY_VISIBLE) == 0)
1309 			ld_sym_adjust_vis(sdp, ofl);
1310 
1311 		if ((sdp->sd_flags & FLG_SY_REDUCED) &&
1312 		    (oflags & FLG_OF_PROCRED)) {
1313 			DBG_CALL(Dbg_syms_reduce(ofl, DBG_SYM_REDUCE_GLOBAL,
1314 			    sdp, 0, 0));
1315 		}
1316 
1317 		/*
1318 		 * Record any STV_SINGLETON existence.
1319 		 */
1320 		if ((vis = ELF_ST_VISIBILITY(sym->st_other)) == STV_SINGLETON)
1321 			ofl->ofl_dtflags_1 |= DF_1_SINGLETON;
1322 
1323 		/*
1324 		 * If building a shared object or executable, and this is a
1325 		 * non-weak UNDEF symbol with reduced visibility (STV_*), then
1326 		 * give a fatal error.
1327 		 */
1328 		if (((oflags & FLG_OF_RELOBJ) == 0) &&
1329 		    (sym->st_shndx == SHN_UNDEF) &&
1330 		    (ELF_ST_BIND(sym->st_info) != STB_WEAK)) {
1331 			if (vis && (vis != STV_SINGLETON)) {
1332 				sym_undef_entry(ofl, sdp, BNDLOCAL,
1333 				    FLG_OF_FATAL, &undef_state);
1334 				continue;
1335 			}
1336 		}
1337 
1338 		/*
1339 		 * If this symbol is defined in a non-allocatable section,
1340 		 * reduce it to local symbol.
1341 		 */
1342 		if (((isp = sdp->sd_isc) != 0) && isp->is_shdr &&
1343 		    ((isp->is_shdr->sh_flags & SHF_ALLOC) == 0)) {
1344 			sdp->sd_flags |= (FLG_SY_REDUCED | FLG_SY_HIDDEN);
1345 		}
1346 
1347 		/*
1348 		 * If this symbol originated as a SHN_SUNW_IGNORE, it will have
1349 		 * been processed as an SHN_UNDEF.  Return the symbol to its
1350 		 * original index for validation, and propagation to the output
1351 		 * file.
1352 		 */
1353 		if (sdp->sd_flags & FLG_SY_IGNORE)
1354 			sdp->sd_shndx = SHN_SUNW_IGNORE;
1355 
1356 		if (undef) {
1357 			/*
1358 			 * If a non-weak reference remains undefined, or if a
1359 			 * mapfile reference is not bound to the relocatable
1360 			 * objects that make up the object being built, we have
1361 			 * a fatal error.
1362 			 *
1363 			 * The exceptions are symbols which are defined to be
1364 			 * found in the parent (FLG_SY_PARENT), which is really
1365 			 * only meaningful for direct binding, or are defined
1366 			 * external (FLG_SY_EXTERN) so as to suppress -zdefs
1367 			 * errors.
1368 			 *
1369 			 * Register symbols are always allowed to be UNDEF.
1370 			 *
1371 			 * Note that we don't include references created via -u
1372 			 * in the same shared object binding test.  This is for
1373 			 * backward compatibility, in that a number of archive
1374 			 * makefile rules used -u to cause archive extraction.
1375 			 * These same rules have been cut and pasted to apply
1376 			 * to shared objects, and thus although the -u reference
1377 			 * is redundant, flagging it as fatal could cause some
1378 			 * build to fail.  Also we have documented the use of
1379 			 * -u as a mechanism to cause binding to weak version
1380 			 * definitions, thus giving users an error condition
1381 			 * would be incorrect.
1382 			 */
1383 			if (!(sdp->sd_flags & FLG_SY_REGSYM) &&
1384 			    ((sym->st_shndx == SHN_UNDEF) &&
1385 			    ((ELF_ST_BIND(sym->st_info) != STB_WEAK) &&
1386 			    ((sdp->sd_flags &
1387 			    (FLG_SY_PARENT | FLG_SY_EXTERN)) == 0)) ||
1388 			    ((sdp->sd_flags &
1389 			    (FLG_SY_MAPREF | FLG_SY_MAPUSED | FLG_SY_HIDDEN |
1390 			    FLG_SY_PROTECT)) == FLG_SY_MAPREF))) {
1391 				sym_undef_entry(ofl, sdp, UNDEF, undef,
1392 				    &undef_state);
1393 				undeferr = 1;
1394 			}
1395 
1396 		} else {
1397 			/*
1398 			 * For building things like shared objects (or anything
1399 			 * -znodefs), undefined symbols are allowed.
1400 			 *
1401 			 * If a mapfile reference remains undefined the user
1402 			 * would probably like a warning at least (they've
1403 			 * usually mis-spelt the reference).  Refer to the above
1404 			 * comments for discussion on -u references, which
1405 			 * are not tested for in the same manner.
1406 			 */
1407 			if ((sdp->sd_flags &
1408 			    (FLG_SY_MAPREF | FLG_SY_MAPUSED)) ==
1409 			    FLG_SY_MAPREF) {
1410 				sym_undef_entry(ofl, sdp, UNDEF, FLG_OF_WARN,
1411 				    &undef_state);
1412 				undeferr = 1;
1413 			}
1414 		}
1415 
1416 		/*
1417 		 * If this symbol comes from a dependency mark the dependency
1418 		 * as required (-z ignore can result in unused dependencies
1419 		 * being dropped).  If we need to record dependency versioning
1420 		 * information indicate what version of the needed shared object
1421 		 * this symbol is part of.  Flag the symbol as undefined if it
1422 		 * has not been made available to us.
1423 		 */
1424 		if ((sdp->sd_ref == REF_DYN_NEED) &&
1425 		    (!(sdp->sd_flags & FLG_SY_REFRSD))) {
1426 			sdp->sd_file->ifl_flags |= FLG_IF_DEPREQD;
1427 
1428 			/*
1429 			 * Capture that we've bound to a symbol that doesn't
1430 			 * allow being directly bound to.
1431 			 */
1432 			if (sdp->sd_flags & FLG_SY_NDIR)
1433 				ofl->ofl_flags1 |= FLG_OF1_NGLBDIR;
1434 
1435 			if (sdp->sd_file->ifl_vercnt) {
1436 				int		vndx;
1437 				Ver_index	*vip;
1438 
1439 				vndx = sdp->sd_aux->sa_dverndx;
1440 				vip = &sdp->sd_file->ifl_verndx[vndx];
1441 				if (vip->vi_flags & FLG_VER_AVAIL) {
1442 					vip->vi_flags |= FLG_VER_REFER;
1443 				} else {
1444 					sym_undef_entry(ofl, sdp, NOTAVAIL,
1445 					    FLG_OF_FATAL, &undef_state);
1446 					continue;
1447 				}
1448 			}
1449 		}
1450 
1451 		/*
1452 		 * Test that we do not bind to symbol supplied from an implicit
1453 		 * shared object.  If a binding is from a weak reference it can
1454 		 * be ignored.
1455 		 */
1456 		if (needed && !undeferr && (sdp->sd_flags & FLG_SY_GLOBREF) &&
1457 		    (sdp->sd_ref == REF_DYN_NEED) &&
1458 		    (sdp->sd_flags & FLG_SY_NOTAVAIL)) {
1459 			sym_undef_entry(ofl, sdp, IMPLICIT, needed,
1460 			    &undef_state);
1461 			if (needed == FLG_OF_FATAL)
1462 				continue;
1463 		}
1464 
1465 		/*
1466 		 * Test that a symbol isn't going to be reduced to local scope
1467 		 * which actually wants to bind to a shared object - if so it's
1468 		 * a fatal error.
1469 		 */
1470 		if ((sdp->sd_ref == REF_DYN_NEED) &&
1471 		    (sdp->sd_flags & (FLG_SY_HIDDEN | FLG_SY_PROTECT))) {
1472 			sym_undef_entry(ofl, sdp, BNDLOCAL, FLG_OF_FATAL,
1473 			    &undef_state);
1474 			continue;
1475 		}
1476 
1477 		/*
1478 		 * If the output image is to be versioned then all symbol
1479 		 * definitions must be associated with a version.  Remove any
1480 		 * versioning that might be left associated with an undefined
1481 		 * symbol.
1482 		 */
1483 		if (verdesc && (sdp->sd_ref == REF_REL_NEED)) {
1484 			if (sym->st_shndx == SHN_UNDEF) {
1485 				if (sdp->sd_aux && sdp->sd_aux->sa_overndx)
1486 					sdp->sd_aux->sa_overndx = 0;
1487 			} else {
1488 				if (!SYM_IS_HIDDEN(sdp) && sdp->sd_aux &&
1489 				    (sdp->sd_aux->sa_overndx == 0)) {
1490 					sym_undef_entry(ofl, sdp, NOVERSION,
1491 					    verdesc, &undef_state);
1492 					continue;
1493 				}
1494 			}
1495 		}
1496 
1497 		/*
1498 		 * If we don't need the symbol there's no need to process it
1499 		 * any further.
1500 		 */
1501 		if (sdp->sd_ref == REF_DYN_SEEN)
1502 			continue;
1503 
1504 		/*
1505 		 * Calculate the size and alignment requirements for the global
1506 		 * .bss and .tls sections.  If we're building a relocatable
1507 		 * object only account for scoped COMMON symbols (these will
1508 		 * be converted to .bss references).
1509 		 *
1510 		 * When -z nopartial is in effect, partially initialized
1511 		 * symbols are directed to the special .data section
1512 		 * created for that purpose (ofl->ofl_isparexpn).
1513 		 * Otherwise, partially initialized symbols go to .bss.
1514 		 *
1515 		 * Also refer to make_mvsections() in sunwmove.c
1516 		 */
1517 		if ((sym->st_shndx == SHN_COMMON) &&
1518 		    (((oflags & FLG_OF_RELOBJ) == 0) ||
1519 		    (SYM_IS_HIDDEN(sdp) && (oflags & FLG_OF_PROCRED)))) {
1520 			if ((sdp->sd_move == NULL) ||
1521 			    ((sdp->sd_flags & FLG_SY_PAREXPN) == 0)) {
1522 				if (type != STT_TLS) {
1523 					need_bss = TRUE;
1524 					bsssize = (Xword)S_ROUND(bsssize,
1525 					    sym->st_value) + sym->st_size;
1526 					if (sym->st_value > bssalign)
1527 						bssalign = sym->st_value;
1528 				} else {
1529 					need_tlsbss = TRUE;
1530 					tlssize = (Xword)S_ROUND(tlssize,
1531 					    sym->st_value) + sym->st_size;
1532 					if (sym->st_value > tlsalign)
1533 						tlsalign = sym->st_value;
1534 				}
1535 			}
1536 		}
1537 
1538 #if	defined(_ELF64)
1539 		/*
1540 		 * Calculate the size and alignment requirement for the global
1541 		 * .lbss. TLS or partially initialized symbols do not need to be
1542 		 * considered yet.
1543 		 */
1544 		if ((ld_targ.t_m.m_mach == EM_AMD64) &&
1545 		    (sym->st_shndx == SHN_X86_64_LCOMMON)) {
1546 			need_lbss = TRUE;
1547 			lbsssize = (Xword)S_ROUND(lbsssize, sym->st_value) +
1548 			    sym->st_size;
1549 			if (sym->st_value > lbssalign)
1550 				lbssalign = sym->st_value;
1551 		}
1552 #endif
1553 		/*
1554 		 * If a symbol was referenced via the command line
1555 		 * (ld -u <>, ...), then this counts as a reference against the
1556 		 * symbol. Mark any section that symbol is defined in.
1557 		 */
1558 		if (((isp = sdp->sd_isc) != 0) &&
1559 		    (sdp->sd_flags & FLG_SY_CMDREF)) {
1560 			isp->is_flags |= FLG_IS_SECTREF;
1561 			isp->is_file->ifl_flags |= FLG_IF_FILEREF;
1562 		}
1563 
1564 		/*
1565 		 * Update the symbol count and the associated name string size.
1566 		 * Note, a capabilities symbol must remain as visible as a
1567 		 * global symbol.  However, the runtime linker recognizes the
1568 		 * hidden requirement and ensures the symbol isn't made globally
1569 		 * available at runtime.
1570 		 */
1571 		if (SYM_IS_HIDDEN(sdp) && (oflags & FLG_OF_PROCRED)) {
1572 			/*
1573 			 * If any reductions are being processed, keep a count
1574 			 * of eliminated symbols, and if the symbol is being
1575 			 * reduced to local, count it's size for the .symtab.
1576 			 */
1577 			if (sdp->sd_flags & FLG_SY_ELIM) {
1578 				ofl->ofl_elimcnt++;
1579 			} else {
1580 				ofl->ofl_scopecnt++;
1581 				if ((((sdp->sd_flags & FLG_SY_REGSYM) == 0) ||
1582 				    sym->st_name) && (st_insert(ofl->ofl_strtab,
1583 				    sdp->sd_name) == -1))
1584 					return (S_ERROR);
1585 				if (allow_ldynsym && sym->st_name &&
1586 				    ldynsym_symtype[type]) {
1587 					ofl->ofl_dynscopecnt++;
1588 					if (st_insert(ofl->ofl_dynstrtab,
1589 					    sdp->sd_name) == -1)
1590 						return (S_ERROR);
1591 					/* Include it in sort section? */
1592 					DYNSORT_COUNT(sdp, sym, type, ++);
1593 				}
1594 			}
1595 		} else {
1596 			ofl->ofl_globcnt++;
1597 
1598 			/*
1599 			 * Check to see if this global variable should go into
1600 			 * a sort section. Sort sections require a
1601 			 * .SUNW_ldynsym section, so, don't check unless a
1602 			 * .SUNW_ldynsym is allowed.
1603 			 */
1604 			if (allow_ldynsym)
1605 				DYNSORT_COUNT(sdp, sym, type, ++);
1606 
1607 			/*
1608 			 * If global direct bindings are in effect, or this
1609 			 * symbol has bound to a dependency which was specified
1610 			 * as requiring direct bindings, and it hasn't
1611 			 * explicitly been defined as a non-direct binding
1612 			 * symbol, mark it.
1613 			 */
1614 			if (((ofl->ofl_dtflags_1 & DF_1_DIRECT) || (isp &&
1615 			    (isp->is_file->ifl_flags & FLG_IF_DIRECT))) &&
1616 			    ((sdp->sd_flags & FLG_SY_NDIR) == 0))
1617 				sdp->sd_flags |= FLG_SY_DIR;
1618 
1619 			/*
1620 			 * Insert the symbol name.
1621 			 */
1622 			if (((sdp->sd_flags & FLG_SY_REGSYM) == 0) ||
1623 			    sym->st_name) {
1624 				if (st_insert(ofl->ofl_strtab,
1625 				    sdp->sd_name) == -1)
1626 					return (S_ERROR);
1627 
1628 				if (!(ofl->ofl_flags & FLG_OF_RELOBJ) &&
1629 				    (st_insert(ofl->ofl_dynstrtab,
1630 				    sdp->sd_name) == -1))
1631 					return (S_ERROR);
1632 			}
1633 
1634 			/*
1635 			 * If this section offers a global symbol - record that
1636 			 * fact.
1637 			 */
1638 			if (isp) {
1639 				isp->is_flags |= FLG_IS_SECTREF;
1640 				isp->is_file->ifl_flags |= FLG_IF_FILEREF;
1641 			}
1642 		}
1643 	}
1644 
1645 	/*
1646 	 * Guidance: Use -z defs|nodefs when building shared objects.
1647 	 *
1648 	 * Our caller issues this, unless we mask it out here. So we mask it
1649 	 * out unless we've issued at least one warnings or fatal error.
1650 	 */
1651 	if (!((oflags & FLG_OF_SHAROBJ) && OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS) &&
1652 	    (undef_state & (FLG_OF_FATAL | FLG_OF_WARN))))
1653 		ofl->ofl_guideflags |= FLG_OFG_NO_DEFS;
1654 
1655 	/*
1656 	 * If we've encountered a fatal error during symbol validation then
1657 	 * return now.
1658 	 */
1659 	if (ofl->ofl_flags & FLG_OF_FATAL)
1660 		return (1);
1661 
1662 	/*
1663 	 * Now that symbol resolution is completed, scan any register symbols.
1664 	 * From now on, we're only interested in those that contribute to the
1665 	 * output file.
1666 	 */
1667 	if (ofl->ofl_regsyms) {
1668 		int	ndx;
1669 
1670 		for (ndx = 0; ndx < ofl->ofl_regsymsno; ndx++) {
1671 			if ((sdp = ofl->ofl_regsyms[ndx]) == NULL)
1672 				continue;
1673 			if (sdp->sd_ref != REF_REL_NEED) {
1674 				ofl->ofl_regsyms[ndx] = NULL;
1675 				continue;
1676 			}
1677 
1678 			ofl->ofl_regsymcnt++;
1679 			if (sdp->sd_sym->st_name == 0)
1680 				sdp->sd_name = MSG_ORIG(MSG_STR_EMPTY);
1681 
1682 			if (SYM_IS_HIDDEN(sdp) ||
1683 			    (ELF_ST_BIND(sdp->sd_sym->st_info) == STB_LOCAL))
1684 				ofl->ofl_lregsymcnt++;
1685 		}
1686 	}
1687 
1688 	/*
1689 	 * Generate the .bss section now that we know its size and alignment.
1690 	 */
1691 	if (need_bss) {
1692 		if (ld_make_bss(ofl, bsssize, bssalign,
1693 		    ld_targ.t_id.id_bss) == S_ERROR)
1694 			return (S_ERROR);
1695 	}
1696 	if (need_tlsbss) {
1697 		if (ld_make_bss(ofl, tlssize, tlsalign,
1698 		    ld_targ.t_id.id_tlsbss) == S_ERROR)
1699 			return (S_ERROR);
1700 	}
1701 #if	defined(_ELF64)
1702 	if ((ld_targ.t_m.m_mach == EM_AMD64) &&
1703 	    need_lbss && !(oflags & FLG_OF_RELOBJ)) {
1704 		if (ld_make_bss(ofl, lbsssize, lbssalign,
1705 		    ld_targ.t_id.id_lbss) == S_ERROR)
1706 			return (S_ERROR);
1707 	}
1708 #endif
1709 	/*
1710 	 * Determine what entry point symbol we need, and if found save its
1711 	 * symbol descriptor so that we can update the ELF header entry with the
1712 	 * symbols value later (see update_oehdr).  Make sure the symbol is
1713 	 * tagged to ensure its update in case -s is in effect.  Use any -e
1714 	 * option first, or the default entry points `_start' and `main'.
1715 	 */
1716 	ret = 0;
1717 	if (ofl->ofl_entry) {
1718 		if ((sdp = ld_sym_find(ofl->ofl_entry, SYM_NOHASH,
1719 		    NULL, ofl)) == NULL) {
1720 			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_NOENTRY),
1721 			    ofl->ofl_entry);
1722 			ret++;
1723 		} else if (ensure_sym_local(ofl, sdp,
1724 		    MSG_INTL(MSG_SYM_ENTRY)) != 0) {
1725 			ret++;
1726 		} else {
1727 			ofl->ofl_entry = (void *)sdp;
1728 		}
1729 	} else if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_START),
1730 	    SYM_NOHASH, NULL, ofl)) != NULL) && (ensure_sym_local(ofl,
1731 	    sdp, 0) == 0)) {
1732 		ofl->ofl_entry = (void *)sdp;
1733 
1734 	} else if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_MAIN),
1735 	    SYM_NOHASH, NULL, ofl)) != NULL) && (ensure_sym_local(ofl,
1736 	    sdp, 0) == 0)) {
1737 		ofl->ofl_entry = (void *)sdp;
1738 	}
1739 
1740 	/*
1741 	 * If ld -zdtrace=<sym> was given, then validate that the symbol is
1742 	 * defined within the current object being built.
1743 	 */
1744 	if ((sdp = ofl->ofl_dtracesym) != 0)
1745 		ret += ensure_sym_local(ofl, sdp, MSG_ORIG(MSG_STR_DTRACE));
1746 
1747 	/*
1748 	 * If any initarray, finiarray or preinitarray functions have been
1749 	 * requested, make sure they are defined within the current object
1750 	 * being built.
1751 	 */
1752 	if (ofl->ofl_initarray) {
1753 		ret += ensure_array_local(ofl, ofl->ofl_initarray,
1754 		    MSG_ORIG(MSG_SYM_INITARRAY));
1755 	}
1756 	if (ofl->ofl_finiarray) {
1757 		ret += ensure_array_local(ofl, ofl->ofl_finiarray,
1758 		    MSG_ORIG(MSG_SYM_FINIARRAY));
1759 	}
1760 	if (ofl->ofl_preiarray) {
1761 		ret += ensure_array_local(ofl, ofl->ofl_preiarray,
1762 		    MSG_ORIG(MSG_SYM_PREINITARRAY));
1763 	}
1764 
1765 	if (ret)
1766 		return (S_ERROR);
1767 
1768 	/*
1769 	 * If we're required to record any needed dependencies versioning
1770 	 * information calculate it now that all symbols have been validated.
1771 	 */
1772 	if ((oflags & (FLG_OF_VERNEED | FLG_OF_NOVERSEC)) == FLG_OF_VERNEED)
1773 		return (ld_vers_check_need(ofl));
1774 	else
1775 		return (1);
1776 }
1777 
1778 /*
1779  * qsort(3c) comparison function.  As an optimization for associating weak
1780  * symbols to their strong counterparts sort global symbols according to their
1781  * section index, address and binding.
1782  */
1783 static int
1784 compare(const void *sdpp1, const void *sdpp2)
1785 {
1786 	Sym_desc	*sdp1 = *((Sym_desc **)sdpp1);
1787 	Sym_desc	*sdp2 = *((Sym_desc **)sdpp2);
1788 	Sym		*sym1, *sym2;
1789 	uchar_t		bind1, bind2;
1790 
1791 	/*
1792 	 * Symbol descriptors may be zero, move these to the front of the
1793 	 * sorted array.
1794 	 */
1795 	if (sdp1 == NULL)
1796 		return (-1);
1797 	if (sdp2 == NULL)
1798 		return (1);
1799 
1800 	sym1 = sdp1->sd_sym;
1801 	sym2 = sdp2->sd_sym;
1802 
1803 	/*
1804 	 * Compare the symbols section index.  This is important when sorting
1805 	 * the symbol tables of relocatable objects.  In this case, a symbols
1806 	 * value is the offset within the associated section, and thus many
1807 	 * symbols can have the same value, but are effectively different
1808 	 * addresses.
1809 	 */
1810 	if (sym1->st_shndx > sym2->st_shndx)
1811 		return (1);
1812 	if (sym1->st_shndx < sym2->st_shndx)
1813 		return (-1);
1814 
1815 	/*
1816 	 * Compare the symbols value (address).
1817 	 */
1818 	if (sym1->st_value > sym2->st_value)
1819 		return (1);
1820 	if (sym1->st_value < sym2->st_value)
1821 		return (-1);
1822 
1823 	bind1 = ELF_ST_BIND(sym1->st_info);
1824 	bind2 = ELF_ST_BIND(sym2->st_info);
1825 
1826 	/*
1827 	 * If two symbols have the same address place the weak symbol before
1828 	 * any strong counterpart.
1829 	 */
1830 	if (bind1 > bind2)
1831 		return (-1);
1832 	if (bind1 < bind2)
1833 		return (1);
1834 
1835 	return (0);
1836 }
1837 
1838 /*
1839  * Issue a MSG_SYM_BADADDR error from ld_sym_process(). This error
1840  * is issued when a symbol address/size is not contained by the
1841  * target section.
1842  *
1843  * Such objects are at least partially corrupt, and the user would
1844  * be well advised to be skeptical of them, and to ask their compiler
1845  * supplier to fix the problem. However, a distinction needs to be
1846  * made between symbols that reference readonly text, and those that
1847  * access writable data. Other than throwing off profiling results,
1848  * the readonly section case is less serious. We have encountered
1849  * such objects in the field. In order to allow existing objects
1850  * to continue working, we issue a warning rather than a fatal error
1851  * if the symbol is against readonly text. Other cases are fatal.
1852  */
1853 static void
1854 issue_badaddr_msg(Ifl_desc *ifl, Ofl_desc *ofl, Sym_desc *sdp,
1855     Sym *sym, Word shndx)
1856 {
1857 	Error		err;
1858 	const char	*msg;
1859 
1860 	if ((sdp->sd_isc->is_shdr->sh_flags & (SHF_WRITE | SHF_ALLOC)) ==
1861 	    SHF_ALLOC) {
1862 		msg = MSG_INTL(MSG_SYM_BADADDR_ROTXT);
1863 		err = ERR_WARNING;
1864 	} else {
1865 		msg = MSG_INTL(MSG_SYM_BADADDR);
1866 		err = ERR_FATAL;
1867 	}
1868 
1869 	ld_eprintf(ofl, err, msg, demangle(sdp->sd_name),
1870 	    ifl->ifl_name, shndx, sdp->sd_isc->is_name,
1871 	    EC_XWORD(sdp->sd_isc->is_shdr->sh_size),
1872 	    EC_XWORD(sym->st_value), EC_XWORD(sym->st_size));
1873 }
1874 
1875 /*
1876  * Global symbols that are candidates for translation to local capability
1877  * symbols under -z symbolcap, are maintained on a local symbol list.  Once
1878  * all symbols of a file are processed, this list is traversed to cull any
1879  * unnecessary weak symbol aliases.
1880  */
1881 typedef struct {
1882 	Sym_desc	*c_nsdp;	/* new lead symbol */
1883 	Sym_desc	*c_osdp;	/* original symbol */
1884 	Cap_group	*c_group;	/* symbol capability group */
1885 	Word		c_ndx;		/* symbol index */
1886 } Cap_pair;
1887 
1888 /*
1889  * Process the symbol table for the specified input file.  At this point all
1890  * input sections from this input file have been assigned an input section
1891  * descriptor which is saved in the `ifl_isdesc' array.
1892  *
1893  *  -	local symbols are saved (as is) if the input file is a 	relocatable
1894  *	object
1895  *
1896  *  -	global symbols are added to the linkers internal symbol table if they
1897  *	are not already present, otherwise a symbol resolution function is
1898  *	called upon to resolve the conflict.
1899  */
1900 uintptr_t
1901 ld_sym_process(Is_desc *isc, Ifl_desc *ifl, Ofl_desc *ofl)
1902 {
1903 	/*
1904 	 * This macro tests the given symbol to see if it is out of
1905 	 * range relative to the section it references.
1906 	 *
1907 	 * entry:
1908 	 *	- ifl is a relative object (ET_REL)
1909 	 *	_sdp - Symbol descriptor
1910 	 *	_sym - Symbol
1911 	 *	_type - Symbol type
1912 	 *
1913 	 * The following are tested:
1914 	 *	- Symbol length is non-zero
1915 	 *	- Symbol type is a type that references code or data
1916 	 *	- Referenced section is not 0 (indicates an UNDEF symbol)
1917 	 *	  and is not in the range of special values above SHN_LORESERVE
1918 	 *	  (excluding SHN_XINDEX, which is OK).
1919 	 *	- We have a valid section header for the target section
1920 	 *
1921 	 * If the above are all true, and the symbol position is not
1922 	 * contained by the target section, this macro evaluates to
1923 	 * True (1). Otherwise, False(0).
1924 	 */
1925 #define	SYM_LOC_BADADDR(_sdp, _sym, _type) \
1926 	(_sym->st_size && dynsymsort_symtype[_type] && \
1927 	(_sym->st_shndx != SHN_UNDEF) && \
1928 	((_sym->st_shndx < SHN_LORESERVE) || \
1929 		(_sym->st_shndx == SHN_XINDEX)) && \
1930 	_sdp->sd_isc && _sdp->sd_isc->is_shdr && \
1931 	((_sym->st_value + _sym->st_size) > _sdp->sd_isc->is_shdr->sh_size))
1932 
1933 	Conv_inv_buf_t	inv_buf;
1934 	Sym		*sym = (Sym *)isc->is_indata->d_buf;
1935 	Word		*symshndx = NULL;
1936 	Shdr		*shdr = isc->is_shdr;
1937 	Sym_desc	*sdp;
1938 	size_t		strsize;
1939 	char		*strs;
1940 	uchar_t		type, bind;
1941 	Word		ndx, hash, local, total;
1942 	uchar_t		osabi = ifl->ifl_ehdr->e_ident[EI_OSABI];
1943 	Half		mach = ifl->ifl_ehdr->e_machine;
1944 	Half		etype = ifl->ifl_ehdr->e_type;
1945 	int		etype_rel;
1946 	const char	*symsecname, *strsecname;
1947 	Word		symsecndx;
1948 	avl_index_t	where;
1949 	int		test_gnu_hidden_bit, weak;
1950 	Cap_desc	*cdp = NULL;
1951 	Alist		*cappairs = NULL;
1952 
1953 	/*
1954 	 * Its possible that a file may contain more that one symbol table,
1955 	 * ie. .dynsym and .symtab in a shared library.  Only process the first
1956 	 * table (here, we assume .dynsym comes before .symtab).
1957 	 */
1958 	if (ifl->ifl_symscnt)
1959 		return (1);
1960 
1961 	if (isc->is_symshndx)
1962 		symshndx = isc->is_symshndx->is_indata->d_buf;
1963 
1964 	DBG_CALL(Dbg_syms_process(ofl->ofl_lml, ifl));
1965 
1966 	symsecndx = isc->is_scnndx;
1967 	if (isc->is_name)
1968 		symsecname = isc->is_name;
1969 	else
1970 		symsecname = MSG_ORIG(MSG_STR_EMPTY);
1971 
1972 	/*
1973 	 * From the symbol tables section header information determine which
1974 	 * strtab table is needed to locate the actual symbol names.
1975 	 */
1976 	if (ifl->ifl_flags & FLG_IF_HSTRTAB) {
1977 		ndx = shdr->sh_link;
1978 		if ((ndx == 0) || (ndx >= ifl->ifl_shnum)) {
1979 			ld_eprintf(ofl, ERR_FATAL,
1980 			    MSG_INTL(MSG_FIL_INVSHLINK), ifl->ifl_name,
1981 			    EC_WORD(symsecndx), symsecname, EC_XWORD(ndx));
1982 			return (S_ERROR);
1983 		}
1984 		strsize = ifl->ifl_isdesc[ndx]->is_shdr->sh_size;
1985 		strs = ifl->ifl_isdesc[ndx]->is_indata->d_buf;
1986 		if (ifl->ifl_isdesc[ndx]->is_name)
1987 			strsecname = ifl->ifl_isdesc[ndx]->is_name;
1988 		else
1989 			strsecname = MSG_ORIG(MSG_STR_EMPTY);
1990 	} else {
1991 		/*
1992 		 * There is no string table section in this input file
1993 		 * although there are symbols in this symbol table section.
1994 		 * This means that these symbols do not have names.
1995 		 * Currently, only scratch register symbols are allowed
1996 		 * not to have names.
1997 		 */
1998 		strsize = 0;
1999 		strs = (char *)MSG_ORIG(MSG_STR_EMPTY);
2000 		strsecname = MSG_ORIG(MSG_STR_EMPTY);
2001 	}
2002 
2003 	/*
2004 	 * Determine the number of local symbols together with the total
2005 	 * number we have to process.
2006 	 */
2007 	total = (Word)(shdr->sh_size / shdr->sh_entsize);
2008 	local = shdr->sh_info;
2009 
2010 	/*
2011 	 * Allocate a symbol table index array and a local symbol array
2012 	 * (global symbols are processed and added to the ofl->ofl_symbkt[]
2013 	 * array).  If we are dealing with a relocatable object, allocate the
2014 	 * local symbol descriptors.  If this isn't a relocatable object we
2015 	 * still have to process any shared object locals to determine if any
2016 	 * register symbols exist.  Although these aren't added to the output
2017 	 * image, they are used as part of symbol resolution.
2018 	 */
2019 	if ((ifl->ifl_oldndx = libld_malloc((size_t)(total *
2020 	    sizeof (Sym_desc *)))) == NULL)
2021 		return (S_ERROR);
2022 	etype_rel = (etype == ET_REL);
2023 	if (etype_rel && local) {
2024 		if ((ifl->ifl_locs =
2025 		    libld_calloc(sizeof (Sym_desc), local)) == NULL)
2026 			return (S_ERROR);
2027 		/* LINTED */
2028 		ifl->ifl_locscnt = (Word)local;
2029 	}
2030 	ifl->ifl_symscnt = total;
2031 
2032 	/*
2033 	 * If there are local symbols to save add them to the symbol table
2034 	 * index array.
2035 	 */
2036 	if (local) {
2037 		int		allow_ldynsym = OFL_ALLOW_LDYNSYM(ofl);
2038 		Sym_desc	*last_file_sdp = NULL;
2039 		int		last_file_ndx = 0;
2040 
2041 		for (sym++, ndx = 1; ndx < local; sym++, ndx++) {
2042 			sd_flag_t	sdflags = FLG_SY_CLEAN;
2043 			Word		shndx;
2044 			const char	*name;
2045 			Sym_desc	*rsdp;
2046 			int		shndx_bad = 0;
2047 			int		symtab_enter = 1;
2048 
2049 			/*
2050 			 * Determine and validate the associated section index.
2051 			 */
2052 			if (symshndx && (sym->st_shndx == SHN_XINDEX)) {
2053 				shndx = symshndx[ndx];
2054 			} else if ((shndx = sym->st_shndx) >= SHN_LORESERVE) {
2055 				sdflags |= FLG_SY_SPECSEC;
2056 			} else if (shndx > ifl->ifl_shnum) {
2057 				/* We need the name before we can issue error */
2058 				shndx_bad = 1;
2059 			}
2060 
2061 			/*
2062 			 * Check if st_name has a valid value or not.
2063 			 */
2064 			if ((name = string(ofl, ifl, sym, strs, strsize, ndx,
2065 			    shndx, symsecndx, symsecname, strsecname,
2066 			    &sdflags)) == NULL)
2067 				continue;
2068 
2069 			/*
2070 			 * Now that we have the name, if the section index
2071 			 * was bad, report it.
2072 			 */
2073 			if (shndx_bad) {
2074 				ld_eprintf(ofl, ERR_WARNING,
2075 				    MSG_INTL(MSG_SYM_INVSHNDX),
2076 				    demangle_symname(name, symsecname, ndx),
2077 				    ifl->ifl_name,
2078 				    conv_sym_shndx(osabi, mach, sym->st_shndx,
2079 				    CONV_FMT_DECIMAL, &inv_buf));
2080 				continue;
2081 			}
2082 
2083 			/*
2084 			 * If this local symbol table originates from a shared
2085 			 * object, then we're only interested in recording
2086 			 * register symbols.  As local symbol descriptors aren't
2087 			 * allocated for shared objects, one will be allocated
2088 			 * to associated with the register symbol.  This symbol
2089 			 * won't become part of the output image, but we must
2090 			 * process it to test for register conflicts.
2091 			 */
2092 			rsdp = sdp = NULL;
2093 			if (sdflags & FLG_SY_REGSYM) {
2094 				/*
2095 				 * The presence of FLG_SY_REGSYM means that
2096 				 * the pointers in ld_targ.t_ms are non-NULL.
2097 				 */
2098 				rsdp = (*ld_targ.t_ms.ms_reg_find)(sym, ofl);
2099 				if (rsdp != 0) {
2100 					/*
2101 					 * The fact that another register def-
2102 					 * inition has been found is fatal.
2103 					 * Call the verification routine to get
2104 					 * the error message and move on.
2105 					 */
2106 					(void) (*ld_targ.t_ms.ms_reg_check)
2107 					    (rsdp, sym, name, ifl, ofl);
2108 					continue;
2109 				}
2110 
2111 				if (etype == ET_DYN) {
2112 					if ((sdp = libld_calloc(
2113 					    sizeof (Sym_desc), 1)) == NULL)
2114 						return (S_ERROR);
2115 					sdp->sd_ref = REF_DYN_SEEN;
2116 
2117 					/* Will not appear in output object */
2118 					symtab_enter = 0;
2119 				}
2120 			} else if (etype == ET_DYN)
2121 				continue;
2122 
2123 			/*
2124 			 * Fill in the remaining symbol descriptor information.
2125 			 */
2126 			if (sdp == NULL) {
2127 				sdp = &(ifl->ifl_locs[ndx]);
2128 				sdp->sd_ref = REF_REL_NEED;
2129 				sdp->sd_symndx = ndx;
2130 			}
2131 			if (rsdp == NULL) {
2132 				sdp->sd_name = name;
2133 				sdp->sd_sym = sym;
2134 				sdp->sd_shndx = shndx;
2135 				sdp->sd_flags = sdflags;
2136 				sdp->sd_file = ifl;
2137 				ifl->ifl_oldndx[ndx] = sdp;
2138 			}
2139 
2140 			DBG_CALL(Dbg_syms_entry(ofl->ofl_lml, ndx, sdp));
2141 
2142 			/*
2143 			 * Reclassify any SHN_SUNW_IGNORE symbols to SHN_UNDEF
2144 			 * so as to simplify future processing.
2145 			 */
2146 			if (sym->st_shndx == SHN_SUNW_IGNORE) {
2147 				sdp->sd_shndx = shndx = SHN_UNDEF;
2148 				sdp->sd_flags |= (FLG_SY_IGNORE | FLG_SY_ELIM);
2149 			}
2150 
2151 			/*
2152 			 * Process any register symbols.
2153 			 */
2154 			if (sdp->sd_flags & FLG_SY_REGSYM) {
2155 				/*
2156 				 * Add a diagnostic to indicate we've caught a
2157 				 * register symbol, as this can be useful if a
2158 				 * register conflict is later discovered.
2159 				 */
2160 				DBG_CALL(Dbg_syms_entered(ofl, sym, sdp));
2161 
2162 				/*
2163 				 * If this register symbol hasn't already been
2164 				 * recorded, enter it now.
2165 				 *
2166 				 * The presence of FLG_SY_REGSYM means that
2167 				 * the pointers in ld_targ.t_ms are non-NULL.
2168 				 */
2169 				if ((rsdp == NULL) &&
2170 				    ((*ld_targ.t_ms.ms_reg_enter)(sdp, ofl) ==
2171 				    0))
2172 					return (S_ERROR);
2173 			}
2174 
2175 			/*
2176 			 * Assign an input section.
2177 			 */
2178 			if ((sym->st_shndx != SHN_UNDEF) &&
2179 			    ((sdp->sd_flags & FLG_SY_SPECSEC) == 0))
2180 				sdp->sd_isc = ifl->ifl_isdesc[shndx];
2181 
2182 			/*
2183 			 * If this symbol falls within the range of a section
2184 			 * being discarded, then discard the symbol itself.
2185 			 * There is no reason to keep this local symbol.
2186 			 */
2187 			if (sdp->sd_isc &&
2188 			    (sdp->sd_isc->is_flags & FLG_IS_DISCARD)) {
2189 				sdp->sd_flags |= FLG_SY_ISDISC;
2190 				DBG_CALL(Dbg_syms_discarded(ofl->ofl_lml, sdp));
2191 				continue;
2192 			}
2193 
2194 			/*
2195 			 * Skip any section symbols as new versions of these
2196 			 * will be created.
2197 			 */
2198 			if ((type = ELF_ST_TYPE(sym->st_info)) == STT_SECTION) {
2199 				if (sym->st_shndx == SHN_UNDEF) {
2200 					ld_eprintf(ofl, ERR_WARNING,
2201 					    MSG_INTL(MSG_SYM_INVSHNDX),
2202 					    demangle_symname(name, symsecname,
2203 					    ndx), ifl->ifl_name,
2204 					    conv_sym_shndx(osabi, mach,
2205 					    sym->st_shndx, CONV_FMT_DECIMAL,
2206 					    &inv_buf));
2207 				}
2208 				continue;
2209 			}
2210 
2211 			/*
2212 			 * For a relocatable object, if this symbol is defined
2213 			 * and has non-zero length and references an address
2214 			 * within an associated section, then check its extents
2215 			 * to make sure the section boundaries encompass it.
2216 			 * If they don't, the ELF file is corrupt.
2217 			 */
2218 			if (etype_rel) {
2219 				if (SYM_LOC_BADADDR(sdp, sym, type)) {
2220 					issue_badaddr_msg(ifl, ofl, sdp,
2221 					    sym, shndx);
2222 					if (ofl->ofl_flags & FLG_OF_FATAL)
2223 						continue;
2224 				}
2225 
2226 				/*
2227 				 * We have observed relocatable objects
2228 				 * containing identical adjacent STT_FILE
2229 				 * symbols. Discard any other than the first,
2230 				 * as they are all equivalent and the extras
2231 				 * do not add information.
2232 				 *
2233 				 * For the purpose of this test, we assume
2234 				 * that only the symbol type and the string
2235 				 * table offset (st_name) matter.
2236 				 */
2237 				if (type == STT_FILE) {
2238 					int toss = (last_file_sdp != NULL) &&
2239 					    ((ndx - 1) == last_file_ndx) &&
2240 					    (sym->st_name ==
2241 					    last_file_sdp->sd_sym->st_name);
2242 
2243 					last_file_sdp = sdp;
2244 					last_file_ndx = ndx;
2245 					if (toss) {
2246 						sdp->sd_flags |= FLG_SY_INVALID;
2247 						DBG_CALL(Dbg_syms_dup_discarded(
2248 						    ofl->ofl_lml, ndx, sdp));
2249 						continue;
2250 					}
2251 				}
2252 			}
2253 
2254 
2255 			/*
2256 			 * Sanity check for TLS
2257 			 */
2258 			if ((sym->st_size != 0) && ((type == STT_TLS) &&
2259 			    (sym->st_shndx != SHN_COMMON))) {
2260 				Is_desc	*isp = sdp->sd_isc;
2261 
2262 				if ((isp == NULL) || (isp->is_shdr == NULL) ||
2263 				    ((isp->is_shdr->sh_flags & SHF_TLS) == 0)) {
2264 					ld_eprintf(ofl, ERR_FATAL,
2265 					    MSG_INTL(MSG_SYM_TLS),
2266 					    demangle(sdp->sd_name),
2267 					    ifl->ifl_name);
2268 					continue;
2269 				}
2270 			}
2271 
2272 			/*
2273 			 * Carry our some basic sanity checks (these are just
2274 			 * some of the erroneous symbol entries we've come
2275 			 * across, there's probably a lot more).  The symbol
2276 			 * will not be carried forward to the output file, which
2277 			 * won't be a problem unless a relocation is required
2278 			 * against it.
2279 			 */
2280 			if (((sdp->sd_flags & FLG_SY_SPECSEC) &&
2281 			    ((sym->st_shndx == SHN_COMMON)) ||
2282 			    ((type == STT_FILE) &&
2283 			    (sym->st_shndx != SHN_ABS))) ||
2284 			    (sdp->sd_isc && (sdp->sd_isc->is_osdesc == NULL))) {
2285 				ld_eprintf(ofl, ERR_WARNING,
2286 				    MSG_INTL(MSG_SYM_INVSHNDX),
2287 				    demangle_symname(name, symsecname, ndx),
2288 				    ifl->ifl_name,
2289 				    conv_sym_shndx(osabi, mach, sym->st_shndx,
2290 				    CONV_FMT_DECIMAL, &inv_buf));
2291 				sdp->sd_isc = NULL;
2292 				sdp->sd_flags |= FLG_SY_INVALID;
2293 				continue;
2294 			}
2295 
2296 			/*
2297 			 * As these local symbols will become part of the output
2298 			 * image, record their number and name string size.
2299 			 * Globals are counted after all input file processing
2300 			 * (and hence symbol resolution) is complete during
2301 			 * sym_validate().
2302 			 */
2303 			if (!(ofl->ofl_flags & FLG_OF_REDLSYM) &&
2304 			    symtab_enter) {
2305 				ofl->ofl_locscnt++;
2306 
2307 				if ((((sdp->sd_flags & FLG_SY_REGSYM) == 0) ||
2308 				    sym->st_name) && (st_insert(ofl->ofl_strtab,
2309 				    sdp->sd_name) == -1))
2310 					return (S_ERROR);
2311 
2312 				if (allow_ldynsym && sym->st_name &&
2313 				    ldynsym_symtype[type]) {
2314 					ofl->ofl_dynlocscnt++;
2315 					if (st_insert(ofl->ofl_dynstrtab,
2316 					    sdp->sd_name) == -1)
2317 						return (S_ERROR);
2318 					/* Include it in sort section? */
2319 					DYNSORT_COUNT(sdp, sym, type, ++);
2320 				}
2321 			}
2322 		}
2323 	}
2324 
2325 	/*
2326 	 * The GNU ld interprets the top bit of the 16-bit Versym value
2327 	 * (0x8000) as the "hidden" bit. If this bit is set, the linker
2328 	 * is supposed to act as if that symbol does not exist. The Solaris
2329 	 * linker does not support this mechanism, or the model of interface
2330 	 * evolution that it allows, but we honor it in GNU ld produced
2331 	 * objects in order to interoperate with them.
2332 	 *
2333 	 * Determine if we should honor the GNU hidden bit for this file.
2334 	 */
2335 	test_gnu_hidden_bit = ((ifl->ifl_flags & FLG_IF_GNUVER) != 0) &&
2336 	    (ifl->ifl_versym != NULL);
2337 
2338 	/*
2339 	 * Determine whether object capabilities for this file are being
2340 	 * converted into symbol capabilities.  If so, global function symbols,
2341 	 * and initialized global data symbols, need special translation and
2342 	 * processing.
2343 	 */
2344 	if ((etype == ET_REL) && (ifl->ifl_flags & FLG_IF_OTOSCAP))
2345 		cdp = ifl->ifl_caps;
2346 
2347 	/*
2348 	 * Now scan the global symbols entering them in the internal symbol
2349 	 * table or resolving them as necessary.
2350 	 */
2351 	sym = (Sym *)isc->is_indata->d_buf;
2352 	sym += local;
2353 	weak = 0;
2354 	/* LINTED */
2355 	for (ndx = (int)local; ndx < total; sym++, ndx++) {
2356 		const char	*name;
2357 		sd_flag_t	sdflags = 0;
2358 		Word		shndx;
2359 		int		shndx_bad = 0;
2360 		Sym		*nsym = sym;
2361 		Cap_pair	*cpp = NULL;
2362 		uchar_t		ntype;
2363 
2364 		/*
2365 		 * Determine and validate the associated section index.
2366 		 */
2367 		if (symshndx && (nsym->st_shndx == SHN_XINDEX)) {
2368 			shndx = symshndx[ndx];
2369 		} else if ((shndx = nsym->st_shndx) >= SHN_LORESERVE) {
2370 			sdflags |= FLG_SY_SPECSEC;
2371 		} else if (shndx > ifl->ifl_shnum) {
2372 			/* We need the name before we can issue error */
2373 			shndx_bad = 1;
2374 		}
2375 
2376 		/*
2377 		 * Check if st_name has a valid value or not.
2378 		 */
2379 		if ((name = string(ofl, ifl, nsym, strs, strsize, ndx, shndx,
2380 		    symsecndx, symsecname, strsecname, &sdflags)) == NULL)
2381 			continue;
2382 
2383 		/*
2384 		 * Now that we have the name, report an erroneous section index.
2385 		 */
2386 		if (shndx_bad) {
2387 			ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SYM_INVSHNDX),
2388 			    demangle_symname(name, symsecname, ndx),
2389 			    ifl->ifl_name,
2390 			    conv_sym_shndx(osabi, mach, nsym->st_shndx,
2391 			    CONV_FMT_DECIMAL, &inv_buf));
2392 			continue;
2393 		}
2394 
2395 		/*
2396 		 * Test for the GNU hidden bit, and ignore symbols that
2397 		 * have it set.
2398 		 */
2399 		if (test_gnu_hidden_bit &&
2400 		    ((ifl->ifl_versym[ndx] & 0x8000) != 0))
2401 			continue;
2402 
2403 		/*
2404 		 * The linker itself will generate symbols for _end, _etext,
2405 		 * _edata, _DYNAMIC and _PROCEDURE_LINKAGE_TABLE_, so don't
2406 		 * bother entering these symbols from shared objects.  This
2407 		 * results in some wasted resolution processing, which is hard
2408 		 * to feel, but if nothing else, pollutes diagnostic relocation
2409 		 * output.
2410 		 */
2411 		if (name[0] && (etype == ET_DYN) && (nsym->st_size == 0) &&
2412 		    (ELF_ST_TYPE(nsym->st_info) == STT_OBJECT) &&
2413 		    (name[0] == '_') && ((name[1] == 'e') ||
2414 		    (name[1] == 'D') || (name[1] == 'P')) &&
2415 		    ((strcmp(name, MSG_ORIG(MSG_SYM_ETEXT_U)) == 0) ||
2416 		    (strcmp(name, MSG_ORIG(MSG_SYM_EDATA_U)) == 0) ||
2417 		    (strcmp(name, MSG_ORIG(MSG_SYM_END_U)) == 0) ||
2418 		    (strcmp(name, MSG_ORIG(MSG_SYM_DYNAMIC_U)) == 0) ||
2419 		    (strcmp(name, MSG_ORIG(MSG_SYM_PLKTBL_U)) == 0))) {
2420 			ifl->ifl_oldndx[ndx] = 0;
2421 			continue;
2422 		}
2423 
2424 		/*
2425 		 * The '-z wrap=XXX' option emulates the GNU ld --wrap=XXX
2426 		 * option. When XXX is the symbol to be wrapped:
2427 		 *
2428 		 *  -	An undefined reference to XXX is converted to __wrap_XXX
2429 		 *  -	An undefined reference to __real_XXX is converted to XXX
2430 		 *
2431 		 * The idea is that the user can supply a wrapper function
2432 		 * __wrap_XXX that does some work, and then uses the name
2433 		 * __real_XXX to pass the call on to the real function. The
2434 		 * wrapper objects are linked with the original unmodified
2435 		 * objects to produce a wrapped version of the output object.
2436 		 */
2437 		if (ofl->ofl_wrap && name[0] && (shndx == SHN_UNDEF)) {
2438 			WrapSymNode wsn, *wsnp;
2439 
2440 			/*
2441 			 * If this is the __real_XXX form, advance the
2442 			 * pointer to reference the wrapped name.
2443 			 */
2444 			wsn.wsn_name = name;
2445 			if ((*name == '_') &&
2446 			    (strncmp(name, MSG_ORIG(MSG_STR_UU_REAL_U),
2447 			    MSG_STR_UU_REAL_U_SIZE) == 0))
2448 				wsn.wsn_name += MSG_STR_UU_REAL_U_SIZE;
2449 
2450 			/*
2451 			 * Is this symbol in the wrap AVL tree? If so, map
2452 			 * XXX to __wrap_XXX, and __real_XXX to XXX. Note that
2453 			 * wsn.wsn_name will equal the current value of name
2454 			 * if the __real_ prefix is not present.
2455 			 */
2456 			if ((wsnp = avl_find(ofl->ofl_wrap, &wsn, 0)) != NULL) {
2457 				const char *old_name = name;
2458 
2459 				name = (wsn.wsn_name == name) ?
2460 				    wsnp->wsn_wrapname : wsn.wsn_name;
2461 				DBG_CALL(Dbg_syms_wrap(ofl->ofl_lml, ndx,
2462 				    old_name, name));
2463 			}
2464 		}
2465 
2466 		/*
2467 		 * Determine and validate the symbols binding.
2468 		 */
2469 		bind = ELF_ST_BIND(nsym->st_info);
2470 		if ((bind != STB_GLOBAL) && (bind != STB_WEAK)) {
2471 			ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SYM_NONGLOB),
2472 			    demangle_symname(name, symsecname, ndx),
2473 			    ifl->ifl_name,
2474 			    conv_sym_info_bind(bind, 0, &inv_buf));
2475 			continue;
2476 		}
2477 		if (bind == STB_WEAK)
2478 			weak++;
2479 
2480 		/*
2481 		 * If this symbol falls within the range of a section being
2482 		 * discarded, then discard the symbol itself.
2483 		 */
2484 		if (((sdflags & FLG_SY_SPECSEC) == 0) &&
2485 		    (nsym->st_shndx != SHN_UNDEF)) {
2486 			Is_desc	*isp;
2487 
2488 			if (shndx >= ifl->ifl_shnum) {
2489 				/*
2490 				 * Carry our some basic sanity checks
2491 				 * The symbol will not be carried forward to
2492 				 * the output file, which won't be a problem
2493 				 * unless a relocation is required against it.
2494 				 */
2495 				ld_eprintf(ofl, ERR_WARNING,
2496 				    MSG_INTL(MSG_SYM_INVSHNDX),
2497 				    demangle_symname(name, symsecname, ndx),
2498 				    ifl->ifl_name,
2499 				    conv_sym_shndx(osabi, mach, nsym->st_shndx,
2500 				    CONV_FMT_DECIMAL, &inv_buf));
2501 				continue;
2502 			}
2503 
2504 			isp = ifl->ifl_isdesc[shndx];
2505 			if (isp && (isp->is_flags & FLG_IS_DISCARD)) {
2506 				if ((sdp =
2507 				    libld_calloc(sizeof (Sym_desc), 1)) == NULL)
2508 					return (S_ERROR);
2509 
2510 				/*
2511 				 * Create a dummy symbol entry so that if we
2512 				 * find any references to this discarded symbol
2513 				 * we can compensate.
2514 				 */
2515 				sdp->sd_name = name;
2516 				sdp->sd_sym = nsym;
2517 				sdp->sd_file = ifl;
2518 				sdp->sd_isc = isp;
2519 				sdp->sd_flags = FLG_SY_ISDISC;
2520 				ifl->ifl_oldndx[ndx] = sdp;
2521 
2522 				DBG_CALL(Dbg_syms_discarded(ofl->ofl_lml, sdp));
2523 				continue;
2524 			}
2525 		}
2526 
2527 		/*
2528 		 * If object capabilities for this file are being converted
2529 		 * into symbol capabilities, then:
2530 		 *
2531 		 *  -	Any global function, or initialized global data symbol
2532 		 *	definitions (ie., those that are not associated with
2533 		 *	special symbol types, ie., ABS, COMMON, etc.), and which
2534 		 *	have not been reduced to locals, are converted to symbol
2535 		 *	references (UNDEF).  This ensures that any reference to
2536 		 *	the original symbol, for example from a relocation, get
2537 		 *	associated to a capabilities family lead symbol, ie., a
2538 		 *	generic instance.
2539 		 *
2540 		 *  -	For each global function, or object symbol definition,
2541 		 *	a new local symbol is created.  The function or object
2542 		 *	is renamed using the capabilities CA_SUNW_ID definition
2543 		 *	(which might have been fabricated for this purpose -
2544 		 *	see get_cap_group()).  The new symbol name is:
2545 		 *
2546 		 *	    <original name>%<capability group identifier>
2547 		 *
2548 		 *	This symbol is associated to the same location, and
2549 		 *	becomes a capabilities family member.
2550 		 */
2551 		/* LINTED */
2552 		hash = (Word)elf_hash(name);
2553 
2554 		ntype = ELF_ST_TYPE(nsym->st_info);
2555 		if (cdp && (nsym->st_shndx != SHN_UNDEF) &&
2556 		    ((sdflags & FLG_SY_SPECSEC) == 0) &&
2557 		    ((ntype == STT_FUNC) || (ntype == STT_OBJECT))) {
2558 			/*
2559 			 * Determine this symbol's visibility.  If a mapfile has
2560 			 * indicated this symbol should be local, then there's
2561 			 * no point in transforming this global symbol to a
2562 			 * capabilities symbol.  Otherwise, create a symbol
2563 			 * capability pair descriptor to record this symbol as
2564 			 * a candidate for translation.
2565 			 */
2566 			if (sym_cap_vis(name, hash, sym, ofl) &&
2567 			    ((cpp = alist_append(&cappairs, NULL,
2568 			    sizeof (Cap_pair), AL_CNT_CAP_PAIRS)) == NULL))
2569 				return (S_ERROR);
2570 		}
2571 
2572 		if (cpp) {
2573 			Sym	*rsym;
2574 
2575 			DBG_CALL(Dbg_syms_cap_convert(ofl, ndx, name, nsym));
2576 
2577 			/*
2578 			 * Allocate a new symbol descriptor to represent the
2579 			 * transformed global symbol.  The descriptor points
2580 			 * to the original symbol information (which might
2581 			 * indicate a global or weak visibility).  The symbol
2582 			 * information will be transformed into a local symbol
2583 			 * later, after any weak aliases are culled.
2584 			 */
2585 			if ((cpp->c_osdp =
2586 			    libld_malloc(sizeof (Sym_desc))) == NULL)
2587 				return (S_ERROR);
2588 
2589 			cpp->c_osdp->sd_name = name;
2590 			cpp->c_osdp->sd_sym = nsym;
2591 			cpp->c_osdp->sd_shndx = shndx;
2592 			cpp->c_osdp->sd_file = ifl;
2593 			cpp->c_osdp->sd_isc = ifl->ifl_isdesc[shndx];
2594 			cpp->c_osdp->sd_ref = REF_REL_NEED;
2595 
2596 			/*
2597 			 * Save the capabilities group this symbol belongs to,
2598 			 * and the original symbol index.
2599 			 */
2600 			cpp->c_group = cdp->ca_groups->apl_data[0];
2601 			cpp->c_ndx = ndx;
2602 
2603 			/*
2604 			 * Replace the original symbol definition with a symbol
2605 			 * reference.  Make sure this reference isn't left as a
2606 			 * weak.
2607 			 */
2608 			if ((rsym = libld_malloc(sizeof (Sym))) == NULL)
2609 				return (S_ERROR);
2610 
2611 			*rsym = *nsym;
2612 
2613 			rsym->st_info = ELF_ST_INFO(STB_GLOBAL, ntype);
2614 			rsym->st_shndx = shndx = SHN_UNDEF;
2615 			rsym->st_value = 0;
2616 			rsym->st_size = 0;
2617 
2618 			sdflags |= FLG_SY_CAP;
2619 
2620 			nsym = rsym;
2621 		}
2622 
2623 		/*
2624 		 * If the symbol does not already exist in the internal symbol
2625 		 * table add it, otherwise resolve the conflict.  If the symbol
2626 		 * from this file is kept, retain its symbol table index for
2627 		 * possible use in associating a global alias.
2628 		 */
2629 		if ((sdp = ld_sym_find(name, hash, &where, ofl)) == NULL) {
2630 			DBG_CALL(Dbg_syms_global(ofl->ofl_lml, ndx, name));
2631 			if ((sdp = ld_sym_enter(name, nsym, hash, ifl, ofl, ndx,
2632 			    shndx, sdflags, &where)) == (Sym_desc *)S_ERROR)
2633 				return (S_ERROR);
2634 
2635 		} else if (ld_sym_resolve(sdp, nsym, ifl, ofl, ndx, shndx,
2636 		    sdflags) == S_ERROR)
2637 			return (S_ERROR);
2638 
2639 		/*
2640 		 * Now that we have a symbol descriptor, retain the descriptor
2641 		 * for later use by symbol capabilities processing.
2642 		 */
2643 		if (cpp)
2644 			cpp->c_nsdp = sdp;
2645 
2646 		/*
2647 		 * After we've compared a defined symbol in one shared
2648 		 * object, flag the symbol so we don't compare it again.
2649 		 */
2650 		if ((etype == ET_DYN) && (nsym->st_shndx != SHN_UNDEF) &&
2651 		    ((sdp->sd_flags & FLG_SY_SOFOUND) == 0))
2652 			sdp->sd_flags |= FLG_SY_SOFOUND;
2653 
2654 		/*
2655 		 * If the symbol is accepted from this file retain the symbol
2656 		 * index for possible use in aliasing.
2657 		 */
2658 		if (sdp->sd_file == ifl)
2659 			sdp->sd_symndx = ndx;
2660 
2661 		ifl->ifl_oldndx[ndx] = sdp;
2662 
2663 		/*
2664 		 * If we've accepted a register symbol, continue to validate
2665 		 * it.
2666 		 */
2667 		if (sdp->sd_flags & FLG_SY_REGSYM) {
2668 			Sym_desc	*rsdp;
2669 
2670 			/*
2671 			 * The presence of FLG_SY_REGSYM means that
2672 			 * the pointers in ld_targ.t_ms are non-NULL.
2673 			 */
2674 			rsdp = (*ld_targ.t_ms.ms_reg_find)(sdp->sd_sym, ofl);
2675 			if (rsdp == NULL) {
2676 				if ((*ld_targ.t_ms.ms_reg_enter)(sdp, ofl) == 0)
2677 					return (S_ERROR);
2678 			} else if (rsdp != sdp) {
2679 				(void) (*ld_targ.t_ms.ms_reg_check)(rsdp,
2680 				    sdp->sd_sym, sdp->sd_name, ifl, ofl);
2681 			}
2682 		}
2683 
2684 		/*
2685 		 * For a relocatable object, if this symbol is defined
2686 		 * and has non-zero length and references an address
2687 		 * within an associated section, then check its extents
2688 		 * to make sure the section boundaries encompass it.
2689 		 * If they don't, the ELF file is corrupt. Note that this
2690 		 * global symbol may have come from another file to satisfy
2691 		 * an UNDEF symbol of the same name from this one. In that
2692 		 * case, we don't check it, because it was already checked
2693 		 * as part of its own file.
2694 		 */
2695 		if (etype_rel && (sdp->sd_file == ifl)) {
2696 			Sym *tsym = sdp->sd_sym;
2697 
2698 			if (SYM_LOC_BADADDR(sdp, tsym,
2699 			    ELF_ST_TYPE(tsym->st_info))) {
2700 				issue_badaddr_msg(ifl, ofl, sdp,
2701 				    tsym, tsym->st_shndx);
2702 				continue;
2703 			}
2704 		}
2705 	}
2706 	DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD));
2707 
2708 	/*
2709 	 * Associate weak (alias) symbols to their non-weak counterparts by
2710 	 * scanning the global symbols one more time.
2711 	 *
2712 	 * This association is needed when processing the symbols from a shared
2713 	 * object dependency when a a weak definition satisfies a reference:
2714 	 *
2715 	 *  -	When building a dynamic executable, if a referenced symbol is a
2716 	 *	data item, the symbol data is copied to the executables address
2717 	 *	space.  In this copy-relocation case, we must also reassociate
2718 	 *	the alias symbol with its new location in the executable.
2719 	 *
2720 	 *  -	If the referenced symbol is a function then we may need to
2721 	 *	promote the symbols binding from undefined weak to undefined,
2722 	 *	otherwise the run-time linker will not generate the correct
2723 	 *	relocation error should the symbol not be found.
2724 	 *
2725 	 * Weak alias association is also required when a local dynsym table
2726 	 * is being created.  This table should only contain one instance of a
2727 	 * symbol that is associated to a given address.
2728 	 *
2729 	 * The true association between a weak/strong symbol pair is that both
2730 	 * symbol entries are identical, thus first we create a sorted symbol
2731 	 * list keyed off of the symbols section index and value.  If the symbol
2732 	 * belongs to the same section and has the same value, then the chances
2733 	 * are that the rest of the symbols data is the same.  This list is then
2734 	 * scanned for weak symbols, and if one is found then any strong
2735 	 * association will exist in the entries that follow.  Thus we just have
2736 	 * to scan one (typically a single alias) or more (in the uncommon
2737 	 * instance of multiple weak to strong associations) entries to
2738 	 * determine if a match exists.
2739 	 */
2740 	if (weak && (OFL_ALLOW_LDYNSYM(ofl) || (etype == ET_DYN)) &&
2741 	    (total > local)) {
2742 		static Sym_desc	**sort;
2743 		static size_t	osize = 0;
2744 		size_t		nsize = (total - local) * sizeof (Sym_desc *);
2745 
2746 		/*
2747 		 * As we might be processing many input files, and many symbols,
2748 		 * try and reuse a static sort buffer.  Note, presently we're
2749 		 * playing the game of never freeing any buffers as there's a
2750 		 * belief this wastes time.
2751 		 */
2752 		if ((osize == 0) || (nsize > osize)) {
2753 			if ((sort = libld_malloc(nsize)) == NULL)
2754 				return (S_ERROR);
2755 			osize = nsize;
2756 		}
2757 		(void) memcpy((void *)sort, &ifl->ifl_oldndx[local], nsize);
2758 
2759 		qsort(sort, (total - local), sizeof (Sym_desc *), compare);
2760 
2761 		for (ndx = 0; ndx < (total - local); ndx++) {
2762 			Sym_desc	*wsdp = sort[ndx];
2763 			Sym		*wsym;
2764 			int		sndx;
2765 
2766 			/*
2767 			 * Ignore any empty symbol descriptor, or the case where
2768 			 * the symbol has been resolved to a different file.
2769 			 */
2770 			if ((wsdp == NULL) || (wsdp->sd_file != ifl))
2771 				continue;
2772 
2773 			wsym = wsdp->sd_sym;
2774 
2775 			if ((wsym->st_shndx == SHN_UNDEF) ||
2776 			    (wsdp->sd_flags & FLG_SY_SPECSEC) ||
2777 			    (ELF_ST_BIND(wsym->st_info) != STB_WEAK))
2778 				continue;
2779 
2780 			/*
2781 			 * We have a weak symbol, if it has a strong alias it
2782 			 * will have been sorted to one of the following sort
2783 			 * table entries.  Note that we could have multiple weak
2784 			 * symbols aliased to one strong (if this occurs then
2785 			 * the strong symbol only maintains one alias back to
2786 			 * the last weak).
2787 			 */
2788 			for (sndx = ndx + 1; sndx < (total - local); sndx++) {
2789 				Sym_desc	*ssdp = sort[sndx];
2790 				Sym		*ssym;
2791 				sd_flag_t	w_dynbits, s_dynbits;
2792 
2793 				/*
2794 				 * Ignore any empty symbol descriptor, or the
2795 				 * case where the symbol has been resolved to a
2796 				 * different file.
2797 				 */
2798 				if ((ssdp == NULL) || (ssdp->sd_file != ifl))
2799 					continue;
2800 
2801 				ssym = ssdp->sd_sym;
2802 
2803 				if (ssym->st_shndx == SHN_UNDEF)
2804 					continue;
2805 
2806 				if ((ssym->st_shndx != wsym->st_shndx) ||
2807 				    (ssym->st_value != wsym->st_value))
2808 					break;
2809 
2810 				if ((ssym->st_size != wsym->st_size) ||
2811 				    (ssdp->sd_flags & FLG_SY_SPECSEC) ||
2812 				    (ELF_ST_BIND(ssym->st_info) == STB_WEAK))
2813 					continue;
2814 
2815 				/*
2816 				 * If a sharable object, set link fields so
2817 				 * that they reference each other.`
2818 				 */
2819 				if (etype == ET_DYN) {
2820 					ssdp->sd_aux->sa_linkndx =
2821 					    (Word)wsdp->sd_symndx;
2822 					wsdp->sd_aux->sa_linkndx =
2823 					    (Word)ssdp->sd_symndx;
2824 				}
2825 
2826 				/*
2827 				 * Determine which of these two symbols go into
2828 				 * the sort section.  If a mapfile has made
2829 				 * explicit settings of the FLG_SY_*DYNSORT
2830 				 * flags for both symbols, then we do what they
2831 				 * say.  If one has the DYNSORT flags set, we
2832 				 * set the NODYNSORT bit in the other.  And if
2833 				 * neither has an explicit setting, then we
2834 				 * favor the weak symbol because they usually
2835 				 * lack the leading underscore.
2836 				 */
2837 				w_dynbits = wsdp->sd_flags &
2838 				    (FLG_SY_DYNSORT | FLG_SY_NODYNSORT);
2839 				s_dynbits = ssdp->sd_flags &
2840 				    (FLG_SY_DYNSORT | FLG_SY_NODYNSORT);
2841 				if (!(w_dynbits && s_dynbits)) {
2842 					if (s_dynbits) {
2843 						if (s_dynbits == FLG_SY_DYNSORT)
2844 							wsdp->sd_flags |=
2845 							    FLG_SY_NODYNSORT;
2846 					} else if (w_dynbits !=
2847 					    FLG_SY_NODYNSORT) {
2848 						ssdp->sd_flags |=
2849 						    FLG_SY_NODYNSORT;
2850 					}
2851 				}
2852 				break;
2853 			}
2854 		}
2855 	}
2856 
2857 	/*
2858 	 * Having processed all symbols, under -z symbolcap, reprocess any
2859 	 * symbols that are being translated from global to locals.  The symbol
2860 	 * pair that has been collected defines the original symbol (c_osdp),
2861 	 * which will become a local, and the new symbol (c_nsdp), which will
2862 	 * become a reference (UNDEF) for the original.
2863 	 *
2864 	 * Scan these symbol pairs looking for weak symbols, which have non-weak
2865 	 * aliases.  There is no need to translate both of these symbols to
2866 	 * locals, only the global is necessary.
2867 	 */
2868 	if (cappairs) {
2869 		Aliste		idx1;
2870 		Cap_pair	*cpp1;
2871 
2872 		for (ALIST_TRAVERSE(cappairs, idx1, cpp1)) {
2873 			Sym_desc	*sdp1 = cpp1->c_osdp;
2874 			Sym		*sym1 = sdp1->sd_sym;
2875 			uchar_t		bind1 = ELF_ST_BIND(sym1->st_info);
2876 			Aliste		idx2;
2877 			Cap_pair	*cpp2;
2878 
2879 			/*
2880 			 * If this symbol isn't weak, it's capability member is
2881 			 * retained for the creation of a local symbol.
2882 			 */
2883 			if (bind1 != STB_WEAK)
2884 				continue;
2885 
2886 			/*
2887 			 * If this is a weak symbol, traverse the capabilities
2888 			 * list again to determine if a corresponding non-weak
2889 			 * symbol exists.
2890 			 */
2891 			for (ALIST_TRAVERSE(cappairs, idx2, cpp2)) {
2892 				Sym_desc	*sdp2 = cpp2->c_osdp;
2893 				Sym		*sym2 = sdp2->sd_sym;
2894 				uchar_t		bind2 =
2895 				    ELF_ST_BIND(sym2->st_info);
2896 
2897 				if ((cpp1 == cpp2) ||
2898 				    (cpp1->c_group != cpp2->c_group) ||
2899 				    (sym1->st_value != sym2->st_value) ||
2900 				    (bind2 == STB_WEAK))
2901 					continue;
2902 
2903 				/*
2904 				 * The weak symbol (sym1) has a non-weak (sym2)
2905 				 * counterpart.  There's no point in translating
2906 				 * both of these equivalent symbols to locals.
2907 				 * Add this symbol capability alias to the
2908 				 * capabilities family information, and remove
2909 				 * the weak symbol.
2910 				 */
2911 				if (ld_cap_add_family(ofl, cpp2->c_nsdp,
2912 				    cpp1->c_nsdp, NULL, NULL) == S_ERROR)
2913 					return (S_ERROR);
2914 
2915 				free((void *)cpp1->c_osdp);
2916 				(void) alist_delete(cappairs, &idx1);
2917 			}
2918 		}
2919 
2920 		DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD));
2921 
2922 		/*
2923 		 * The capability pairs information now represents all the
2924 		 * global symbols that need transforming to locals.  These
2925 		 * local symbols are renamed using their group identifiers.
2926 		 */
2927 		for (ALIST_TRAVERSE(cappairs, idx1, cpp1)) {
2928 			Sym_desc	*osdp = cpp1->c_osdp;
2929 			Objcapset	*capset;
2930 			size_t		nsize, tsize;
2931 			const char	*oname;
2932 			char		*cname, *idstr;
2933 			Sym		*csym;
2934 
2935 			/*
2936 			 * If the local symbol has not yet been translated
2937 			 * convert it to a local symbol with a name.
2938 			 */
2939 			if ((osdp->sd_flags & FLG_SY_CAP) != 0)
2940 				continue;
2941 
2942 			/*
2943 			 * As we're converting object capabilities to symbol
2944 			 * capabilities, obtain the capabilities set for this
2945 			 * object, so as to retrieve the CA_SUNW_ID value.
2946 			 */
2947 			capset = &cpp1->c_group->cg_set;
2948 
2949 			/*
2950 			 * Create a new name from the existing symbol and the
2951 			 * capabilities group identifier.  Note, the delimiter
2952 			 * between the symbol name and identifier name is hard-
2953 			 * coded here (%), so that we establish a convention
2954 			 * for transformed symbol names.
2955 			 */
2956 			oname = osdp->sd_name;
2957 
2958 			idstr = capset->oc_id.cs_str;
2959 			nsize = strlen(oname);
2960 			tsize = nsize + 1 + strlen(idstr) + 1;
2961 			if ((cname = libld_malloc(tsize)) == 0)
2962 				return (S_ERROR);
2963 
2964 			(void) strcpy(cname, oname);
2965 			cname[nsize++] = '%';
2966 			(void) strcpy(&cname[nsize], idstr);
2967 
2968 			/*
2969 			 * Allocate a new symbol table entry, transform this
2970 			 * symbol to a local, and assign the new name.
2971 			 */
2972 			if ((csym = libld_malloc(sizeof (Sym))) == NULL)
2973 				return (S_ERROR);
2974 
2975 			*csym = *osdp->sd_sym;
2976 			csym->st_info = ELF_ST_INFO(STB_LOCAL,
2977 			    ELF_ST_TYPE(osdp->sd_sym->st_info));
2978 
2979 			osdp->sd_name = cname;
2980 			osdp->sd_sym = csym;
2981 			osdp->sd_flags = FLG_SY_CAP;
2982 
2983 			/*
2984 			 * Keep track of this new local symbol.  As -z symbolcap
2985 			 * can only be used to create a relocatable object, a
2986 			 * dynamic symbol table can't exist.  Ensure there is
2987 			 * space reserved in the string table.
2988 			 */
2989 			ofl->ofl_caploclcnt++;
2990 			if (st_insert(ofl->ofl_strtab, cname) == -1)
2991 				return (S_ERROR);
2992 
2993 			DBG_CALL(Dbg_syms_cap_local(ofl, cpp1->c_ndx,
2994 			    cname, csym, osdp));
2995 
2996 			/*
2997 			 * Establish this capability pair as a family.
2998 			 */
2999 			if (ld_cap_add_family(ofl, cpp1->c_nsdp, osdp,
3000 			    cpp1->c_group, &ifl->ifl_caps->ca_syms) == S_ERROR)
3001 				return (S_ERROR);
3002 		}
3003 	}
3004 
3005 	return (1);
3006 
3007 #undef SYM_LOC_BADADDR
3008 }
3009 
3010 /*
3011  * Add an undefined symbol to the symbol table.  The reference originates from
3012  * the location identified by the message id (mid).  These references can
3013  * originate from command line options such as -e, -u, -initarray, etc.
3014  * (identified with MSG_INTL(MSG_STR_COMMAND)), or from internally generated
3015  * TLS relocation references (identified with MSG_INTL(MSG_STR_TLSREL)).
3016  */
3017 Sym_desc *
3018 ld_sym_add_u(const char *name, Ofl_desc *ofl, Msg mid)
3019 {
3020 	Sym		*sym;
3021 	Ifl_desc	*ifl = NULL, *_ifl;
3022 	Sym_desc	*sdp;
3023 	Word		hash;
3024 	Aliste		idx;
3025 	avl_index_t	where;
3026 	const char	*reference = MSG_INTL(mid);
3027 
3028 	/*
3029 	 * As an optimization, determine whether we've already generated this
3030 	 * reference.  If the symbol doesn't already exist we'll create it.
3031 	 * Or if the symbol does exist from a different source, we'll resolve
3032 	 * the conflict.
3033 	 */
3034 	/* LINTED */
3035 	hash = (Word)elf_hash(name);
3036 	if ((sdp = ld_sym_find(name, hash, &where, ofl)) != NULL) {
3037 		if ((sdp->sd_sym->st_shndx == SHN_UNDEF) &&
3038 		    (sdp->sd_file->ifl_name == reference))
3039 			return (sdp);
3040 	}
3041 
3042 	/*
3043 	 * Determine whether a pseudo input file descriptor exists to represent
3044 	 * the command line, as any global symbol needs an input file descriptor
3045 	 * during any symbol resolution (refer to map_ifl() which provides a
3046 	 * similar method for adding symbols from mapfiles).
3047 	 */
3048 	for (APLIST_TRAVERSE(ofl->ofl_objs, idx, _ifl))
3049 		if (strcmp(_ifl->ifl_name, reference) == 0) {
3050 			ifl = _ifl;
3051 			break;
3052 		}
3053 
3054 	/*
3055 	 * If no descriptor exists create one.
3056 	 */
3057 	if (ifl == NULL) {
3058 		if ((ifl = libld_calloc(sizeof (Ifl_desc), 1)) == NULL)
3059 			return ((Sym_desc *)S_ERROR);
3060 		ifl->ifl_name = reference;
3061 		ifl->ifl_flags = FLG_IF_NEEDED | FLG_IF_FILEREF;
3062 		if ((ifl->ifl_ehdr = libld_calloc(sizeof (Ehdr), 1)) == NULL)
3063 			return ((Sym_desc *)S_ERROR);
3064 		ifl->ifl_ehdr->e_type = ET_REL;
3065 
3066 		if (aplist_append(&ofl->ofl_objs, ifl, AL_CNT_OFL_OBJS) == NULL)
3067 			return ((Sym_desc *)S_ERROR);
3068 	}
3069 
3070 	/*
3071 	 * Allocate a symbol structure and add it to the global symbol table.
3072 	 */
3073 	if ((sym = libld_calloc(sizeof (Sym), 1)) == NULL)
3074 		return ((Sym_desc *)S_ERROR);
3075 	sym->st_info = ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE);
3076 	sym->st_shndx = SHN_UNDEF;
3077 
3078 	DBG_CALL(Dbg_syms_process(ofl->ofl_lml, ifl));
3079 	if (sdp == NULL) {
3080 		DBG_CALL(Dbg_syms_global(ofl->ofl_lml, 0, name));
3081 		if ((sdp = ld_sym_enter(name, sym, hash, ifl, ofl, 0, SHN_UNDEF,
3082 		    0, &where)) == (Sym_desc *)S_ERROR)
3083 			return ((Sym_desc *)S_ERROR);
3084 	} else if (ld_sym_resolve(sdp, sym, ifl, ofl, 0,
3085 	    SHN_UNDEF, 0) == S_ERROR)
3086 		return ((Sym_desc *)S_ERROR);
3087 
3088 	sdp->sd_flags &= ~FLG_SY_CLEAN;
3089 	sdp->sd_flags |= FLG_SY_CMDREF;
3090 
3091 	return (sdp);
3092 }
3093 
3094 /*
3095  * STT_SECTION symbols have their st_name field set to NULL, and consequently
3096  * have no name. Generate a name suitable for diagnostic use for such a symbol
3097  * and store it in the input section descriptor. The resulting name will be
3098  * of the form:
3099  *
3100  *	"XXX (section)"
3101  *
3102  * where XXX is the name of the section.
3103  *
3104  * entry:
3105  *	isc - Input section associated with the symbol.
3106  *	fmt - NULL, or format string to use.
3107  *
3108  * exit:
3109  *	Sets isp->is_sym_name to the allocated string. Returns the
3110  *	string pointer, or NULL on allocation failure.
3111  */
3112 const const char *
3113 ld_stt_section_sym_name(Is_desc *isp)
3114 {
3115 	const char	*fmt;
3116 	char		*str;
3117 	size_t		len;
3118 
3119 	if ((isp == NULL) || (isp->is_name == NULL))
3120 		return (NULL);
3121 
3122 	if (isp->is_sym_name == NULL) {
3123 		fmt = (isp->is_flags & FLG_IS_GNSTRMRG) ?
3124 		    MSG_INTL(MSG_STR_SECTION_MSTR) : MSG_INTL(MSG_STR_SECTION);
3125 
3126 		len = strlen(fmt) + strlen(isp->is_name) + 1;
3127 
3128 		if ((str = libld_malloc(len)) == NULL)
3129 			return (NULL);
3130 		(void) snprintf(str, len, fmt, isp->is_name);
3131 		isp->is_sym_name = str;
3132 	}
3133 
3134 	return (isp->is_sym_name);
3135 }
3136