xref: /illumos-gate/usr/src/cmd/sgs/libld/common/update.c (revision 6a634c9d)
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  * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
27  */
28 
29 /*
30  * Update the new output file image, perform virtual address, offset and
31  * displacement calculations on the program headers and sections headers,
32  * and generate any new output section information.
33  */
34 
35 #define	ELF_TARGET_AMD64
36 
37 #include	<stdio.h>
38 #include	<string.h>
39 #include	<unistd.h>
40 #include	<debug.h>
41 #include	"msg.h"
42 #include	"_libld.h"
43 
44 /*
45  * Comparison routine used by qsort() for sorting of the global symbol list
46  * based off of the hashbuckets the symbol will eventually be deposited in.
47  */
48 static int
49 sym_hash_compare(Sym_s_list * s1, Sym_s_list * s2)
50 {
51 	return (s1->sl_hval - s2->sl_hval);
52 }
53 
54 /*
55  * Comparison routine used by qsort() for sorting of dyn[sym|tls]sort section
56  * indices based on the address of the symbols they reference. The
57  * use of the global dynsort_compare_syms variable is needed because
58  * we need to examine the symbols the indices reference. It is safe, because
59  * the linker is single threaded.
60  */
61 Sym *dynsort_compare_syms;
62 
63 static int
64 dynsort_compare(const void *idx1, const void *idx2)
65 {
66 	Sym *s1 = dynsort_compare_syms + *((const Word *) idx1);
67 	Sym *s2 = dynsort_compare_syms + *((const Word *) idx2);
68 
69 	/*
70 	 * Note: the logical computation for this is
71 	 *	(st_value1 - st_value2)
72 	 * However, that is only correct if the address type is smaller
73 	 * than a pointer. Writing it this way makes it immune to the
74 	 * class (32 or 64-bit) of the linker.
75 	 */
76 	return ((s1->st_value < s2->st_value) ? -1 :
77 	    (s1->st_value > s2->st_value));
78 }
79 
80 /*
81  * Scan the sorted symbols, and issue warnings if there are any duplicate
82  * values in the list. We only do this if -zverbose is set, or we are
83  * running with LD_DEBUG defined
84  *
85  * entry:
86  *	ofl - Output file descriptor
87  *	ldynsym - Pointer to start of .SUNW_ldynsym section that the
88  *		sort section indexes reference.
89  *	symsort - Pointer to start of .SUNW_dynsymsort or .SUNW_dyntlssort
90  *		section.
91  *	n - # of indices in symsort array
92  *	secname - Name of the symsort section.
93  *
94  * exit:
95  *	If the symsort section contains indexes to more than one
96  *	symbol with the same address value, a warning is issued.
97  */
98 static void
99 dynsort_dupwarn(Ofl_desc *ofl, Sym *ldynsym, const char *str,
100     Word *symsort, Word n, const char *secname)
101 {
102 	int zverbose = (ofl->ofl_flags & FLG_OF_VERBOSE) != 0;
103 	Word ndx, cmp_ndx;
104 	Addr addr, cmp_addr;
105 
106 	/* Nothing to do if -zverbose or LD_DEBUG are not active */
107 	if (!(zverbose || DBG_ENABLED))
108 		return;
109 
110 	cmp_ndx = 0;
111 	cmp_addr = ldynsym[symsort[cmp_ndx]].st_value;
112 	for (ndx = 1; ndx < n; ndx++) {
113 		addr = ldynsym[symsort[ndx]].st_value;
114 		if (cmp_addr == addr) {
115 			if (zverbose)
116 				ld_eprintf(ofl, ERR_WARNING,
117 				    MSG_INTL(MSG_SYM_DUPSORTADDR), secname,
118 				    str + ldynsym[symsort[cmp_ndx]].st_name,
119 				    str + ldynsym[symsort[ndx]].st_name,
120 				    EC_ADDR(addr));
121 			DBG_CALL(Dbg_syms_dup_sort_addr(ofl->ofl_lml, secname,
122 			    str + ldynsym[symsort[cmp_ndx]].st_name,
123 			    str + ldynsym[symsort[ndx]].st_name,
124 			    EC_ADDR(addr)));
125 		} else {	/* Not a dup. Move reference up */
126 			cmp_ndx = ndx;
127 			cmp_addr = addr;
128 		}
129 	}
130 }
131 
132 /*
133  * Build and update any output symbol tables.  Here we work on all the symbol
134  * tables at once to reduce the duplication of symbol and string manipulation.
135  * Symbols and their associated strings are copied from the read-only input
136  * file images to the output image and their values and index's updated in the
137  * output image.
138  */
139 static Addr
140 update_osym(Ofl_desc *ofl)
141 {
142 	/*
143 	 * There are several places in this function where we wish
144 	 * to insert a symbol index to the combined .SUNW_ldynsym/.dynsym
145 	 * symbol table into one of the two sort sections (.SUNW_dynsymsort
146 	 * or .SUNW_dyntlssort), if that symbol has the right attributes.
147 	 * This macro is used to generate the necessary code from a single
148 	 * specification.
149 	 *
150 	 * entry:
151 	 *	_sdp, _sym, _type - As per DYNSORT_COUNT. See _libld.h
152 	 *	_sym_ndx - Index that _sym will have in the combined
153 	 *		.SUNW_ldynsym/.dynsym symbol table.
154 	 */
155 #define	ADD_TO_DYNSORT(_sdp, _sym, _type, _sym_ndx) \
156 	{ \
157 		Word *_dynsort_arr, *_dynsort_ndx; \
158 		\
159 		if (dynsymsort_symtype[_type]) { \
160 			_dynsort_arr = dynsymsort; \
161 			_dynsort_ndx = &dynsymsort_ndx; \
162 		} else if (_type == STT_TLS) { \
163 			_dynsort_arr = dyntlssort; \
164 			_dynsort_ndx = &dyntlssort_ndx; \
165 		} else { \
166 			_dynsort_arr = NULL; \
167 		} \
168 		if ((_dynsort_arr != NULL) && DYNSORT_TEST_ATTR(_sdp, _sym)) \
169 		    _dynsort_arr[(*_dynsort_ndx)++] = _sym_ndx; \
170 	}
171 
172 	Sym_desc	*sdp;
173 	Sym_avlnode	*sav;
174 	Sg_desc		*sgp, *tsgp = NULL, *dsgp = NULL, *esgp = NULL;
175 	Os_desc		*osp, *iosp = NULL, *fosp = NULL;
176 	Is_desc		*isc;
177 	Ifl_desc	*ifl;
178 	Word		bssndx, etext_ndx, edata_ndx = 0, end_ndx, start_ndx;
179 	Word		end_abs = 0, etext_abs = 0, edata_abs;
180 	Word		tlsbssndx = 0, parexpnndx;
181 #if	defined(_ELF64)
182 	Word		lbssndx = 0;
183 	Addr		lbssaddr = 0;
184 #endif
185 	Addr		bssaddr, etext = 0, edata = 0, end = 0, start = 0;
186 	Addr		tlsbssaddr = 0;
187 	Addr 		parexpnbase, parexpnaddr;
188 	int		start_set = 0;
189 	Sym		_sym = {0}, *sym, *symtab = NULL;
190 	Sym		*dynsym = NULL, *ldynsym = NULL;
191 	Word		symtab_ndx = 0;		/* index into .symtab */
192 	Word		symtab_gbl_bndx;	/* .symtab ndx 1st global */
193 	Word		ldynsym_ndx = 0;	/* index into .SUNW_ldynsym */
194 	Word		dynsym_ndx = 0;		/* index into .dynsym */
195 	Word		scopesym_ndx = 0;	/* index into scoped symbols */
196 	Word		scopesym_bndx = 0;	/* .symtab ndx 1st scoped sym */
197 	Word		ldynscopesym_ndx = 0;	/* index to ldynsym scoped */
198 						/*	symbols */
199 	Word		*dynsymsort = NULL;	/* SUNW_dynsymsort index */
200 						/*	vector */
201 	Word		*dyntlssort = NULL;	/* SUNW_dyntlssort index */
202 						/*	vector */
203 	Word		dynsymsort_ndx;		/* index dynsymsort array */
204 	Word		dyntlssort_ndx;		/* index dyntlssort array */
205 	Word		*symndx;		/* symbol index (for */
206 						/*	relocation use) */
207 	Word		*symshndx = NULL;	/* .symtab_shndx table */
208 	Word		*dynshndx = NULL;	/* .dynsym_shndx table */
209 	Word		*ldynshndx = NULL;	/* .SUNW_ldynsym_shndx table */
210 	Word		ldynsym_cnt = NULL;	/* number of items in */
211 						/*	.SUNW_ldynsym */
212 	Str_tbl		*shstrtab;
213 	Str_tbl		*strtab;
214 	Str_tbl		*dynstr;
215 	Word		*hashtab;	/* hash table pointer */
216 	Word		*hashbkt;	/* hash table bucket pointer */
217 	Word		*hashchain;	/* hash table chain pointer */
218 	Wk_desc		*wkp;
219 	Alist		*weak = NULL;
220 	ofl_flag_t	flags = ofl->ofl_flags;
221 	Versym		*versym;
222 	Gottable	*gottable;	/* used for display got debugging */
223 					/*	information */
224 	Syminfo		*syminfo;
225 	Sym_s_list	*sorted_syms;	/* table to hold sorted symbols */
226 	Word		ssndx;		/* global index into sorted_syms */
227 	Word		scndx;		/* scoped index into sorted_syms */
228 	size_t		stoff;		/* string offset */
229 	Aliste		idx1;
230 
231 	/*
232 	 * Initialize pointers to the symbol table entries and the symbol
233 	 * table strings.  Skip the first symbol entry and the first string
234 	 * table byte.  Note that if we are not generating any output symbol
235 	 * tables we must still generate and update internal copies so
236 	 * that the relocation phase has the correct information.
237 	 */
238 	if (!(flags & FLG_OF_STRIP) || (flags & FLG_OF_RELOBJ) ||
239 	    ((flags & FLG_OF_STATIC) && ofl->ofl_osversym)) {
240 		symtab = (Sym *)ofl->ofl_ossymtab->os_outdata->d_buf;
241 		symtab[symtab_ndx++] = _sym;
242 		if (ofl->ofl_ossymshndx)
243 			symshndx =
244 			    (Word *)ofl->ofl_ossymshndx->os_outdata->d_buf;
245 	}
246 	if (OFL_ALLOW_DYNSYM(ofl)) {
247 		dynsym = (Sym *)ofl->ofl_osdynsym->os_outdata->d_buf;
248 		dynsym[dynsym_ndx++] = _sym;
249 		/*
250 		 * If we are also constructing a .SUNW_ldynsym section
251 		 * to contain local function symbols, then set it up too.
252 		 */
253 		if (ofl->ofl_osldynsym) {
254 			ldynsym = (Sym *)ofl->ofl_osldynsym->os_outdata->d_buf;
255 			ldynsym[ldynsym_ndx++] = _sym;
256 			ldynsym_cnt = 1 + ofl->ofl_dynlocscnt +
257 			    ofl->ofl_dynscopecnt;
258 
259 			/*
260 			 * If there is a SUNW_ldynsym, then there may also
261 			 * be a .SUNW_dynsymsort and/or .SUNW_dyntlssort
262 			 * sections, used to collect indices of function
263 			 * and data symbols sorted by address order.
264 			 */
265 			if (ofl->ofl_osdynsymsort) {	/* .SUNW_dynsymsort */
266 				dynsymsort = (Word *)
267 				    ofl->ofl_osdynsymsort->os_outdata->d_buf;
268 				dynsymsort_ndx = 0;
269 			}
270 			if (ofl->ofl_osdyntlssort) {	/* .SUNW_dyntlssort */
271 				dyntlssort = (Word *)
272 				    ofl->ofl_osdyntlssort->os_outdata->d_buf;
273 				dyntlssort_ndx = 0;
274 			}
275 		}
276 
277 		/*
278 		 * Initialize the hash table.
279 		 */
280 		hashtab = (Word *)(ofl->ofl_oshash->os_outdata->d_buf);
281 		hashbkt = &hashtab[2];
282 		hashchain = &hashtab[2 + ofl->ofl_hashbkts];
283 		hashtab[0] = ofl->ofl_hashbkts;
284 		hashtab[1] = DYNSYM_ALL_CNT(ofl);
285 		if (ofl->ofl_osdynshndx)
286 			dynshndx =
287 			    (Word *)ofl->ofl_osdynshndx->os_outdata->d_buf;
288 		if (ofl->ofl_osldynshndx)
289 			ldynshndx =
290 			    (Word *)ofl->ofl_osldynshndx->os_outdata->d_buf;
291 	}
292 
293 	/*
294 	 * symndx is the symbol index to be used for relocation processing.  It
295 	 * points to the relevant symtab's (.dynsym or .symtab) symbol ndx.
296 	 */
297 	if (dynsym)
298 		symndx = &dynsym_ndx;
299 	else
300 		symndx = &symtab_ndx;
301 
302 	/*
303 	 * If we have version definitions initialize the version symbol index
304 	 * table.  There is one entry for each symbol which contains the symbols
305 	 * version index.
306 	 */
307 	if (!(flags & FLG_OF_NOVERSEC) &&
308 	    (flags & (FLG_OF_VERNEED | FLG_OF_VERDEF))) {
309 		versym = (Versym *)ofl->ofl_osversym->os_outdata->d_buf;
310 		versym[0] = NULL;
311 	} else
312 		versym = NULL;
313 
314 	/*
315 	 * If syminfo section exists be prepared to fill it in.
316 	 */
317 	if (ofl->ofl_ossyminfo) {
318 		syminfo = ofl->ofl_ossyminfo->os_outdata->d_buf;
319 		syminfo[0].si_flags = SYMINFO_CURRENT;
320 	} else
321 		syminfo = NULL;
322 
323 	/*
324 	 * Setup our string tables.
325 	 */
326 	shstrtab = ofl->ofl_shdrsttab;
327 	strtab = ofl->ofl_strtab;
328 	dynstr = ofl->ofl_dynstrtab;
329 
330 	DBG_CALL(Dbg_syms_sec_title(ofl->ofl_lml));
331 
332 	/*
333 	 * Put output file name to the first .symtab and .SUNW_ldynsym symbol.
334 	 */
335 	if (symtab) {
336 		(void) st_setstring(strtab, ofl->ofl_name, &stoff);
337 		sym = &symtab[symtab_ndx++];
338 		/* LINTED */
339 		sym->st_name = stoff;
340 		sym->st_value = 0;
341 		sym->st_size = 0;
342 		sym->st_info = ELF_ST_INFO(STB_LOCAL, STT_FILE);
343 		sym->st_other = 0;
344 		sym->st_shndx = SHN_ABS;
345 
346 		if (versym && !dynsym)
347 			versym[1] = 0;
348 	}
349 	if (ldynsym) {
350 		(void) st_setstring(dynstr, ofl->ofl_name, &stoff);
351 		sym = &ldynsym[ldynsym_ndx];
352 		/* LINTED */
353 		sym->st_name = stoff;
354 		sym->st_value = 0;
355 		sym->st_size = 0;
356 		sym->st_info = ELF_ST_INFO(STB_LOCAL, STT_FILE);
357 		sym->st_other = 0;
358 		sym->st_shndx = SHN_ABS;
359 
360 		/* Scoped symbols get filled in global loop below */
361 		ldynscopesym_ndx = ldynsym_ndx + 1;
362 		ldynsym_ndx += ofl->ofl_dynscopecnt;
363 	}
364 
365 	/*
366 	 * If we are to display GOT summary information, then allocate
367 	 * the buffer to 'cache' the GOT symbols into now.
368 	 */
369 	if (DBG_ENABLED) {
370 		if ((ofl->ofl_gottable = gottable =
371 		    libld_calloc(ofl->ofl_gotcnt, sizeof (Gottable))) == NULL)
372 			return ((Addr)S_ERROR);
373 	}
374 
375 	/*
376 	 * Traverse the program headers.  Determine the last executable segment
377 	 * and the last data segment so that we can update etext and edata. If
378 	 * we have empty segments (reservations) record them for setting _end.
379 	 */
380 	for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
381 		Phdr	*phd = &(sgp->sg_phdr);
382 		Os_desc	*osp;
383 		Aliste	idx2;
384 
385 		if (phd->p_type == PT_LOAD) {
386 			if (sgp->sg_osdescs != NULL) {
387 				Word	_flags = phd->p_flags & (PF_W | PF_R);
388 
389 				if (_flags == PF_R)
390 					tsgp = sgp;
391 				else if (_flags == (PF_W | PF_R))
392 					dsgp = sgp;
393 			} else if (sgp->sg_flags & FLG_SG_EMPTY)
394 				esgp = sgp;
395 		}
396 
397 		/*
398 		 * Generate a section symbol for each output section.
399 		 */
400 		for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
401 			Word	sectndx;
402 
403 			sym = &_sym;
404 			sym->st_value = osp->os_shdr->sh_addr;
405 			sym->st_info = ELF_ST_INFO(STB_LOCAL, STT_SECTION);
406 			/* LINTED */
407 			sectndx = elf_ndxscn(osp->os_scn);
408 
409 			if (symtab) {
410 				if (sectndx >= SHN_LORESERVE) {
411 					symshndx[symtab_ndx] = sectndx;
412 					sym->st_shndx = SHN_XINDEX;
413 				} else {
414 					/* LINTED */
415 					sym->st_shndx = (Half)sectndx;
416 				}
417 				symtab[symtab_ndx++] = *sym;
418 			}
419 
420 			if (dynsym && (osp->os_flags & FLG_OS_OUTREL))
421 				dynsym[dynsym_ndx++] = *sym;
422 
423 			if ((dynsym == NULL) ||
424 			    (osp->os_flags & FLG_OS_OUTREL)) {
425 				if (versym)
426 					versym[*symndx - 1] = 0;
427 				osp->os_identndx = *symndx - 1;
428 				DBG_CALL(Dbg_syms_sec_entry(ofl->ofl_lml,
429 				    osp->os_identndx, sgp, osp));
430 			}
431 
432 			/*
433 			 * Generate the .shstrtab for this section.
434 			 */
435 			(void) st_setstring(shstrtab, osp->os_name, &stoff);
436 			osp->os_shdr->sh_name = (Word)stoff;
437 
438 			/*
439 			 * Find the section index for our special symbols.
440 			 */
441 			if (sgp == tsgp) {
442 				/* LINTED */
443 				etext_ndx = elf_ndxscn(osp->os_scn);
444 			} else if (dsgp == sgp) {
445 				if (osp->os_shdr->sh_type != SHT_NOBITS) {
446 					/* LINTED */
447 					edata_ndx = elf_ndxscn(osp->os_scn);
448 				}
449 			}
450 
451 			if (start_set == 0) {
452 				start = sgp->sg_phdr.p_vaddr;
453 				/* LINTED */
454 				start_ndx = elf_ndxscn(osp->os_scn);
455 				start_set++;
456 			}
457 
458 			/*
459 			 * While we're here, determine whether a .init or .fini
460 			 * section exist.
461 			 */
462 			if ((iosp == NULL) && (strcmp(osp->os_name,
463 			    MSG_ORIG(MSG_SCN_INIT)) == 0))
464 				iosp = osp;
465 			if ((fosp == NULL) && (strcmp(osp->os_name,
466 			    MSG_ORIG(MSG_SCN_FINI)) == 0))
467 				fosp = osp;
468 		}
469 	}
470 
471 	/*
472 	 * Add local register symbols to the .dynsym.  These are required as
473 	 * DT_REGISTER .dynamic entries must have a symbol to reference.
474 	 */
475 	if (ofl->ofl_regsyms && dynsym) {
476 		int	ndx;
477 
478 		for (ndx = 0; ndx < ofl->ofl_regsymsno; ndx++) {
479 			Sym_desc	*rsdp;
480 
481 			if ((rsdp = ofl->ofl_regsyms[ndx]) == NULL)
482 				continue;
483 
484 			if (!SYM_IS_HIDDEN(rsdp) &&
485 			    (ELF_ST_BIND(rsdp->sd_sym->st_info) != STB_LOCAL))
486 				continue;
487 
488 			dynsym[dynsym_ndx] = *(rsdp->sd_sym);
489 			rsdp->sd_symndx = *symndx;
490 
491 			if (dynsym[dynsym_ndx].st_name) {
492 				(void) st_setstring(dynstr, rsdp->sd_name,
493 				    &stoff);
494 				dynsym[dynsym_ndx].st_name = stoff;
495 			}
496 			dynsym_ndx++;
497 		}
498 	}
499 
500 	/*
501 	 * Having traversed all the output segments, warn the user if the
502 	 * traditional text or data segments don't exist.  Otherwise from these
503 	 * segments establish the values for `etext', `edata', `end', `END',
504 	 * and `START'.
505 	 */
506 	if (!(flags & FLG_OF_RELOBJ)) {
507 		Sg_desc	*sgp;
508 
509 		if (tsgp)
510 			etext = tsgp->sg_phdr.p_vaddr + tsgp->sg_phdr.p_filesz;
511 		else {
512 			etext = (Addr)0;
513 			etext_ndx = SHN_ABS;
514 			etext_abs = 1;
515 			if (flags & FLG_OF_VERBOSE)
516 				ld_eprintf(ofl, ERR_WARNING,
517 				    MSG_INTL(MSG_UPD_NOREADSEG));
518 		}
519 		if (dsgp) {
520 			edata = dsgp->sg_phdr.p_vaddr + dsgp->sg_phdr.p_filesz;
521 		} else {
522 			edata = (Addr)0;
523 			edata_ndx = SHN_ABS;
524 			edata_abs = 1;
525 			if (flags & FLG_OF_VERBOSE)
526 				ld_eprintf(ofl, ERR_WARNING,
527 				    MSG_INTL(MSG_UPD_NORDWRSEG));
528 		}
529 
530 		if (dsgp == NULL) {
531 			if (tsgp)
532 				sgp = tsgp;
533 			else
534 				sgp = 0;
535 		} else if (tsgp == NULL)
536 			sgp = dsgp;
537 		else if (dsgp->sg_phdr.p_vaddr > tsgp->sg_phdr.p_vaddr)
538 			sgp = dsgp;
539 		else if (dsgp->sg_phdr.p_vaddr < tsgp->sg_phdr.p_vaddr)
540 			sgp = tsgp;
541 		else {
542 			/*
543 			 * One of the segments must be of zero size.
544 			 */
545 			if (tsgp->sg_phdr.p_memsz)
546 				sgp = tsgp;
547 			else
548 				sgp = dsgp;
549 		}
550 
551 		if (esgp && (esgp->sg_phdr.p_vaddr > sgp->sg_phdr.p_vaddr))
552 			sgp = esgp;
553 
554 		if (sgp) {
555 			end = sgp->sg_phdr.p_vaddr + sgp->sg_phdr.p_memsz;
556 
557 			/*
558 			 * If the last loadable segment is a read-only segment,
559 			 * then the application which uses the symbol _end to
560 			 * find the beginning of writable heap area may cause
561 			 * segmentation violation. We adjust the value of the
562 			 * _end to skip to the next page boundary.
563 			 *
564 			 * 6401812 System interface which returs beginning
565 			 *	   heap would be nice.
566 			 * When the above RFE is implemented, the changes below
567 			 * could be changed in a better way.
568 			 */
569 			if ((sgp->sg_phdr.p_flags & PF_W) == 0)
570 				end = (Addr)S_ROUND(end, sysconf(_SC_PAGESIZE));
571 
572 			/*
573 			 * If we're dealing with a memory reservation there are
574 			 * no sections to establish an index for _end, so assign
575 			 * it as an absolute.
576 			 */
577 			if (sgp->sg_osdescs != NULL) {
578 				/*
579 				 * Determine the last section for this segment.
580 				 */
581 				Os_desc	*osp = sgp->sg_osdescs->apl_data
582 				    [sgp->sg_osdescs->apl_nitems - 1];
583 
584 				/* LINTED */
585 				end_ndx = elf_ndxscn(osp->os_scn);
586 			} else {
587 				end_ndx = SHN_ABS;
588 				end_abs = 1;
589 			}
590 		} else {
591 			end = (Addr) 0;
592 			end_ndx = SHN_ABS;
593 			end_abs = 1;
594 			ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_UPD_NOSEG));
595 		}
596 	}
597 
598 	/*
599 	 * Initialize the scoped symbol table entry point.  This is for all
600 	 * the global symbols that have been scoped to locals and will be
601 	 * filled in during global symbol processing so that we don't have
602 	 * to traverse the globals symbol hash array more than once.
603 	 */
604 	if (symtab) {
605 		scopesym_bndx = symtab_ndx;
606 		scopesym_ndx = scopesym_bndx;
607 		symtab_ndx += ofl->ofl_scopecnt;
608 	}
609 
610 	/*
611 	 * If expanding partially expanded symbols under '-z nopartial',
612 	 * prepare to do that.
613 	 */
614 	if (ofl->ofl_isparexpn) {
615 		osp = ofl->ofl_isparexpn->is_osdesc;
616 		parexpnbase = parexpnaddr = (Addr)(osp->os_shdr->sh_addr +
617 		    ofl->ofl_isparexpn->is_indata->d_off);
618 		/* LINTED */
619 		parexpnndx = elf_ndxscn(osp->os_scn);
620 		ofl->ofl_parexpnndx = osp->os_identndx;
621 	}
622 
623 	/*
624 	 * If we are generating a .symtab collect all the local symbols,
625 	 * assigning a new virtual address or displacement (value).
626 	 */
627 	for (APLIST_TRAVERSE(ofl->ofl_objs, idx1, ifl)) {
628 		Xword		lndx, local = ifl->ifl_locscnt;
629 		Cap_desc	*cdp = ifl->ifl_caps;
630 
631 		for (lndx = 1; lndx < local; lndx++) {
632 			Gotndx		*gnp;
633 			uchar_t		type;
634 			Word		*_symshndx;
635 			int		enter_in_symtab, enter_in_ldynsym;
636 			int		update_done;
637 
638 			sdp = ifl->ifl_oldndx[lndx];
639 			sym = sdp->sd_sym;
640 
641 			/*
642 			 * Assign a got offset if necessary.
643 			 */
644 			if ((ld_targ.t_mr.mr_assign_got != NULL) &&
645 			    (*ld_targ.t_mr.mr_assign_got)(ofl, sdp) == S_ERROR)
646 				return ((Addr)S_ERROR);
647 
648 			if (DBG_ENABLED) {
649 				Aliste	idx2;
650 
651 				for (ALIST_TRAVERSE(sdp->sd_GOTndxs,
652 				    idx2, gnp)) {
653 					gottable->gt_sym = sdp;
654 					gottable->gt_gndx.gn_gotndx =
655 					    gnp->gn_gotndx;
656 					gottable->gt_gndx.gn_addend =
657 					    gnp->gn_addend;
658 					gottable++;
659 				}
660 			}
661 
662 			if ((type = ELF_ST_TYPE(sym->st_info)) == STT_SECTION)
663 				continue;
664 
665 			/*
666 			 * Ignore any symbols that have been marked as invalid
667 			 * during input processing.  Providing these aren't used
668 			 * for relocation they'll just be dropped from the
669 			 * output image.
670 			 */
671 			if (sdp->sd_flags & FLG_SY_INVALID)
672 				continue;
673 
674 			/*
675 			 * If the section that this symbol was associated
676 			 * with has been discarded - then we discard
677 			 * the local symbol along with it.
678 			 */
679 			if (sdp->sd_flags & FLG_SY_ISDISC)
680 				continue;
681 
682 			/*
683 			 * If this symbol is from a different file
684 			 * than the input descriptor we are processing,
685 			 * treat it as if it has FLG_SY_ISDISC set.
686 			 * This happens when sloppy_comdat_reloc()
687 			 * replaces a symbol to a discarded comdat section
688 			 * with an equivalent symbol from a different
689 			 * file. We only want to enter such a symbol
690 			 * once --- as part of the file that actually
691 			 * supplies it.
692 			 */
693 			if (ifl != sdp->sd_file)
694 				continue;
695 
696 			/*
697 			 * Generate an output symbol to represent this input
698 			 * symbol.  Even if the symbol table is to be stripped
699 			 * we still need to update any local symbols that are
700 			 * used during relocation.
701 			 */
702 			enter_in_symtab = symtab &&
703 			    (!(ofl->ofl_flags & FLG_OF_REDLSYM) ||
704 			    sdp->sd_move);
705 			enter_in_ldynsym = ldynsym && sdp->sd_name &&
706 			    ldynsym_symtype[type] &&
707 			    !(ofl->ofl_flags & FLG_OF_REDLSYM);
708 			_symshndx = NULL;
709 
710 			if (enter_in_symtab) {
711 				if (!dynsym)
712 					sdp->sd_symndx = *symndx;
713 				symtab[symtab_ndx] = *sym;
714 
715 				/*
716 				 * Provided this isn't an unnamed register
717 				 * symbol, update its name.
718 				 */
719 				if (((sdp->sd_flags & FLG_SY_REGSYM) == 0) ||
720 				    symtab[symtab_ndx].st_name) {
721 					(void) st_setstring(strtab,
722 					    sdp->sd_name, &stoff);
723 					symtab[symtab_ndx].st_name = stoff;
724 				}
725 				sdp->sd_flags &= ~FLG_SY_CLEAN;
726 				if (symshndx)
727 					_symshndx = &symshndx[symtab_ndx];
728 				sdp->sd_sym = sym = &symtab[symtab_ndx++];
729 
730 				if ((sdp->sd_flags & FLG_SY_SPECSEC) &&
731 				    (sym->st_shndx == SHN_ABS) &&
732 				    !enter_in_ldynsym)
733 					continue;
734 			} else if (enter_in_ldynsym) {
735 				/*
736 				 * Not using symtab, but we do have ldynsym
737 				 * available.
738 				 */
739 				ldynsym[ldynsym_ndx] = *sym;
740 				(void) st_setstring(dynstr, sdp->sd_name,
741 				    &stoff);
742 				ldynsym[ldynsym_ndx].st_name = stoff;
743 
744 				sdp->sd_flags &= ~FLG_SY_CLEAN;
745 				if (ldynshndx)
746 					_symshndx = &ldynshndx[ldynsym_ndx];
747 				sdp->sd_sym = sym = &ldynsym[ldynsym_ndx];
748 				/* Add it to sort section if it qualifies */
749 				ADD_TO_DYNSORT(sdp, sym, type, ldynsym_ndx);
750 				ldynsym_ndx++;
751 			} else {	/* Not using symtab or ldynsym */
752 				/*
753 				 * If this symbol requires modifying to provide
754 				 * for a relocation or move table update, make
755 				 * a copy of it.
756 				 */
757 				if (!(sdp->sd_flags & FLG_SY_UPREQD) &&
758 				    !(sdp->sd_move))
759 					continue;
760 				if ((sdp->sd_flags & FLG_SY_SPECSEC) &&
761 				    (sym->st_shndx == SHN_ABS))
762 					continue;
763 
764 				if (ld_sym_copy(sdp) == S_ERROR)
765 					return ((Addr)S_ERROR);
766 				sym = sdp->sd_sym;
767 			}
768 
769 			/*
770 			 * Update the symbols contents if necessary.
771 			 */
772 			update_done = 0;
773 			if (type == STT_FILE) {
774 				sdp->sd_shndx = sym->st_shndx = SHN_ABS;
775 				sdp->sd_flags |= FLG_SY_SPECSEC;
776 				update_done = 1;
777 			}
778 
779 			/*
780 			 * If we are expanding the locally bound partially
781 			 * initialized symbols, then update the address here.
782 			 */
783 			if (ofl->ofl_isparexpn &&
784 			    (sdp->sd_flags & FLG_SY_PAREXPN) && !update_done) {
785 				sym->st_shndx = parexpnndx;
786 				sdp->sd_isc = ofl->ofl_isparexpn;
787 				sym->st_value = parexpnaddr;
788 				parexpnaddr += sym->st_size;
789 				if ((flags & FLG_OF_RELOBJ) == 0)
790 					sym->st_value -= parexpnbase;
791 			}
792 
793 			/*
794 			 * If this isn't an UNDEF symbol (ie. an input section
795 			 * is associated), update the symbols value and index.
796 			 */
797 			if (((isc = sdp->sd_isc) != NULL) && !update_done) {
798 				Word	sectndx;
799 
800 				osp = isc->is_osdesc;
801 				/* LINTED */
802 				sym->st_value +=
803 				    (Off)_elf_getxoff(isc->is_indata);
804 				if ((flags & FLG_OF_RELOBJ) == 0) {
805 					sym->st_value += osp->os_shdr->sh_addr;
806 					/*
807 					 * TLS symbols are relative to
808 					 * the TLS segment.
809 					 */
810 					if ((type == STT_TLS) &&
811 					    (ofl->ofl_tlsphdr)) {
812 						sym->st_value -=
813 						    ofl->ofl_tlsphdr->p_vaddr;
814 					}
815 				}
816 				/* LINTED */
817 				if ((sdp->sd_shndx = sectndx =
818 				    elf_ndxscn(osp->os_scn)) >= SHN_LORESERVE) {
819 					if (_symshndx) {
820 						*_symshndx = sectndx;
821 					}
822 					sym->st_shndx = SHN_XINDEX;
823 				} else {
824 					/* LINTED */
825 					sym->st_shndx = sectndx;
826 				}
827 			}
828 
829 			/*
830 			 * If entering the symbol in both the symtab and the
831 			 * ldynsym, then the one in symtab needs to be
832 			 * copied to ldynsym. If it is only in the ldynsym,
833 			 * then the code above already set it up and we have
834 			 * nothing more to do here.
835 			 */
836 			if (enter_in_symtab && enter_in_ldynsym) {
837 				ldynsym[ldynsym_ndx] = *sym;
838 				(void) st_setstring(dynstr, sdp->sd_name,
839 				    &stoff);
840 				ldynsym[ldynsym_ndx].st_name = stoff;
841 
842 				if (_symshndx && ldynshndx)
843 					ldynshndx[ldynsym_ndx] = *_symshndx;
844 
845 				/* Add it to sort section if it qualifies */
846 				ADD_TO_DYNSORT(sdp, sym, type, ldynsym_ndx);
847 
848 				ldynsym_ndx++;
849 			}
850 		}
851 
852 		/*
853 		 * If this input file has undergone object to symbol
854 		 * capabilities conversion, supply any new capabilities symbols.
855 		 * These symbols are copies of the original global symbols, and
856 		 * follow the existing local symbols that are supplied from this
857 		 * input file (which are identified with a preceding STT_FILE).
858 		 */
859 		if (symtab && cdp && cdp->ca_syms) {
860 			Aliste		idx2;
861 			Cap_sym		*csp;
862 
863 			for (APLIST_TRAVERSE(cdp->ca_syms, idx2, csp)) {
864 				Is_desc	*isp;
865 
866 				sdp = csp->cs_sdp;
867 				sym = sdp->sd_sym;
868 
869 				if ((isp = sdp->sd_isc) != NULL) {
870 					Os_desc	*osp = isp->is_osdesc;
871 
872 					/*
873 					 * Update the symbols value.
874 					 */
875 					/* LINTED */
876 					sym->st_value +=
877 					    (Off)_elf_getxoff(isp->is_indata);
878 					if ((flags & FLG_OF_RELOBJ) == 0)
879 						sym->st_value +=
880 						    osp->os_shdr->sh_addr;
881 
882 					/*
883 					 * Update the symbols section index.
884 					 */
885 					sdp->sd_shndx = sym->st_shndx =
886 					    elf_ndxscn(osp->os_scn);
887 				}
888 
889 				symtab[symtab_ndx] = *sym;
890 				(void) st_setstring(strtab, sdp->sd_name,
891 				    &stoff);
892 				symtab[symtab_ndx].st_name = stoff;
893 				sdp->sd_symndx = symtab_ndx++;
894 			}
895 		}
896 	}
897 
898 	symtab_gbl_bndx = symtab_ndx;	/* .symtab index of 1st global entry */
899 
900 	/*
901 	 * Two special symbols are `_init' and `_fini'.  If these are supplied
902 	 * by crti.o then they are used to represent the total concatenation of
903 	 * the `.init' and `.fini' sections.
904 	 *
905 	 * Determine whether any .init or .fini sections exist.  If these
906 	 * sections exist and a dynamic object is being built, but no `_init'
907 	 * or `_fini' symbols are found, then the user is probably building
908 	 * this object directly from ld(1) rather than using a compiler driver
909 	 * that provides the symbols via crt's.
910 	 *
911 	 * If the .init or .fini section exist, and their associated symbols,
912 	 * determine the size of the sections and updated the symbols value
913 	 * accordingly.
914 	 */
915 	if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_INIT_U), SYM_NOHASH, 0,
916 	    ofl)) != NULL) && (sdp->sd_ref == REF_REL_NEED) && sdp->sd_isc &&
917 	    (sdp->sd_isc->is_osdesc == iosp)) {
918 		if (ld_sym_copy(sdp) == S_ERROR)
919 			return ((Addr)S_ERROR);
920 		sdp->sd_sym->st_size = sdp->sd_isc->is_osdesc->os_shdr->sh_size;
921 
922 	} else if (iosp && !(flags & FLG_OF_RELOBJ)) {
923 		ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SYM_NOCRT),
924 		    MSG_ORIG(MSG_SYM_INIT_U), MSG_ORIG(MSG_SCN_INIT));
925 	}
926 
927 	if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_FINI_U), SYM_NOHASH, 0,
928 	    ofl)) != NULL) && (sdp->sd_ref == REF_REL_NEED) && sdp->sd_isc &&
929 	    (sdp->sd_isc->is_osdesc == fosp)) {
930 		if (ld_sym_copy(sdp) == S_ERROR)
931 			return ((Addr)S_ERROR);
932 		sdp->sd_sym->st_size = sdp->sd_isc->is_osdesc->os_shdr->sh_size;
933 
934 	} else if (fosp && !(flags & FLG_OF_RELOBJ)) {
935 		ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SYM_NOCRT),
936 		    MSG_ORIG(MSG_SYM_FINI_U), MSG_ORIG(MSG_SCN_FINI));
937 	}
938 
939 	/*
940 	 * Assign .bss information for use with updating COMMON symbols.
941 	 */
942 	if (ofl->ofl_isbss) {
943 		isc = ofl->ofl_isbss;
944 		osp = isc->is_osdesc;
945 
946 		bssaddr = osp->os_shdr->sh_addr +
947 		    (Off)_elf_getxoff(isc->is_indata);
948 		/* LINTED */
949 		bssndx = elf_ndxscn(osp->os_scn);
950 	}
951 
952 #if	defined(_ELF64)
953 	/*
954 	 * For amd64 target, assign .lbss information for use
955 	 * with updating LCOMMON symbols.
956 	 */
957 	if ((ld_targ.t_m.m_mach == EM_AMD64) && ofl->ofl_islbss) {
958 		osp = ofl->ofl_islbss->is_osdesc;
959 
960 		lbssaddr = osp->os_shdr->sh_addr +
961 		    (Off)_elf_getxoff(ofl->ofl_islbss->is_indata);
962 		/* LINTED */
963 		lbssndx = elf_ndxscn(osp->os_scn);
964 	}
965 #endif
966 	/*
967 	 * Assign .tlsbss information for use with updating COMMON symbols.
968 	 */
969 	if (ofl->ofl_istlsbss) {
970 		osp = ofl->ofl_istlsbss->is_osdesc;
971 		tlsbssaddr = osp->os_shdr->sh_addr +
972 		    (Off)_elf_getxoff(ofl->ofl_istlsbss->is_indata);
973 		/* LINTED */
974 		tlsbssndx = elf_ndxscn(osp->os_scn);
975 	}
976 
977 	if ((sorted_syms = libld_calloc(ofl->ofl_globcnt +
978 	    ofl->ofl_elimcnt + ofl->ofl_scopecnt,
979 	    sizeof (*sorted_syms))) == NULL)
980 		return ((Addr)S_ERROR);
981 
982 	scndx = 0;
983 	ssndx = ofl->ofl_scopecnt + ofl->ofl_elimcnt;
984 
985 	DBG_CALL(Dbg_syms_up_title(ofl->ofl_lml));
986 
987 	/*
988 	 * Traverse the internal symbol table updating global symbol information
989 	 * and allocating common.
990 	 */
991 	for (sav = avl_first(&ofl->ofl_symavl); sav;
992 	    sav = AVL_NEXT(&ofl->ofl_symavl, sav)) {
993 		Sym	*symptr;
994 		int	local;
995 		int	restore;
996 
997 		sdp = sav->sav_sdp;
998 
999 		/*
1000 		 * Ignore any symbols that have been marked as invalid during
1001 		 * input processing.  Providing these aren't used for
1002 		 * relocation, they will be dropped from the output image.
1003 		 */
1004 		if (sdp->sd_flags & FLG_SY_INVALID) {
1005 			DBG_CALL(Dbg_syms_old(ofl, sdp));
1006 			DBG_CALL(Dbg_syms_ignore(ofl, sdp));
1007 			continue;
1008 		}
1009 
1010 		/*
1011 		 * Only needed symbols are copied to the output symbol table.
1012 		 */
1013 		if (sdp->sd_ref == REF_DYN_SEEN)
1014 			continue;
1015 
1016 		if (SYM_IS_HIDDEN(sdp) && (flags & FLG_OF_PROCRED))
1017 			local = 1;
1018 		else
1019 			local = 0;
1020 
1021 		if (local || (ofl->ofl_hashbkts == 0)) {
1022 			sorted_syms[scndx++].sl_sdp = sdp;
1023 		} else {
1024 			sorted_syms[ssndx].sl_hval = sdp->sd_aux->sa_hash %
1025 			    ofl->ofl_hashbkts;
1026 			sorted_syms[ssndx].sl_sdp = sdp;
1027 			ssndx++;
1028 		}
1029 
1030 		/*
1031 		 * Note - expand the COMMON symbols here because an address
1032 		 * must be assigned to them in the same order that space was
1033 		 * calculated in sym_validate().  If this ordering isn't
1034 		 * followed differing alignment requirements can throw us all
1035 		 * out of whack.
1036 		 *
1037 		 * The expanded .bss global symbol is handled here as well.
1038 		 *
1039 		 * The actual adding entries into the symbol table still occurs
1040 		 * below in hashbucket order.
1041 		 */
1042 		symptr = sdp->sd_sym;
1043 		restore = 0;
1044 		if ((sdp->sd_flags & FLG_SY_PAREXPN) ||
1045 		    ((sdp->sd_flags & FLG_SY_SPECSEC) &&
1046 		    (sdp->sd_shndx = symptr->st_shndx) == SHN_COMMON)) {
1047 
1048 			/*
1049 			 * An expanded symbol goes to a special .data section
1050 			 * prepared for that purpose (ofl->ofl_isparexpn).
1051 			 * Assign COMMON allocations to .bss.
1052 			 * Otherwise leave it as is.
1053 			 */
1054 			if (sdp->sd_flags & FLG_SY_PAREXPN) {
1055 				restore = 1;
1056 				sdp->sd_shndx = parexpnndx;
1057 				sdp->sd_flags &= ~FLG_SY_SPECSEC;
1058 				symptr->st_value = (Xword) S_ROUND(
1059 				    parexpnaddr, symptr->st_value);
1060 				parexpnaddr = symptr->st_value +
1061 				    symptr->st_size;
1062 				sdp->sd_isc = ofl->ofl_isparexpn;
1063 				sdp->sd_flags |= FLG_SY_COMMEXP;
1064 
1065 			} else if (ELF_ST_TYPE(symptr->st_info) != STT_TLS &&
1066 			    (local || !(flags & FLG_OF_RELOBJ))) {
1067 				restore = 1;
1068 				sdp->sd_shndx = bssndx;
1069 				sdp->sd_flags &= ~FLG_SY_SPECSEC;
1070 				symptr->st_value = (Xword)S_ROUND(bssaddr,
1071 				    symptr->st_value);
1072 				bssaddr = symptr->st_value + symptr->st_size;
1073 				sdp->sd_isc = ofl->ofl_isbss;
1074 				sdp->sd_flags |= FLG_SY_COMMEXP;
1075 
1076 			} else if (ELF_ST_TYPE(symptr->st_info) == STT_TLS &&
1077 			    (local || !(flags & FLG_OF_RELOBJ))) {
1078 				restore = 1;
1079 				sdp->sd_shndx = tlsbssndx;
1080 				sdp->sd_flags &= ~FLG_SY_SPECSEC;
1081 				symptr->st_value = (Xword)S_ROUND(tlsbssaddr,
1082 				    symptr->st_value);
1083 				tlsbssaddr = symptr->st_value + symptr->st_size;
1084 				sdp->sd_isc = ofl->ofl_istlsbss;
1085 				sdp->sd_flags |= FLG_SY_COMMEXP;
1086 				/*
1087 				 * TLS symbols are relative to the TLS segment.
1088 				 */
1089 				symptr->st_value -= ofl->ofl_tlsphdr->p_vaddr;
1090 			}
1091 #if	defined(_ELF64)
1092 		} else if ((ld_targ.t_m.m_mach == EM_AMD64) &&
1093 		    (sdp->sd_flags & FLG_SY_SPECSEC) &&
1094 		    ((sdp->sd_shndx = symptr->st_shndx) ==
1095 		    SHN_X86_64_LCOMMON) &&
1096 		    ((local || !(flags & FLG_OF_RELOBJ)))) {
1097 			restore = 1;
1098 			sdp->sd_shndx = lbssndx;
1099 			sdp->sd_flags &= ~FLG_SY_SPECSEC;
1100 			symptr->st_value = (Xword)S_ROUND(lbssaddr,
1101 			    symptr->st_value);
1102 			lbssaddr = symptr->st_value + symptr->st_size;
1103 			sdp->sd_isc = ofl->ofl_islbss;
1104 			sdp->sd_flags |= FLG_SY_COMMEXP;
1105 #endif
1106 		}
1107 
1108 		if (restore != 0) {
1109 			uchar_t		type, bind;
1110 
1111 			/*
1112 			 * Make sure this COMMON symbol is returned to the same
1113 			 * binding as was defined in the original relocatable
1114 			 * object reference.
1115 			 */
1116 			type = ELF_ST_TYPE(symptr->st_info);
1117 			if (sdp->sd_flags & FLG_SY_GLOBREF)
1118 				bind = STB_GLOBAL;
1119 			else
1120 				bind = STB_WEAK;
1121 
1122 			symptr->st_info = ELF_ST_INFO(bind, type);
1123 		}
1124 	}
1125 
1126 	/*
1127 	 * If this is a dynamic object then add any local capabilities symbols.
1128 	 */
1129 	if (dynsym && ofl->ofl_capfamilies) {
1130 		Cap_avlnode	*cav;
1131 
1132 		for (cav = avl_first(ofl->ofl_capfamilies); cav;
1133 		    cav = AVL_NEXT(ofl->ofl_capfamilies, cav)) {
1134 			Cap_sym		*csp;
1135 			Aliste		idx;
1136 
1137 			for (APLIST_TRAVERSE(cav->cn_members, idx, csp)) {
1138 				sdp = csp->cs_sdp;
1139 
1140 				DBG_CALL(Dbg_syms_created(ofl->ofl_lml,
1141 				    sdp->sd_name));
1142 				DBG_CALL(Dbg_syms_entered(ofl, sdp->sd_sym,
1143 				    sdp));
1144 
1145 				dynsym[dynsym_ndx] = *sdp->sd_sym;
1146 
1147 				(void) st_setstring(dynstr, sdp->sd_name,
1148 				    &stoff);
1149 				dynsym[dynsym_ndx].st_name = stoff;
1150 
1151 				sdp->sd_sym = &dynsym[dynsym_ndx];
1152 				sdp->sd_symndx = dynsym_ndx;
1153 
1154 				/*
1155 				 * Indicate that this is a capabilities symbol.
1156 				 * Note, that this identification only provides
1157 				 * information regarding the symbol that is
1158 				 * visible from elfdump(1) -y.  The association
1159 				 * of a symbol to its capabilities is derived
1160 				 * from a .SUNW_capinfo entry.
1161 				 */
1162 				if (syminfo) {
1163 					syminfo[dynsym_ndx].si_flags |=
1164 					    SYMINFO_FLG_CAP;
1165 				}
1166 
1167 				dynsym_ndx++;
1168 			}
1169 		}
1170 	}
1171 
1172 	if (ofl->ofl_hashbkts) {
1173 		qsort(sorted_syms + ofl->ofl_scopecnt + ofl->ofl_elimcnt,
1174 		    ofl->ofl_globcnt, sizeof (Sym_s_list),
1175 		    (int (*)(const void *, const void *))sym_hash_compare);
1176 	}
1177 
1178 	for (ssndx = 0; ssndx < (ofl->ofl_elimcnt + ofl->ofl_scopecnt +
1179 	    ofl->ofl_globcnt); ssndx++) {
1180 		const char	*name;
1181 		Sym		*sym;
1182 		Sym_aux		*sap;
1183 		Half		spec;
1184 		int		local = 0, dynlocal = 0, enter_in_symtab;
1185 		Gotndx		*gnp;
1186 		Word		sectndx;
1187 
1188 		sdp = sorted_syms[ssndx].sl_sdp;
1189 		sectndx = 0;
1190 
1191 		if (symtab)
1192 			enter_in_symtab = 1;
1193 		else
1194 			enter_in_symtab = 0;
1195 
1196 		/*
1197 		 * Assign a got offset if necessary.
1198 		 */
1199 		if ((ld_targ.t_mr.mr_assign_got != NULL) &&
1200 		    (*ld_targ.t_mr.mr_assign_got)(ofl, sdp) == S_ERROR)
1201 			return ((Addr)S_ERROR);
1202 
1203 		if (DBG_ENABLED) {
1204 			Aliste	idx2;
1205 
1206 			for (ALIST_TRAVERSE(sdp->sd_GOTndxs, idx2, gnp)) {
1207 				gottable->gt_sym = sdp;
1208 				gottable->gt_gndx.gn_gotndx = gnp->gn_gotndx;
1209 				gottable->gt_gndx.gn_addend = gnp->gn_addend;
1210 				gottable++;
1211 			}
1212 
1213 			if (sdp->sd_aux && sdp->sd_aux->sa_PLTGOTndx) {
1214 				gottable->gt_sym = sdp;
1215 				gottable->gt_gndx.gn_gotndx =
1216 				    sdp->sd_aux->sa_PLTGOTndx;
1217 				gottable++;
1218 			}
1219 		}
1220 
1221 		/*
1222 		 * If this symbol has been marked as being reduced to local
1223 		 * scope then it will have to be placed in the scoped portion
1224 		 * of the .symtab.  Retain the appropriate index for use in
1225 		 * version symbol indexing and relocation.
1226 		 */
1227 		if (SYM_IS_HIDDEN(sdp) && (flags & FLG_OF_PROCRED)) {
1228 			local = 1;
1229 			if (!(sdp->sd_flags & FLG_SY_ELIM) && !dynsym)
1230 				sdp->sd_symndx = scopesym_ndx;
1231 			else
1232 				sdp->sd_symndx = 0;
1233 
1234 			if (sdp->sd_flags & FLG_SY_ELIM) {
1235 				enter_in_symtab = 0;
1236 			} else if (ldynsym && sdp->sd_sym->st_name &&
1237 			    ldynsym_symtype[
1238 			    ELF_ST_TYPE(sdp->sd_sym->st_info)]) {
1239 				dynlocal = 1;
1240 			}
1241 		} else {
1242 			sdp->sd_symndx = *symndx;
1243 		}
1244 
1245 		/*
1246 		 * Copy basic symbol and string information.
1247 		 */
1248 		name = sdp->sd_name;
1249 		sap = sdp->sd_aux;
1250 
1251 		/*
1252 		 * If we require to record version symbol indexes, update the
1253 		 * associated version symbol information for all defined
1254 		 * symbols.  If a version definition is required any zero value
1255 		 * symbol indexes would have been flagged as undefined symbol
1256 		 * errors, however if we're just scoping these need to fall into
1257 		 * the base of global symbols.
1258 		 */
1259 		if (sdp->sd_symndx && versym) {
1260 			Half	vndx = 0;
1261 
1262 			if (sdp->sd_flags & FLG_SY_MVTOCOMM) {
1263 				vndx = VER_NDX_GLOBAL;
1264 			} else if (sdp->sd_ref == REF_REL_NEED) {
1265 				vndx = sap->sa_overndx;
1266 
1267 				if ((vndx == 0) &&
1268 				    (sdp->sd_sym->st_shndx != SHN_UNDEF)) {
1269 					if (SYM_IS_HIDDEN(sdp))
1270 						vndx = VER_NDX_LOCAL;
1271 					else
1272 						vndx = VER_NDX_GLOBAL;
1273 				}
1274 			} else if ((sdp->sd_ref == REF_DYN_NEED) &&
1275 			    (sap->sa_dverndx > 0) &&
1276 			    (sap->sa_dverndx <= sdp->sd_file->ifl_vercnt) &&
1277 			    (sdp->sd_file->ifl_verndx != NULL)) {
1278 				/* Use index of verneed record */
1279 				vndx = sdp->sd_file->ifl_verndx
1280 				    [sap->sa_dverndx].vi_overndx;
1281 			}
1282 			versym[sdp->sd_symndx] = vndx;
1283 		}
1284 
1285 		/*
1286 		 * If we are creating the .syminfo section then set per symbol
1287 		 * flags here.
1288 		 */
1289 		if (sdp->sd_symndx && syminfo &&
1290 		    !(sdp->sd_flags & FLG_SY_NOTAVAIL)) {
1291 			int	ndx = sdp->sd_symndx;
1292 			APlist	**alpp = &(ofl->ofl_symdtent);
1293 
1294 			if (sdp->sd_flags & FLG_SY_MVTOCOMM)
1295 				/*
1296 				 * Identify a copy relocation symbol.
1297 				 */
1298 				syminfo[ndx].si_flags |= SYMINFO_FLG_COPY;
1299 
1300 			if (sdp->sd_ref == REF_DYN_NEED) {
1301 				/*
1302 				 * A reference is bound to a needed dependency.
1303 				 * Save the syminfo entry, so that when the
1304 				 * .dynamic section has been updated, a
1305 				 * DT_NEEDED entry can be associated
1306 				 * (see update_osyminfo()).
1307 				 */
1308 				if (aplist_append(alpp, sdp,
1309 				    AL_CNT_OFL_SYMINFOSYMS) == NULL)
1310 					return (0);
1311 
1312 				/*
1313 				 * Flag that the symbol has a direct association
1314 				 * with the external reference (this is an old
1315 				 * tagging, that has no real effect by itself).
1316 				 */
1317 				syminfo[ndx].si_flags |= SYMINFO_FLG_DIRECT;
1318 
1319 				/*
1320 				 * Flag any lazy or deferred reference.
1321 				 */
1322 				if (sdp->sd_flags & FLG_SY_LAZYLD)
1323 					syminfo[ndx].si_flags |=
1324 					    SYMINFO_FLG_LAZYLOAD;
1325 				if (sdp->sd_flags & FLG_SY_DEFERRED)
1326 					syminfo[ndx].si_flags |=
1327 					    SYMINFO_FLG_DEFERRED;
1328 
1329 				/*
1330 				 * Enable direct symbol bindings if:
1331 				 *
1332 				 *  -	Symbol was identified with the DIRECT
1333 				 *	keyword in a mapfile.
1334 				 *
1335 				 *  -	Symbol reference has been bound to a
1336 				 * 	dependency which was specified as
1337 				 *	requiring direct bindings with -zdirect.
1338 				 *
1339 				 *  -	All symbol references are required to
1340 				 *	use direct bindings via -Bdirect.
1341 				 */
1342 				if (sdp->sd_flags & FLG_SY_DIR)
1343 					syminfo[ndx].si_flags |=
1344 					    SYMINFO_FLG_DIRECTBIND;
1345 
1346 			} else if ((sdp->sd_flags & FLG_SY_EXTERN) &&
1347 			    (sdp->sd_sym->st_shndx == SHN_UNDEF)) {
1348 				/*
1349 				 * If this symbol has been explicitly defined
1350 				 * as external, and remains unresolved, mark
1351 				 * it as external.
1352 				 */
1353 				syminfo[ndx].si_boundto = SYMINFO_BT_EXTERN;
1354 
1355 			} else if ((sdp->sd_flags & FLG_SY_PARENT) &&
1356 			    (sdp->sd_sym->st_shndx == SHN_UNDEF)) {
1357 				/*
1358 				 * If this symbol has been explicitly defined
1359 				 * to be a reference to a parent object,
1360 				 * indicate whether a direct binding should be
1361 				 * established.
1362 				 */
1363 				syminfo[ndx].si_flags |= SYMINFO_FLG_DIRECT;
1364 				syminfo[ndx].si_boundto = SYMINFO_BT_PARENT;
1365 				if (sdp->sd_flags & FLG_SY_DIR)
1366 					syminfo[ndx].si_flags |=
1367 					    SYMINFO_FLG_DIRECTBIND;
1368 
1369 			} else if (sdp->sd_flags & FLG_SY_STDFLTR) {
1370 				/*
1371 				 * A filter definition.  Although this symbol
1372 				 * can only be a stub, it might be necessary to
1373 				 * prevent external direct bindings.
1374 				 */
1375 				syminfo[ndx].si_flags |= SYMINFO_FLG_FILTER;
1376 				if (sdp->sd_flags & FLG_SY_NDIR)
1377 					syminfo[ndx].si_flags |=
1378 					    SYMINFO_FLG_NOEXTDIRECT;
1379 
1380 			} else if (sdp->sd_flags & FLG_SY_AUXFLTR) {
1381 				/*
1382 				 * An auxiliary filter definition.  By nature,
1383 				 * this definition is direct, in that should the
1384 				 * filtee lookup fail, we'll fall back to this
1385 				 * object.  It may still be necessary to
1386 				 * prevent external direct bindings.
1387 				 */
1388 				syminfo[ndx].si_flags |= SYMINFO_FLG_AUXILIARY;
1389 				if (sdp->sd_flags & FLG_SY_NDIR)
1390 					syminfo[ndx].si_flags |=
1391 					    SYMINFO_FLG_NOEXTDIRECT;
1392 
1393 			} else if ((sdp->sd_ref == REF_REL_NEED) &&
1394 			    (sdp->sd_sym->st_shndx != SHN_UNDEF)) {
1395 				/*
1396 				 * This definition exists within the object
1397 				 * being created.  Provide a default boundto
1398 				 * definition, which may be overridden later.
1399 				 */
1400 				syminfo[ndx].si_boundto = SYMINFO_BT_NONE;
1401 
1402 				/*
1403 				 * Indicate whether it is necessary to prevent
1404 				 * external direct bindings.
1405 				 */
1406 				if (sdp->sd_flags & FLG_SY_NDIR) {
1407 					syminfo[ndx].si_flags |=
1408 					    SYMINFO_FLG_NOEXTDIRECT;
1409 				}
1410 
1411 				/*
1412 				 * Indicate that this symbol is acting as an
1413 				 * individual interposer.
1414 				 */
1415 				if (sdp->sd_flags & FLG_SY_INTPOSE) {
1416 					syminfo[ndx].si_flags |=
1417 					    SYMINFO_FLG_INTERPOSE;
1418 				}
1419 
1420 				/*
1421 				 * Indicate that this symbol is deferred, and
1422 				 * hence should not be bound to during BIND_NOW
1423 				 * relocations.
1424 				 */
1425 				if (sdp->sd_flags & FLG_SY_DEFERRED) {
1426 					syminfo[ndx].si_flags |=
1427 					    SYMINFO_FLG_DEFERRED;
1428 				}
1429 
1430 				/*
1431 				 * If external bindings are allowed, indicate
1432 				 * the binding, and a direct binding if
1433 				 * necessary.
1434 				 */
1435 				if ((sdp->sd_flags & FLG_SY_NDIR) == 0) {
1436 					syminfo[ndx].si_flags |=
1437 					    SYMINFO_FLG_DIRECT;
1438 
1439 					if (sdp->sd_flags & FLG_SY_DIR)
1440 						syminfo[ndx].si_flags |=
1441 						    SYMINFO_FLG_DIRECTBIND;
1442 
1443 					/*
1444 					 * Provide a default boundto definition,
1445 					 * which may be overridden later.
1446 					 */
1447 					syminfo[ndx].si_boundto =
1448 					    SYMINFO_BT_SELF;
1449 				}
1450 
1451 				/*
1452 				 * Indicate that this is a capabilities symbol.
1453 				 * Note, that this identification only provides
1454 				 * information regarding the symbol that is
1455 				 * visible from elfdump(1) -y.  The association
1456 				 * of a symbol to its capabilities is derived
1457 				 * from a .SUNW_capinfo entry.
1458 				 */
1459 				if ((sdp->sd_flags & FLG_SY_CAP) &&
1460 				    ofl->ofl_oscapinfo) {
1461 					syminfo[ndx].si_flags |=
1462 					    SYMINFO_FLG_CAP;
1463 				}
1464 			}
1465 		}
1466 
1467 		/*
1468 		 * Note that the `sym' value is reset to be one of the new
1469 		 * symbol table entries.  This symbol will be updated further
1470 		 * depending on the type of the symbol.  Process the .symtab
1471 		 * first, followed by the .dynsym, thus the `sym' value will
1472 		 * remain as the .dynsym value when the .dynsym is present.
1473 		 * This ensures that any versioning symbols st_name value will
1474 		 * be appropriate for the string table used by version
1475 		 * entries.
1476 		 */
1477 		if (enter_in_symtab) {
1478 			Word	_symndx;
1479 
1480 			if (local)
1481 				_symndx = scopesym_ndx;
1482 			else
1483 				_symndx = symtab_ndx;
1484 
1485 			symtab[_symndx] = *sdp->sd_sym;
1486 			sdp->sd_sym = sym = &symtab[_symndx];
1487 			(void) st_setstring(strtab, name, &stoff);
1488 			sym->st_name = stoff;
1489 		}
1490 		if (dynlocal) {
1491 			ldynsym[ldynscopesym_ndx] = *sdp->sd_sym;
1492 			sdp->sd_sym = sym = &ldynsym[ldynscopesym_ndx];
1493 			(void) st_setstring(dynstr, name, &stoff);
1494 			ldynsym[ldynscopesym_ndx].st_name = stoff;
1495 			/* Add it to sort section if it qualifies */
1496 			ADD_TO_DYNSORT(sdp, sym, ELF_ST_TYPE(sym->st_info),
1497 			    ldynscopesym_ndx);
1498 		}
1499 
1500 		if (dynsym && !local) {
1501 			dynsym[dynsym_ndx] = *sdp->sd_sym;
1502 
1503 			/*
1504 			 * Provided this isn't an unnamed register symbol,
1505 			 * update the symbols name and hash value.
1506 			 */
1507 			if (((sdp->sd_flags & FLG_SY_REGSYM) == 0) ||
1508 			    dynsym[dynsym_ndx].st_name) {
1509 				(void) st_setstring(dynstr, name, &stoff);
1510 				dynsym[dynsym_ndx].st_name = stoff;
1511 
1512 				if (stoff) {
1513 					Word	hashval, _hashndx;
1514 
1515 					hashval =
1516 					    sap->sa_hash % ofl->ofl_hashbkts;
1517 
1518 					/* LINTED */
1519 					if (_hashndx = hashbkt[hashval]) {
1520 						while (hashchain[_hashndx]) {
1521 							_hashndx =
1522 							    hashchain[_hashndx];
1523 						}
1524 						hashchain[_hashndx] =
1525 						    sdp->sd_symndx;
1526 					} else {
1527 						hashbkt[hashval] =
1528 						    sdp->sd_symndx;
1529 					}
1530 				}
1531 			}
1532 			sdp->sd_sym = sym = &dynsym[dynsym_ndx];
1533 
1534 			/*
1535 			 * Add it to sort section if it qualifies.
1536 			 * The indexes in that section are relative to the
1537 			 * the adjacent SUNW_ldynsym/dymsym pair, so we
1538 			 * add the number of items in SUNW_ldynsym to the
1539 			 * dynsym index.
1540 			 */
1541 			ADD_TO_DYNSORT(sdp, sym, ELF_ST_TYPE(sym->st_info),
1542 			    ldynsym_cnt + dynsym_ndx);
1543 		}
1544 
1545 		if (!enter_in_symtab && (!dynsym || (local && !dynlocal))) {
1546 			if (!(sdp->sd_flags & FLG_SY_UPREQD))
1547 				continue;
1548 			sym = sdp->sd_sym;
1549 		} else
1550 			sdp->sd_flags &= ~FLG_SY_CLEAN;
1551 
1552 		/*
1553 		 * If we have a weak data symbol for which we need the real
1554 		 * symbol also, save this processing until later.
1555 		 *
1556 		 * The exception to this is if the weak/strong have PLT's
1557 		 * assigned to them.  In that case we don't do the post-weak
1558 		 * processing because the PLT's must be maintained so that we
1559 		 * can do 'interpositioning' on both of the symbols.
1560 		 */
1561 		if ((sap->sa_linkndx) &&
1562 		    (ELF_ST_BIND(sym->st_info) == STB_WEAK) &&
1563 		    (!sap->sa_PLTndx)) {
1564 			Sym_desc	*_sdp;
1565 
1566 			_sdp = sdp->sd_file->ifl_oldndx[sap->sa_linkndx];
1567 
1568 			if (_sdp->sd_ref != REF_DYN_SEEN) {
1569 				Wk_desc	wk;
1570 
1571 				if (enter_in_symtab) {
1572 					if (local) {
1573 						wk.wk_symtab =
1574 						    &symtab[scopesym_ndx];
1575 						scopesym_ndx++;
1576 					} else {
1577 						wk.wk_symtab =
1578 						    &symtab[symtab_ndx];
1579 						symtab_ndx++;
1580 					}
1581 				} else {
1582 					wk.wk_symtab = NULL;
1583 				}
1584 				if (dynsym) {
1585 					if (!local) {
1586 						wk.wk_dynsym =
1587 						    &dynsym[dynsym_ndx];
1588 						dynsym_ndx++;
1589 					} else if (dynlocal) {
1590 						wk.wk_dynsym =
1591 						    &ldynsym[ldynscopesym_ndx];
1592 						ldynscopesym_ndx++;
1593 					}
1594 				} else {
1595 					wk.wk_dynsym = NULL;
1596 				}
1597 				wk.wk_weak = sdp;
1598 				wk.wk_alias = _sdp;
1599 
1600 				if (alist_append(&weak, &wk,
1601 				    sizeof (Wk_desc), AL_CNT_WEAK) == NULL)
1602 					return ((Addr)S_ERROR);
1603 
1604 				continue;
1605 			}
1606 		}
1607 
1608 		DBG_CALL(Dbg_syms_old(ofl, sdp));
1609 
1610 		spec = NULL;
1611 		/*
1612 		 * assign new symbol value.
1613 		 */
1614 		sectndx = sdp->sd_shndx;
1615 		if (sectndx == SHN_UNDEF) {
1616 			if (((sdp->sd_flags & FLG_SY_REGSYM) == 0) &&
1617 			    (sym->st_value != 0)) {
1618 				ld_eprintf(ofl, ERR_WARNING,
1619 				    MSG_INTL(MSG_SYM_NOTNULL),
1620 				    demangle(name), sdp->sd_file->ifl_name);
1621 			}
1622 
1623 			/*
1624 			 * Undefined weak global, if we are generating a static
1625 			 * executable, output as an absolute zero.  Otherwise
1626 			 * leave it as is, ld.so.1 will skip symbols of this
1627 			 * type (this technique allows applications and
1628 			 * libraries to test for the existence of a symbol as an
1629 			 * indication of the presence or absence of certain
1630 			 * functionality).
1631 			 */
1632 			if (OFL_IS_STATIC_EXEC(ofl) &&
1633 			    (ELF_ST_BIND(sym->st_info) == STB_WEAK)) {
1634 				sdp->sd_flags |= FLG_SY_SPECSEC;
1635 				sdp->sd_shndx = sectndx = SHN_ABS;
1636 			}
1637 		} else if ((sdp->sd_flags & FLG_SY_SPECSEC) &&
1638 		    (sectndx == SHN_COMMON)) {
1639 			/* COMMONs have already been processed */
1640 			/* EMPTY */
1641 			;
1642 		} else {
1643 			if ((sdp->sd_flags & FLG_SY_SPECSEC) &&
1644 			    (sectndx == SHN_ABS))
1645 				spec = sdp->sd_aux->sa_symspec;
1646 
1647 			/* LINTED */
1648 			if (sdp->sd_flags & FLG_SY_COMMEXP) {
1649 				/*
1650 				 * This is (or was) a COMMON symbol which was
1651 				 * processed above - no processing
1652 				 * required here.
1653 				 */
1654 				;
1655 			} else if (sdp->sd_ref == REF_DYN_NEED) {
1656 				uchar_t	type, bind;
1657 
1658 				sectndx = SHN_UNDEF;
1659 				sym->st_value = 0;
1660 				sym->st_size = 0;
1661 
1662 				/*
1663 				 * Make sure this undefined symbol is returned
1664 				 * to the same binding as was defined in the
1665 				 * original relocatable object reference.
1666 				 */
1667 				type = ELF_ST_TYPE(sym-> st_info);
1668 				if (sdp->sd_flags & FLG_SY_GLOBREF)
1669 					bind = STB_GLOBAL;
1670 				else
1671 					bind = STB_WEAK;
1672 
1673 				sym->st_info = ELF_ST_INFO(bind, type);
1674 
1675 			} else if (((sdp->sd_flags & FLG_SY_SPECSEC) == 0) &&
1676 			    (sdp->sd_ref == REF_REL_NEED)) {
1677 				osp = sdp->sd_isc->is_osdesc;
1678 				/* LINTED */
1679 				sectndx = elf_ndxscn(osp->os_scn);
1680 
1681 				/*
1682 				 * In an executable, the new symbol value is the
1683 				 * old value (offset into defining section) plus
1684 				 * virtual address of defining section.  In a
1685 				 * relocatable, the new value is the old value
1686 				 * plus the displacement of the section within
1687 				 * the file.
1688 				 */
1689 				/* LINTED */
1690 				sym->st_value +=
1691 				    (Off)_elf_getxoff(sdp->sd_isc->is_indata);
1692 
1693 				if (!(flags & FLG_OF_RELOBJ)) {
1694 					sym->st_value += osp->os_shdr->sh_addr;
1695 					/*
1696 					 * TLS symbols are relative to
1697 					 * the TLS segment.
1698 					 */
1699 					if ((ELF_ST_TYPE(sym->st_info) ==
1700 					    STT_TLS) && (ofl->ofl_tlsphdr))
1701 						sym->st_value -=
1702 						    ofl->ofl_tlsphdr->p_vaddr;
1703 				}
1704 			}
1705 		}
1706 
1707 		if (spec) {
1708 			switch (spec) {
1709 			case SDAUX_ID_ETEXT:
1710 				sym->st_value = etext;
1711 				sectndx = etext_ndx;
1712 				if (etext_abs)
1713 					sdp->sd_flags |= FLG_SY_SPECSEC;
1714 				else
1715 					sdp->sd_flags &= ~FLG_SY_SPECSEC;
1716 				break;
1717 			case SDAUX_ID_EDATA:
1718 				sym->st_value = edata;
1719 				sectndx = edata_ndx;
1720 				if (edata_abs)
1721 					sdp->sd_flags |= FLG_SY_SPECSEC;
1722 				else
1723 					sdp->sd_flags &= ~FLG_SY_SPECSEC;
1724 				break;
1725 			case SDAUX_ID_END:
1726 				sym->st_value = end;
1727 				sectndx = end_ndx;
1728 				if (end_abs)
1729 					sdp->sd_flags |= FLG_SY_SPECSEC;
1730 				else
1731 					sdp->sd_flags &= ~FLG_SY_SPECSEC;
1732 				break;
1733 			case SDAUX_ID_START:
1734 				sym->st_value = start;
1735 				sectndx = start_ndx;
1736 				sdp->sd_flags &= ~FLG_SY_SPECSEC;
1737 				break;
1738 			case SDAUX_ID_DYN:
1739 				if (flags & FLG_OF_DYNAMIC) {
1740 					sym->st_value = ofl->
1741 					    ofl_osdynamic->os_shdr->sh_addr;
1742 					/* LINTED */
1743 					sectndx = elf_ndxscn(
1744 					    ofl->ofl_osdynamic->os_scn);
1745 					sdp->sd_flags &= ~FLG_SY_SPECSEC;
1746 				}
1747 				break;
1748 			case SDAUX_ID_PLT:
1749 				if (ofl->ofl_osplt) {
1750 					sym->st_value = ofl->
1751 					    ofl_osplt->os_shdr->sh_addr;
1752 					/* LINTED */
1753 					sectndx = elf_ndxscn(
1754 					    ofl->ofl_osplt->os_scn);
1755 					sdp->sd_flags &= ~FLG_SY_SPECSEC;
1756 				}
1757 				break;
1758 			case SDAUX_ID_GOT:
1759 				/*
1760 				 * Symbol bias for negative growing tables is
1761 				 * stored in symbol's value during
1762 				 * allocate_got().
1763 				 */
1764 				sym->st_value += ofl->
1765 				    ofl_osgot->os_shdr->sh_addr;
1766 				/* LINTED */
1767 				sectndx = elf_ndxscn(ofl->
1768 				    ofl_osgot->os_scn);
1769 				sdp->sd_flags &= ~FLG_SY_SPECSEC;
1770 				break;
1771 			default:
1772 				/* NOTHING */
1773 				;
1774 			}
1775 		}
1776 
1777 		/*
1778 		 * If a plt index has been assigned to an undefined function,
1779 		 * update the symbols value to the appropriate .plt address.
1780 		 */
1781 		if ((flags & FLG_OF_DYNAMIC) && (flags & FLG_OF_EXEC) &&
1782 		    (sdp->sd_file) &&
1783 		    (sdp->sd_file->ifl_ehdr->e_type == ET_DYN) &&
1784 		    (ELF_ST_TYPE(sym->st_info) == STT_FUNC) &&
1785 		    !(flags & FLG_OF_BFLAG)) {
1786 			if (sap->sa_PLTndx)
1787 				sym->st_value =
1788 				    (*ld_targ.t_mr.mr_calc_plt_addr)(sdp, ofl);
1789 		}
1790 
1791 		/*
1792 		 * Finish updating the symbols.
1793 		 */
1794 
1795 		/*
1796 		 * Sym Update: if scoped local - set local binding
1797 		 */
1798 		if (local)
1799 			sym->st_info = ELF_ST_INFO(STB_LOCAL,
1800 			    ELF_ST_TYPE(sym->st_info));
1801 
1802 		/*
1803 		 * Sym Updated: If both the .symtab and .dynsym
1804 		 * are present then we've actually updated the information in
1805 		 * the .dynsym, therefore copy this same information to the
1806 		 * .symtab entry.
1807 		 */
1808 		sdp->sd_shndx = sectndx;
1809 		if (enter_in_symtab && dynsym && (!local || dynlocal)) {
1810 			Word _symndx = dynlocal ? scopesym_ndx : symtab_ndx;
1811 
1812 			symtab[_symndx].st_value = sym->st_value;
1813 			symtab[_symndx].st_size = sym->st_size;
1814 			symtab[_symndx].st_info = sym->st_info;
1815 			symtab[_symndx].st_other = sym->st_other;
1816 		}
1817 
1818 		if (enter_in_symtab) {
1819 			Word	_symndx;
1820 
1821 			if (local)
1822 				_symndx = scopesym_ndx++;
1823 			else
1824 				_symndx = symtab_ndx++;
1825 			if (((sdp->sd_flags & FLG_SY_SPECSEC) == 0) &&
1826 			    (sectndx >= SHN_LORESERVE)) {
1827 				assert(symshndx != NULL);
1828 				symshndx[_symndx] = sectndx;
1829 				symtab[_symndx].st_shndx = SHN_XINDEX;
1830 			} else {
1831 				/* LINTED */
1832 				symtab[_symndx].st_shndx = (Half)sectndx;
1833 			}
1834 		}
1835 
1836 		if (dynsym && (!local || dynlocal)) {
1837 			/*
1838 			 * dynsym and ldynsym are distinct tables, so
1839 			 * we use indirection to access the right one
1840 			 * and the related extended section index array.
1841 			 */
1842 			Word	_symndx;
1843 			Sym	*_dynsym;
1844 			Word	*_dynshndx;
1845 
1846 			if (!local) {
1847 				_symndx = dynsym_ndx++;
1848 				_dynsym = dynsym;
1849 				_dynshndx = dynshndx;
1850 			} else {
1851 				_symndx = ldynscopesym_ndx++;
1852 				_dynsym = ldynsym;
1853 				_dynshndx = ldynshndx;
1854 			}
1855 			if (((sdp->sd_flags & FLG_SY_SPECSEC) == 0) &&
1856 			    (sectndx >= SHN_LORESERVE)) {
1857 				assert(_dynshndx != NULL);
1858 				_dynshndx[_symndx] = sectndx;
1859 				_dynsym[_symndx].st_shndx = SHN_XINDEX;
1860 			} else {
1861 				/* LINTED */
1862 				_dynsym[_symndx].st_shndx = (Half)sectndx;
1863 			}
1864 		}
1865 
1866 		DBG_CALL(Dbg_syms_new(ofl, sym, sdp));
1867 	}
1868 
1869 	/*
1870 	 * Now that all the symbols have been processed update any weak symbols
1871 	 * information (ie. copy all information except `st_name').  As both
1872 	 * symbols will be represented in the output, return the weak symbol to
1873 	 * its correct type.
1874 	 */
1875 	for (ALIST_TRAVERSE(weak, idx1, wkp)) {
1876 		Sym_desc	*sdp, *_sdp;
1877 		Sym		*sym, *_sym, *__sym;
1878 		uchar_t		bind;
1879 
1880 		sdp = wkp->wk_weak;
1881 		_sdp = wkp->wk_alias;
1882 		_sym = __sym = _sdp->sd_sym;
1883 
1884 		sdp->sd_flags |= FLG_SY_WEAKDEF;
1885 
1886 		/*
1887 		 * If the symbol definition has been scoped then assign it to
1888 		 * be local, otherwise if it's from a shared object then we need
1889 		 * to maintain the binding of the original reference.
1890 		 */
1891 		if (SYM_IS_HIDDEN(sdp)) {
1892 			if (flags & FLG_OF_PROCRED)
1893 				bind = STB_LOCAL;
1894 			else
1895 				bind = STB_WEAK;
1896 		} else if ((sdp->sd_ref == REF_DYN_NEED) &&
1897 		    (sdp->sd_flags & FLG_SY_GLOBREF))
1898 			bind = STB_GLOBAL;
1899 		else
1900 			bind = STB_WEAK;
1901 
1902 		DBG_CALL(Dbg_syms_old(ofl, sdp));
1903 		if ((sym = wkp->wk_symtab) != NULL) {
1904 			sym->st_value = _sym->st_value;
1905 			sym->st_size = _sym->st_size;
1906 			sym->st_other = _sym->st_other;
1907 			sym->st_shndx = _sym->st_shndx;
1908 			sym->st_info = ELF_ST_INFO(bind,
1909 			    ELF_ST_TYPE(sym->st_info));
1910 			__sym = sym;
1911 		}
1912 		if ((sym = wkp->wk_dynsym) != NULL) {
1913 			sym->st_value = _sym->st_value;
1914 			sym->st_size = _sym->st_size;
1915 			sym->st_other = _sym->st_other;
1916 			sym->st_shndx = _sym->st_shndx;
1917 			sym->st_info = ELF_ST_INFO(bind,
1918 			    ELF_ST_TYPE(sym->st_info));
1919 			__sym = sym;
1920 		}
1921 		DBG_CALL(Dbg_syms_new(ofl, __sym, sdp));
1922 	}
1923 
1924 	/*
1925 	 * Now display GOT debugging information if required.
1926 	 */
1927 	DBG_CALL(Dbg_got_display(ofl, 0, 0,
1928 	    ld_targ.t_m.m_got_xnumber, ld_targ.t_m.m_got_entsize));
1929 
1930 	/*
1931 	 * Update the section headers information. sh_info is
1932 	 * supposed to contain the offset at which the first
1933 	 * global symbol resides in the symbol table, while
1934 	 * sh_link contains the section index of the associated
1935 	 * string table.
1936 	 */
1937 	if (symtab) {
1938 		Shdr	*shdr = ofl->ofl_ossymtab->os_shdr;
1939 
1940 		shdr->sh_info = symtab_gbl_bndx;
1941 		/* LINTED */
1942 		shdr->sh_link = (Word)elf_ndxscn(ofl->ofl_osstrtab->os_scn);
1943 		if (symshndx)
1944 			ofl->ofl_ossymshndx->os_shdr->sh_link =
1945 			    (Word)elf_ndxscn(ofl->ofl_ossymtab->os_scn);
1946 
1947 		/*
1948 		 * Ensure that the expected number of symbols
1949 		 * were entered into the right spots:
1950 		 *	- Scoped symbols in the right range
1951 		 *	- Globals start at the right spot
1952 		 *		(correct number of locals entered)
1953 		 *	- The table is exactly filled
1954 		 *		(correct number of globals entered)
1955 		 */
1956 		assert((scopesym_bndx + ofl->ofl_scopecnt) == scopesym_ndx);
1957 		assert(shdr->sh_info == SYMTAB_LOC_CNT(ofl));
1958 		assert((shdr->sh_info + ofl->ofl_globcnt) == symtab_ndx);
1959 	}
1960 	if (dynsym) {
1961 		Shdr	*shdr = ofl->ofl_osdynsym->os_shdr;
1962 
1963 		shdr->sh_info = DYNSYM_LOC_CNT(ofl);
1964 		/* LINTED */
1965 		shdr->sh_link = (Word)elf_ndxscn(ofl->ofl_osdynstr->os_scn);
1966 
1967 		ofl->ofl_oshash->os_shdr->sh_link =
1968 		    /* LINTED */
1969 		    (Word)elf_ndxscn(ofl->ofl_osdynsym->os_scn);
1970 		if (dynshndx) {
1971 			shdr = ofl->ofl_osdynshndx->os_shdr;
1972 			shdr->sh_link =
1973 			    (Word)elf_ndxscn(ofl->ofl_osdynsym->os_scn);
1974 		}
1975 	}
1976 	if (ldynsym) {
1977 		Shdr	*shdr = ofl->ofl_osldynsym->os_shdr;
1978 
1979 		/* ldynsym has no globals, so give index one past the end */
1980 		shdr->sh_info = ldynsym_ndx;
1981 
1982 		/*
1983 		 * The ldynsym and dynsym must be adjacent. The
1984 		 * idea is that rtld should be able to start with
1985 		 * the ldynsym and march straight through the end
1986 		 * of dynsym, seeing them as a single symbol table,
1987 		 * despite the fact that they are in distinct sections.
1988 		 * Ensure that this happened correctly.
1989 		 *
1990 		 * Note that I use ldynsym_ndx here instead of the
1991 		 * computation I used to set the section size
1992 		 * (found in ldynsym_cnt). The two will agree, unless
1993 		 * we somehow miscounted symbols or failed to insert them
1994 		 * all. Using ldynsym_ndx here catches that error in
1995 		 * addition to checking for adjacency.
1996 		 */
1997 		assert(dynsym == (ldynsym + ldynsym_ndx));
1998 
1999 
2000 		/* LINTED */
2001 		shdr->sh_link = (Word)elf_ndxscn(ofl->ofl_osdynstr->os_scn);
2002 
2003 		if (ldynshndx) {
2004 			shdr = ofl->ofl_osldynshndx->os_shdr;
2005 			shdr->sh_link =
2006 			    (Word)elf_ndxscn(ofl->ofl_osldynsym->os_scn);
2007 		}
2008 
2009 		/*
2010 		 * The presence of .SUNW_ldynsym means that there may be
2011 		 * associated sort sections, one for regular symbols
2012 		 * and the other for TLS. Each sort section needs the
2013 		 * following done:
2014 		 *	- Section header link references .SUNW_ldynsym
2015 		 *	- Should have received the expected # of items
2016 		 *	- Sorted by increasing address
2017 		 */
2018 		if (ofl->ofl_osdynsymsort) {	/* .SUNW_dynsymsort */
2019 			ofl->ofl_osdynsymsort->os_shdr->sh_link =
2020 			    (Word)elf_ndxscn(ofl->ofl_osldynsym->os_scn);
2021 			assert(ofl->ofl_dynsymsortcnt == dynsymsort_ndx);
2022 
2023 			if (dynsymsort_ndx > 1) {
2024 				dynsort_compare_syms = ldynsym;
2025 				qsort(dynsymsort, dynsymsort_ndx,
2026 				    sizeof (*dynsymsort), dynsort_compare);
2027 				dynsort_dupwarn(ofl, ldynsym,
2028 				    st_getstrbuf(dynstr),
2029 				    dynsymsort, dynsymsort_ndx,
2030 				    MSG_ORIG(MSG_SCN_DYNSYMSORT));
2031 			}
2032 		}
2033 		if (ofl->ofl_osdyntlssort) {	/* .SUNW_dyntlssort */
2034 			ofl->ofl_osdyntlssort->os_shdr->sh_link =
2035 			    (Word)elf_ndxscn(ofl->ofl_osldynsym->os_scn);
2036 			assert(ofl->ofl_dyntlssortcnt == dyntlssort_ndx);
2037 
2038 			if (dyntlssort_ndx > 1) {
2039 				dynsort_compare_syms = ldynsym;
2040 				qsort(dyntlssort, dyntlssort_ndx,
2041 				    sizeof (*dyntlssort), dynsort_compare);
2042 				dynsort_dupwarn(ofl, ldynsym,
2043 				    st_getstrbuf(dynstr),
2044 				    dyntlssort, dyntlssort_ndx,
2045 				    MSG_ORIG(MSG_SCN_DYNTLSSORT));
2046 			}
2047 		}
2048 	}
2049 
2050 	/*
2051 	 * Used by ld.so.1 only.
2052 	 */
2053 	return (etext);
2054 
2055 #undef ADD_TO_DYNSORT
2056 }
2057 
2058 /*
2059  * Build the dynamic section.
2060  *
2061  * This routine must be maintained in parallel with make_dynamic()
2062  * in sections.c
2063  */
2064 static int
2065 update_odynamic(Ofl_desc *ofl)
2066 {
2067 	Aliste		idx;
2068 	Ifl_desc	*ifl;
2069 	Sym_desc	*sdp;
2070 	Shdr		*shdr;
2071 	Dyn		*_dyn = (Dyn *)ofl->ofl_osdynamic->os_outdata->d_buf;
2072 	Dyn		*dyn;
2073 	Os_desc		*symosp, *strosp;
2074 	Str_tbl		*strtbl;
2075 	size_t		stoff;
2076 	ofl_flag_t	flags = ofl->ofl_flags;
2077 	int		not_relobj = !(flags & FLG_OF_RELOBJ);
2078 	Word		cnt;
2079 
2080 	/*
2081 	 * Relocatable objects can be built with -r and -dy to trigger the
2082 	 * creation of a .dynamic section.  This model is used to create kernel
2083 	 * device drivers.  The .dynamic section provides a subset of userland
2084 	 * .dynamic entries, typically entries such as DT_NEEDED and DT_RUNPATH.
2085 	 *
2086 	 * Within a dynamic object, any .dynamic string references are to the
2087 	 * .dynstr table.  Within a relocatable object, these strings can reside
2088 	 * within the .strtab.
2089 	 */
2090 	if (OFL_IS_STATIC_OBJ(ofl)) {
2091 		symosp = ofl->ofl_ossymtab;
2092 		strosp = ofl->ofl_osstrtab;
2093 		strtbl = ofl->ofl_strtab;
2094 	} else {
2095 		symosp = ofl->ofl_osdynsym;
2096 		strosp = ofl->ofl_osdynstr;
2097 		strtbl = ofl->ofl_dynstrtab;
2098 	}
2099 
2100 	/* LINTED */
2101 	ofl->ofl_osdynamic->os_shdr->sh_link = (Word)elf_ndxscn(strosp->os_scn);
2102 
2103 	dyn = _dyn;
2104 
2105 	for (APLIST_TRAVERSE(ofl->ofl_sos, idx, ifl)) {
2106 		if ((ifl->ifl_flags &
2107 		    (FLG_IF_IGNORE | FLG_IF_DEPREQD)) == FLG_IF_IGNORE)
2108 			continue;
2109 
2110 		/*
2111 		 * Create and set up the DT_POSFLAG_1 entry here if required.
2112 		 */
2113 		if ((ifl->ifl_flags & MSK_IF_POSFLAG1) &&
2114 		    (ifl->ifl_flags & FLG_IF_NEEDED) && not_relobj) {
2115 			dyn->d_tag = DT_POSFLAG_1;
2116 			if (ifl->ifl_flags & FLG_IF_LAZYLD)
2117 				dyn->d_un.d_val = DF_P1_LAZYLOAD;
2118 			if (ifl->ifl_flags & FLG_IF_GRPPRM)
2119 				dyn->d_un.d_val |= DF_P1_GROUPPERM;
2120 			if (ifl->ifl_flags & FLG_IF_DEFERRED)
2121 				dyn->d_un.d_val |= DF_P1_DEFERRED;
2122 			dyn++;
2123 		}
2124 
2125 		if (ifl->ifl_flags & (FLG_IF_NEEDED | FLG_IF_NEEDSTR))
2126 			dyn->d_tag = DT_NEEDED;
2127 		else
2128 			continue;
2129 
2130 		(void) st_setstring(strtbl, ifl->ifl_soname, &stoff);
2131 		dyn->d_un.d_val = stoff;
2132 		/* LINTED */
2133 		ifl->ifl_neededndx = (Half)(((uintptr_t)dyn - (uintptr_t)_dyn) /
2134 		    sizeof (Dyn));
2135 		dyn++;
2136 	}
2137 
2138 	if (not_relobj) {
2139 		if (ofl->ofl_dtsfltrs != NULL) {
2140 			Dfltr_desc	*dftp;
2141 
2142 			for (ALIST_TRAVERSE(ofl->ofl_dtsfltrs, idx, dftp)) {
2143 				if (dftp->dft_flag == FLG_SY_AUXFLTR)
2144 					dyn->d_tag = DT_SUNW_AUXILIARY;
2145 				else
2146 					dyn->d_tag = DT_SUNW_FILTER;
2147 
2148 				(void) st_setstring(strtbl, dftp->dft_str,
2149 				    &stoff);
2150 				dyn->d_un.d_val = stoff;
2151 				dftp->dft_ndx = (Half)(((uintptr_t)dyn -
2152 				    (uintptr_t)_dyn) / sizeof (Dyn));
2153 				dyn++;
2154 			}
2155 		}
2156 		if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_INIT_U),
2157 		    SYM_NOHASH, 0, ofl)) != NULL) &&
2158 		    (sdp->sd_ref == REF_REL_NEED) &&
2159 		    (sdp->sd_sym->st_shndx != SHN_UNDEF)) {
2160 			dyn->d_tag = DT_INIT;
2161 			dyn->d_un.d_ptr = sdp->sd_sym->st_value;
2162 			dyn++;
2163 		}
2164 		if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_FINI_U),
2165 		    SYM_NOHASH, 0, ofl)) != NULL) &&
2166 		    (sdp->sd_ref == REF_REL_NEED) &&
2167 		    (sdp->sd_sym->st_shndx != SHN_UNDEF)) {
2168 			dyn->d_tag = DT_FINI;
2169 			dyn->d_un.d_ptr = sdp->sd_sym->st_value;
2170 			dyn++;
2171 		}
2172 		if (ofl->ofl_soname) {
2173 			dyn->d_tag = DT_SONAME;
2174 			(void) st_setstring(strtbl, ofl->ofl_soname, &stoff);
2175 			dyn->d_un.d_val = stoff;
2176 			dyn++;
2177 		}
2178 		if (ofl->ofl_filtees) {
2179 			if (flags & FLG_OF_AUX) {
2180 				dyn->d_tag = DT_AUXILIARY;
2181 			} else {
2182 				dyn->d_tag = DT_FILTER;
2183 			}
2184 			(void) st_setstring(strtbl, ofl->ofl_filtees, &stoff);
2185 			dyn->d_un.d_val = stoff;
2186 			dyn++;
2187 		}
2188 	}
2189 
2190 	if (ofl->ofl_rpath) {
2191 		(void) st_setstring(strtbl, ofl->ofl_rpath, &stoff);
2192 		dyn->d_tag = DT_RUNPATH;
2193 		dyn->d_un.d_val = stoff;
2194 		dyn++;
2195 		dyn->d_tag = DT_RPATH;
2196 		dyn->d_un.d_val = stoff;
2197 		dyn++;
2198 	}
2199 
2200 	if (not_relobj) {
2201 		Aliste	idx;
2202 		Sg_desc	*sgp;
2203 
2204 		if (ofl->ofl_config) {
2205 			dyn->d_tag = DT_CONFIG;
2206 			(void) st_setstring(strtbl, ofl->ofl_config, &stoff);
2207 			dyn->d_un.d_val = stoff;
2208 			dyn++;
2209 		}
2210 		if (ofl->ofl_depaudit) {
2211 			dyn->d_tag = DT_DEPAUDIT;
2212 			(void) st_setstring(strtbl, ofl->ofl_depaudit, &stoff);
2213 			dyn->d_un.d_val = stoff;
2214 			dyn++;
2215 		}
2216 		if (ofl->ofl_audit) {
2217 			dyn->d_tag = DT_AUDIT;
2218 			(void) st_setstring(strtbl, ofl->ofl_audit, &stoff);
2219 			dyn->d_un.d_val = stoff;
2220 			dyn++;
2221 		}
2222 
2223 		dyn->d_tag = DT_HASH;
2224 		dyn->d_un.d_ptr = ofl->ofl_oshash->os_shdr->sh_addr;
2225 		dyn++;
2226 
2227 		shdr = strosp->os_shdr;
2228 		dyn->d_tag = DT_STRTAB;
2229 		dyn->d_un.d_ptr = shdr->sh_addr;
2230 		dyn++;
2231 
2232 		dyn->d_tag = DT_STRSZ;
2233 		dyn->d_un.d_ptr = shdr->sh_size;
2234 		dyn++;
2235 
2236 		/*
2237 		 * Note, the shdr is set and used in the ofl->ofl_osldynsym case
2238 		 * that follows.
2239 		 */
2240 		shdr = symosp->os_shdr;
2241 		dyn->d_tag = DT_SYMTAB;
2242 		dyn->d_un.d_ptr = shdr->sh_addr;
2243 		dyn++;
2244 
2245 		dyn->d_tag = DT_SYMENT;
2246 		dyn->d_un.d_ptr = shdr->sh_entsize;
2247 		dyn++;
2248 
2249 		if (ofl->ofl_osldynsym) {
2250 			Shdr	*lshdr = ofl->ofl_osldynsym->os_shdr;
2251 
2252 			/*
2253 			 * We have arranged for the .SUNW_ldynsym data to be
2254 			 * immediately in front of the .dynsym data.
2255 			 * This means that you could start at the top
2256 			 * of .SUNW_ldynsym and see the data for both tables
2257 			 * without a break. This is the view we want to
2258 			 * provide for DT_SUNW_SYMTAB, which is why we
2259 			 * add the lengths together.
2260 			 */
2261 			dyn->d_tag = DT_SUNW_SYMTAB;
2262 			dyn->d_un.d_ptr = lshdr->sh_addr;
2263 			dyn++;
2264 
2265 			dyn->d_tag = DT_SUNW_SYMSZ;
2266 			dyn->d_un.d_val = lshdr->sh_size + shdr->sh_size;
2267 			dyn++;
2268 		}
2269 
2270 		if (ofl->ofl_osdynsymsort || ofl->ofl_osdyntlssort) {
2271 			dyn->d_tag = DT_SUNW_SORTENT;
2272 			dyn->d_un.d_val = sizeof (Word);
2273 			dyn++;
2274 		}
2275 
2276 		if (ofl->ofl_osdynsymsort) {
2277 			shdr = ofl->ofl_osdynsymsort->os_shdr;
2278 
2279 			dyn->d_tag = DT_SUNW_SYMSORT;
2280 			dyn->d_un.d_ptr = shdr->sh_addr;
2281 			dyn++;
2282 
2283 			dyn->d_tag = DT_SUNW_SYMSORTSZ;
2284 			dyn->d_un.d_val = shdr->sh_size;
2285 			dyn++;
2286 		}
2287 
2288 		if (ofl->ofl_osdyntlssort) {
2289 			shdr = ofl->ofl_osdyntlssort->os_shdr;
2290 
2291 			dyn->d_tag = DT_SUNW_TLSSORT;
2292 			dyn->d_un.d_ptr = shdr->sh_addr;
2293 			dyn++;
2294 
2295 			dyn->d_tag = DT_SUNW_TLSSORTSZ;
2296 			dyn->d_un.d_val = shdr->sh_size;
2297 			dyn++;
2298 		}
2299 
2300 		/*
2301 		 * Reserve the DT_CHECKSUM entry.  Its value will be filled in
2302 		 * after the complete image is built.
2303 		 */
2304 		dyn->d_tag = DT_CHECKSUM;
2305 		ofl->ofl_checksum = &dyn->d_un.d_val;
2306 		dyn++;
2307 
2308 		/*
2309 		 * Versioning sections: DT_VERDEF and DT_VERNEED.
2310 		 *
2311 		 * The Solaris ld does not produce DT_VERSYM, but the GNU ld
2312 		 * does, in order to support their style of versioning, which
2313 		 * differs from ours:
2314 		 *
2315 		 *	- The top bit of the 16-bit Versym index is
2316 		 *		not part of the version, but is interpreted
2317 		 *		as a "hidden bit".
2318 		 *
2319 		 *	- External (SHN_UNDEF) symbols can have non-zero
2320 		 *		Versym values, which specify versions in
2321 		 *		referenced objects, via the Verneed section.
2322 		 *
2323 		 *	- The vna_other field of the Vernaux structures
2324 		 *		found in the Verneed section are not zero as
2325 		 *		with Solaris, but instead contain the version
2326 		 *		index to be used by Versym indices to reference
2327 		 *		the given external version.
2328 		 *
2329 		 * The Solaris ld, rtld, and elfdump programs all interpret the
2330 		 * presence of DT_VERSYM as meaning that GNU versioning rules
2331 		 * apply to the given file. If DT_VERSYM is not present,
2332 		 * then Solaris versioning rules apply. If we should ever need
2333 		 * to change our ld so that it does issue DT_VERSYM, then
2334 		 * this rule for detecting GNU versioning will no longer work.
2335 		 * In that case, we will have to invent a way to explicitly
2336 		 * specify the style of versioning in use, perhaps via a
2337 		 * new dynamic entry named something like DT_SUNW_VERSIONSTYLE,
2338 		 * where the d_un.d_val value specifies which style is to be
2339 		 * used.
2340 		 */
2341 		if ((flags & (FLG_OF_VERDEF | FLG_OF_NOVERSEC)) ==
2342 		    FLG_OF_VERDEF) {
2343 			shdr = ofl->ofl_osverdef->os_shdr;
2344 
2345 			dyn->d_tag = DT_VERDEF;
2346 			dyn->d_un.d_ptr = shdr->sh_addr;
2347 			dyn++;
2348 			dyn->d_tag = DT_VERDEFNUM;
2349 			dyn->d_un.d_ptr = shdr->sh_info;
2350 			dyn++;
2351 		}
2352 		if ((flags & (FLG_OF_VERNEED | FLG_OF_NOVERSEC)) ==
2353 		    FLG_OF_VERNEED) {
2354 			shdr = ofl->ofl_osverneed->os_shdr;
2355 
2356 			dyn->d_tag = DT_VERNEED;
2357 			dyn->d_un.d_ptr = shdr->sh_addr;
2358 			dyn++;
2359 			dyn->d_tag = DT_VERNEEDNUM;
2360 			dyn->d_un.d_ptr = shdr->sh_info;
2361 			dyn++;
2362 		}
2363 
2364 		if ((flags & FLG_OF_COMREL) && ofl->ofl_relocrelcnt) {
2365 			dyn->d_tag = ld_targ.t_m.m_rel_dt_count;
2366 			dyn->d_un.d_val = ofl->ofl_relocrelcnt;
2367 			dyn++;
2368 		}
2369 		if (flags & FLG_OF_TEXTREL) {
2370 			/*
2371 			 * Only the presence of this entry is used in this
2372 			 * implementation, not the value stored.
2373 			 */
2374 			dyn->d_tag = DT_TEXTREL;
2375 			dyn->d_un.d_val = 0;
2376 			dyn++;
2377 		}
2378 
2379 		if (ofl->ofl_osfiniarray) {
2380 			shdr = ofl->ofl_osfiniarray->os_shdr;
2381 
2382 			dyn->d_tag = DT_FINI_ARRAY;
2383 			dyn->d_un.d_ptr = shdr->sh_addr;
2384 			dyn++;
2385 
2386 			dyn->d_tag = DT_FINI_ARRAYSZ;
2387 			dyn->d_un.d_val = shdr->sh_size;
2388 			dyn++;
2389 		}
2390 
2391 		if (ofl->ofl_osinitarray) {
2392 			shdr = ofl->ofl_osinitarray->os_shdr;
2393 
2394 			dyn->d_tag = DT_INIT_ARRAY;
2395 			dyn->d_un.d_ptr = shdr->sh_addr;
2396 			dyn++;
2397 
2398 			dyn->d_tag = DT_INIT_ARRAYSZ;
2399 			dyn->d_un.d_val = shdr->sh_size;
2400 			dyn++;
2401 		}
2402 
2403 		if (ofl->ofl_ospreinitarray) {
2404 			shdr = ofl->ofl_ospreinitarray->os_shdr;
2405 
2406 			dyn->d_tag = DT_PREINIT_ARRAY;
2407 			dyn->d_un.d_ptr = shdr->sh_addr;
2408 			dyn++;
2409 
2410 			dyn->d_tag = DT_PREINIT_ARRAYSZ;
2411 			dyn->d_un.d_val = shdr->sh_size;
2412 			dyn++;
2413 		}
2414 
2415 		if (ofl->ofl_pltcnt) {
2416 			shdr = ofl->ofl_osplt->os_relosdesc->os_shdr;
2417 
2418 			dyn->d_tag = DT_PLTRELSZ;
2419 			dyn->d_un.d_ptr = shdr->sh_size;
2420 			dyn++;
2421 			dyn->d_tag = DT_PLTREL;
2422 			dyn->d_un.d_ptr = ld_targ.t_m.m_rel_dt_type;
2423 			dyn++;
2424 			dyn->d_tag = DT_JMPREL;
2425 			dyn->d_un.d_ptr = shdr->sh_addr;
2426 			dyn++;
2427 		}
2428 		if (ofl->ofl_pltpad) {
2429 			shdr = ofl->ofl_osplt->os_shdr;
2430 
2431 			dyn->d_tag = DT_PLTPAD;
2432 			if (ofl->ofl_pltcnt) {
2433 				dyn->d_un.d_ptr = shdr->sh_addr +
2434 				    ld_targ.t_m.m_plt_reservsz +
2435 				    ofl->ofl_pltcnt * ld_targ.t_m.m_plt_entsize;
2436 			} else
2437 				dyn->d_un.d_ptr = shdr->sh_addr;
2438 			dyn++;
2439 			dyn->d_tag = DT_PLTPADSZ;
2440 			dyn->d_un.d_val = ofl->ofl_pltpad *
2441 			    ld_targ.t_m.m_plt_entsize;
2442 			dyn++;
2443 		}
2444 		if (ofl->ofl_relocsz) {
2445 			shdr = ofl->ofl_osrelhead->os_shdr;
2446 
2447 			dyn->d_tag = ld_targ.t_m.m_rel_dt_type;
2448 			dyn->d_un.d_ptr = shdr->sh_addr;
2449 			dyn++;
2450 			dyn->d_tag = ld_targ.t_m.m_rel_dt_size;
2451 			dyn->d_un.d_ptr = ofl->ofl_relocsz;
2452 			dyn++;
2453 			dyn->d_tag = ld_targ.t_m.m_rel_dt_ent;
2454 			if (shdr->sh_type == SHT_REL)
2455 				dyn->d_un.d_ptr = sizeof (Rel);
2456 			else
2457 				dyn->d_un.d_ptr = sizeof (Rela);
2458 			dyn++;
2459 		}
2460 		if (ofl->ofl_ossyminfo) {
2461 			shdr = ofl->ofl_ossyminfo->os_shdr;
2462 
2463 			dyn->d_tag = DT_SYMINFO;
2464 			dyn->d_un.d_ptr = shdr->sh_addr;
2465 			dyn++;
2466 			dyn->d_tag = DT_SYMINSZ;
2467 			dyn->d_un.d_val = shdr->sh_size;
2468 			dyn++;
2469 			dyn->d_tag = DT_SYMINENT;
2470 			dyn->d_un.d_val = sizeof (Syminfo);
2471 			dyn++;
2472 		}
2473 		if (ofl->ofl_osmove) {
2474 			shdr = ofl->ofl_osmove->os_shdr;
2475 
2476 			dyn->d_tag = DT_MOVETAB;
2477 			dyn->d_un.d_val = shdr->sh_addr;
2478 			dyn++;
2479 			dyn->d_tag = DT_MOVESZ;
2480 			dyn->d_un.d_val = shdr->sh_size;
2481 			dyn++;
2482 			dyn->d_tag = DT_MOVEENT;
2483 			dyn->d_un.d_val = shdr->sh_entsize;
2484 			dyn++;
2485 		}
2486 		if (ofl->ofl_regsymcnt) {
2487 			int	ndx;
2488 
2489 			for (ndx = 0; ndx < ofl->ofl_regsymsno; ndx++) {
2490 				if ((sdp = ofl->ofl_regsyms[ndx]) == NULL)
2491 					continue;
2492 
2493 				dyn->d_tag = ld_targ.t_m.m_dt_register;
2494 				dyn->d_un.d_val = sdp->sd_symndx;
2495 				dyn++;
2496 			}
2497 		}
2498 
2499 		for (APLIST_TRAVERSE(ofl->ofl_rtldinfo, idx, sdp)) {
2500 			dyn->d_tag = DT_SUNW_RTLDINF;
2501 			dyn->d_un.d_ptr = sdp->sd_sym->st_value;
2502 			dyn++;
2503 		}
2504 
2505 		if (((sgp = ofl->ofl_osdynamic->os_sgdesc) != NULL) &&
2506 		    (sgp->sg_phdr.p_flags & PF_W) && ofl->ofl_osinterp) {
2507 			dyn->d_tag = DT_DEBUG;
2508 			dyn->d_un.d_ptr = 0;
2509 			dyn++;
2510 		}
2511 
2512 		if (ofl->ofl_oscap) {
2513 			dyn->d_tag = DT_SUNW_CAP;
2514 			dyn->d_un.d_val = ofl->ofl_oscap->os_shdr->sh_addr;
2515 			dyn++;
2516 		}
2517 		if (ofl->ofl_oscapinfo) {
2518 			dyn->d_tag = DT_SUNW_CAPINFO;
2519 			dyn->d_un.d_val = ofl->ofl_oscapinfo->os_shdr->sh_addr;
2520 			dyn++;
2521 		}
2522 		if (ofl->ofl_oscapchain) {
2523 			shdr = ofl->ofl_oscapchain->os_shdr;
2524 
2525 			dyn->d_tag = DT_SUNW_CAPCHAIN;
2526 			dyn->d_un.d_val = shdr->sh_addr;
2527 			dyn++;
2528 			dyn->d_tag = DT_SUNW_CAPCHAINSZ;
2529 			dyn->d_un.d_val = shdr->sh_size;
2530 			dyn++;
2531 			dyn->d_tag = DT_SUNW_CAPCHAINENT;
2532 			dyn->d_un.d_val = shdr->sh_entsize;
2533 			dyn++;
2534 		}
2535 		if (flags & FLG_OF_SYMBOLIC) {
2536 			dyn->d_tag = DT_SYMBOLIC;
2537 			dyn->d_un.d_val = 0;
2538 			dyn++;
2539 		}
2540 	}
2541 
2542 	dyn->d_tag = DT_FLAGS;
2543 	dyn->d_un.d_val = ofl->ofl_dtflags;
2544 	dyn++;
2545 
2546 	/*
2547 	 * If -Bdirect was specified, but some NODIRECT symbols were specified
2548 	 * via a mapfile, or -znodirect was used on the command line, then
2549 	 * clear the DF_1_DIRECT flag.  The resultant object will use per-symbol
2550 	 * direct bindings rather than be enabled for global direct bindings.
2551 	 *
2552 	 * If any no-direct bindings exist within this object, set the
2553 	 * DF_1_NODIRECT flag.  ld(1) recognizes this flag when processing
2554 	 * dependencies, and performs extra work to ensure that no direct
2555 	 * bindings are established to the no-direct symbols that exist
2556 	 * within these dependencies.
2557 	 */
2558 	if (ofl->ofl_flags1 & FLG_OF1_NGLBDIR)
2559 		ofl->ofl_dtflags_1 &= ~DF_1_DIRECT;
2560 	if (ofl->ofl_flags1 & FLG_OF1_NDIRECT)
2561 		ofl->ofl_dtflags_1 |= DF_1_NODIRECT;
2562 
2563 	dyn->d_tag = DT_FLAGS_1;
2564 	dyn->d_un.d_val = ofl->ofl_dtflags_1;
2565 	dyn++;
2566 
2567 	dyn->d_tag = DT_SUNW_STRPAD;
2568 	dyn->d_un.d_val = DYNSTR_EXTRA_PAD;
2569 	dyn++;
2570 
2571 	dyn->d_tag = DT_SUNW_LDMACH;
2572 	dyn->d_un.d_val = ld_sunw_ldmach();
2573 	dyn++;
2574 
2575 	(*ld_targ.t_mr.mr_mach_update_odynamic)(ofl, &dyn);
2576 
2577 	for (cnt = 1 + DYNAMIC_EXTRA_ELTS; cnt--; dyn++) {
2578 		dyn->d_tag = DT_NULL;
2579 		dyn->d_un.d_val = 0;
2580 	}
2581 
2582 	/*
2583 	 * Ensure that we wrote the right number of entries. If not, we either
2584 	 * miscounted in make_dynamic(), or we did something wrong in this
2585 	 * function.
2586 	 */
2587 	assert((ofl->ofl_osdynamic->os_shdr->sh_size /
2588 	    ofl->ofl_osdynamic->os_shdr->sh_entsize) ==
2589 	    ((uintptr_t)dyn - (uintptr_t)_dyn) / sizeof (*dyn));
2590 
2591 	return (1);
2592 }
2593 
2594 /*
2595  * Build the version definition section
2596  */
2597 static int
2598 update_overdef(Ofl_desc *ofl)
2599 {
2600 	Aliste		idx1;
2601 	Ver_desc	*vdp, *_vdp;
2602 	Verdef		*vdf, *_vdf;
2603 	int		num = 0;
2604 	Os_desc		*strosp;
2605 	Str_tbl		*strtbl;
2606 
2607 	/*
2608 	 * Determine which string table to use.
2609 	 */
2610 	if (OFL_IS_STATIC_OBJ(ofl)) {
2611 		strtbl = ofl->ofl_strtab;
2612 		strosp = ofl->ofl_osstrtab;
2613 	} else {
2614 		strtbl = ofl->ofl_dynstrtab;
2615 		strosp = ofl->ofl_osdynstr;
2616 	}
2617 
2618 	/*
2619 	 * Traverse the version descriptors and update the version structures
2620 	 * to point to the dynstr name in preparation for building the version
2621 	 * section structure.
2622 	 */
2623 	for (APLIST_TRAVERSE(ofl->ofl_verdesc, idx1, vdp)) {
2624 		Sym_desc	*sdp;
2625 
2626 		if (vdp->vd_flags & VER_FLG_BASE) {
2627 			const char	*name = vdp->vd_name;
2628 			size_t		stoff;
2629 
2630 			/*
2631 			 * Create a new string table entry to represent the base
2632 			 * version name (there is no corresponding symbol for
2633 			 * this).
2634 			 */
2635 			(void) st_setstring(strtbl, name, &stoff);
2636 			/* LINTED */
2637 			vdp->vd_name = (const char *)stoff;
2638 		} else {
2639 			sdp = ld_sym_find(vdp->vd_name, vdp->vd_hash, 0, ofl);
2640 			/* LINTED */
2641 			vdp->vd_name = (const char *)
2642 			    (uintptr_t)sdp->sd_sym->st_name;
2643 		}
2644 	}
2645 
2646 	_vdf = vdf = (Verdef *)ofl->ofl_osverdef->os_outdata->d_buf;
2647 
2648 	/*
2649 	 * Traverse the version descriptors and update the version section to
2650 	 * reflect each version and its associated dependencies.
2651 	 */
2652 	for (APLIST_TRAVERSE(ofl->ofl_verdesc, idx1, vdp)) {
2653 		Aliste		idx2;
2654 		Half		cnt = 1;
2655 		Verdaux		*vdap, *_vdap;
2656 
2657 		_vdap = vdap = (Verdaux *)(vdf + 1);
2658 
2659 		vdf->vd_version = VER_DEF_CURRENT;
2660 		vdf->vd_flags	= vdp->vd_flags & MSK_VER_USER;
2661 		vdf->vd_ndx	= vdp->vd_ndx;
2662 		vdf->vd_hash	= vdp->vd_hash;
2663 
2664 		/* LINTED */
2665 		vdap->vda_name = (uintptr_t)vdp->vd_name;
2666 		vdap++;
2667 		/* LINTED */
2668 		_vdap->vda_next = (Word)((uintptr_t)vdap - (uintptr_t)_vdap);
2669 
2670 		/*
2671 		 * Traverse this versions dependency list generating the
2672 		 * appropriate version dependency entries.
2673 		 */
2674 		for (APLIST_TRAVERSE(vdp->vd_deps, idx2, _vdp)) {
2675 			/* LINTED */
2676 			vdap->vda_name = (uintptr_t)_vdp->vd_name;
2677 			_vdap = vdap;
2678 			vdap++, cnt++;
2679 			/* LINTED */
2680 			_vdap->vda_next = (Word)((uintptr_t)vdap -
2681 			    (uintptr_t)_vdap);
2682 		}
2683 		_vdap->vda_next = 0;
2684 
2685 		/*
2686 		 * Record the versions auxiliary array offset and the associated
2687 		 * dependency count.
2688 		 */
2689 		/* LINTED */
2690 		vdf->vd_aux = (Word)((uintptr_t)(vdf + 1) - (uintptr_t)vdf);
2691 		vdf->vd_cnt = cnt;
2692 
2693 		/*
2694 		 * Record the next versions offset and update the version
2695 		 * pointer.  Remember the previous version offset as the very
2696 		 * last structures next pointer should be null.
2697 		 */
2698 		_vdf = vdf;
2699 		vdf = (Verdef *)vdap, num++;
2700 		/* LINTED */
2701 		_vdf->vd_next = (Word)((uintptr_t)vdf - (uintptr_t)_vdf);
2702 	}
2703 	_vdf->vd_next = 0;
2704 
2705 	/*
2706 	 * Record the string table association with the version definition
2707 	 * section, and the symbol table associated with the version symbol
2708 	 * table (the actual contents of the version symbol table are filled
2709 	 * in during symbol update).
2710 	 */
2711 	/* LINTED */
2712 	ofl->ofl_osverdef->os_shdr->sh_link = (Word)elf_ndxscn(strosp->os_scn);
2713 
2714 	/*
2715 	 * The version definition sections `info' field is used to indicate the
2716 	 * number of entries in this section.
2717 	 */
2718 	ofl->ofl_osverdef->os_shdr->sh_info = num;
2719 
2720 	return (1);
2721 }
2722 
2723 /*
2724  * Finish the version symbol index section
2725  */
2726 static void
2727 update_oversym(Ofl_desc *ofl)
2728 {
2729 	Os_desc		*osp;
2730 
2731 	/*
2732 	 * Record the symbol table associated with the version symbol table.
2733 	 * The contents of the version symbol table are filled in during
2734 	 * symbol update.
2735 	 */
2736 	if (OFL_IS_STATIC_OBJ(ofl))
2737 		osp = ofl->ofl_ossymtab;
2738 	else
2739 		osp = ofl->ofl_osdynsym;
2740 
2741 	/* LINTED */
2742 	ofl->ofl_osversym->os_shdr->sh_link = (Word)elf_ndxscn(osp->os_scn);
2743 }
2744 
2745 /*
2746  * Build the version needed section
2747  */
2748 static int
2749 update_overneed(Ofl_desc *ofl)
2750 {
2751 	Aliste		idx1;
2752 	Ifl_desc	*ifl;
2753 	Verneed		*vnd, *_vnd;
2754 	Os_desc		*strosp;
2755 	Str_tbl		*strtbl;
2756 	Word		num = 0;
2757 
2758 	_vnd = vnd = (Verneed *)ofl->ofl_osverneed->os_outdata->d_buf;
2759 
2760 	/*
2761 	 * Determine which string table is appropriate.
2762 	 */
2763 	if (OFL_IS_STATIC_OBJ(ofl)) {
2764 		strosp = ofl->ofl_osstrtab;
2765 		strtbl = ofl->ofl_strtab;
2766 	} else {
2767 		strosp = ofl->ofl_osdynstr;
2768 		strtbl = ofl->ofl_dynstrtab;
2769 	}
2770 
2771 	/*
2772 	 * Traverse the shared object list looking for dependencies that have
2773 	 * versions defined within them.
2774 	 */
2775 	for (APLIST_TRAVERSE(ofl->ofl_sos, idx1, ifl)) {
2776 		Half		_cnt;
2777 		Word		cnt = 0;
2778 		Vernaux		*_vnap, *vnap;
2779 		size_t		stoff;
2780 
2781 		if (!(ifl->ifl_flags & FLG_IF_VERNEED))
2782 			continue;
2783 
2784 		vnd->vn_version = VER_NEED_CURRENT;
2785 
2786 		(void) st_setstring(strtbl, ifl->ifl_soname, &stoff);
2787 		vnd->vn_file = stoff;
2788 
2789 		_vnap = vnap = (Vernaux *)(vnd + 1);
2790 
2791 		/*
2792 		 * Traverse the version index list recording
2793 		 * each version as a needed dependency.
2794 		 */
2795 		for (_cnt = 0; _cnt <= ifl->ifl_vercnt; _cnt++) {
2796 			Ver_index	*vip = &ifl->ifl_verndx[_cnt];
2797 
2798 			if (vip->vi_flags & FLG_VER_REFER) {
2799 				(void) st_setstring(strtbl, vip->vi_name,
2800 				    &stoff);
2801 				vnap->vna_name = stoff;
2802 
2803 				if (vip->vi_desc) {
2804 					vnap->vna_hash = vip->vi_desc->vd_hash;
2805 					vnap->vna_flags =
2806 					    vip->vi_desc->vd_flags;
2807 				} else {
2808 					vnap->vna_hash = 0;
2809 					vnap->vna_flags = 0;
2810 				}
2811 				vnap->vna_other = vip->vi_overndx;
2812 
2813 				/*
2814 				 * If version A inherits version B, then
2815 				 * B is implicit in A. It suffices for ld.so.1
2816 				 * to verify A at runtime and skip B. The
2817 				 * version normalization process sets the INFO
2818 				 * flag for the versions we want ld.so.1 to
2819 				 * skip.
2820 				 */
2821 				if (vip->vi_flags & VER_FLG_INFO)
2822 					vnap->vna_flags |= VER_FLG_INFO;
2823 
2824 				_vnap = vnap;
2825 				vnap++, cnt++;
2826 				_vnap->vna_next =
2827 				    /* LINTED */
2828 				    (Word)((uintptr_t)vnap - (uintptr_t)_vnap);
2829 			}
2830 		}
2831 
2832 		_vnap->vna_next = 0;
2833 
2834 		/*
2835 		 * Record the versions auxiliary array offset and
2836 		 * the associated dependency count.
2837 		 */
2838 		/* LINTED */
2839 		vnd->vn_aux = (Word)((uintptr_t)(vnd + 1) - (uintptr_t)vnd);
2840 		/* LINTED */
2841 		vnd->vn_cnt = (Half)cnt;
2842 
2843 		/*
2844 		 * Record the next versions offset and update the version
2845 		 * pointer.  Remember the previous version offset as the very
2846 		 * last structures next pointer should be null.
2847 		 */
2848 		_vnd = vnd;
2849 		vnd = (Verneed *)vnap, num++;
2850 		/* LINTED */
2851 		_vnd->vn_next = (Word)((uintptr_t)vnd - (uintptr_t)_vnd);
2852 	}
2853 	_vnd->vn_next = 0;
2854 
2855 	/*
2856 	 * Use sh_link to record the associated string table section, and
2857 	 * sh_info to indicate the number of entries contained in the section.
2858 	 */
2859 	/* LINTED */
2860 	ofl->ofl_osverneed->os_shdr->sh_link = (Word)elf_ndxscn(strosp->os_scn);
2861 	ofl->ofl_osverneed->os_shdr->sh_info = num;
2862 
2863 	return (1);
2864 }
2865 
2866 /*
2867  * Update syminfo section.
2868  */
2869 static uintptr_t
2870 update_osyminfo(Ofl_desc *ofl)
2871 {
2872 	Os_desc		*symosp, *infosp = ofl->ofl_ossyminfo;
2873 	Syminfo		*sip = infosp->os_outdata->d_buf;
2874 	Shdr		*shdr = infosp->os_shdr;
2875 	char		*strtab;
2876 	Aliste		idx;
2877 	Sym_desc	*sdp;
2878 	Sfltr_desc	*sftp;
2879 
2880 	if (ofl->ofl_flags & FLG_OF_RELOBJ) {
2881 		symosp = ofl->ofl_ossymtab;
2882 		strtab = ofl->ofl_osstrtab->os_outdata->d_buf;
2883 	} else {
2884 		symosp = ofl->ofl_osdynsym;
2885 		strtab = ofl->ofl_osdynstr->os_outdata->d_buf;
2886 	}
2887 
2888 	/* LINTED */
2889 	infosp->os_shdr->sh_link = (Word)elf_ndxscn(symosp->os_scn);
2890 	if (ofl->ofl_osdynamic)
2891 		infosp->os_shdr->sh_info =
2892 		    /* LINTED */
2893 		    (Word)elf_ndxscn(ofl->ofl_osdynamic->os_scn);
2894 
2895 	/*
2896 	 * Update any references with the index into the dynamic table.
2897 	 */
2898 	for (APLIST_TRAVERSE(ofl->ofl_symdtent, idx, sdp))
2899 		sip[sdp->sd_symndx].si_boundto = sdp->sd_file->ifl_neededndx;
2900 
2901 	/*
2902 	 * Update any filtee references with the index into the dynamic table.
2903 	 */
2904 	for (ALIST_TRAVERSE(ofl->ofl_symfltrs, idx, sftp)) {
2905 		Dfltr_desc	*dftp;
2906 
2907 		dftp = alist_item(ofl->ofl_dtsfltrs, sftp->sft_idx);
2908 		sip[sftp->sft_sdp->sd_symndx].si_boundto = dftp->dft_ndx;
2909 	}
2910 
2911 	/*
2912 	 * Display debugging information about section.
2913 	 */
2914 	DBG_CALL(Dbg_syminfo_title(ofl->ofl_lml));
2915 	if (DBG_ENABLED) {
2916 		Word	_cnt, cnt = shdr->sh_size / shdr->sh_entsize;
2917 		Sym	*symtab = symosp->os_outdata->d_buf;
2918 		Dyn	*dyn;
2919 
2920 		if (ofl->ofl_osdynamic)
2921 			dyn = ofl->ofl_osdynamic->os_outdata->d_buf;
2922 		else
2923 			dyn = NULL;
2924 
2925 		for (_cnt = 1; _cnt < cnt; _cnt++) {
2926 			if (sip[_cnt].si_flags || sip[_cnt].si_boundto)
2927 				/* LINTED */
2928 				DBG_CALL(Dbg_syminfo_entry(ofl->ofl_lml, _cnt,
2929 				    &sip[_cnt], &symtab[_cnt], strtab, dyn));
2930 		}
2931 	}
2932 	return (1);
2933 }
2934 
2935 /*
2936  * Build the output elf header.
2937  */
2938 static uintptr_t
2939 update_oehdr(Ofl_desc * ofl)
2940 {
2941 	Ehdr	*ehdr = ofl->ofl_nehdr;
2942 
2943 	/*
2944 	 * If an entry point symbol has already been established (refer
2945 	 * sym_validate()) simply update the elf header entry point with the
2946 	 * symbols value.  If no entry point is defined it will have been filled
2947 	 * with the start address of the first section within the text segment
2948 	 * (refer update_outfile()).
2949 	 */
2950 	if (ofl->ofl_entry)
2951 		ehdr->e_entry =
2952 		    ((Sym_desc *)(ofl->ofl_entry))->sd_sym->st_value;
2953 
2954 	ehdr->e_ident[EI_DATA] = ld_targ.t_m.m_data;
2955 	ehdr->e_version = ofl->ofl_dehdr->e_version;
2956 
2957 	/*
2958 	 * When generating a relocatable object under -z symbolcap, set the
2959 	 * e_machine to be generic, and remove any e_flags.  Input relocatable
2960 	 * objects may identify alternative e_machine (m.machplus) and e_flags
2961 	 * values.  However, the functions within the created output object
2962 	 * are selected at runtime using the capabilities mechanism, which
2963 	 * supersedes the e-machine and e_flags information.  Therefore,
2964 	 * e_machine and e_flag values are not propagated to the output object,
2965 	 * as these values might prevent the kernel from loading the object
2966 	 * before the runtime linker gets control.
2967 	 */
2968 	if (ofl->ofl_flags & FLG_OF_OTOSCAP) {
2969 		ehdr->e_machine = ld_targ.t_m.m_mach;
2970 		ehdr->e_flags = 0;
2971 	} else {
2972 		/*
2973 		 * Note. it may be necessary to update the e_flags field in the
2974 		 * machine dependent section.
2975 		 */
2976 		ehdr->e_machine = ofl->ofl_dehdr->e_machine;
2977 		ehdr->e_flags = ofl->ofl_dehdr->e_flags;
2978 
2979 		if (ehdr->e_machine != ld_targ.t_m.m_mach) {
2980 			if (ehdr->e_machine != ld_targ.t_m.m_machplus)
2981 				return (S_ERROR);
2982 			if ((ehdr->e_flags & ld_targ.t_m.m_flagsplus) == 0)
2983 				return (S_ERROR);
2984 		}
2985 	}
2986 
2987 	if (ofl->ofl_flags & FLG_OF_SHAROBJ)
2988 		ehdr->e_type = ET_DYN;
2989 	else if (ofl->ofl_flags & FLG_OF_RELOBJ)
2990 		ehdr->e_type = ET_REL;
2991 	else
2992 		ehdr->e_type = ET_EXEC;
2993 
2994 	return (1);
2995 }
2996 
2997 /*
2998  * Perform move table expansion.
2999  */
3000 static void
3001 expand_move(Ofl_desc *ofl, Sym_desc *sdp, Move *mvp)
3002 {
3003 	Os_desc		*osp;
3004 	uchar_t		*taddr, *taddr0;
3005 	Sxword		offset;
3006 	Half		cnt;
3007 	uint_t		stride;
3008 
3009 	osp = ofl->ofl_isparexpn->is_osdesc;
3010 	offset = sdp->sd_sym->st_value - osp->os_shdr->sh_addr;
3011 
3012 	taddr0 = taddr = osp->os_outdata->d_buf;
3013 	taddr += offset;
3014 	taddr = taddr + mvp->m_poffset;
3015 
3016 	for (cnt = 0; cnt < mvp->m_repeat; cnt++) {
3017 		/* LINTED */
3018 		DBG_CALL(Dbg_move_expand(ofl->ofl_lml, mvp,
3019 		    (Addr)(taddr - taddr0)));
3020 		stride = (uint_t)mvp->m_stride + 1;
3021 
3022 		/*
3023 		 * Update the target address based upon the move entry size.
3024 		 * This size was validated in ld_process_move().
3025 		 */
3026 		/* LINTED */
3027 		switch (ELF_M_SIZE(mvp->m_info)) {
3028 		case 1:
3029 			/* LINTED */
3030 			*taddr = (uchar_t)mvp->m_value;
3031 			taddr += stride;
3032 			break;
3033 		case 2:
3034 			/* LINTED */
3035 			*((Half *)taddr) = (Half)mvp->m_value;
3036 			taddr += 2 * stride;
3037 			break;
3038 		case 4:
3039 			/* LINTED */
3040 			*((Word *)taddr) = (Word)mvp->m_value;
3041 			taddr += 4 * stride;
3042 			break;
3043 		case 8:
3044 			/* LINTED */
3045 			*((u_longlong_t *)taddr) = mvp->m_value;
3046 			taddr += 8 * stride;
3047 			break;
3048 		}
3049 	}
3050 }
3051 
3052 /*
3053  * Update Move sections.
3054  */
3055 static void
3056 update_move(Ofl_desc *ofl)
3057 {
3058 	Word		ndx = 0;
3059 	ofl_flag_t	flags = ofl->ofl_flags;
3060 	Move		*omvp;
3061 	Aliste		idx1;
3062 	Sym_desc	*sdp;
3063 
3064 	/*
3065 	 * Determine the index of the symbol table that will be referenced by
3066 	 * the Move section.
3067 	 */
3068 	if (OFL_ALLOW_DYNSYM(ofl))
3069 		/* LINTED */
3070 		ndx = (Word) elf_ndxscn(ofl->ofl_osdynsym->os_scn);
3071 	else if (!(flags & FLG_OF_STRIP) || (flags & FLG_OF_RELOBJ))
3072 		/* LINTED */
3073 		ndx = (Word) elf_ndxscn(ofl->ofl_ossymtab->os_scn);
3074 
3075 	/*
3076 	 * Update sh_link of the Move section, and point to the new Move data.
3077 	 */
3078 	if (ofl->ofl_osmove) {
3079 		ofl->ofl_osmove->os_shdr->sh_link = ndx;
3080 		omvp = (Move *)ofl->ofl_osmove->os_outdata->d_buf;
3081 	}
3082 
3083 	/*
3084 	 * Update symbol entry index
3085 	 */
3086 	for (APLIST_TRAVERSE(ofl->ofl_parsyms, idx1, sdp)) {
3087 		Aliste		idx2;
3088 		Mv_desc		*mdp;
3089 
3090 		/*
3091 		 * Expand move table
3092 		 */
3093 		if (sdp->sd_flags & FLG_SY_PAREXPN) {
3094 			const char	*str;
3095 
3096 			if (flags & FLG_OF_STATIC)
3097 				str = MSG_INTL(MSG_PSYM_EXPREASON1);
3098 			else if (ofl->ofl_flags1 & FLG_OF1_NOPARTI)
3099 				str = MSG_INTL(MSG_PSYM_EXPREASON2);
3100 			else
3101 				str = MSG_INTL(MSG_PSYM_EXPREASON3);
3102 
3103 			DBG_CALL(Dbg_move_parexpn(ofl->ofl_lml,
3104 			    sdp->sd_name, str));
3105 
3106 			for (ALIST_TRAVERSE(sdp->sd_move, idx2, mdp)) {
3107 				DBG_CALL(Dbg_move_entry1(ofl->ofl_lml, 0,
3108 				    mdp->md_move, sdp));
3109 				expand_move(ofl, sdp, mdp->md_move);
3110 			}
3111 			continue;
3112 		}
3113 
3114 		/*
3115 		 * Process move table
3116 		 */
3117 		DBG_CALL(Dbg_move_outmove(ofl->ofl_lml, sdp->sd_name));
3118 
3119 		for (ALIST_TRAVERSE(sdp->sd_move, idx2, mdp)) {
3120 			Move	*imvp;
3121 			int	idx = 1;
3122 			Sym	*sym;
3123 
3124 			imvp = mdp->md_move;
3125 			sym = sdp->sd_sym;
3126 
3127 			DBG_CALL(Dbg_move_entry1(ofl->ofl_lml, 1, imvp, sdp));
3128 
3129 			*omvp = *imvp;
3130 			if ((flags & FLG_OF_RELOBJ) == 0) {
3131 				if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) {
3132 					Os_desc	*osp = sdp->sd_isc->is_osdesc;
3133 					Word	ndx = osp->os_identndx;
3134 
3135 					omvp->m_info =
3136 					    /* LINTED */
3137 					    ELF_M_INFO(ndx, imvp->m_info);
3138 
3139 					if (ELF_ST_TYPE(sym->st_info) !=
3140 					    STT_SECTION) {
3141 						omvp->m_poffset =
3142 						    sym->st_value -
3143 						    osp->os_shdr->sh_addr +
3144 						    imvp->m_poffset;
3145 					}
3146 				} else {
3147 					omvp->m_info =
3148 					    /* LINTED */
3149 					    ELF_M_INFO(sdp->sd_symndx,
3150 					    imvp->m_info);
3151 				}
3152 			} else {
3153 				Boolean 	isredloc = FALSE;
3154 
3155 				if ((ELF_ST_BIND(sym->st_info) == STB_LOCAL) &&
3156 				    (ofl->ofl_flags & FLG_OF_REDLSYM))
3157 					isredloc = TRUE;
3158 
3159 				if (isredloc && !(sdp->sd_move)) {
3160 					Os_desc	*osp = sdp->sd_isc->is_osdesc;
3161 					Word	ndx = osp->os_identndx;
3162 
3163 					omvp->m_info =
3164 					    /* LINTED */
3165 					    ELF_M_INFO(ndx, imvp->m_info);
3166 
3167 					omvp->m_poffset += sym->st_value;
3168 				} else {
3169 					if (isredloc)
3170 						DBG_CALL(Dbg_syms_reduce(ofl,
3171 						    DBG_SYM_REDUCE_RETAIN,
3172 						    sdp, idx,
3173 						    ofl->ofl_osmove->os_name));
3174 
3175 					omvp->m_info =
3176 					    /* LINTED */
3177 					    ELF_M_INFO(sdp->sd_symndx,
3178 					    imvp->m_info);
3179 				}
3180 			}
3181 
3182 			DBG_CALL(Dbg_move_entry1(ofl->ofl_lml, 0, omvp, sdp));
3183 			omvp++;
3184 			idx++;
3185 		}
3186 	}
3187 }
3188 
3189 /*
3190  * Scan through the SHT_GROUP output sections.  Update their sh_link/sh_info
3191  * fields as well as the section contents.
3192  */
3193 static uintptr_t
3194 update_ogroup(Ofl_desc *ofl)
3195 {
3196 	Aliste		idx;
3197 	Os_desc		*osp;
3198 	uintptr_t	error = 0;
3199 
3200 	for (APLIST_TRAVERSE(ofl->ofl_osgroups, idx, osp)) {
3201 		Is_desc		*isp;
3202 		Ifl_desc	*ifl;
3203 		Shdr		*shdr = osp->os_shdr;
3204 		Sym_desc	*sdp;
3205 		Xword		i, grpcnt;
3206 		Word		*gdata;
3207 
3208 		/*
3209 		 * Since input GROUP sections always create unique
3210 		 * output GROUP sections - we know there is only one
3211 		 * item on the list.
3212 		 */
3213 		isp = ld_os_first_isdesc(osp);
3214 
3215 		ifl = isp->is_file;
3216 		sdp = ifl->ifl_oldndx[isp->is_shdr->sh_info];
3217 		shdr->sh_link = (Word)elf_ndxscn(ofl->ofl_ossymtab->os_scn);
3218 		shdr->sh_info = sdp->sd_symndx;
3219 
3220 		/*
3221 		 * Scan through the group data section and update
3222 		 * all of the links to new values.
3223 		 */
3224 		grpcnt = shdr->sh_size / shdr->sh_entsize;
3225 		gdata = (Word *)osp->os_outdata->d_buf;
3226 
3227 		for (i = 1; i < grpcnt; i++) {
3228 			Os_desc	*_osp;
3229 			Is_desc	*_isp = ifl->ifl_isdesc[gdata[i]];
3230 
3231 			/*
3232 			 * If the referenced section didn't make it to the
3233 			 * output file - just zero out the entry.
3234 			 */
3235 			if ((_osp = _isp->is_osdesc) == NULL)
3236 				gdata[i] = 0;
3237 			else
3238 				gdata[i] = (Word)elf_ndxscn(_osp->os_scn);
3239 		}
3240 	}
3241 	return (error);
3242 }
3243 
3244 static void
3245 update_ostrtab(Os_desc *osp, Str_tbl *stp, uint_t extra)
3246 {
3247 	Elf_Data	*data;
3248 
3249 	if (osp == NULL)
3250 		return;
3251 
3252 	data = osp->os_outdata;
3253 	assert(data->d_size == (st_getstrtab_sz(stp) + extra));
3254 	(void) st_setstrbuf(stp, data->d_buf, data->d_size - extra);
3255 	/* If leaving an extra hole at the end, zero it */
3256 	if (extra > 0)
3257 		(void) memset((char *)data->d_buf + data->d_size - extra,
3258 		    0x0, extra);
3259 }
3260 
3261 /*
3262  * Update capabilities information.
3263  *
3264  * If string table capabilities exist, then the associated string must be
3265  * translated into an offset into the string table.
3266  */
3267 static void
3268 update_oscap(Ofl_desc *ofl)
3269 {
3270 	Os_desc		*strosp, *cosp;
3271 	Cap		*cap;
3272 	Str_tbl		*strtbl;
3273 	Capstr		*capstr;
3274 	size_t		stoff;
3275 	Aliste		idx1;
3276 
3277 	/*
3278 	 * Determine which symbol table or string table is appropriate.
3279 	 */
3280 	if (OFL_IS_STATIC_OBJ(ofl)) {
3281 		strosp = ofl->ofl_osstrtab;
3282 		strtbl = ofl->ofl_strtab;
3283 	} else {
3284 		strosp = ofl->ofl_osdynstr;
3285 		strtbl = ofl->ofl_dynstrtab;
3286 	}
3287 
3288 	/*
3289 	 * If symbol capabilities exist, set the sh_link field of the .SUNW_cap
3290 	 * section to the .SUNW_capinfo section.
3291 	 */
3292 	if (ofl->ofl_oscapinfo) {
3293 		cosp = ofl->ofl_oscap;
3294 		cosp->os_shdr->sh_link =
3295 		    (Word)elf_ndxscn(ofl->ofl_oscapinfo->os_scn);
3296 	}
3297 
3298 	/*
3299 	 * If there are capability strings to process, set the sh_info
3300 	 * field of the .SUNW_cap section to the associated string table, and
3301 	 * proceed to process any CA_SUNW_PLAT entries.
3302 	 */
3303 	if ((ofl->ofl_flags & FLG_OF_CAPSTRS) == 0)
3304 		return;
3305 
3306 	cosp = ofl->ofl_oscap;
3307 	cosp->os_shdr->sh_info = (Word)elf_ndxscn(strosp->os_scn);
3308 
3309 	cap = ofl->ofl_oscap->os_outdata->d_buf;
3310 
3311 	/*
3312 	 * Determine whether an object capability identifier, or object
3313 	 * machine/platform capabilities exists.
3314 	 */
3315 	capstr = &ofl->ofl_ocapset.oc_id;
3316 	if (capstr->cs_str) {
3317 		(void) st_setstring(strtbl, capstr->cs_str, &stoff);
3318 		cap[capstr->cs_ndx].c_un.c_ptr = stoff;
3319 	}
3320 	for (ALIST_TRAVERSE(ofl->ofl_ocapset.oc_plat.cl_val, idx1, capstr)) {
3321 		(void) st_setstring(strtbl, capstr->cs_str, &stoff);
3322 		cap[capstr->cs_ndx].c_un.c_ptr = stoff;
3323 	}
3324 	for (ALIST_TRAVERSE(ofl->ofl_ocapset.oc_mach.cl_val, idx1, capstr)) {
3325 		(void) st_setstring(strtbl, capstr->cs_str, &stoff);
3326 		cap[capstr->cs_ndx].c_un.c_ptr = stoff;
3327 	}
3328 
3329 	/*
3330 	 * Determine any symbol capability identifiers, or machine/platform
3331 	 * capabilities.
3332 	 */
3333 	if (ofl->ofl_capgroups) {
3334 		Cap_group	*cgp;
3335 
3336 		for (APLIST_TRAVERSE(ofl->ofl_capgroups, idx1, cgp)) {
3337 			Objcapset	*ocapset = &cgp->cg_set;
3338 			Aliste		idx2;
3339 
3340 			capstr = &ocapset->oc_id;
3341 			if (capstr->cs_str) {
3342 				(void) st_setstring(strtbl, capstr->cs_str,
3343 				    &stoff);
3344 				cap[capstr->cs_ndx].c_un.c_ptr = stoff;
3345 			}
3346 			for (ALIST_TRAVERSE(ocapset->oc_plat.cl_val, idx2,
3347 			    capstr)) {
3348 				(void) st_setstring(strtbl, capstr->cs_str,
3349 				    &stoff);
3350 				cap[capstr->cs_ndx].c_un.c_ptr = stoff;
3351 			}
3352 			for (ALIST_TRAVERSE(ocapset->oc_mach.cl_val, idx2,
3353 			    capstr)) {
3354 				(void) st_setstring(strtbl, capstr->cs_str,
3355 				    &stoff);
3356 				cap[capstr->cs_ndx].c_un.c_ptr = stoff;
3357 			}
3358 		}
3359 	}
3360 }
3361 
3362 /*
3363  * Update the .SUNW_capinfo, and possibly the .SUNW_capchain sections.
3364  */
3365 static void
3366 update_oscapinfo(Ofl_desc *ofl)
3367 {
3368 	Os_desc		*symosp, *ciosp, *ccosp = NULL;
3369 	Capinfo		*ocapinfo;
3370 	Capchain	*ocapchain;
3371 	Cap_avlnode	*cav;
3372 	Word		chainndx = 0;
3373 
3374 	/*
3375 	 * Determine which symbol table is appropriate.
3376 	 */
3377 	if (OFL_IS_STATIC_OBJ(ofl))
3378 		symosp = ofl->ofl_ossymtab;
3379 	else
3380 		symosp = ofl->ofl_osdynsym;
3381 
3382 	/*
3383 	 * Update the .SUNW_capinfo sh_link to point to the appropriate symbol
3384 	 * table section.  If we're creating a dynamic object, the
3385 	 * .SUNW_capinfo sh_info is updated to point to the .SUNW_capchain
3386 	 * section.
3387 	 */
3388 	ciosp = ofl->ofl_oscapinfo;
3389 	ciosp->os_shdr->sh_link = (Word)elf_ndxscn(symosp->os_scn);
3390 
3391 	if (OFL_IS_STATIC_OBJ(ofl) == 0) {
3392 		ccosp = ofl->ofl_oscapchain;
3393 		ciosp->os_shdr->sh_info = (Word)elf_ndxscn(ccosp->os_scn);
3394 	}
3395 
3396 	/*
3397 	 * Establish the data for each section.  The first element of each
3398 	 * section defines the section's version number.
3399 	 */
3400 	ocapinfo = ciosp->os_outdata->d_buf;
3401 	ocapinfo[0] = CAPINFO_CURRENT;
3402 	if (ccosp) {
3403 		ocapchain = ccosp->os_outdata->d_buf;
3404 		ocapchain[chainndx++] = CAPCHAIN_CURRENT;
3405 	}
3406 
3407 	/*
3408 	 * Traverse all capabilities families.  Each member has a .SUNW_capinfo
3409 	 * assignment.  The .SUNW_capinfo entry differs for relocatable objects
3410 	 * and dynamic objects.
3411 	 *
3412 	 * Relocatable objects:
3413 	 *			ELF_C_GROUP		ELF_C_SYM
3414 	 *
3415 	 * Family lead:		CAPINFO_SUNW_GLOB	lead symbol index
3416 	 * Family lead alias:	CAPINFO_SUNW_GLOB	lead symbol index
3417 	 * Family member:	.SUNW_cap index		lead symbol index
3418 	 *
3419 	 * Dynamic objects:
3420 	 *			ELF_C_GROUP		ELF_C_SYM
3421 	 *
3422 	 * Family lead:		CAPINFO_SUNW_GLOB	.SUNW_capchain index
3423 	 * Family lead alias:	CAPINFO_SUNW_GLOB	.SUNW_capchain index
3424 	 * Family member:	.SUNW_cap index		lead symbol index
3425 	 *
3426 	 * The ELF_C_GROUP field identifies a capabilities symbol.  Lead
3427 	 * capability symbols, and lead capability aliases are identified by
3428 	 * a CAPINFO_SUNW_GLOB group identifier.  For family members, the
3429 	 * ELF_C_GROUP provides an index to the associate capabilities group
3430 	 * (i.e, an index into the SUNW_cap section that defines a group).
3431 	 *
3432 	 * For relocatable objects, the ELF_C_SYM field identifies the lead
3433 	 * capability symbol.  For the lead symbol itself, the .SUNW_capinfo
3434 	 * index is the same as the ELF_C_SYM value.  For lead alias symbols,
3435 	 * the .SUNW_capinfo index differs from the ELF_C_SYM value.  This
3436 	 * differentiation of CAPINFO_SUNW_GLOB symbols allows ld(1) to
3437 	 * identify, and propagate lead alias symbols.  For example, the lead
3438 	 * capability symbol memcpy() would have the ELF_C_SYM for memcpy(),
3439 	 * and the lead alias _memcpy() would also have the ELF_C_SYM for
3440 	 * memcpy().
3441 	 *
3442 	 * For dynamic objects, both a lead capability symbol, and alias symbol
3443 	 * would have a ELF_C_SYM value that represents the same capability
3444 	 * chain index.  The capability chain allows ld.so.1 to traverse a
3445 	 * family chain for a given lead symbol, and select the most appropriate
3446 	 * family member.  The .SUNW_capchain array contains a series of symbol
3447 	 * indexes for each family member:
3448 	 *
3449 	 *    chaincap[n]  chaincap[n + 1]  chaincap[n + 2]  chaincap[n + x]
3450 	 *	foo() ndx    foo%x() ndx	foo%y() ndx	0
3451 	 *
3452 	 * For family members, the ELF_C_SYM value associates the capability
3453 	 * members with their family lead symbol.  This association, although
3454 	 * unused within a dynamic object, allows ld(1) to identify, and
3455 	 * propagate family members when processing relocatable objects.
3456 	 */
3457 	for (cav = avl_first(ofl->ofl_capfamilies); cav;
3458 	    cav = AVL_NEXT(ofl->ofl_capfamilies, cav)) {
3459 		Cap_sym		*csp;
3460 		Aliste		idx;
3461 		Sym_desc	*asdp, *lsdp = cav->cn_symavlnode.sav_sdp;
3462 
3463 		if (ccosp) {
3464 			/*
3465 			 * For a dynamic object, identify this lead symbol, and
3466 			 * point it to the head of a capability chain.  Set the
3467 			 * head of the capability chain to the same lead symbol.
3468 			 */
3469 			ocapinfo[lsdp->sd_symndx] =
3470 			    ELF_C_INFO(chainndx, CAPINFO_SUNW_GLOB);
3471 			ocapchain[chainndx] = lsdp->sd_symndx;
3472 		} else {
3473 			/*
3474 			 * For a relocatable object, identify this lead symbol,
3475 			 * and set the lead symbol index to itself.
3476 			 */
3477 			ocapinfo[lsdp->sd_symndx] =
3478 			    ELF_C_INFO(lsdp->sd_symndx, CAPINFO_SUNW_GLOB);
3479 		}
3480 
3481 		/*
3482 		 * Gather any lead symbol aliases.
3483 		 */
3484 		for (APLIST_TRAVERSE(cav->cn_aliases, idx, asdp)) {
3485 			if (ccosp) {
3486 				/*
3487 				 * For a dynamic object, identify this lead
3488 				 * alias symbol, and point it to the same
3489 				 * capability chain index as the lead symbol.
3490 				 */
3491 				ocapinfo[asdp->sd_symndx] =
3492 				    ELF_C_INFO(chainndx, CAPINFO_SUNW_GLOB);
3493 			} else {
3494 				/*
3495 				 * For a relocatable object, identify this lead
3496 				 * alias symbol, and set the lead symbol index
3497 				 * to the lead symbol.
3498 				 */
3499 				ocapinfo[asdp->sd_symndx] =
3500 				    ELF_C_INFO(lsdp->sd_symndx,
3501 				    CAPINFO_SUNW_GLOB);
3502 			}
3503 		}
3504 
3505 		chainndx++;
3506 
3507 		/*
3508 		 * Gather the family members.
3509 		 */
3510 		for (APLIST_TRAVERSE(cav->cn_members, idx, csp)) {
3511 			Sym_desc	*msdp = csp->cs_sdp;
3512 
3513 			/*
3514 			 * Identify the members capability group, and the lead
3515 			 * symbol of the family this symbol is a member of.
3516 			 */
3517 			ocapinfo[msdp->sd_symndx] =
3518 			    ELF_C_INFO(lsdp->sd_symndx, csp->cs_group->cg_ndx);
3519 			if (ccosp) {
3520 				/*
3521 				 * For a dynamic object, set the next capability
3522 				 * chain to point to this family member.
3523 				 */
3524 				ocapchain[chainndx++] = msdp->sd_symndx;
3525 			}
3526 		}
3527 
3528 		/*
3529 		 * Any chain of family members is terminated with a 0 element.
3530 		 */
3531 		if (ccosp)
3532 			ocapchain[chainndx++] = 0;
3533 	}
3534 }
3535 
3536 /*
3537  * Translate the shdr->sh_{link, info} from its input section value to that
3538  * of the corresponding shdr->sh_{link, info} output section value.
3539  */
3540 static Word
3541 translate_link(Ofl_desc *ofl, Os_desc *osp, Word link, const char *msg)
3542 {
3543 	Is_desc		*isp;
3544 	Ifl_desc	*ifl;
3545 
3546 	/*
3547 	 * Don't translate the special section numbers.
3548 	 */
3549 	if (link >= SHN_LORESERVE)
3550 		return (link);
3551 
3552 	/*
3553 	 * Does this output section translate back to an input file.  If not
3554 	 * then there is no translation to do.  In this case we will assume that
3555 	 * if sh_link has a value, it's the right value.
3556 	 */
3557 	isp = ld_os_first_isdesc(osp);
3558 	if ((ifl = isp->is_file) == NULL)
3559 		return (link);
3560 
3561 	/*
3562 	 * Sanity check to make sure that the sh_{link, info} value
3563 	 * is within range for the input file.
3564 	 */
3565 	if (link >= ifl->ifl_shnum) {
3566 		ld_eprintf(ofl, ERR_WARNING, msg, ifl->ifl_name,
3567 		    EC_WORD(isp->is_scnndx), isp->is_name, EC_XWORD(link));
3568 		return (link);
3569 	}
3570 
3571 	/*
3572 	 * Follow the link to the input section.
3573 	 */
3574 	if ((isp = ifl->ifl_isdesc[link]) == NULL)
3575 		return (0);
3576 	if ((osp = isp->is_osdesc) == NULL)
3577 		return (0);
3578 
3579 	/* LINTED */
3580 	return ((Word)elf_ndxscn(osp->os_scn));
3581 }
3582 
3583 /*
3584  * Having created all of the necessary sections, segments, and associated
3585  * headers, fill in the program headers and update any other data in the
3586  * output image.  Some general rules:
3587  *
3588  *  -	If an interpreter is required always generate a PT_PHDR entry as
3589  *	well.  It is this entry that triggers the kernel into passing the
3590  *	interpreter an aux vector instead of just a file descriptor.
3591  *
3592  *  -	When generating an image that will be interpreted (ie. a dynamic
3593  *	executable, a shared object, or a static executable that has been
3594  *	provided with an interpreter - weird, but possible), make the initial
3595  *	loadable segment include both the ehdr and phdr[].  Both of these
3596  *	tables are used by the interpreter therefore it seems more intuitive
3597  *	to explicitly defined them as part of the mapped image rather than
3598  *	relying on page rounding by the interpreter to allow their access.
3599  *
3600  *  -	When generating a static image that does not require an interpreter
3601  *	have the first loadable segment indicate the address of the first
3602  *	.section as the start address (things like /kernel/unix and ufsboot
3603  *	expect this behavior).
3604  */
3605 uintptr_t
3606 ld_update_outfile(Ofl_desc *ofl)
3607 {
3608 	Addr		size, etext, vaddr;
3609 	Sg_desc		*sgp;
3610 	Sg_desc		*dtracesgp = NULL, *capsgp = NULL, *intpsgp = NULL;
3611 	Os_desc		*osp;
3612 	int		phdrndx = 0, segndx = -1, secndx, intppndx, intpsndx;
3613 	int		dtracepndx, dtracesndx, cappndx, capsndx;
3614 	Ehdr		*ehdr = ofl->ofl_nehdr;
3615 	Shdr		*hshdr;
3616 	Phdr		*_phdr = NULL;
3617 	Word		phdrsz = (ehdr->e_phnum * ehdr->e_phentsize), shscnndx;
3618 	ofl_flag_t	flags = ofl->ofl_flags;
3619 	Word		ehdrsz = ehdr->e_ehsize;
3620 	Boolean		nobits;
3621 	Off		offset;
3622 	Aliste		idx1;
3623 
3624 	/*
3625 	 * Initialize the starting address for the first segment.  Executables
3626 	 * have different starting addresses depending upon the target ABI,
3627 	 * where as shared objects have a starting address of 0.  If this is
3628 	 * a 64-bit executable that is being constructed to run in a restricted
3629 	 * address space, use an alternative origin that will provide more free
3630 	 * address space for the the eventual process.
3631 	 */
3632 	if (ofl->ofl_flags & FLG_OF_EXEC) {
3633 #if	defined(_ELF64)
3634 		if (ofl->ofl_ocapset.oc_sf_1.cm_val & SF1_SUNW_ADDR32)
3635 			vaddr = ld_targ.t_m.m_segm_aorigin;
3636 		else
3637 #endif
3638 			vaddr = ld_targ.t_m.m_segm_origin;
3639 	} else
3640 		vaddr = 0;
3641 
3642 	/*
3643 	 * Loop through the segment descriptors and pick out what we need.
3644 	 */
3645 	DBG_CALL(Dbg_seg_title(ofl->ofl_lml));
3646 	for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
3647 		Phdr		*phdr = &(sgp->sg_phdr);
3648 		Xword 		p_align;
3649 		Aliste		idx2;
3650 		Sym_desc	*sdp;
3651 
3652 		segndx++;
3653 
3654 		/*
3655 		 * If an interpreter is required generate a PT_INTERP and
3656 		 * PT_PHDR program header entry.  The PT_PHDR entry describes
3657 		 * the program header table itself.  This information will be
3658 		 * passed via the aux vector to the interpreter (ld.so.1).
3659 		 * The program header array is actually part of the first
3660 		 * loadable segment (and the PT_PHDR entry is the first entry),
3661 		 * therefore its virtual address isn't known until the first
3662 		 * loadable segment is processed.
3663 		 */
3664 		if (phdr->p_type == PT_PHDR) {
3665 			if (ofl->ofl_osinterp) {
3666 				phdr->p_offset = ehdr->e_phoff;
3667 				phdr->p_filesz = phdr->p_memsz = phdrsz;
3668 
3669 				DBG_CALL(Dbg_seg_entry(ofl, segndx, sgp));
3670 				ofl->ofl_phdr[phdrndx++] = *phdr;
3671 			}
3672 			continue;
3673 		}
3674 		if (phdr->p_type == PT_INTERP) {
3675 			if (ofl->ofl_osinterp) {
3676 				intpsgp = sgp;
3677 				intpsndx = segndx;
3678 				intppndx = phdrndx++;
3679 			}
3680 			continue;
3681 		}
3682 
3683 		/*
3684 		 * If we are creating a PT_SUNWDTRACE segment, remember where
3685 		 * the program header is.  The header values are assigned after
3686 		 * update_osym() has completed and the symbol table addresses
3687 		 * have been updated.
3688 		 */
3689 		if (phdr->p_type == PT_SUNWDTRACE) {
3690 			if (ofl->ofl_dtracesym &&
3691 			    ((flags & FLG_OF_RELOBJ) == 0)) {
3692 				dtracesgp = sgp;
3693 				dtracesndx = segndx;
3694 				dtracepndx = phdrndx++;
3695 			}
3696 			continue;
3697 		}
3698 
3699 		/*
3700 		 * If a hardware/software capabilities section is required,
3701 		 * generate the PT_SUNWCAP header.  Note, as this comes before
3702 		 * the first loadable segment, we don't yet know its real
3703 		 * virtual address.  This is updated later.
3704 		 */
3705 		if (phdr->p_type == PT_SUNWCAP) {
3706 			if (ofl->ofl_oscap && (ofl->ofl_flags & FLG_OF_PTCAP) &&
3707 			    ((flags & FLG_OF_RELOBJ) == 0)) {
3708 				capsgp = sgp;
3709 				capsndx = segndx;
3710 				cappndx = phdrndx++;
3711 			}
3712 			continue;
3713 		}
3714 
3715 		/*
3716 		 * As the dynamic program header occurs after the loadable
3717 		 * headers in the segment descriptor table, all the address
3718 		 * information for the .dynamic output section will have been
3719 		 * figured out by now.
3720 		 */
3721 		if (phdr->p_type == PT_DYNAMIC) {
3722 			if (OFL_ALLOW_DYNSYM(ofl)) {
3723 				Shdr	*shdr = ofl->ofl_osdynamic->os_shdr;
3724 
3725 				phdr->p_vaddr = shdr->sh_addr;
3726 				phdr->p_offset = shdr->sh_offset;
3727 				phdr->p_filesz = shdr->sh_size;
3728 				phdr->p_flags = ld_targ.t_m.m_dataseg_perm;
3729 
3730 				DBG_CALL(Dbg_seg_entry(ofl, segndx, sgp));
3731 				ofl->ofl_phdr[phdrndx++] = *phdr;
3732 			}
3733 			continue;
3734 		}
3735 
3736 		/*
3737 		 * As the unwind (.eh_frame_hdr) program header occurs after
3738 		 * the loadable headers in the segment descriptor table, all
3739 		 * the address information for the .eh_frame output section
3740 		 * will have been figured out by now.
3741 		 */
3742 		if (phdr->p_type == PT_SUNW_UNWIND) {
3743 			Shdr	    *shdr;
3744 
3745 			if (ofl->ofl_unwindhdr == NULL)
3746 				continue;
3747 
3748 			shdr = ofl->ofl_unwindhdr->os_shdr;
3749 
3750 			phdr->p_flags = PF_R;
3751 			phdr->p_vaddr = shdr->sh_addr;
3752 			phdr->p_memsz = shdr->sh_size;
3753 			phdr->p_filesz = shdr->sh_size;
3754 			phdr->p_offset = shdr->sh_offset;
3755 			phdr->p_align = shdr->sh_addralign;
3756 			phdr->p_paddr = 0;
3757 			ofl->ofl_phdr[phdrndx++] = *phdr;
3758 			continue;
3759 		}
3760 
3761 		/*
3762 		 * The sunwstack program is used to convey non-default
3763 		 * flags for the process stack. Only emit it if it would
3764 		 * change the default.
3765 		 */
3766 		if (phdr->p_type == PT_SUNWSTACK) {
3767 			if (((flags & FLG_OF_RELOBJ) == 0) &&
3768 			    ((sgp->sg_flags & FLG_SG_DISABLED) == 0))
3769 				ofl->ofl_phdr[phdrndx++] = *phdr;
3770 			continue;
3771 		}
3772 
3773 		/*
3774 		 * As the TLS program header occurs after the loadable
3775 		 * headers in the segment descriptor table, all the address
3776 		 * information for the .tls output section will have been
3777 		 * figured out by now.
3778 		 */
3779 		if (phdr->p_type == PT_TLS) {
3780 			Os_desc		*tlsosp;
3781 			Shdr		*lastfileshdr = NULL;
3782 			Shdr		*firstshdr = NULL, *lastshdr;
3783 			Aliste		idx;
3784 
3785 			if (ofl->ofl_ostlsseg == NULL)
3786 				continue;
3787 
3788 			/*
3789 			 * Scan the output sections that have contributed TLS.
3790 			 * Remember the first and last so as to determine the
3791 			 * TLS memory size requirement.  Remember the last
3792 			 * progbits section to determine the TLS data
3793 			 * contribution, which determines the TLS program
3794 			 * header filesz.
3795 			 */
3796 			for (APLIST_TRAVERSE(ofl->ofl_ostlsseg, idx, tlsosp)) {
3797 				Shdr	*tlsshdr = tlsosp->os_shdr;
3798 
3799 				if (firstshdr == NULL)
3800 					firstshdr = tlsshdr;
3801 				if (tlsshdr->sh_type != SHT_NOBITS)
3802 					lastfileshdr = tlsshdr;
3803 				lastshdr = tlsshdr;
3804 			}
3805 
3806 			phdr->p_flags = PF_R | PF_W;
3807 			phdr->p_vaddr = firstshdr->sh_addr;
3808 			phdr->p_offset = firstshdr->sh_offset;
3809 			phdr->p_align = firstshdr->sh_addralign;
3810 
3811 			/*
3812 			 * Determine the initialized TLS data size.  This
3813 			 * address range is from the start of the TLS segment
3814 			 * to the end of the last piece of initialized data.
3815 			 */
3816 			if (lastfileshdr)
3817 				phdr->p_filesz = lastfileshdr->sh_offset +
3818 				    lastfileshdr->sh_size - phdr->p_offset;
3819 			else
3820 				phdr->p_filesz = 0;
3821 
3822 			/*
3823 			 * Determine the total TLS memory size.  This includes
3824 			 * all TLS data and TLS uninitialized data.  This
3825 			 * address range is from the start of the TLS segment
3826 			 * to the memory address of the last piece of
3827 			 * uninitialized data.
3828 			 */
3829 			phdr->p_memsz = lastshdr->sh_addr +
3830 			    lastshdr->sh_size - phdr->p_vaddr;
3831 
3832 			DBG_CALL(Dbg_seg_entry(ofl, segndx, sgp));
3833 			ofl->ofl_phdr[phdrndx] = *phdr;
3834 			ofl->ofl_tlsphdr = &ofl->ofl_phdr[phdrndx++];
3835 			continue;
3836 		}
3837 
3838 		/*
3839 		 * If this is an empty segment declaration, it will occur after
3840 		 * all other loadable segments.  As empty segments can be
3841 		 * defined with fixed addresses, make sure that no loadable
3842 		 * segments overlap.  This might occur as the object evolves
3843 		 * and the loadable segments grow, thus encroaching upon an
3844 		 * existing segment reservation.
3845 		 *
3846 		 * Segments are only created for dynamic objects, thus this
3847 		 * checking can be skipped when building a relocatable object.
3848 		 */
3849 		if (!(flags & FLG_OF_RELOBJ) &&
3850 		    (sgp->sg_flags & FLG_SG_EMPTY)) {
3851 			int	i;
3852 			Addr	v_e;
3853 
3854 			vaddr = phdr->p_vaddr;
3855 			phdr->p_memsz = sgp->sg_length;
3856 			DBG_CALL(Dbg_seg_entry(ofl, segndx, sgp));
3857 			ofl->ofl_phdr[phdrndx++] = *phdr;
3858 
3859 			if (phdr->p_type != PT_LOAD)
3860 				continue;
3861 
3862 			v_e = vaddr + phdr->p_memsz;
3863 
3864 			/*
3865 			 * Check overlaps
3866 			 */
3867 			for (i = 0; i < phdrndx - 1; i++) {
3868 				Addr 	p_s = (ofl->ofl_phdr[i]).p_vaddr;
3869 				Addr 	p_e;
3870 
3871 				if ((ofl->ofl_phdr[i]).p_type != PT_LOAD)
3872 					continue;
3873 
3874 				p_e = p_s + (ofl->ofl_phdr[i]).p_memsz;
3875 				if (((p_s <= vaddr) && (p_e > vaddr)) ||
3876 				    ((vaddr <= p_s) && (v_e > p_s)))
3877 					ld_eprintf(ofl, ERR_WARNING,
3878 					    MSG_INTL(MSG_UPD_SEGOVERLAP),
3879 					    ofl->ofl_name, EC_ADDR(p_e),
3880 					    sgp->sg_name, EC_ADDR(vaddr));
3881 			}
3882 			continue;
3883 		}
3884 
3885 		/*
3886 		 * Having processed any of the special program headers any
3887 		 * remaining headers will be built to express individual
3888 		 * segments.  Segments are only built if they have output
3889 		 * section descriptors associated with them (ie. some form of
3890 		 * input section has been matched to this segment).
3891 		 */
3892 		if (sgp->sg_osdescs == NULL)
3893 			continue;
3894 
3895 		/*
3896 		 * Determine the segments offset and size from the section
3897 		 * information provided from elf_update().
3898 		 * Allow for multiple NOBITS sections.
3899 		 */
3900 		osp = sgp->sg_osdescs->apl_data[0];
3901 		hshdr = osp->os_shdr;
3902 
3903 		phdr->p_filesz = 0;
3904 		phdr->p_memsz = 0;
3905 		phdr->p_offset = offset = hshdr->sh_offset;
3906 
3907 		nobits = ((hshdr->sh_type == SHT_NOBITS) &&
3908 		    ((sgp->sg_flags & FLG_SG_PHREQ) == 0));
3909 
3910 		for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
3911 			Shdr	*shdr = osp->os_shdr;
3912 
3913 			p_align = 0;
3914 			if (shdr->sh_addralign > p_align)
3915 				p_align = shdr->sh_addralign;
3916 
3917 			offset = (Off)S_ROUND(offset, shdr->sh_addralign);
3918 			offset += shdr->sh_size;
3919 
3920 			if (shdr->sh_type != SHT_NOBITS) {
3921 				if (nobits) {
3922 					ld_eprintf(ofl, ERR_FATAL,
3923 					    MSG_INTL(MSG_UPD_NOBITS));
3924 					return (S_ERROR);
3925 				}
3926 				phdr->p_filesz = offset - phdr->p_offset;
3927 			} else if ((sgp->sg_flags & FLG_SG_PHREQ) == 0)
3928 				nobits = TRUE;
3929 		}
3930 		phdr->p_memsz = offset - hshdr->sh_offset;
3931 
3932 		/*
3933 		 * If this is the first loadable segment of a dynamic object,
3934 		 * or an interpreter has been specified (a static object built
3935 		 * with an interpreter will still be given a PT_HDR entry), then
3936 		 * compensate for the elf header and program header array.  Both
3937 		 * of these are actually part of the loadable segment as they
3938 		 * may be inspected by the interpreter.  Adjust the segments
3939 		 * size and offset accordingly.
3940 		 */
3941 		if ((_phdr == NULL) && (phdr->p_type == PT_LOAD) &&
3942 		    ((ofl->ofl_osinterp) || (flags & FLG_OF_DYNAMIC)) &&
3943 		    (!(ofl->ofl_dtflags_1 & DF_1_NOHDR))) {
3944 			size = (Addr)S_ROUND((phdrsz + ehdrsz),
3945 			    hshdr->sh_addralign);
3946 			phdr->p_offset -= size;
3947 			phdr->p_filesz += size;
3948 			phdr->p_memsz += size;
3949 		}
3950 
3951 		/*
3952 		 * If segment size symbols are required (specified via a
3953 		 * mapfile) update their value.
3954 		 */
3955 		for (APLIST_TRAVERSE(sgp->sg_sizesym, idx2, sdp))
3956 			sdp->sd_sym->st_value = phdr->p_memsz;
3957 
3958 		/*
3959 		 * If no file content has been assigned to this segment (it
3960 		 * only contains no-bits sections), then reset the offset for
3961 		 * consistency.
3962 		 */
3963 		if (phdr->p_filesz == 0)
3964 			phdr->p_offset = 0;
3965 
3966 		/*
3967 		 * If a virtual address has been specified for this segment
3968 		 * from a mapfile use it and make sure the previous segment
3969 		 * does not run into this segment.
3970 		 */
3971 		if (phdr->p_type == PT_LOAD) {
3972 			if ((sgp->sg_flags & FLG_SG_P_VADDR)) {
3973 				if (_phdr && (vaddr > phdr->p_vaddr) &&
3974 				    (phdr->p_type == PT_LOAD))
3975 					ld_eprintf(ofl, ERR_WARNING,
3976 					    MSG_INTL(MSG_UPD_SEGOVERLAP),
3977 					    ofl->ofl_name, EC_ADDR(vaddr),
3978 					    sgp->sg_name,
3979 					    EC_ADDR(phdr->p_vaddr));
3980 				vaddr = phdr->p_vaddr;
3981 				phdr->p_align = 0;
3982 			} else {
3983 				vaddr = phdr->p_vaddr =
3984 				    (Addr)S_ROUND(vaddr, phdr->p_align);
3985 			}
3986 		}
3987 
3988 		/*
3989 		 * Adjust the address offset and p_align if needed.
3990 		 */
3991 		if (((sgp->sg_flags & FLG_SG_P_VADDR) == 0) &&
3992 		    ((ofl->ofl_dtflags_1 & DF_1_NOHDR) == 0)) {
3993 			if (phdr->p_align != 0)
3994 				vaddr += phdr->p_offset % phdr->p_align;
3995 			else
3996 				vaddr += phdr->p_offset;
3997 			phdr->p_vaddr = vaddr;
3998 		}
3999 
4000 		/*
4001 		 * If an interpreter is required set the virtual address of the
4002 		 * PT_PHDR program header now that we know the virtual address
4003 		 * of the loadable segment that contains it.  Update the
4004 		 * PT_SUNWCAP header similarly.
4005 		 */
4006 		if ((_phdr == NULL) && (phdr->p_type == PT_LOAD)) {
4007 			_phdr = phdr;
4008 
4009 			if ((ofl->ofl_dtflags_1 & DF_1_NOHDR) == 0) {
4010 				if (ofl->ofl_osinterp)
4011 					ofl->ofl_phdr[0].p_vaddr =
4012 					    vaddr + ehdrsz;
4013 
4014 				/*
4015 				 * Finally, if we're creating a dynamic object
4016 				 * (or a static object in which an interpreter
4017 				 * is specified) update the vaddr to reflect
4018 				 * the address of the first section within this
4019 				 * segment.
4020 				 */
4021 				if ((ofl->ofl_osinterp) ||
4022 				    (flags & FLG_OF_DYNAMIC))
4023 					vaddr += size;
4024 			} else {
4025 				/*
4026 				 * If the DF_1_NOHDR flag was set, and an
4027 				 * interpreter is being generated, the PT_PHDR
4028 				 * will not be part of any loadable segment.
4029 				 */
4030 				if (ofl->ofl_osinterp) {
4031 					ofl->ofl_phdr[0].p_vaddr = 0;
4032 					ofl->ofl_phdr[0].p_memsz = 0;
4033 					ofl->ofl_phdr[0].p_flags = 0;
4034 				}
4035 			}
4036 		}
4037 
4038 		/*
4039 		 * Ensure the ELF entry point defaults to zero.  Typically, this
4040 		 * value is overridden in update_oehdr() to one of the standard
4041 		 * entry points.  Historically, this default was set to the
4042 		 * address of first executable section, but this has since been
4043 		 * found to be more confusing than it is helpful.
4044 		 */
4045 		ehdr->e_entry = 0;
4046 
4047 		DBG_CALL(Dbg_seg_entry(ofl, segndx, sgp));
4048 
4049 		/*
4050 		 * Traverse the output section descriptors for this segment so
4051 		 * that we can update the section headers addresses.  We've
4052 		 * calculated the virtual address of the initial section within
4053 		 * this segment, so each successive section can be calculated
4054 		 * based on their offsets from each other.
4055 		 */
4056 		secndx = 0;
4057 		hshdr = 0;
4058 		for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
4059 			Shdr	*shdr = osp->os_shdr;
4060 
4061 			if (shdr->sh_link)
4062 				shdr->sh_link = translate_link(ofl, osp,
4063 				    shdr->sh_link, MSG_INTL(MSG_FIL_INVSHLINK));
4064 
4065 			if (shdr->sh_info && (shdr->sh_flags & SHF_INFO_LINK))
4066 				shdr->sh_info = translate_link(ofl, osp,
4067 				    shdr->sh_info, MSG_INTL(MSG_FIL_INVSHINFO));
4068 
4069 			if (!(flags & FLG_OF_RELOBJ) &&
4070 			    (phdr->p_type == PT_LOAD)) {
4071 				if (hshdr)
4072 					vaddr += (shdr->sh_offset -
4073 					    hshdr->sh_offset);
4074 
4075 				shdr->sh_addr = vaddr;
4076 				hshdr = shdr;
4077 			}
4078 
4079 			DBG_CALL(Dbg_seg_os(ofl, osp, secndx));
4080 			secndx++;
4081 		}
4082 
4083 		/*
4084 		 * Establish the virtual address of the end of the last section
4085 		 * in this segment so that the next segments offset can be
4086 		 * calculated from this.
4087 		 */
4088 		if (hshdr)
4089 			vaddr += hshdr->sh_size;
4090 
4091 		/*
4092 		 * Output sections for this segment complete.  Adjust the
4093 		 * virtual offset for the last sections size, and make sure we
4094 		 * haven't exceeded any maximum segment length specification.
4095 		 */
4096 		if ((sgp->sg_length != 0) && (sgp->sg_length < phdr->p_memsz)) {
4097 			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_UPD_LARGSIZE),
4098 			    ofl->ofl_name, sgp->sg_name,
4099 			    EC_XWORD(phdr->p_memsz), EC_XWORD(sgp->sg_length));
4100 			return (S_ERROR);
4101 		}
4102 
4103 		if (phdr->p_type == PT_NOTE) {
4104 			phdr->p_vaddr = 0;
4105 			phdr->p_paddr = 0;
4106 			phdr->p_align = 0;
4107 			phdr->p_memsz = 0;
4108 		}
4109 
4110 		if ((phdr->p_type != PT_NULL) && !(flags & FLG_OF_RELOBJ))
4111 			ofl->ofl_phdr[phdrndx++] = *phdr;
4112 	}
4113 
4114 	/*
4115 	 * Update any new output sections.  When building the initial output
4116 	 * image, a number of sections were created but left uninitialized (eg.
4117 	 * .dynsym, .dynstr, .symtab, .symtab, etc.).  Here we update these
4118 	 * sections with the appropriate data.  Other sections may still be
4119 	 * modified via reloc_process().
4120 	 *
4121 	 * Copy the interpreter name into the .interp section.
4122 	 */
4123 	if (ofl->ofl_interp)
4124 		(void) strcpy((char *)ofl->ofl_osinterp->os_outdata->d_buf,
4125 		    ofl->ofl_interp);
4126 
4127 	/*
4128 	 * Update the .shstrtab, .strtab and .dynstr sections.
4129 	 */
4130 	update_ostrtab(ofl->ofl_osshstrtab, ofl->ofl_shdrsttab, 0);
4131 	update_ostrtab(ofl->ofl_osstrtab, ofl->ofl_strtab, 0);
4132 	update_ostrtab(ofl->ofl_osdynstr, ofl->ofl_dynstrtab, DYNSTR_EXTRA_PAD);
4133 
4134 	/*
4135 	 * Build any output symbol tables, the symbols information is copied
4136 	 * and updated into the new output image.
4137 	 */
4138 	if ((etext = update_osym(ofl)) == (Addr)S_ERROR)
4139 		return (S_ERROR);
4140 
4141 	/*
4142 	 * If we have an PT_INTERP phdr, update it now from the associated
4143 	 * section information.
4144 	 */
4145 	if (intpsgp) {
4146 		Phdr	*phdr = &(intpsgp->sg_phdr);
4147 		Shdr	*shdr = ofl->ofl_osinterp->os_shdr;
4148 
4149 		phdr->p_vaddr = shdr->sh_addr;
4150 		phdr->p_offset = shdr->sh_offset;
4151 		phdr->p_memsz = phdr->p_filesz = shdr->sh_size;
4152 		phdr->p_flags = PF_R;
4153 
4154 		DBG_CALL(Dbg_seg_entry(ofl, intpsndx, intpsgp));
4155 		ofl->ofl_phdr[intppndx] = *phdr;
4156 	}
4157 
4158 	/*
4159 	 * If we have a PT_SUNWDTRACE phdr, update it now with the address of
4160 	 * the symbol.  It's only now been updated via update_sym().
4161 	 */
4162 	if (dtracesgp) {
4163 		Phdr		*aphdr, *phdr = &(dtracesgp->sg_phdr);
4164 		Sym_desc	*sdp = ofl->ofl_dtracesym;
4165 
4166 		phdr->p_vaddr = sdp->sd_sym->st_value;
4167 		phdr->p_memsz = sdp->sd_sym->st_size;
4168 
4169 		/*
4170 		 * Take permissions from the segment that the symbol is
4171 		 * associated with.
4172 		 */
4173 		aphdr = &sdp->sd_isc->is_osdesc->os_sgdesc->sg_phdr;
4174 		assert(aphdr);
4175 		phdr->p_flags = aphdr->p_flags;
4176 
4177 		DBG_CALL(Dbg_seg_entry(ofl, dtracesndx, dtracesgp));
4178 		ofl->ofl_phdr[dtracepndx] = *phdr;
4179 	}
4180 
4181 	/*
4182 	 * If we have a PT_SUNWCAP phdr, update it now from the associated
4183 	 * section information.
4184 	 */
4185 	if (capsgp) {
4186 		Phdr	*phdr = &(capsgp->sg_phdr);
4187 		Shdr	*shdr = ofl->ofl_oscap->os_shdr;
4188 
4189 		phdr->p_vaddr = shdr->sh_addr;
4190 		phdr->p_offset = shdr->sh_offset;
4191 		phdr->p_memsz = phdr->p_filesz = shdr->sh_size;
4192 		phdr->p_flags = PF_R;
4193 
4194 		DBG_CALL(Dbg_seg_entry(ofl, capsndx, capsgp));
4195 		ofl->ofl_phdr[cappndx] = *phdr;
4196 	}
4197 
4198 	/*
4199 	 * Update the GROUP sections.
4200 	 */
4201 	if (update_ogroup(ofl) == S_ERROR)
4202 		return (S_ERROR);
4203 
4204 	/*
4205 	 * Update Move Table.
4206 	 */
4207 	if (ofl->ofl_osmove || ofl->ofl_isparexpn)
4208 		update_move(ofl);
4209 
4210 	/*
4211 	 * Build any output headers, version information, dynamic structure and
4212 	 * syminfo structure.
4213 	 */
4214 	if (update_oehdr(ofl) == S_ERROR)
4215 		return (S_ERROR);
4216 	if (!(flags & FLG_OF_NOVERSEC)) {
4217 		if ((flags & FLG_OF_VERDEF) &&
4218 		    (update_overdef(ofl) == S_ERROR))
4219 			return (S_ERROR);
4220 		if ((flags & FLG_OF_VERNEED) &&
4221 		    (update_overneed(ofl) == S_ERROR))
4222 			return (S_ERROR);
4223 		if (flags & (FLG_OF_VERNEED | FLG_OF_VERDEF))
4224 			update_oversym(ofl);
4225 	}
4226 	if (flags & FLG_OF_DYNAMIC) {
4227 		if (update_odynamic(ofl) == S_ERROR)
4228 			return (S_ERROR);
4229 	}
4230 	if (ofl->ofl_ossyminfo) {
4231 		if (update_osyminfo(ofl) == S_ERROR)
4232 			return (S_ERROR);
4233 	}
4234 
4235 	/*
4236 	 * Update capabilities information if required.
4237 	 */
4238 	if (ofl->ofl_oscap)
4239 		update_oscap(ofl);
4240 	if (ofl->ofl_oscapinfo)
4241 		update_oscapinfo(ofl);
4242 
4243 	/*
4244 	 * Sanity test: the first and last data byte of a string table
4245 	 * must be NULL.
4246 	 */
4247 	assert((ofl->ofl_osshstrtab == NULL) ||
4248 	    (*((char *)ofl->ofl_osshstrtab->os_outdata->d_buf) == '\0'));
4249 	assert((ofl->ofl_osshstrtab == NULL) ||
4250 	    (*(((char *)ofl->ofl_osshstrtab->os_outdata->d_buf) +
4251 	    ofl->ofl_osshstrtab->os_outdata->d_size - 1) == '\0'));
4252 
4253 	assert((ofl->ofl_osstrtab == NULL) ||
4254 	    (*((char *)ofl->ofl_osstrtab->os_outdata->d_buf) == '\0'));
4255 	assert((ofl->ofl_osstrtab == NULL) ||
4256 	    (*(((char *)ofl->ofl_osstrtab->os_outdata->d_buf) +
4257 	    ofl->ofl_osstrtab->os_outdata->d_size - 1) == '\0'));
4258 
4259 	assert((ofl->ofl_osdynstr == NULL) ||
4260 	    (*((char *)ofl->ofl_osdynstr->os_outdata->d_buf) == '\0'));
4261 	assert((ofl->ofl_osdynstr == NULL) ||
4262 	    (*(((char *)ofl->ofl_osdynstr->os_outdata->d_buf) +
4263 	    ofl->ofl_osdynstr->os_outdata->d_size - DYNSTR_EXTRA_PAD - 1) ==
4264 	    '\0'));
4265 
4266 	/*
4267 	 * Emit Strtab diagnostics.
4268 	 */
4269 	DBG_CALL(Dbg_sec_strtab(ofl->ofl_lml, ofl->ofl_osshstrtab,
4270 	    ofl->ofl_shdrsttab));
4271 	DBG_CALL(Dbg_sec_strtab(ofl->ofl_lml, ofl->ofl_osstrtab,
4272 	    ofl->ofl_strtab));
4273 	DBG_CALL(Dbg_sec_strtab(ofl->ofl_lml, ofl->ofl_osdynstr,
4274 	    ofl->ofl_dynstrtab));
4275 
4276 	/*
4277 	 * Initialize the section headers string table index within the elf
4278 	 * header.
4279 	 */
4280 	/* LINTED */
4281 	if ((shscnndx = elf_ndxscn(ofl->ofl_osshstrtab->os_scn)) <
4282 	    SHN_LORESERVE) {
4283 		ofl->ofl_nehdr->e_shstrndx =
4284 		    /* LINTED */
4285 		    (Half)shscnndx;
4286 	} else {
4287 		/*
4288 		 * If the STRTAB section index doesn't fit into
4289 		 * e_shstrndx, then we store it in 'shdr[0].st_link'.
4290 		 */
4291 		Elf_Scn	*scn;
4292 		Shdr	*shdr0;
4293 
4294 		if ((scn = elf_getscn(ofl->ofl_elf, 0)) == NULL) {
4295 			ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_GETSCN),
4296 			    ofl->ofl_name);
4297 			return (S_ERROR);
4298 		}
4299 		if ((shdr0 = elf_getshdr(scn)) == NULL) {
4300 			ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_GETSHDR),
4301 			    ofl->ofl_name);
4302 			return (S_ERROR);
4303 		}
4304 		ofl->ofl_nehdr->e_shstrndx = SHN_XINDEX;
4305 		shdr0->sh_link = shscnndx;
4306 	}
4307 
4308 	return ((uintptr_t)etext);
4309 }
4310