xref: /titanic_51/usr/src/cmd/sgs/libld/common/sections.c (revision b72c368a02e0464faeef362bc5a1cf0fc69981da)
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 2009 Sun Microsystems, Inc.  All rights reserved.
27  * Use is subject to license terms.
28  */
29 
30 /*
31  * Module sections. Initialize special sections
32  */
33 
34 #define	ELF_TARGET_AMD64
35 
36 #include	<string.h>
37 #include	<strings.h>
38 #include	<stdio.h>
39 #include	<link.h>
40 #include	<debug.h>
41 #include	"msg.h"
42 #include	"_libld.h"
43 
44 inline static void
45 remove_local(Ofl_desc *ofl, Sym_desc *sdp, int allow_ldynsym)
46 {
47 	Sym	*sym = sdp->sd_sym;
48 	uchar_t	type = ELF_ST_TYPE(sym->st_info);
49 	/* LINTED - only used for assert() */
50 	int	err;
51 
52 	if ((ofl->ofl_flags & FLG_OF_REDLSYM) == 0) {
53 		ofl->ofl_locscnt--;
54 
55 		err = st_delstring(ofl->ofl_strtab, sdp->sd_name);
56 		assert(err != -1);
57 
58 		if (allow_ldynsym && ldynsym_symtype[type]) {
59 			ofl->ofl_dynlocscnt--;
60 
61 			err = st_delstring(ofl->ofl_dynstrtab, sdp->sd_name);
62 			assert(err != -1);
63 			/* Remove from sort section? */
64 			DYNSORT_COUNT(sdp, sym, type, --);
65 		}
66 	}
67 	sdp->sd_flags |= FLG_SY_ISDISC;
68 }
69 
70 inline static void
71 remove_scoped(Ofl_desc *ofl, Sym_desc *sdp, int allow_ldynsym)
72 {
73 	Sym	*sym = sdp->sd_sym;
74 	uchar_t	type = ELF_ST_TYPE(sym->st_info);
75 	/* LINTED - only used for assert() */
76 	int	err;
77 
78 	ofl->ofl_scopecnt--;
79 	ofl->ofl_elimcnt++;
80 
81 	err = st_delstring(ofl->ofl_strtab, sdp->sd_name);
82 	assert(err != -1);
83 
84 	if (allow_ldynsym && ldynsym_symtype[type]) {
85 		ofl->ofl_dynscopecnt--;
86 
87 		err = st_delstring(ofl->ofl_dynstrtab, sdp->sd_name);
88 		assert(err != -1);
89 		/* Remove from sort section? */
90 		DYNSORT_COUNT(sdp, sym, type, --);
91 	}
92 	sdp->sd_flags |= FLG_SY_ELIM;
93 }
94 
95 inline static void
96 ignore_sym(Ofl_desc *ofl, Ifl_desc *ifl, Sym_desc *sdp, int allow_ldynsym)
97 {
98 	Os_desc	*osp;
99 	Is_desc	*isp = sdp->sd_isc;
100 	uchar_t	bind = ELF_ST_BIND(sdp->sd_sym->st_info);
101 
102 	if (bind == STB_LOCAL) {
103 		uchar_t	type = ELF_ST_TYPE(sdp->sd_sym->st_info);
104 
105 		/*
106 		 * Skip section symbols, these were never collected in the
107 		 * first place.
108 		 */
109 		if (type == STT_SECTION)
110 			return;
111 
112 		/*
113 		 * Determine if the whole file is being removed.  Remove any
114 		 * file symbol, and any symbol that is not associated with a
115 		 * section, provided the symbol has not been identified as
116 		 * (update) required.
117 		 */
118 		if (((ifl->ifl_flags & FLG_IF_FILEREF) == 0) &&
119 		    ((type == STT_FILE) || ((isp == NULL) &&
120 		    ((sdp->sd_flags & FLG_SY_UPREQD) == 0)))) {
121 			DBG_CALL(Dbg_syms_discarded(ofl->ofl_lml, sdp));
122 			if (ifl->ifl_flags & FLG_IF_IGNORE)
123 				remove_local(ofl, sdp, allow_ldynsym);
124 			return;
125 		}
126 
127 	} else {
128 		/*
129 		 * Global symbols can only be eliminated when the interfaces of
130 		 * an object have been defined via versioning/scoping.
131 		 */
132 		if ((sdp->sd_flags & FLG_SY_HIDDEN) == 0)
133 			return;
134 
135 		/*
136 		 * Remove any unreferenced symbols that are not associated with
137 		 * a section.
138 		 */
139 		if ((isp == NULL) && ((sdp->sd_flags & FLG_SY_UPREQD) == 0)) {
140 			DBG_CALL(Dbg_syms_discarded(ofl->ofl_lml, sdp));
141 			if (ifl->ifl_flags & FLG_IF_IGNORE)
142 				remove_scoped(ofl, sdp, allow_ldynsym);
143 			return;
144 		}
145 	}
146 
147 	/*
148 	 * Do not discard any symbols that are associated with non-allocable
149 	 * segments.
150 	 */
151 	if (isp && ((isp->is_flags & FLG_IS_SECTREF) == 0) &&
152 	    ((osp = isp->is_osdesc) != 0) &&
153 	    (osp->os_sgdesc->sg_phdr.p_type == PT_LOAD)) {
154 		DBG_CALL(Dbg_syms_discarded(ofl->ofl_lml, sdp));
155 		if (ifl->ifl_flags & FLG_IF_IGNORE) {
156 			if (bind == STB_LOCAL)
157 				remove_local(ofl, sdp, allow_ldynsym);
158 			else
159 				remove_scoped(ofl, sdp, allow_ldynsym);
160 		}
161 	}
162 }
163 
164 /*
165  * There are situations where we may count output sections (ofl_shdrcnt)
166  * that are subsequently eliminated from the output object. Whether or
167  * not this happens cannot be known until all input has been seen and
168  * section elimination code has run. However, the situations where this
169  * outcome is possible are known, and are flagged by setting FLG_OF_ADJOSCNT.
170  *
171  * If FLG_OF_ADJOSCNT is set, this routine makes a pass over the output
172  * sections. If an unused output section is encountered, we decrement
173  * ofl->ofl_shdrcnt and remove the section name from the .shstrtab string
174  * table (ofl->ofl_shdrsttab).
175  *
176  * This code must be kept in sync with the similar code
177  * found in outfile.c:ld_create_outfile().
178  */
179 static void
180 adjust_os_count(Ofl_desc *ofl)
181 {
182 	Sg_desc		*sgp;
183 	Is_desc		*isp;
184 	Os_desc		*osp;
185 	Ifl_desc	*ifl;
186 	Aliste		idx1;
187 
188 	if ((ofl->ofl_flags & FLG_OF_ADJOSCNT) == 0)
189 		return;
190 
191 	/*
192 	 * For each output section, look at the input sections to find at least
193 	 * one input section that has not been eliminated. If none are found,
194 	 * the -z ignore processing above has eliminated that output section.
195 	 */
196 	for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
197 		Aliste	idx2;
198 		Word	ptype = sgp->sg_phdr.p_type;
199 
200 		for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
201 			Aliste	idx3;
202 			int	keep = 0, os_isdescs_idx;
203 
204 			OS_ISDESCS_TRAVERSE(os_isdescs_idx, osp, idx3, isp) {
205 				ifl = isp->is_file;
206 
207 				/* Input section is tagged for discard? */
208 				if (isp->is_flags & FLG_IS_DISCARD)
209 					continue;
210 
211 				/*
212 				 * If the file is discarded, it will take
213 				 * the section with it.
214 				 */
215 				if (ifl &&
216 				    (((ifl->ifl_flags & FLG_IF_FILEREF) == 0) ||
217 				    ((ptype == PT_LOAD) &&
218 				    ((isp->is_flags & FLG_IS_SECTREF) == 0) &&
219 				    (isp->is_shdr->sh_size > 0))) &&
220 				    (ifl->ifl_flags & FLG_IF_IGNORE))
221 					continue;
222 
223 				/*
224 				 * We have found a kept input section,
225 				 * so the output section will be created.
226 				 */
227 				keep = 1;
228 				break;
229 			}
230 			/*
231 			 * If no section of this name was kept, decrement
232 			 * the count and remove the name from .shstrtab.
233 			 */
234 			if (keep == 0) {
235 				/* LINTED - only used for assert() */
236 				int err;
237 
238 				ofl->ofl_shdrcnt--;
239 				err = st_delstring(ofl->ofl_shdrsttab,
240 				    osp->os_name);
241 				assert(err != -1);
242 			}
243 		}
244 	}
245 }
246 
247 /*
248  * If -zignore has been in effect, scan all input files to determine if the
249  * file, or sections from the file, have been referenced.  If not, the file or
250  * some of the files sections can be discarded. If sections are to be
251  * discarded, rescan the output relocations and the symbol table and remove
252  * the relocations and symbol entries that are no longer required.
253  *
254  * Note:  It's possible that a section which is being discarded has contributed
255  *	  to the GOT table or the PLT table.  However, we can't at this point
256  *	  eliminate the corresponding entries.  This is because there could well
257  *	  be other sections referencing those same entries, but we don't have
258  *	  the infrastructure to determine this.  So, keep the PLT and GOT
259  *	  entries in the table in case someone wants them.
260  * Note:  The section to be affected needs to be allocatable.
261  *	  So even if -zignore is in effect, if the section is not allocatable,
262  *	  we do not eliminate it.
263  */
264 static uintptr_t
265 ignore_section_processing(Ofl_desc *ofl)
266 {
267 	Sg_desc		*sgp;
268 	Is_desc		*isp;
269 	Os_desc		*osp;
270 	Ifl_desc	*ifl;
271 	Rel_cache	*rcp;
272 	int		allow_ldynsym = OFL_ALLOW_LDYNSYM(ofl);
273 	Aliste		idx1;
274 
275 	for (APLIST_TRAVERSE(ofl->ofl_objs, idx1, ifl)) {
276 		uint_t	num, discard;
277 
278 		/*
279 		 * Diagnose (-D unused) a completely unreferenced file.
280 		 */
281 		if ((ifl->ifl_flags & FLG_IF_FILEREF) == 0)
282 			DBG_CALL(Dbg_unused_file(ofl->ofl_lml,
283 			    ifl->ifl_name, 0, 0));
284 		if (((ofl->ofl_flags1 & FLG_OF1_IGNPRC) == 0) ||
285 		    ((ifl->ifl_flags & FLG_IF_IGNORE) == 0))
286 			continue;
287 
288 		/*
289 		 * Before scanning the whole symbol table to determine if
290 		 * symbols should be discard - quickly (relatively) scan the
291 		 * sections to determine if any are to be discarded.
292 		 */
293 		discard = 0;
294 		if (ifl->ifl_flags & FLG_IF_FILEREF) {
295 			for (num = 1; num < ifl->ifl_shnum; num++) {
296 				if (((isp = ifl->ifl_isdesc[num]) != NULL) &&
297 				    ((isp->is_flags & FLG_IS_SECTREF) == 0) &&
298 				    ((osp = isp->is_osdesc) != NULL) &&
299 				    ((sgp = osp->os_sgdesc) != NULL) &&
300 				    (sgp->sg_phdr.p_type == PT_LOAD)) {
301 					discard++;
302 					break;
303 				}
304 			}
305 		}
306 
307 		/*
308 		 * No sections are to be 'ignored'
309 		 */
310 		if ((discard == 0) && (ifl->ifl_flags & FLG_IF_FILEREF))
311 			continue;
312 
313 		/*
314 		 * We know that we have discarded sections.  Scan the symbol
315 		 * table for this file to determine if symbols need to be
316 		 * discarded that are associated with the 'ignored' sections.
317 		 */
318 		for (num = 1; num < ifl->ifl_symscnt; num++) {
319 			Sym_desc	*sdp;
320 
321 			/*
322 			 * If the symbol definition has been resolved to another
323 			 * file, or the symbol has already been discarded or
324 			 * eliminated, skip it.
325 			 */
326 			sdp = ifl->ifl_oldndx[num];
327 			if ((sdp->sd_file != ifl) ||
328 			    (sdp->sd_flags &
329 			    (FLG_SY_ISDISC | FLG_SY_INVALID | FLG_SY_ELIM)))
330 				continue;
331 
332 			/*
333 			 * Complete the investigation of the symbol.
334 			 */
335 			ignore_sym(ofl, ifl, sdp, allow_ldynsym);
336 		}
337 	}
338 
339 	/*
340 	 * If we were only here to solicit debugging diagnostics, we're done.
341 	 */
342 	if ((ofl->ofl_flags1 & FLG_OF1_IGNPRC) == 0)
343 		return (1);
344 
345 	/*
346 	 * Scan all output relocations searching for those against discarded or
347 	 * ignored sections.  If one is found, decrement the total outrel count.
348 	 */
349 	for (APLIST_TRAVERSE(ofl->ofl_outrels, idx1, rcp)) {
350 		Rel_desc	*rsp;
351 
352 		/* LINTED */
353 		for (rsp = (Rel_desc *)(rcp + 1); rsp < rcp->rc_free; rsp++) {
354 			Is_desc		*isc = rsp->rel_isdesc;
355 			uint_t		flags, entsize;
356 			Shdr		*shdr;
357 
358 			if ((isc == NULL) ||
359 			    ((isc->is_flags & (FLG_IS_SECTREF))) ||
360 			    ((ifl = isc->is_file) == NULL) ||
361 			    ((ifl->ifl_flags & FLG_IF_IGNORE) == 0) ||
362 			    ((shdr = isc->is_shdr) == NULL) ||
363 			    ((shdr->sh_flags & SHF_ALLOC) == 0))
364 				continue;
365 
366 			flags = rsp->rel_flags;
367 
368 			if (flags & (FLG_REL_GOT | FLG_REL_BSS |
369 			    FLG_REL_NOINFO | FLG_REL_PLT))
370 				continue;
371 
372 			osp = rsp->rel_osdesc;
373 
374 			if (rsp->rel_flags & FLG_REL_RELA)
375 				entsize = sizeof (Rela);
376 			else
377 				entsize = sizeof (Rel);
378 
379 			assert(osp->os_szoutrels > 0);
380 			osp->os_szoutrels -= entsize;
381 
382 			if (!(flags & FLG_REL_PLT))
383 				ofl->ofl_reloccntsub++;
384 
385 			if (rsp->rel_rtype == ld_targ.t_m.m_r_relative)
386 				ofl->ofl_relocrelcnt--;
387 		}
388 	}
389 
390 	/*
391 	 * As a result of our work here, the number of output sections may
392 	 * have decreased. Trigger a call to adjust_os_count().
393 	 */
394 	ofl->ofl_flags |= FLG_OF_ADJOSCNT;
395 
396 	return (1);
397 }
398 
399 /*
400  * Allocate Elf_Data, Shdr, and Is_desc structures for a new
401  * section.
402  *
403  * entry:
404  *	ofl - Output file descriptor
405  *	shtype - SHT_ type code for section.
406  *	shname - String giving the name for the new section.
407  *	entcnt - # of items contained in the data part of the new section.
408  *		This value is multiplied against the known element size
409  *		for the section type to determine the size of the data
410  *		area for the section. It is only meaningful in cases where
411  *		the section type has a non-zero element size. In other cases,
412  *		the caller must set the size fields in the *ret_data and
413  *		*ret_shdr structs manually.
414  *	ret_isec, ret_shdr, ret_data - Address of pointers to
415  *		receive address of newly allocated structs.
416  *
417  * exit:
418  *	On error, returns S_ERROR. On success, returns (1), and the
419  *	ret_ pointers have been updated to point at the new structures,
420  *	which have been filled in. To finish the task, the caller must
421  *	update any fields within the supplied descriptors that differ
422  *	from its needs, and then call ld_place_section().
423  */
424 static uintptr_t
425 new_section(Ofl_desc *ofl, Word shtype, const char *shname, Xword entcnt,
426 	Is_desc **ret_isec, Shdr **ret_shdr, Elf_Data **ret_data)
427 {
428 	typedef struct sec_info {
429 		Word d_type;
430 		Word align;	/* Used in both data and section header */
431 		Word sh_flags;
432 		Word sh_entsize;
433 	} SEC_INFO_T;
434 
435 	const SEC_INFO_T	*sec_info;
436 
437 	Shdr		*shdr;
438 	Elf_Data	*data;
439 	Is_desc		*isec;
440 	size_t		size;
441 
442 	/*
443 	 * For each type of section, we have a distinct set of
444 	 * SEC_INFO_T values. This macro defines a static structure
445 	 * containing those values and generates code to set the sec_info
446 	 * pointer to refer to it. The pointer in sec_info remains valid
447 	 * outside of the declaration scope because the info_s struct is static.
448 	 *
449 	 * We can't determine the value of M_WORD_ALIGN at compile time, so
450 	 * a different variant is used for those cases.
451 	 */
452 #define	SET_SEC_INFO(d_type, d_align, sh_flags, sh_entsize) \
453 	{ \
454 		static const SEC_INFO_T info_s = { d_type, d_align, sh_flags, \
455 		    sh_entsize}; \
456 		sec_info = &info_s; \
457 	}
458 #define	SET_SEC_INFO_WORD_ALIGN(d_type, sh_flags, sh_entsize) \
459 	{ \
460 		static SEC_INFO_T info_s = { d_type, 0, sh_flags, \
461 		    sh_entsize}; \
462 		info_s.align = ld_targ.t_m.m_word_align; \
463 		sec_info = &info_s; \
464 	}
465 
466 	switch (shtype) {
467 	case SHT_PROGBITS:
468 		/*
469 		 * SHT_PROGBITS sections contain are used for many
470 		 * different sections. Alignments and flags differ.
471 		 * Some have a standard entsize, and others don't.
472 		 * We set some defaults here, but there is no expectation
473 		 * that they are correct or complete for any specific
474 		 * purpose. The caller must provide the correct values.
475 		 */
476 		SET_SEC_INFO_WORD_ALIGN(ELF_T_BYTE, SHF_ALLOC, 0)
477 		break;
478 
479 	case SHT_SYMTAB:
480 		SET_SEC_INFO_WORD_ALIGN(ELF_T_SYM, 0, sizeof (Sym))
481 		break;
482 
483 	case SHT_DYNSYM:
484 		SET_SEC_INFO_WORD_ALIGN(ELF_T_SYM, SHF_ALLOC, sizeof (Sym))
485 		break;
486 
487 	case SHT_SUNW_LDYNSYM:
488 		ofl->ofl_flags |= FLG_OF_OSABI;
489 		SET_SEC_INFO_WORD_ALIGN(ELF_T_SYM, SHF_ALLOC, sizeof (Sym))
490 		break;
491 
492 	case SHT_STRTAB:
493 		/*
494 		 * A string table may or may not be allocable, depending
495 		 * on context, so we leave that flag unset and leave it to
496 		 * the caller to add it if necessary.
497 		 *
498 		 * String tables do not have a standard entsize, so
499 		 * we set it to 0.
500 		 */
501 		SET_SEC_INFO(ELF_T_BYTE, 1, SHF_STRINGS, 0)
502 		break;
503 
504 	case SHT_RELA:
505 		/*
506 		 * Relocations with an addend (Everything except 32-bit X86).
507 		 * The caller is expected to set all section header flags.
508 		 */
509 		SET_SEC_INFO_WORD_ALIGN(ELF_T_RELA, 0, sizeof (Rela))
510 		break;
511 
512 	case SHT_REL:
513 		/*
514 		 * Relocations without an addend (32-bit X86 only).
515 		 * The caller is expected to set all section header flags.
516 		 */
517 		SET_SEC_INFO_WORD_ALIGN(ELF_T_REL, 0, sizeof (Rel))
518 		break;
519 
520 	case SHT_HASH:
521 		SET_SEC_INFO_WORD_ALIGN(ELF_T_WORD, SHF_ALLOC, sizeof (Word))
522 		break;
523 
524 	case SHT_SUNW_symsort:
525 	case SHT_SUNW_tlssort:
526 		ofl->ofl_flags |= FLG_OF_OSABI;
527 		SET_SEC_INFO_WORD_ALIGN(ELF_T_WORD, SHF_ALLOC, sizeof (Word))
528 		break;
529 
530 	case SHT_DYNAMIC:
531 		/*
532 		 * A dynamic section may or may not be allocable, depending
533 		 * on context, so we leave that flag unset and leave it to
534 		 * the caller to add it if necessary.
535 		 */
536 		SET_SEC_INFO_WORD_ALIGN(ELF_T_DYN, SHF_WRITE, sizeof (Dyn))
537 		break;
538 
539 	case SHT_NOBITS:
540 		/*
541 		 * SHT_NOBITS is used for BSS-type sections. The size and
542 		 * alignment depend on the specific use and must be adjusted
543 		 * by the caller.
544 		 */
545 		SET_SEC_INFO(ELF_T_BYTE, 0, SHF_ALLOC | SHF_WRITE, 0)
546 		break;
547 
548 	case SHT_INIT_ARRAY:
549 	case SHT_FINI_ARRAY:
550 	case SHT_PREINIT_ARRAY:
551 		SET_SEC_INFO(ELF_T_ADDR, sizeof (Addr), SHF_ALLOC | SHF_WRITE,
552 		    sizeof (Addr))
553 		break;
554 
555 	case SHT_SYMTAB_SHNDX:
556 		/*
557 		 * Note that these sections are created to be associated
558 		 * with both symtab and dynsym symbol tables. However, they
559 		 * are non-allocable in all cases, because the runtime
560 		 * linker has no need for this information. It is purely
561 		 * informational, used by elfdump(1), debuggers, etc.
562 		 */
563 		SET_SEC_INFO_WORD_ALIGN(ELF_T_WORD, 0, sizeof (Word));
564 		break;
565 
566 	case SHT_SUNW_cap:
567 		ofl->ofl_flags |= FLG_OF_OSABI;
568 		SET_SEC_INFO_WORD_ALIGN(ELF_T_CAP, SHF_ALLOC, sizeof (Cap));
569 		break;
570 
571 	case SHT_SUNW_move:
572 		ofl->ofl_flags |= FLG_OF_OSABI;
573 		/*
574 		 * The sh_info field of the SHT_*_syminfo section points
575 		 * to the header index of the associated .dynamic section,
576 		 * so we also set SHF_INFO_LINK.
577 		 */
578 		SET_SEC_INFO(ELF_T_BYTE, sizeof (Lword),
579 		    SHF_ALLOC | SHF_WRITE, sizeof (Move));
580 		break;
581 
582 	case SHT_SUNW_syminfo:
583 		ofl->ofl_flags |= FLG_OF_OSABI;
584 		/*
585 		 * The sh_info field of the SHT_*_syminfo section points
586 		 * to the header index of the associated .dynamic section,
587 		 * so we also set SHF_INFO_LINK.
588 		 */
589 		SET_SEC_INFO_WORD_ALIGN(ELF_T_BYTE,
590 		    SHF_ALLOC | SHF_INFO_LINK, sizeof (Syminfo));
591 		break;
592 
593 	case SHT_SUNW_verneed:
594 	case SHT_SUNW_verdef:
595 		ofl->ofl_flags |= FLG_OF_OSABI;
596 		/*
597 		 * The info for verneed and versym happen to be the same.
598 		 * The entries in these sections are not of uniform size,
599 		 * so we set the entsize to 0.
600 		 */
601 		SET_SEC_INFO_WORD_ALIGN(ELF_T_BYTE, SHF_ALLOC, 0);
602 		break;
603 
604 	case SHT_SUNW_versym:
605 		ofl->ofl_flags |= FLG_OF_OSABI;
606 		SET_SEC_INFO_WORD_ALIGN(ELF_T_BYTE, SHF_ALLOC,
607 		    sizeof (Versym));
608 		break;
609 
610 	default:
611 		/* Should not happen: fcn called with unknown section type */
612 		assert(0);
613 		return (S_ERROR);
614 	}
615 #undef	SET_SEC_INFO
616 #undef	SET_SEC_INFO_WORD_ALIGN
617 
618 	size = entcnt * sec_info->sh_entsize;
619 
620 	/*
621 	 * Allocate and initialize the Elf_Data structure.
622 	 */
623 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == NULL)
624 		return (S_ERROR);
625 	data->d_type = sec_info->d_type;
626 	data->d_size = size;
627 	data->d_align = sec_info->align;
628 	data->d_version = ofl->ofl_dehdr->e_version;
629 
630 	/*
631 	 * Allocate and initialize the Shdr structure.
632 	 */
633 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == NULL)
634 		return (S_ERROR);
635 	shdr->sh_type = shtype;
636 	shdr->sh_size = size;
637 	shdr->sh_flags = sec_info->sh_flags;
638 	shdr->sh_addralign = sec_info->align;
639 	shdr->sh_entsize = sec_info->sh_entsize;
640 
641 	/*
642 	 * Allocate and initialize the Is_desc structure.
643 	 */
644 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == NULL)
645 		return (S_ERROR);
646 	isec->is_name = shname;
647 	isec->is_shdr = shdr;
648 	isec->is_indata = data;
649 
650 
651 	*ret_isec = isec;
652 	*ret_shdr = shdr;
653 	*ret_data = data;
654 	return (1);
655 }
656 
657 /*
658  * Use an existing input section as a template to create a new
659  * input section with the same values as the original, other than
660  * the size of the data area which is supplied by the caller.
661  *
662  * entry:
663  *	ofl - Output file descriptor
664  *	ifl - Input file section to use as a template
665  *	size - Size of data area for new section
666  *	ret_isec, ret_shdr, ret_data - Address of pointers to
667  *		receive address of newly allocated structs.
668  *
669  * exit:
670  *	On error, returns S_ERROR. On success, returns (1), and the
671  *	ret_ pointers have been updated to point at the new structures,
672  *	which have been filled in. To finish the task, the caller must
673  *	update any fields within the supplied descriptors that differ
674  *	from its needs, and then call ld_place_section().
675  */
676 static uintptr_t
677 new_section_from_template(Ofl_desc *ofl, Is_desc *tmpl_isp, size_t size,
678 	Is_desc **ret_isec, Shdr **ret_shdr, Elf_Data **ret_data)
679 {
680 	Shdr		*shdr;
681 	Elf_Data	*data;
682 	Is_desc		*isec;
683 
684 	/*
685 	 * Allocate and initialize the Elf_Data structure.
686 	 */
687 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == NULL)
688 		return (S_ERROR);
689 	data->d_type = tmpl_isp->is_indata->d_type;
690 	data->d_size = size;
691 	data->d_align = tmpl_isp->is_shdr->sh_addralign;
692 	data->d_version = ofl->ofl_dehdr->e_version;
693 
694 	/*
695 	 * Allocate and initialize the Shdr structure.
696 	 */
697 	if ((shdr = libld_malloc(sizeof (Shdr))) == NULL)
698 		return (S_ERROR);
699 	*shdr = *tmpl_isp->is_shdr;
700 	shdr->sh_addr = 0;
701 	shdr->sh_offset = 0;
702 	shdr->sh_size = size;
703 
704 	/*
705 	 * Allocate and initialize the Is_desc structure.
706 	 */
707 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == NULL)
708 		return (S_ERROR);
709 	isec->is_name = tmpl_isp->is_name;
710 	isec->is_shdr = shdr;
711 	isec->is_indata = data;
712 
713 
714 	*ret_isec = isec;
715 	*ret_shdr = shdr;
716 	*ret_data = data;
717 	return (1);
718 }
719 
720 /*
721  * Build a .bss section for allocation of tentative definitions.  Any `static'
722  * .bss definitions would have been associated to their own .bss sections and
723  * thus collected from the input files.  `global' .bss definitions are tagged
724  * as COMMON and do not cause any associated .bss section elements to be
725  * generated.  Here we add up all these COMMON symbols and generate the .bss
726  * section required to represent them.
727  */
728 uintptr_t
729 ld_make_bss(Ofl_desc *ofl, Xword size, Xword align, uint_t ident)
730 {
731 	Shdr		*shdr;
732 	Elf_Data	*data;
733 	Is_desc		*isec;
734 	Os_desc		*osp;
735 	Xword		rsize = (Xword)ofl->ofl_relocbsssz;
736 
737 	/*
738 	 * Allocate header structs. We will set the name ourselves below,
739 	 * and there is no entcnt for a BSS. So, the shname and entcnt
740 	 * arguments are 0.
741 	 */
742 	if (new_section(ofl, SHT_NOBITS, NULL, 0,
743 	    &isec, &shdr, &data) == S_ERROR)
744 		return (S_ERROR);
745 
746 	data->d_size = (size_t)size;
747 	data->d_align = (size_t)align;
748 
749 	shdr->sh_size = size;
750 	shdr->sh_addralign = align;
751 
752 	if (ident == ld_targ.t_id.id_tlsbss) {
753 		isec->is_name = MSG_ORIG(MSG_SCN_TBSS);
754 		ofl->ofl_istlsbss = isec;
755 		shdr->sh_flags |= SHF_TLS;
756 
757 	} else if (ident == ld_targ.t_id.id_bss) {
758 		isec->is_name = MSG_ORIG(MSG_SCN_BSS);
759 		ofl->ofl_isbss = isec;
760 
761 #if	defined(_ELF64)
762 	} else if ((ld_targ.t_m.m_mach == EM_AMD64) &&
763 	    (ident == ld_targ.t_id.id_lbss)) {
764 		isec->is_name = MSG_ORIG(MSG_SCN_LBSS);
765 		ofl->ofl_islbss = isec;
766 		shdr->sh_flags |= SHF_AMD64_LARGE;
767 #endif
768 	}
769 
770 	/*
771 	 * Retain this .*bss input section as this will be where global symbol
772 	 * references are added.
773 	 */
774 	if ((osp = ld_place_section(ofl, isec, ident, NULL)) ==
775 	    (Os_desc *)S_ERROR)
776 		return (S_ERROR);
777 
778 	/*
779 	 * If relocations exist against a .*bss section, a section symbol must
780 	 * be created for the section in the .dynsym symbol table.
781 	 */
782 	if (!(osp->os_flags & FLG_OS_OUTREL)) {
783 		ofl_flag_t	flagtotest;
784 
785 		if (ident == ld_targ.t_id.id_tlsbss)
786 			flagtotest = FLG_OF1_TLSOREL;
787 		else
788 			flagtotest = FLG_OF1_BSSOREL;
789 
790 		if (ofl->ofl_flags1 & flagtotest) {
791 			ofl->ofl_dynshdrcnt++;
792 			osp->os_flags |= FLG_OS_OUTREL;
793 		}
794 	}
795 
796 	osp->os_szoutrels = rsize;
797 	return (1);
798 }
799 
800 /*
801  * Build a SHT_{INIT|FINI|PREINIT}ARRAY section (specified via
802  * ld -z *array=name).
803  */
804 static uintptr_t
805 make_array(Ofl_desc *ofl, Word shtype, const char *sectname, APlist *alp)
806 {
807 	uint_t		entcount;
808 	Aliste		idx;
809 	Elf_Data	*data;
810 	Is_desc		*isec;
811 	Shdr		*shdr;
812 	Sym_desc	*sdp;
813 	Rel_desc	reld;
814 	Rela		reloc;
815 	Os_desc		*osp;
816 	uintptr_t	ret = 1;
817 
818 	if (alp == NULL)
819 		return (1);
820 
821 	entcount = 0;
822 	for (APLIST_TRAVERSE(alp, idx, sdp))
823 		entcount++;
824 
825 	if (new_section(ofl, shtype, sectname, entcount, &isec, &shdr, &data) ==
826 	    S_ERROR)
827 		return (S_ERROR);
828 
829 	if ((data->d_buf = libld_calloc(sizeof (Addr), entcount)) == NULL)
830 		return (S_ERROR);
831 
832 	if (ld_place_section(ofl, isec, ld_targ.t_id.id_array, NULL) ==
833 	    (Os_desc *)S_ERROR)
834 		return (S_ERROR);
835 
836 	osp = isec->is_osdesc;
837 
838 	if ((ofl->ofl_osinitarray == NULL) && (shtype == SHT_INIT_ARRAY))
839 		ofl->ofl_osinitarray = osp;
840 	if ((ofl->ofl_ospreinitarray == NULL) && (shtype == SHT_PREINIT_ARRAY))
841 		ofl->ofl_ospreinitarray = osp;
842 	else if ((ofl->ofl_osfiniarray == NULL) && (shtype == SHT_FINI_ARRAY))
843 		ofl->ofl_osfiniarray = osp;
844 
845 	/*
846 	 * Create relocations against this section to initialize it to the
847 	 * function addresses.
848 	 */
849 	reld.rel_osdesc = osp;
850 	reld.rel_isdesc = isec;
851 	reld.rel_move = 0;
852 	reld.rel_flags = FLG_REL_LOAD;
853 
854 	/*
855 	 * Fabricate the relocation information (as if a relocation record had
856 	 * been input - see init_rel()).
857 	 */
858 	reld.rel_rtype = ld_targ.t_m.m_r_arrayaddr;
859 	reld.rel_roffset = 0;
860 	reld.rel_raddend = 0;
861 	reld.rel_typedata = 0;
862 
863 	/*
864 	 * Create a minimal relocation record to satisfy process_sym_reloc()
865 	 * debugging requirements.
866 	 */
867 	reloc.r_offset = 0;
868 	reloc.r_info = ELF_R_INFO(0, ld_targ.t_m.m_r_arrayaddr);
869 	reloc.r_addend = 0;
870 
871 	DBG_CALL(Dbg_reloc_generate(ofl->ofl_lml, osp,
872 	    ld_targ.t_m.m_rel_sht_type));
873 	for (APLIST_TRAVERSE(alp, idx, sdp)) {
874 		reld.rel_sname = sdp->sd_name;
875 		reld.rel_sym = sdp;
876 
877 		if (ld_process_sym_reloc(ofl, &reld, (Rel *)&reloc, isec,
878 		    MSG_INTL(MSG_STR_COMMAND), 0) == S_ERROR) {
879 			ret = S_ERROR;
880 			continue;
881 		}
882 
883 		reld.rel_roffset += (Xword)sizeof (Addr);
884 		reloc.r_offset = reld.rel_roffset;
885 	}
886 
887 	return (ret);
888 }
889 
890 /*
891  * Build a comment section (-Qy option).
892  */
893 static uintptr_t
894 make_comment(Ofl_desc *ofl)
895 {
896 	Shdr		*shdr;
897 	Elf_Data	*data;
898 	Is_desc		*isec;
899 
900 	if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_COMMENT), 0,
901 	    &isec, &shdr, &data) == S_ERROR)
902 		return (S_ERROR);
903 
904 	data->d_buf = (void *)ofl->ofl_sgsid;
905 	data->d_size = strlen(ofl->ofl_sgsid) + 1;
906 	data->d_align = 1;
907 
908 	shdr->sh_size = (Xword)data->d_size;
909 	shdr->sh_flags = 0;
910 	shdr->sh_addralign = 1;
911 
912 	return ((uintptr_t)ld_place_section(ofl, isec,
913 	    ld_targ.t_id.id_note, NULL));
914 }
915 
916 /*
917  * Make the dynamic section.  Calculate the size of any strings referenced
918  * within this structure, they will be added to the global string table
919  * (.dynstr).  This routine should be called before make_dynstr().
920  *
921  * This routine must be maintained in parallel with update_odynamic()
922  * in update.c
923  */
924 static uintptr_t
925 make_dynamic(Ofl_desc *ofl)
926 {
927 	Shdr		*shdr;
928 	Os_desc		*osp;
929 	Elf_Data	*data;
930 	Is_desc		*isec;
931 	size_t		cnt = 0;
932 	Aliste		idx;
933 	Ifl_desc	*ifl;
934 	Sym_desc	*sdp;
935 	size_t		size;
936 	Str_tbl		*strtbl;
937 	ofl_flag_t	flags = ofl->ofl_flags;
938 	int		not_relobj = !(flags & FLG_OF_RELOBJ);
939 	int		unused = 0;
940 
941 	/*
942 	 * Select the required string table.
943 	 */
944 	if (OFL_IS_STATIC_OBJ(ofl))
945 		strtbl = ofl->ofl_strtab;
946 	else
947 		strtbl = ofl->ofl_dynstrtab;
948 
949 	/*
950 	 * Only a limited subset of DT_ entries apply to relocatable
951 	 * objects. See the comment at the head of update_odynamic() in
952 	 * update.c for details.
953 	 */
954 	if (new_section(ofl, SHT_DYNAMIC, MSG_ORIG(MSG_SCN_DYNAMIC), 0,
955 	    &isec, &shdr, &data) == S_ERROR)
956 		return (S_ERROR);
957 
958 	/* new_section() does not set SHF_ALLOC. Add it if needed */
959 	if (not_relobj)
960 		shdr->sh_flags |= SHF_ALLOC;
961 
962 	osp = ofl->ofl_osdynamic =
963 	    ld_place_section(ofl, isec, ld_targ.t_id.id_dynamic, NULL);
964 
965 	/*
966 	 * Reserve entries for any needed dependencies.
967 	 */
968 	for (APLIST_TRAVERSE(ofl->ofl_sos, idx, ifl)) {
969 		if (!(ifl->ifl_flags & (FLG_IF_NEEDED | FLG_IF_NEEDSTR)))
970 			continue;
971 
972 		/*
973 		 * If this dependency didn't satisfy any symbol references,
974 		 * generate a debugging diagnostic (ld(1) -Dunused can be used
975 		 * to display these).  If this is a standard needed dependency,
976 		 * and -z ignore is in effect, drop the dependency.  Explicitly
977 		 * defined dependencies (i.e., -N dep) don't get dropped, and
978 		 * are flagged as being required to simplify update_odynamic()
979 		 * processing.
980 		 */
981 		if ((ifl->ifl_flags & FLG_IF_NEEDSTR) ||
982 		    ((ifl->ifl_flags & FLG_IF_DEPREQD) == 0)) {
983 			if (unused++ == 0)
984 				DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD));
985 			DBG_CALL(Dbg_unused_file(ofl->ofl_lml, ifl->ifl_soname,
986 			    (ifl->ifl_flags & FLG_IF_NEEDSTR), 0));
987 
988 			if (ifl->ifl_flags & FLG_IF_NEEDSTR)
989 				ifl->ifl_flags |= FLG_IF_DEPREQD;
990 			else if (ifl->ifl_flags & FLG_IF_IGNORE)
991 				continue;
992 		}
993 
994 		/*
995 		 * If this object is a lazyload reserve a DT_POSFLAG_1 entry.
996 		 */
997 		if ((ifl->ifl_flags & (FLG_IF_LAZYLD | FLG_IF_GRPPRM)) &&
998 		    not_relobj)
999 			cnt++;
1000 
1001 		if (st_insert(strtbl, ifl->ifl_soname) == -1)
1002 			return (S_ERROR);
1003 		cnt++;
1004 
1005 		/*
1006 		 * If the needed entry contains the $ORIGIN token make sure
1007 		 * the associated DT_1_FLAGS entry is created.
1008 		 */
1009 		if (strstr(ifl->ifl_soname, MSG_ORIG(MSG_STR_ORIGIN))) {
1010 			ofl->ofl_dtflags_1 |= DF_1_ORIGIN;
1011 			ofl->ofl_dtflags |= DF_ORIGIN;
1012 		}
1013 	}
1014 
1015 	if (unused)
1016 		DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD));
1017 
1018 	if (not_relobj) {
1019 		/*
1020 		 * Reserve entries for any per-symbol auxiliary/filter strings.
1021 		 */
1022 		cnt += alist_nitems(ofl->ofl_dtsfltrs);
1023 
1024 		/*
1025 		 * Reserve entries for _init() and _fini() section addresses.
1026 		 */
1027 		if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_INIT_U),
1028 		    SYM_NOHASH, NULL, ofl)) != NULL) &&
1029 		    (sdp->sd_ref == REF_REL_NEED) &&
1030 		    (sdp->sd_sym->st_shndx != SHN_UNDEF)) {
1031 			sdp->sd_flags |= FLG_SY_UPREQD;
1032 			cnt++;
1033 		}
1034 		if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_FINI_U),
1035 		    SYM_NOHASH, NULL, ofl)) != NULL) &&
1036 		    (sdp->sd_ref == REF_REL_NEED) &&
1037 		    (sdp->sd_sym->st_shndx != SHN_UNDEF)) {
1038 			sdp->sd_flags |= FLG_SY_UPREQD;
1039 			cnt++;
1040 		}
1041 
1042 		/*
1043 		 * Reserve entries for any soname, filter name (shared libs
1044 		 * only), run-path pointers, cache names and audit requirements.
1045 		 */
1046 		if (ofl->ofl_soname) {
1047 			cnt++;
1048 			if (st_insert(strtbl, ofl->ofl_soname) == -1)
1049 				return (S_ERROR);
1050 		}
1051 		if (ofl->ofl_filtees) {
1052 			cnt++;
1053 			if (st_insert(strtbl, ofl->ofl_filtees) == -1)
1054 				return (S_ERROR);
1055 
1056 			/*
1057 			 * If the filtees entry contains the $ORIGIN token
1058 			 * make sure the associated DT_1_FLAGS entry is created.
1059 			 */
1060 			if (strstr(ofl->ofl_filtees,
1061 			    MSG_ORIG(MSG_STR_ORIGIN))) {
1062 				ofl->ofl_dtflags_1 |= DF_1_ORIGIN;
1063 				ofl->ofl_dtflags |= DF_ORIGIN;
1064 			}
1065 		}
1066 	}
1067 
1068 	if (ofl->ofl_rpath) {
1069 		cnt += 2;	/* DT_RPATH & DT_RUNPATH */
1070 		if (st_insert(strtbl, ofl->ofl_rpath) == -1)
1071 			return (S_ERROR);
1072 
1073 		/*
1074 		 * If the rpath entry contains the $ORIGIN token make sure
1075 		 * the associated DT_1_FLAGS entry is created.
1076 		 */
1077 		if (strstr(ofl->ofl_rpath, MSG_ORIG(MSG_STR_ORIGIN))) {
1078 			ofl->ofl_dtflags_1 |= DF_1_ORIGIN;
1079 			ofl->ofl_dtflags |= DF_ORIGIN;
1080 		}
1081 	}
1082 
1083 	if (not_relobj) {
1084 		Aliste	idx;
1085 
1086 		if (ofl->ofl_config) {
1087 			cnt++;
1088 			if (st_insert(strtbl, ofl->ofl_config) == -1)
1089 				return (S_ERROR);
1090 
1091 			/*
1092 			 * If the config entry contains the $ORIGIN token
1093 			 * make sure the associated DT_1_FLAGS entry is created.
1094 			 */
1095 			if (strstr(ofl->ofl_config, MSG_ORIG(MSG_STR_ORIGIN))) {
1096 				ofl->ofl_dtflags_1 |= DF_1_ORIGIN;
1097 				ofl->ofl_dtflags |= DF_ORIGIN;
1098 			}
1099 		}
1100 		if (ofl->ofl_depaudit) {
1101 			cnt++;
1102 			if (st_insert(strtbl, ofl->ofl_depaudit) == -1)
1103 				return (S_ERROR);
1104 		}
1105 		if (ofl->ofl_audit) {
1106 			cnt++;
1107 			if (st_insert(strtbl, ofl->ofl_audit) == -1)
1108 				return (S_ERROR);
1109 		}
1110 
1111 		/*
1112 		 * Reserve entries for the HASH, STRTAB, STRSZ, SYMTAB, SYMENT,
1113 		 * and CHECKSUM.
1114 		 */
1115 		cnt += 6;
1116 
1117 		/*
1118 		 * If we are including local functions at the head of
1119 		 * the dynsym, then also reserve entries for DT_SUNW_SYMTAB
1120 		 * and DT_SUNW_SYMSZ.
1121 		 */
1122 		if (OFL_ALLOW_LDYNSYM(ofl))
1123 			cnt += 2;
1124 
1125 		if ((ofl->ofl_dynsymsortcnt > 0) ||
1126 		    (ofl->ofl_dyntlssortcnt > 0))
1127 			cnt++;		/* DT_SUNW_SORTENT */
1128 
1129 		if (ofl->ofl_dynsymsortcnt > 0)
1130 			cnt += 2;	/* DT_SUNW_[SYMSORT|SYMSORTSZ] */
1131 
1132 		if (ofl->ofl_dyntlssortcnt > 0)
1133 			cnt += 2;	/* DT_SUNW_[TLSSORT|TLSSORTSZ] */
1134 
1135 		if ((flags & (FLG_OF_VERDEF | FLG_OF_NOVERSEC)) ==
1136 		    FLG_OF_VERDEF)
1137 			cnt += 2;		/* DT_VERDEF & DT_VERDEFNUM */
1138 
1139 		if ((flags & (FLG_OF_VERNEED | FLG_OF_NOVERSEC)) ==
1140 		    FLG_OF_VERNEED)
1141 			cnt += 2;		/* DT_VERNEED & DT_VERNEEDNUM */
1142 
1143 		if ((flags & FLG_OF_COMREL) && ofl->ofl_relocrelcnt)
1144 			cnt++;			/* RELACOUNT */
1145 
1146 		if (flags & FLG_OF_TEXTREL)	/* TEXTREL */
1147 			cnt++;
1148 
1149 		if (ofl->ofl_osfiniarray)	/* FINI_ARRAY & FINI_ARRAYSZ */
1150 			cnt += 2;
1151 
1152 		if (ofl->ofl_osinitarray)	/* INIT_ARRAY & INIT_ARRAYSZ */
1153 			cnt += 2;
1154 
1155 		if (ofl->ofl_ospreinitarray)	/* PREINIT_ARRAY & */
1156 			cnt += 2;		/*	PREINIT_ARRAYSZ */
1157 
1158 		/*
1159 		 * If we have plt's reserve a PLT, PLTSZ, PLTREL and JMPREL.
1160 		 */
1161 		if (ofl->ofl_pltcnt)
1162 			cnt += 3;
1163 
1164 		/*
1165 		 * If pltpadding is needed (Sparcv9)
1166 		 */
1167 		if (ofl->ofl_pltpad)
1168 			cnt += 2;		/* DT_PLTPAD & DT_PLTPADSZ */
1169 
1170 		/*
1171 		 * If we have any relocations reserve a REL, RELSZ and
1172 		 * RELENT entry.
1173 		 */
1174 		if (ofl->ofl_relocsz)
1175 			cnt += 3;
1176 
1177 		/*
1178 		 * If a syminfo section is required create SYMINFO, SYMINSZ,
1179 		 * and SYMINENT entries.
1180 		 */
1181 		if (flags & FLG_OF_SYMINFO)
1182 			cnt += 3;
1183 
1184 		/*
1185 		 * If there are any partially initialized sections allocate
1186 		 * MOVEENT, MOVESZ and MOVETAB.
1187 		 */
1188 		if (ofl->ofl_osmove)
1189 			cnt += 3;
1190 
1191 		/*
1192 		 * Allocate one DT_REGISTER entry for every register symbol.
1193 		 */
1194 		cnt += ofl->ofl_regsymcnt;
1195 
1196 		/*
1197 		 * Reserve a entry for each '-zrtldinfo=...' specified
1198 		 * on the command line.
1199 		 */
1200 		for (APLIST_TRAVERSE(ofl->ofl_rtldinfo, idx, sdp))
1201 			cnt++;
1202 
1203 		/*
1204 		 * These two entries should only be placed in a segment
1205 		 * which is writable.  If it's a read-only segment
1206 		 * (due to mapfile magic, e.g. libdl.so.1) then don't allocate
1207 		 * these entries.
1208 		 */
1209 		if ((osp->os_sgdesc) &&
1210 		    (osp->os_sgdesc->sg_phdr.p_flags & PF_W)) {
1211 			cnt++;			/* FEATURE_1 */
1212 
1213 			if (ofl->ofl_osinterp)
1214 				cnt++;		/* DEBUG */
1215 		}
1216 
1217 		/*
1218 		 * Any hardware/software capabilities?
1219 		 */
1220 		if (ofl->ofl_oscap)
1221 			cnt++;			/* SUNW_CAP */
1222 
1223 		if (flags & FLG_OF_SYMBOLIC)
1224 			cnt++;			/* SYMBOLIC */
1225 	}
1226 
1227 	/*
1228 	 * Account for Architecture dependent .dynamic entries, and defaults.
1229 	 */
1230 	(*ld_targ.t_mr.mr_mach_make_dynamic)(ofl, &cnt);
1231 
1232 	/*
1233 	 * DT_FLAGS, DT_FLAGS_1, DT_SUNW_STRPAD, and DT_NULL. Also,
1234 	 * allow room for the unused extra DT_NULLs. These are included
1235 	 * to allow an ELF editor room to add items later.
1236 	 */
1237 	cnt += 4 + DYNAMIC_EXTRA_ELTS;
1238 
1239 	/*
1240 	 * DT_SUNW_LDMACH. Used to hold the ELF machine code of the
1241 	 * linker that produced the output object. This information
1242 	 * allows us to determine whether a given object was linked
1243 	 * natively, or by a linker running on a different type of
1244 	 * system. This information can be valuable if one suspects
1245 	 * that a problem might be due to alignment or byte order issues.
1246 	 */
1247 	cnt++;
1248 
1249 	/*
1250 	 * Determine the size of the section from the number of entries.
1251 	 */
1252 	size = cnt * (size_t)shdr->sh_entsize;
1253 
1254 	shdr->sh_size = (Xword)size;
1255 	data->d_size = size;
1256 
1257 	/*
1258 	 * There are several tags that are specific to the Solaris osabi
1259 	 * range which we unconditionally put into any dynamic section
1260 	 * we create (e.g. DT_SUNW_STRPAD or DT_SUNW_LDMACH). As such,
1261 	 * any Solaris object with a dynamic section should be tagged as
1262 	 * ELFOSABI_SOLARIS.
1263 	 */
1264 	ofl->ofl_flags |= FLG_OF_OSABI;
1265 
1266 	return ((uintptr_t)ofl->ofl_osdynamic);
1267 }
1268 
1269 /*
1270  * Build the GOT section and its associated relocation entries.
1271  */
1272 uintptr_t
1273 ld_make_got(Ofl_desc *ofl)
1274 {
1275 	Elf_Data	*data;
1276 	Shdr	*shdr;
1277 	Is_desc	*isec;
1278 	size_t	size = (size_t)ofl->ofl_gotcnt * ld_targ.t_m.m_got_entsize;
1279 	size_t	rsize = (size_t)ofl->ofl_relocgotsz;
1280 
1281 	if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_GOT), 0,
1282 	    &isec, &shdr, &data) == S_ERROR)
1283 		return (S_ERROR);
1284 
1285 	data->d_size = size;
1286 
1287 	shdr->sh_flags |= SHF_WRITE;
1288 	shdr->sh_size = (Xword)size;
1289 	shdr->sh_entsize = ld_targ.t_m.m_got_entsize;
1290 
1291 	ofl->ofl_osgot = ld_place_section(ofl, isec, ld_targ.t_id.id_got, NULL);
1292 	if (ofl->ofl_osgot == (Os_desc *)S_ERROR)
1293 		return (S_ERROR);
1294 
1295 	ofl->ofl_osgot->os_szoutrels = (Xword)rsize;
1296 
1297 	return (1);
1298 }
1299 
1300 /*
1301  * Build an interpreter section.
1302  */
1303 static uintptr_t
1304 make_interp(Ofl_desc *ofl)
1305 {
1306 	Shdr		*shdr;
1307 	Elf_Data	*data;
1308 	Is_desc		*isec;
1309 	const char	*iname = ofl->ofl_interp;
1310 	size_t		size;
1311 
1312 	/*
1313 	 * If -z nointerp is in effect, don't create an interpreter section.
1314 	 */
1315 	if (ofl->ofl_flags1 & FLG_OF1_NOINTRP)
1316 		return (1);
1317 
1318 	/*
1319 	 * We always build an .interp section for dynamic executables.  However
1320 	 * if the user has specifically specified an interpreter we'll build
1321 	 * this section for any output (presumably the user knows what they are
1322 	 * doing. refer ABI section 5-4, and ld.1 man page use of -I).
1323 	 */
1324 	if (((ofl->ofl_flags & (FLG_OF_DYNAMIC | FLG_OF_EXEC |
1325 	    FLG_OF_RELOBJ)) != (FLG_OF_DYNAMIC | FLG_OF_EXEC)) && !iname)
1326 		return (1);
1327 
1328 	/*
1329 	 * In the case of a dynamic executable supply a default interpreter
1330 	 * if a specific interpreter has not been specified.
1331 	 */
1332 	if (iname == NULL)
1333 		iname = ofl->ofl_interp = ld_targ.t_m.m_def_interp;
1334 
1335 	size = strlen(iname) + 1;
1336 
1337 	if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_INTERP), 0,
1338 	    &isec, &shdr, &data) == S_ERROR)
1339 		return (S_ERROR);
1340 
1341 	data->d_size = size;
1342 	shdr->sh_size = (Xword)size;
1343 	data->d_align = shdr->sh_addralign = 1;
1344 
1345 	ofl->ofl_osinterp =
1346 	    ld_place_section(ofl, isec, ld_targ.t_id.id_interp, NULL);
1347 	return ((uintptr_t)ofl->ofl_osinterp);
1348 }
1349 
1350 /*
1351  * Build a hardware/software capabilities section.
1352  */
1353 static uintptr_t
1354 make_cap(Ofl_desc *ofl)
1355 {
1356 	Shdr		*shdr;
1357 	Elf_Data	*data;
1358 	Is_desc		*isec;
1359 	Os_desc		*osec;
1360 	Cap		*cap;
1361 	size_t		size = 0;
1362 
1363 	/*
1364 	 * Determine how many entries are required.
1365 	 */
1366 	if (ofl->ofl_hwcap_1)
1367 		size++;
1368 	if (ofl->ofl_sfcap_1)
1369 		size++;
1370 	if (size == 0)
1371 		return (1);
1372 	size++;				/* Add CA_SUNW_NULL */
1373 
1374 	if (new_section(ofl, SHT_SUNW_cap, MSG_ORIG(MSG_SCN_SUNWCAP), size,
1375 	    &isec, &shdr, &data) == S_ERROR)
1376 		return (S_ERROR);
1377 
1378 	if ((data->d_buf = libld_malloc(shdr->sh_size)) == NULL)
1379 		return (S_ERROR);
1380 
1381 	cap = (Cap *)data->d_buf;
1382 	if (ofl->ofl_hwcap_1) {
1383 		cap->c_tag = CA_SUNW_HW_1;
1384 		cap->c_un.c_val = ofl->ofl_hwcap_1;
1385 		cap++;
1386 	}
1387 	if (ofl->ofl_sfcap_1) {
1388 		cap->c_tag = CA_SUNW_SF_1;
1389 		cap->c_un.c_val = ofl->ofl_sfcap_1;
1390 		cap++;
1391 	}
1392 	cap->c_tag = CA_SUNW_NULL;
1393 	cap->c_un.c_val = 0;
1394 
1395 	/*
1396 	 * If we're not creating a relocatable object, save the output section
1397 	 * to trigger the creation of an associated program header.
1398 	 */
1399 	osec = ld_place_section(ofl, isec, ld_targ.t_id.id_cap, NULL);
1400 	if ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0)
1401 		ofl->ofl_oscap = osec;
1402 
1403 	return ((uintptr_t)osec);
1404 }
1405 
1406 /*
1407  * Build the PLT section and its associated relocation entries.
1408  */
1409 static uintptr_t
1410 make_plt(Ofl_desc *ofl)
1411 {
1412 	Shdr		*shdr;
1413 	Elf_Data	*data;
1414 	Is_desc		*isec;
1415 	size_t		size = ld_targ.t_m.m_plt_reservsz +
1416 	    (((size_t)ofl->ofl_pltcnt + (size_t)ofl->ofl_pltpad) *
1417 	    ld_targ.t_m.m_plt_entsize);
1418 	size_t		rsize = (size_t)ofl->ofl_relocpltsz;
1419 
1420 	/*
1421 	 * On sparc, account for the NOP at the end of the plt.
1422 	 */
1423 	if (ld_targ.t_m.m_mach == LD_TARG_BYCLASS(EM_SPARC, EM_SPARCV9))
1424 		size += sizeof (Word);
1425 
1426 	if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_PLT), 0,
1427 	    &isec, &shdr, &data) == S_ERROR)
1428 		return (S_ERROR);
1429 
1430 	data->d_size = size;
1431 	data->d_align = ld_targ.t_m.m_plt_align;
1432 
1433 	shdr->sh_flags = ld_targ.t_m.m_plt_shf_flags;
1434 	shdr->sh_size = (Xword)size;
1435 	shdr->sh_addralign = ld_targ.t_m.m_plt_align;
1436 	shdr->sh_entsize = ld_targ.t_m.m_plt_entsize;
1437 
1438 	ofl->ofl_osplt = ld_place_section(ofl, isec, ld_targ.t_id.id_plt, NULL);
1439 	if (ofl->ofl_osplt == (Os_desc *)S_ERROR)
1440 		return (S_ERROR);
1441 
1442 	ofl->ofl_osplt->os_szoutrels = (Xword)rsize;
1443 
1444 	return (1);
1445 }
1446 
1447 /*
1448  * Make the hash table.  Only built for dynamic executables and shared
1449  * libraries, and provides hashed lookup into the global symbol table
1450  * (.dynsym) for the run-time linker to resolve symbol lookups.
1451  */
1452 static uintptr_t
1453 make_hash(Ofl_desc *ofl)
1454 {
1455 	Shdr		*shdr;
1456 	Elf_Data	*data;
1457 	Is_desc		*isec;
1458 	size_t		size;
1459 	Word		nsyms = ofl->ofl_globcnt;
1460 	size_t		cnt;
1461 
1462 	/*
1463 	 * Allocate section header structures. We set entcnt to 0
1464 	 * because it's going to change after we place this section.
1465 	 */
1466 	if (new_section(ofl, SHT_HASH, MSG_ORIG(MSG_SCN_HASH), 0,
1467 	    &isec, &shdr, &data) == S_ERROR)
1468 		return (S_ERROR);
1469 
1470 	/*
1471 	 * Place the section first since it will affect the local symbol
1472 	 * count.
1473 	 */
1474 	ofl->ofl_oshash =
1475 	    ld_place_section(ofl, isec, ld_targ.t_id.id_hash, NULL);
1476 	if (ofl->ofl_oshash == (Os_desc *)S_ERROR)
1477 		return (S_ERROR);
1478 
1479 	/*
1480 	 * Calculate the number of output hash buckets.
1481 	 */
1482 	ofl->ofl_hashbkts = findprime(nsyms);
1483 
1484 	/*
1485 	 * The size of the hash table is determined by
1486 	 *
1487 	 *	i.	the initial nbucket and nchain entries (2)
1488 	 *	ii.	the number of buckets (calculated above)
1489 	 *	iii.	the number of chains (this is based on the number of
1490 	 *		symbols in the .dynsym array).
1491 	 */
1492 	cnt = 2 + ofl->ofl_hashbkts + DYNSYM_ALL_CNT(ofl);
1493 	size = cnt * shdr->sh_entsize;
1494 
1495 	/*
1496 	 * Finalize the section header and data buffer initialization.
1497 	 */
1498 	if ((data->d_buf = libld_calloc(size, 1)) == NULL)
1499 		return (S_ERROR);
1500 	data->d_size = size;
1501 	shdr->sh_size = (Xword)size;
1502 
1503 	return (1);
1504 }
1505 
1506 /*
1507  * Generate the standard symbol table.  Contains all locals and globals,
1508  * and resides in a non-allocatable section (ie. it can be stripped).
1509  */
1510 static uintptr_t
1511 make_symtab(Ofl_desc *ofl)
1512 {
1513 	Shdr		*shdr;
1514 	Elf_Data	*data;
1515 	Is_desc		*isec;
1516 	Is_desc		*xisec = 0;
1517 	size_t		size;
1518 	Word		symcnt;
1519 
1520 	/*
1521 	 * Create the section headers. Note that we supply an ent_cnt
1522 	 * of 0. We won't know the count until the section has been placed.
1523 	 */
1524 	if (new_section(ofl, SHT_SYMTAB, MSG_ORIG(MSG_SCN_SYMTAB), 0,
1525 	    &isec, &shdr, &data) == S_ERROR)
1526 		return (S_ERROR);
1527 
1528 	/*
1529 	 * Place the section first since it will affect the local symbol
1530 	 * count.
1531 	 */
1532 	if ((ofl->ofl_ossymtab = ld_place_section(ofl, isec,
1533 	    ld_targ.t_id.id_symtab, NULL)) == (Os_desc *)S_ERROR)
1534 		return (S_ERROR);
1535 
1536 	/*
1537 	 * At this point we've created all but the 'shstrtab' section.
1538 	 * Determine if we have to use 'Extended Sections'.  If so - then
1539 	 * also create a SHT_SYMTAB_SHNDX section.
1540 	 */
1541 	if ((ofl->ofl_shdrcnt + 1) >= SHN_LORESERVE) {
1542 		Shdr		*xshdr;
1543 		Elf_Data	*xdata;
1544 
1545 		if (new_section(ofl, SHT_SYMTAB_SHNDX,
1546 		    MSG_ORIG(MSG_SCN_SYMTAB_SHNDX), 0, &xisec,
1547 		    &xshdr, &xdata) == S_ERROR)
1548 			return (S_ERROR);
1549 
1550 		if ((ofl->ofl_ossymshndx = ld_place_section(ofl, xisec,
1551 		    ld_targ.t_id.id_symtab_ndx, NULL)) == (Os_desc *)S_ERROR)
1552 			return (S_ERROR);
1553 	}
1554 
1555 	/*
1556 	 * Calculated number of symbols, which need to be augmented by
1557 	 * the (yet to be created) .shstrtab entry.
1558 	 */
1559 	symcnt = (size_t)(1 + SYMTAB_ALL_CNT(ofl));
1560 	size = symcnt * shdr->sh_entsize;
1561 
1562 	/*
1563 	 * Finalize the section header and data buffer initialization.
1564 	 */
1565 	data->d_size = size;
1566 	shdr->sh_size = (Xword)size;
1567 
1568 	/*
1569 	 * If we created a SHT_SYMTAB_SHNDX - then set it's sizes too.
1570 	 */
1571 	if (xisec) {
1572 		size_t	xsize = symcnt * sizeof (Word);
1573 
1574 		xisec->is_indata->d_size = xsize;
1575 		xisec->is_shdr->sh_size = (Xword)xsize;
1576 	}
1577 
1578 	return (1);
1579 }
1580 
1581 
1582 /*
1583  * Build a dynamic symbol table. These tables reside in the text
1584  * segment of a dynamic executable or shared library.
1585  *
1586  *	.SUNW_ldynsym contains local function symbols
1587  *	.dynsym contains only globals symbols
1588  *
1589  * The two tables are created adjacent to each other, with .SUNW_ldynsym
1590  * coming first.
1591  */
1592 static uintptr_t
1593 make_dynsym(Ofl_desc *ofl)
1594 {
1595 	Shdr		*shdr, *lshdr;
1596 	Elf_Data	*data, *ldata;
1597 	Is_desc		*isec, *lisec;
1598 	size_t		size;
1599 	Xword		cnt;
1600 	int		allow_ldynsym;
1601 
1602 	/*
1603 	 * Unless explicitly disabled, always produce a .SUNW_ldynsym section
1604 	 * when it is allowed by the file type, even if the resulting
1605 	 * table only ends up with a single STT_FILE in it. There are
1606 	 * two reasons: (1) It causes the generation of the DT_SUNW_SYMTAB
1607 	 * entry in the .dynamic section, which is something we would
1608 	 * like to encourage, and (2) Without it, we cannot generate
1609 	 * the associated .SUNW_dyn[sym|tls]sort sections, which are of
1610 	 * value to DTrace.
1611 	 *
1612 	 * In practice, it is extremely rare for an object not to have
1613 	 * local symbols for .SUNW_ldynsym, so 99% of the time, we'd be
1614 	 * doing it anyway.
1615 	 */
1616 	allow_ldynsym = OFL_ALLOW_LDYNSYM(ofl);
1617 
1618 	/*
1619 	 * Create the section headers. Note that we supply an ent_cnt
1620 	 * of 0. We won't know the count until the section has been placed.
1621 	 */
1622 	if (allow_ldynsym && new_section(ofl, SHT_SUNW_LDYNSYM,
1623 	    MSG_ORIG(MSG_SCN_LDYNSYM), 0, &lisec, &lshdr, &ldata) == S_ERROR)
1624 		return (S_ERROR);
1625 
1626 	if (new_section(ofl, SHT_DYNSYM, MSG_ORIG(MSG_SCN_DYNSYM), 0,
1627 	    &isec, &shdr, &data) == S_ERROR)
1628 		return (S_ERROR);
1629 
1630 	/*
1631 	 * Place the section(s) first since it will affect the local symbol
1632 	 * count.
1633 	 */
1634 	if (allow_ldynsym &&
1635 	    ((ofl->ofl_osldynsym = ld_place_section(ofl, lisec,
1636 	    ld_targ.t_id.id_ldynsym, NULL)) == (Os_desc *)S_ERROR))
1637 		return (S_ERROR);
1638 	ofl->ofl_osdynsym =
1639 	    ld_place_section(ofl, isec, ld_targ.t_id.id_dynsym, NULL);
1640 	if (ofl->ofl_osdynsym == (Os_desc *)S_ERROR)
1641 		return (S_ERROR);
1642 
1643 	cnt = DYNSYM_ALL_CNT(ofl);
1644 	size = (size_t)cnt * shdr->sh_entsize;
1645 
1646 	/*
1647 	 * Finalize the section header and data buffer initialization.
1648 	 */
1649 	data->d_size = size;
1650 	shdr->sh_size = (Xword)size;
1651 
1652 	/*
1653 	 * An ldynsym contains local function symbols. It is not
1654 	 * used for linking, but if present, serves to allow better
1655 	 * stack traces to be generated in contexts where the symtab
1656 	 * is not available. (dladdr(), or stripped executable/library files).
1657 	 */
1658 	if (allow_ldynsym) {
1659 		cnt = 1 + ofl->ofl_dynlocscnt + ofl->ofl_dynscopecnt;
1660 		size = (size_t)cnt * shdr->sh_entsize;
1661 
1662 		ldata->d_size = size;
1663 		lshdr->sh_size = (Xword)size;
1664 	}
1665 
1666 	return (1);
1667 }
1668 
1669 /*
1670  * Build .SUNW_dynsymsort and/or .SUNW_dyntlssort sections. These are
1671  * index sections for the .SUNW_ldynsym/.dynsym pair that present data
1672  * and function symbols sorted by address.
1673  */
1674 static uintptr_t
1675 make_dynsort(Ofl_desc *ofl)
1676 {
1677 	Shdr		*shdr;
1678 	Elf_Data	*data;
1679 	Is_desc		*isec;
1680 
1681 	/* Only do it if the .SUNW_ldynsym section is present */
1682 	if (!OFL_ALLOW_LDYNSYM(ofl))
1683 		return (1);
1684 
1685 	/* .SUNW_dynsymsort */
1686 	if (ofl->ofl_dynsymsortcnt > 0) {
1687 		if (new_section(ofl, SHT_SUNW_symsort,
1688 		    MSG_ORIG(MSG_SCN_DYNSYMSORT), ofl->ofl_dynsymsortcnt,
1689 		    &isec, &shdr, &data) == S_ERROR)
1690 		return (S_ERROR);
1691 
1692 		if ((ofl->ofl_osdynsymsort = ld_place_section(ofl, isec,
1693 		    ld_targ.t_id.id_dynsort, NULL)) == (Os_desc *)S_ERROR)
1694 			return (S_ERROR);
1695 	}
1696 
1697 	/* .SUNW_dyntlssort */
1698 	if (ofl->ofl_dyntlssortcnt > 0) {
1699 		if (new_section(ofl, SHT_SUNW_tlssort,
1700 		    MSG_ORIG(MSG_SCN_DYNTLSSORT),
1701 		    ofl->ofl_dyntlssortcnt, &isec, &shdr, &data) == S_ERROR)
1702 		return (S_ERROR);
1703 
1704 		if ((ofl->ofl_osdyntlssort = ld_place_section(ofl, isec,
1705 		    ld_targ.t_id.id_dynsort, NULL)) == (Os_desc *)S_ERROR)
1706 			return (S_ERROR);
1707 	}
1708 
1709 	return (1);
1710 }
1711 
1712 /*
1713  * Helper routine for make_dynsym_shndx. Builds a
1714  * a SHT_SYMTAB_SHNDX for .dynsym or .SUNW_ldynsym, without knowing
1715  * which one it is.
1716  */
1717 static uintptr_t
1718 make_dyn_shndx(Ofl_desc *ofl, const char *shname, Os_desc *symtab,
1719     Os_desc **ret_os)
1720 {
1721 	Is_desc		*isec;
1722 	Is_desc		*dynsymisp;
1723 	Shdr		*shdr, *dynshdr;
1724 	Elf_Data	*data;
1725 
1726 	dynsymisp = ld_os_first_isdesc(symtab);
1727 	dynshdr = dynsymisp->is_shdr;
1728 
1729 	if (new_section(ofl, SHT_SYMTAB_SHNDX, shname,
1730 	    (dynshdr->sh_size / dynshdr->sh_entsize),
1731 	    &isec, &shdr, &data) == S_ERROR)
1732 		return (S_ERROR);
1733 
1734 	if ((*ret_os = ld_place_section(ofl, isec,
1735 	    ld_targ.t_id.id_dynsym_ndx, NULL)) == (Os_desc *)S_ERROR)
1736 		return (S_ERROR);
1737 
1738 	assert(*ret_os);
1739 
1740 	return (1);
1741 }
1742 
1743 /*
1744  * Build a SHT_SYMTAB_SHNDX for the .dynsym, and .SUNW_ldynsym
1745  */
1746 static uintptr_t
1747 make_dynsym_shndx(Ofl_desc *ofl)
1748 {
1749 	/*
1750 	 * If there is a .SUNW_ldynsym, generate a section for its extended
1751 	 * index section as well.
1752 	 */
1753 	if (OFL_ALLOW_LDYNSYM(ofl)) {
1754 		if (make_dyn_shndx(ofl, MSG_ORIG(MSG_SCN_LDYNSYM_SHNDX),
1755 		    ofl->ofl_osldynsym, &ofl->ofl_osldynshndx) == S_ERROR)
1756 			return (S_ERROR);
1757 	}
1758 
1759 	/* The Generate a section for the dynsym */
1760 	if (make_dyn_shndx(ofl, MSG_ORIG(MSG_SCN_DYNSYM_SHNDX),
1761 	    ofl->ofl_osdynsym, &ofl->ofl_osdynshndx) == S_ERROR)
1762 		return (S_ERROR);
1763 
1764 	return (1);
1765 }
1766 
1767 
1768 /*
1769  * Build a string table for the section headers.
1770  */
1771 static uintptr_t
1772 make_shstrtab(Ofl_desc *ofl)
1773 {
1774 	Shdr		*shdr;
1775 	Elf_Data	*data;
1776 	Is_desc		*isec;
1777 	size_t		size;
1778 
1779 	if (new_section(ofl, SHT_STRTAB, MSG_ORIG(MSG_SCN_SHSTRTAB),
1780 	    0, &isec, &shdr, &data) == S_ERROR)
1781 		return (S_ERROR);
1782 
1783 	/*
1784 	 * Place the section first, as it may effect the number of section
1785 	 * headers to account for.
1786 	 */
1787 	ofl->ofl_osshstrtab =
1788 	    ld_place_section(ofl, isec, ld_targ.t_id.id_note, NULL);
1789 	if (ofl->ofl_osshstrtab == (Os_desc *)S_ERROR)
1790 		return (S_ERROR);
1791 
1792 	size = st_getstrtab_sz(ofl->ofl_shdrsttab);
1793 	assert(size > 0);
1794 
1795 	data->d_size = size;
1796 	shdr->sh_size = (Xword)size;
1797 
1798 	return (1);
1799 }
1800 
1801 /*
1802  * Build a string section for the standard symbol table.
1803  */
1804 static uintptr_t
1805 make_strtab(Ofl_desc *ofl)
1806 {
1807 	Shdr		*shdr;
1808 	Elf_Data	*data;
1809 	Is_desc		*isec;
1810 	size_t		size;
1811 
1812 	/*
1813 	 * This string table consists of all the global and local symbols.
1814 	 * Account for null bytes at end of the file name and the beginning
1815 	 * of section.
1816 	 */
1817 	if (st_insert(ofl->ofl_strtab, ofl->ofl_name) == -1)
1818 		return (S_ERROR);
1819 
1820 	size = st_getstrtab_sz(ofl->ofl_strtab);
1821 	assert(size > 0);
1822 
1823 	if (new_section(ofl, SHT_STRTAB, MSG_ORIG(MSG_SCN_STRTAB),
1824 	    0, &isec, &shdr, &data) == S_ERROR)
1825 		return (S_ERROR);
1826 
1827 	/* Set the size of the data area */
1828 	data->d_size = size;
1829 	shdr->sh_size = (Xword)size;
1830 
1831 	ofl->ofl_osstrtab =
1832 	    ld_place_section(ofl, isec, ld_targ.t_id.id_strtab, NULL);
1833 	return ((uintptr_t)ofl->ofl_osstrtab);
1834 }
1835 
1836 /*
1837  * Build a string table for the dynamic symbol table.
1838  */
1839 static uintptr_t
1840 make_dynstr(Ofl_desc *ofl)
1841 {
1842 	Shdr		*shdr;
1843 	Elf_Data	*data;
1844 	Is_desc		*isec;
1845 	size_t		size;
1846 
1847 	/*
1848 	 * If producing a .SUNW_ldynsym, account for the initial STT_FILE
1849 	 * symbol that precedes the scope reduced global symbols.
1850 	 */
1851 	if (OFL_ALLOW_LDYNSYM(ofl)) {
1852 		if (st_insert(ofl->ofl_dynstrtab, ofl->ofl_name) == -1)
1853 			return (S_ERROR);
1854 		ofl->ofl_dynscopecnt++;
1855 	}
1856 
1857 
1858 	/*
1859 	 * Account for any local, named register symbols.  These locals are
1860 	 * required for reference from DT_REGISTER .dynamic entries.
1861 	 */
1862 	if (ofl->ofl_regsyms) {
1863 		int	ndx;
1864 
1865 		for (ndx = 0; ndx < ofl->ofl_regsymsno; ndx++) {
1866 			Sym_desc	*sdp;
1867 
1868 			if ((sdp = ofl->ofl_regsyms[ndx]) == NULL)
1869 				continue;
1870 
1871 			if (((sdp->sd_flags & FLG_SY_HIDDEN) == 0) &&
1872 			    (ELF_ST_BIND(sdp->sd_sym->st_info) != STB_LOCAL))
1873 				continue;
1874 
1875 			if (sdp->sd_sym->st_name == NULL)
1876 				continue;
1877 
1878 			if (st_insert(ofl->ofl_dynstrtab, sdp->sd_name) == -1)
1879 				return (S_ERROR);
1880 		}
1881 	}
1882 
1883 	/*
1884 	 * Reserve entries for any per-symbol auxiliary/filter strings.
1885 	 */
1886 	if (ofl->ofl_dtsfltrs != NULL) {
1887 		Dfltr_desc	*dftp;
1888 		Aliste		idx;
1889 
1890 		for (ALIST_TRAVERSE(ofl->ofl_dtsfltrs, idx, dftp))
1891 			if (st_insert(ofl->ofl_dynstrtab, dftp->dft_str) == -1)
1892 				return (S_ERROR);
1893 	}
1894 
1895 	size = st_getstrtab_sz(ofl->ofl_dynstrtab);
1896 	assert(size > 0);
1897 
1898 	if (new_section(ofl, SHT_STRTAB, MSG_ORIG(MSG_SCN_DYNSTR),
1899 	    0, &isec, &shdr, &data) == S_ERROR)
1900 		return (S_ERROR);
1901 
1902 	/* Make it allocable if necessary */
1903 	if (!(ofl->ofl_flags & FLG_OF_RELOBJ))
1904 		shdr->sh_flags |= SHF_ALLOC;
1905 
1906 	/* Set the size of the data area */
1907 	data->d_size = size + DYNSTR_EXTRA_PAD;
1908 
1909 	shdr->sh_size = (Xword)size;
1910 
1911 	ofl->ofl_osdynstr =
1912 	    ld_place_section(ofl, isec, ld_targ.t_id.id_dynstr, NULL);
1913 	return ((uintptr_t)ofl->ofl_osdynstr);
1914 }
1915 
1916 /*
1917  * Generate an output relocation section which will contain the relocation
1918  * information to be applied to the `osp' section.
1919  *
1920  * If (osp == NULL) then we are creating the coalesced relocation section
1921  * for an executable and/or a shared object.
1922  */
1923 static uintptr_t
1924 make_reloc(Ofl_desc *ofl, Os_desc *osp)
1925 {
1926 	Shdr		*shdr;
1927 	Elf_Data	*data;
1928 	Is_desc		*isec;
1929 	size_t		size;
1930 	Xword		sh_flags;
1931 	char 		*sectname;
1932 	Os_desc		*rosp;
1933 	Word		relsize;
1934 	const char	*rel_prefix;
1935 
1936 	/* LINTED */
1937 	if (ld_targ.t_m.m_rel_sht_type == SHT_REL) {
1938 		/* REL */
1939 		relsize = sizeof (Rel);
1940 		rel_prefix = MSG_ORIG(MSG_SCN_REL);
1941 	} else {
1942 		/* RELA */
1943 		relsize = sizeof (Rela);
1944 		rel_prefix = MSG_ORIG(MSG_SCN_RELA);
1945 	}
1946 
1947 	if (osp) {
1948 		size = osp->os_szoutrels;
1949 		sh_flags = osp->os_shdr->sh_flags;
1950 		if ((sectname = libld_malloc(strlen(rel_prefix) +
1951 		    strlen(osp->os_name) + 1)) == 0)
1952 			return (S_ERROR);
1953 		(void) strcpy(sectname, rel_prefix);
1954 		(void) strcat(sectname, osp->os_name);
1955 	} else if (ofl->ofl_flags & FLG_OF_COMREL) {
1956 		size = (ofl->ofl_reloccnt - ofl->ofl_reloccntsub) * relsize;
1957 		sh_flags = SHF_ALLOC;
1958 		sectname = (char *)MSG_ORIG(MSG_SCN_SUNWRELOC);
1959 	} else {
1960 		size = ofl->ofl_relocrelsz;
1961 		sh_flags = SHF_ALLOC;
1962 		sectname = (char *)rel_prefix;
1963 	}
1964 
1965 	/*
1966 	 * Keep track of total size of 'output relocations' (to be stored
1967 	 * in .dynamic)
1968 	 */
1969 	/* LINTED */
1970 	ofl->ofl_relocsz += (Xword)size;
1971 
1972 	if (new_section(ofl, ld_targ.t_m.m_rel_sht_type, sectname, 0, &isec,
1973 	    &shdr, &data) == S_ERROR)
1974 		return (S_ERROR);
1975 
1976 	data->d_size = size;
1977 
1978 	shdr->sh_size = (Xword)size;
1979 	if (OFL_ALLOW_DYNSYM(ofl) && (sh_flags & SHF_ALLOC))
1980 		shdr->sh_flags = SHF_ALLOC;
1981 
1982 	if (osp) {
1983 		/*
1984 		 * The sh_info field of the SHT_REL* sections points to the
1985 		 * section the relocations are to be applied to.
1986 		 */
1987 		shdr->sh_flags |= SHF_INFO_LINK;
1988 	}
1989 
1990 	rosp = ld_place_section(ofl, isec, ld_targ.t_id.id_rel, NULL);
1991 	if (rosp == (Os_desc *)S_ERROR)
1992 		return (S_ERROR);
1993 
1994 	/*
1995 	 * Associate this relocation section to the section its going to
1996 	 * relocate.
1997 	 */
1998 	if (osp) {
1999 		Aliste	idx;
2000 		Is_desc	*risp;
2001 
2002 		/*
2003 		 * This is used primarily so that we can update
2004 		 * SHT_GROUP[sect_no] entries to point to the
2005 		 * created output relocation sections.
2006 		 */
2007 		for (APLIST_TRAVERSE(osp->os_relisdescs, idx, risp)) {
2008 			risp->is_osdesc = rosp;
2009 
2010 			/*
2011 			 * If the input relocation section had the SHF_GROUP
2012 			 * flag set - propagate it to the output relocation
2013 			 * section.
2014 			 */
2015 			if (risp->is_shdr->sh_flags & SHF_GROUP) {
2016 				rosp->os_shdr->sh_flags |= SHF_GROUP;
2017 				break;
2018 			}
2019 		}
2020 		osp->os_relosdesc = rosp;
2021 	} else
2022 		ofl->ofl_osrel = rosp;
2023 
2024 	/*
2025 	 * If this is the first relocation section we've encountered save it
2026 	 * so that the .dynamic entry can be initialized accordingly.
2027 	 */
2028 	if (ofl->ofl_osrelhead == (Os_desc *)0)
2029 		ofl->ofl_osrelhead = rosp;
2030 
2031 	return (1);
2032 }
2033 
2034 /*
2035  * Generate version needed section.
2036  */
2037 static uintptr_t
2038 make_verneed(Ofl_desc *ofl)
2039 {
2040 	Shdr		*shdr;
2041 	Elf_Data	*data;
2042 	Is_desc		*isec;
2043 
2044 	/*
2045 	 * verneed sections do not have a constant element size, so the
2046 	 * value of ent_cnt specified here (0) is meaningless.
2047 	 */
2048 	if (new_section(ofl, SHT_SUNW_verneed, MSG_ORIG(MSG_SCN_SUNWVERSION),
2049 	    0, &isec, &shdr, &data) == S_ERROR)
2050 		return (S_ERROR);
2051 
2052 	/* During version processing we calculated the total size. */
2053 	data->d_size = ofl->ofl_verneedsz;
2054 	shdr->sh_size = (Xword)ofl->ofl_verneedsz;
2055 
2056 	ofl->ofl_osverneed =
2057 	    ld_place_section(ofl, isec, ld_targ.t_id.id_version, NULL);
2058 	return ((uintptr_t)ofl->ofl_osverneed);
2059 }
2060 
2061 /*
2062  * Generate a version definition section.
2063  *
2064  *  o	the SHT_SUNW_verdef section defines the versions that exist within this
2065  *	image.
2066  */
2067 static uintptr_t
2068 make_verdef(Ofl_desc *ofl)
2069 {
2070 	Shdr		*shdr;
2071 	Elf_Data	*data;
2072 	Is_desc		*isec;
2073 	Ver_desc	*vdp;
2074 	Str_tbl		*strtab;
2075 
2076 	/*
2077 	 * Reserve a string table entry for the base version dependency (other
2078 	 * dependencies have symbol representations, which will already be
2079 	 * accounted for during symbol processing).
2080 	 */
2081 	vdp = (Ver_desc *)ofl->ofl_verdesc->apl_data[0];
2082 
2083 	if (OFL_IS_STATIC_OBJ(ofl))
2084 		strtab = ofl->ofl_strtab;
2085 	else
2086 		strtab = ofl->ofl_dynstrtab;
2087 
2088 	if (st_insert(strtab, vdp->vd_name) == -1)
2089 		return (S_ERROR);
2090 
2091 	/*
2092 	 * verdef sections do not have a constant element size, so the
2093 	 * value of ent_cnt specified here (0) is meaningless.
2094 	 */
2095 	if (new_section(ofl, SHT_SUNW_verdef, MSG_ORIG(MSG_SCN_SUNWVERSION),
2096 	    0, &isec, &shdr, &data) == S_ERROR)
2097 		return (S_ERROR);
2098 
2099 	/* During version processing we calculated the total size. */
2100 	data->d_size = ofl->ofl_verdefsz;
2101 	shdr->sh_size = (Xword)ofl->ofl_verdefsz;
2102 
2103 	ofl->ofl_osverdef =
2104 	    ld_place_section(ofl, isec, ld_targ.t_id.id_version, NULL);
2105 	return ((uintptr_t)ofl->ofl_osverdef);
2106 }
2107 
2108 /*
2109  * Common function used to build both the SHT_SUNW_versym
2110  * section and the SHT_SUNW_syminfo section.  Each of these sections
2111  * provides additional symbol information.
2112  */
2113 static Os_desc *
2114 make_sym_sec(Ofl_desc *ofl, const char *sectname, Word stype, int ident)
2115 {
2116 	Shdr		*shdr;
2117 	Elf_Data	*data;
2118 	Is_desc		*isec;
2119 
2120 	/*
2121 	 * We don't know the size of this section yet, so set it to 0.
2122 	 * It gets filled in after the dynsym is sized.
2123 	 */
2124 	if (new_section(ofl, stype, sectname, 0, &isec, &shdr, &data) ==
2125 	    S_ERROR)
2126 		return ((Os_desc *)S_ERROR);
2127 
2128 	return (ld_place_section(ofl, isec, ident, NULL));
2129 }
2130 
2131 /*
2132  * This routine is called when -z nopartial is in effect.
2133  */
2134 uintptr_t
2135 ld_make_parexpn_data(Ofl_desc *ofl, size_t size, Xword align)
2136 {
2137 	Shdr		*shdr;
2138 	Elf_Data	*data;
2139 	Is_desc		*isec;
2140 	Os_desc		*osp;
2141 
2142 	if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_DATA), 0,
2143 	    &isec, &shdr, &data) == S_ERROR)
2144 		return (S_ERROR);
2145 
2146 	shdr->sh_flags |= SHF_WRITE;
2147 	data->d_size = size;
2148 	shdr->sh_size = (Xword)size;
2149 	if (align != 0) {
2150 		data->d_align = align;
2151 		shdr->sh_addralign = align;
2152 	}
2153 
2154 	if ((data->d_buf = libld_calloc(size, 1)) == NULL)
2155 		return (S_ERROR);
2156 
2157 	/*
2158 	 * Retain handle to this .data input section. Variables using move
2159 	 * sections (partial initialization) will be redirected here when
2160 	 * such global references are added and '-z nopartial' is in effect.
2161 	 */
2162 	ofl->ofl_isparexpn = isec;
2163 	osp = ld_place_section(ofl, isec, ld_targ.t_id.id_data, NULL);
2164 	if (osp == (Os_desc *)S_ERROR)
2165 		return (S_ERROR);
2166 
2167 	if (!(osp->os_flags & FLG_OS_OUTREL)) {
2168 		ofl->ofl_dynshdrcnt++;
2169 		osp->os_flags |= FLG_OS_OUTREL;
2170 	}
2171 	return (1);
2172 }
2173 
2174 /*
2175  * Make .sunwmove section
2176  */
2177 uintptr_t
2178 ld_make_sunwmove(Ofl_desc *ofl, int mv_nums)
2179 {
2180 	Shdr		*shdr;
2181 	Elf_Data	*data;
2182 	Is_desc		*isec;
2183 	Aliste		idx;
2184 	Sym_desc	*sdp;
2185 	int 		cnt = 1;
2186 
2187 
2188 	if (new_section(ofl, SHT_SUNW_move, MSG_ORIG(MSG_SCN_SUNWMOVE),
2189 	    mv_nums, &isec, &shdr, &data) == S_ERROR)
2190 		return (S_ERROR);
2191 
2192 	if ((data->d_buf = libld_calloc(data->d_size, 1)) == NULL)
2193 		return (S_ERROR);
2194 
2195 	/*
2196 	 * Copy move entries
2197 	 */
2198 	for (APLIST_TRAVERSE(ofl->ofl_parsyms, idx, sdp)) {
2199 		Aliste		idx2;
2200 		Mv_desc		*mdp;
2201 
2202 		if (sdp->sd_flags & FLG_SY_PAREXPN)
2203 			continue;
2204 
2205 		for (ALIST_TRAVERSE(sdp->sd_move, idx2, mdp))
2206 			mdp->md_oidx = cnt++;
2207 	}
2208 
2209 	if ((ofl->ofl_osmove = ld_place_section(ofl, isec, 0, NULL)) ==
2210 	    (Os_desc *)S_ERROR)
2211 		return (S_ERROR);
2212 
2213 	return (1);
2214 }
2215 
2216 /*
2217  * Given a relocation descriptor that references a string table
2218  * input section, locate the string referenced and return a pointer
2219  * to it.
2220  */
2221 static const char *
2222 strmerge_get_reloc_str(Ofl_desc *ofl, Rel_desc *rsp)
2223 {
2224 	Sym_desc *sdp = rsp->rel_sym;
2225 	Xword	 str_off;
2226 
2227 	/*
2228 	 * In the case of an STT_SECTION symbol, the addend of the
2229 	 * relocation gives the offset into the string section. For
2230 	 * other symbol types, the symbol value is the offset.
2231 	 */
2232 
2233 	if (ELF_ST_TYPE(sdp->sd_sym->st_info) != STT_SECTION) {
2234 		str_off = sdp->sd_sym->st_value;
2235 	} else if ((rsp->rel_flags & FLG_REL_RELA) == FLG_REL_RELA) {
2236 		/*
2237 		 * For SHT_RELA, the addend value is found in the
2238 		 * rel_raddend field of the relocation.
2239 		 */
2240 		str_off = rsp->rel_raddend;
2241 	} else {	/* REL and STT_SECTION */
2242 		/*
2243 		 * For SHT_REL, the "addend" is not part of the relocation
2244 		 * record. Instead, it is found at the relocation target
2245 		 * address.
2246 		 */
2247 		uchar_t *addr = (uchar_t *)((uintptr_t)rsp->rel_roffset +
2248 		    (uintptr_t)rsp->rel_isdesc->is_indata->d_buf);
2249 
2250 		if (ld_reloc_targval_get(ofl, rsp, addr, &str_off) == 0)
2251 			return (0);
2252 	}
2253 
2254 	return (str_off + (char *)sdp->sd_isc->is_indata->d_buf);
2255 }
2256 
2257 /*
2258  * First pass over the relocation records for string table merging.
2259  * Build lists of relocations and symbols that will need modification,
2260  * and insert the strings they reference into the mstrtab string table.
2261  *
2262  * entry:
2263  *	ofl, osp - As passed to ld_make_strmerge().
2264  *	mstrtab - String table to receive input strings. This table
2265  *		must be in its first (initialization) pass and not
2266  *		yet cooked (st_getstrtab_sz() not yet called).
2267  *	rel_alpp - APlist to receive pointer to any relocation
2268  *		descriptors with STT_SECTION symbols that reference
2269  *		one of the input sections being merged.
2270  *	sym_alpp - APlist to receive pointer to any symbols that reference
2271  *		one of the input sections being merged.
2272  *	reloc_list - List of relocation descriptors to examine.
2273  *		Either ofl->&ofl->ofl_actrels (active relocations)
2274  *		or &ofl->ofl_outrels (output relocations).
2275  *
2276  * exit:
2277  *	On success, rel_alpp and sym_alpp are updated, and
2278  *	any strings in the mergable input sections referenced by
2279  *	a relocation has been entered into mstrtab. True (1) is returned.
2280  *
2281  *	On failure, False (0) is returned.
2282  */
2283 static int
2284 strmerge_pass1(Ofl_desc *ofl, Os_desc *osp, Str_tbl *mstrtab,
2285     APlist **rel_alpp, APlist **sym_alpp, APlist *reloc_alp)
2286 {
2287 	Aliste		idx;
2288 	Rel_cache	*rcp;
2289 	Sym_desc	*sdp;
2290 	Sym_desc	*last_sdp = NULL;
2291 	Rel_desc	*rsp;
2292 	const char	*name;
2293 
2294 	for (APLIST_TRAVERSE(reloc_alp, idx, rcp)) {
2295 		/* LINTED */
2296 		for (rsp = (Rel_desc *)(rcp + 1); rsp < rcp->rc_free; rsp++) {
2297 			sdp = rsp->rel_sym;
2298 			if ((sdp->sd_isc == NULL) ||
2299 			    ((sdp->sd_isc->is_flags &
2300 			    (FLG_IS_DISCARD | FLG_IS_INSTRMRG)) !=
2301 			    FLG_IS_INSTRMRG) ||
2302 			    (sdp->sd_isc->is_osdesc != osp))
2303 				continue;
2304 
2305 			/*
2306 			 * Remember symbol for use in the third pass.
2307 			 * There is no reason to save a given symbol more
2308 			 * than once, so we take advantage of the fact that
2309 			 * relocations to a given symbol tend to cluster
2310 			 * in the list. If this is the same symbol we saved
2311 			 * last time, don't bother.
2312 			 */
2313 			if (last_sdp != sdp) {
2314 				if (aplist_append(sym_alpp, sdp,
2315 				    AL_CNT_STRMRGSYM) == NULL)
2316 					return (0);
2317 				last_sdp = sdp;
2318 			}
2319 
2320 			/* Enter the string into our new string table */
2321 			name = strmerge_get_reloc_str(ofl, rsp);
2322 			if (st_insert(mstrtab, name) == -1)
2323 				return (0);
2324 
2325 			/*
2326 			 * If this is an STT_SECTION symbol, then the
2327 			 * second pass will need to modify this relocation,
2328 			 * so hang on to it.
2329 			 */
2330 			if ((ELF_ST_TYPE(sdp->sd_sym->st_info) ==
2331 			    STT_SECTION) &&
2332 			    (aplist_append(rel_alpp, rsp,
2333 			    AL_CNT_STRMRGREL) == NULL))
2334 				return (0);
2335 		}
2336 	}
2337 
2338 	return (1);
2339 }
2340 
2341 /*
2342  * If the output section has any SHF_MERGE|SHF_STRINGS input sections,
2343  * replace them with a single merged/compressed input section.
2344  *
2345  * entry:
2346  *	ofl - Output file descriptor
2347  *	osp - Output section descriptor
2348  *	rel_alpp, sym_alpp, - Address of 2 APlists, to be used
2349  *		for internal processing. On the initial call to
2350  *		ld_make_strmerge, these list pointers must be NULL.
2351  *		The caller is encouraged to pass the same lists back for
2352  *		successive calls to this function without freeing
2353  *		them in between calls. This causes a single pair of
2354  *		memory allocations to be reused multiple times.
2355  *
2356  * exit:
2357  *	If section merging is possible, it is done. If no errors are
2358  *	encountered, True (1) is returned. On error, S_ERROR.
2359  *
2360  *	The contents of rel_alpp and sym_alpp on exit are
2361  *	undefined. The caller can free them, or pass them back to a subsequent
2362  *	call to this routine, but should not examine their contents.
2363  */
2364 static uintptr_t
2365 ld_make_strmerge(Ofl_desc *ofl, Os_desc *osp, APlist **rel_alpp,
2366     APlist **sym_alpp)
2367 {
2368 	Str_tbl		*mstrtab;	/* string table for string merge secs */
2369 	Is_desc		*mstrsec;	/* Generated string merge section */
2370 	Is_desc		*isp;
2371 	Shdr		*mstr_shdr;
2372 	Elf_Data	*mstr_data;
2373 	Sym_desc	*sdp;
2374 	Rel_desc	*rsp;
2375 	Aliste		idx;
2376 	size_t		data_size;
2377 	int		st_setstring_status;
2378 	size_t		stoff;
2379 
2380 	/* If string table compression is disabled, there's nothing to do */
2381 	if ((ofl->ofl_flags1 & FLG_OF1_NCSTTAB) != 0)
2382 		return (1);
2383 
2384 	/*
2385 	 * Pass over the mergeable input sections, and if they haven't
2386 	 * all been discarded, create a string table.
2387 	 */
2388 	mstrtab = NULL;
2389 	for (APLIST_TRAVERSE(osp->os_mstrisdescs, idx, isp)) {
2390 		if (isp->is_flags & FLG_IS_DISCARD)
2391 			continue;
2392 
2393 		/*
2394 		 * We have at least one non-discarded section.
2395 		 * Create a string table descriptor.
2396 		 */
2397 		if ((mstrtab = st_new(FLG_STNEW_COMPRESS)) == NULL)
2398 			return (S_ERROR);
2399 		break;
2400 	}
2401 
2402 	/* If no string table was created, we have no mergeable sections */
2403 	if (mstrtab == NULL)
2404 		return (1);
2405 
2406 	/*
2407 	 * This routine has to make 3 passes:
2408 	 *
2409 	 *	1) Examine all relocations, insert strings from relocations
2410 	 *		to the mergable input sections into the string table.
2411 	 *	2) Modify the relocation values to be correct for the
2412 	 *		new merged section.
2413 	 *	3) Modify the symbols used by the relocations to reference
2414 	 *		the new section.
2415 	 *
2416 	 * These passes cannot be combined:
2417 	 *	- The string table code works in two passes, and all
2418 	 *		strings have to be loaded in pass one before the
2419 	 *		offset of any strings can be determined.
2420 	 *	- Multiple relocations reference a single symbol, so the
2421 	 *		symbol cannot be modified until all relocations are
2422 	 *		fixed.
2423 	 *
2424 	 * The number of relocations related to section merging is usually
2425 	 * a mere fraction of the overall active and output relocation lists,
2426 	 * and the number of symbols is usually a fraction of the number
2427 	 * of related relocations. We therefore build APlists for the
2428 	 * relocations and symbols in the first pass, and then use those
2429 	 * lists to accelerate the operation of pass 2 and 3.
2430 	 *
2431 	 * Reinitialize the lists to a completely empty state.
2432 	 */
2433 	aplist_reset(*rel_alpp);
2434 	aplist_reset(*sym_alpp);
2435 
2436 	/*
2437 	 * Pass 1:
2438 	 *
2439 	 * Every relocation related to this output section (and the input
2440 	 * sections that make it up) is found in either the active, or the
2441 	 * output relocation list, depending on whether the relocation is to
2442 	 * be processed by this invocation of the linker, or inserted into the
2443 	 * output object.
2444 	 *
2445 	 * Build lists of relocations and symbols that will need modification,
2446 	 * and insert the strings they reference into the mstrtab string table.
2447 	 */
2448 	if (strmerge_pass1(ofl, osp, mstrtab, rel_alpp, sym_alpp,
2449 	    ofl->ofl_actrels) == 0)
2450 		goto return_s_error;
2451 	if (strmerge_pass1(ofl, osp, mstrtab, rel_alpp, sym_alpp,
2452 	    ofl->ofl_outrels) == 0)
2453 		goto return_s_error;
2454 
2455 	/*
2456 	 * Get the size of the new input section. Requesting the
2457 	 * string table size "cooks" the table, and finalizes its contents.
2458 	 */
2459 	data_size = st_getstrtab_sz(mstrtab);
2460 
2461 	/* Create a new input section to hold the merged strings */
2462 	if (new_section_from_template(ofl, isp, data_size,
2463 	    &mstrsec, &mstr_shdr, &mstr_data) == S_ERROR)
2464 		goto return_s_error;
2465 	mstrsec->is_flags |= FLG_IS_GNSTRMRG;
2466 
2467 	/*
2468 	 * Allocate a data buffer for the new input section.
2469 	 * Then, associate the buffer with the string table descriptor.
2470 	 */
2471 	if ((mstr_data->d_buf = libld_malloc(data_size)) == NULL)
2472 		goto return_s_error;
2473 	if (st_setstrbuf(mstrtab, mstr_data->d_buf, data_size) == -1)
2474 		goto return_s_error;
2475 
2476 	/* Add the new section to the output image */
2477 	if (ld_place_section(ofl, mstrsec, osp->os_identndx, NULL) ==
2478 	    (Os_desc *)S_ERROR)
2479 		goto return_s_error;
2480 
2481 	/*
2482 	 * Pass 2:
2483 	 *
2484 	 * Revisit the relocation descriptors with STT_SECTION symbols
2485 	 * that were saved by the first pass. Update each relocation
2486 	 * record so that the offset it contains is for the new section
2487 	 * instead of the original.
2488 	 */
2489 	for (APLIST_TRAVERSE(*rel_alpp, idx, rsp)) {
2490 		const char	*name;
2491 
2492 		/* Put the string into the merged string table */
2493 		name = strmerge_get_reloc_str(ofl, rsp);
2494 		st_setstring_status = st_setstring(mstrtab, name, &stoff);
2495 		if (st_setstring_status == -1) {
2496 			/*
2497 			 * A failure to insert at this point means that
2498 			 * something is corrupt. This isn't a resource issue.
2499 			 */
2500 			assert(st_setstring_status != -1);
2501 			goto return_s_error;
2502 		}
2503 
2504 		/*
2505 		 * Alter the relocation to access the string at the
2506 		 * new offset in our new string table.
2507 		 *
2508 		 * For SHT_RELA platforms, it suffices to simply
2509 		 * update the rel_raddend field of the relocation.
2510 		 *
2511 		 * For SHT_REL platforms, the new "addend" value
2512 		 * needs to be written at the address being relocated.
2513 		 * However, we can't alter the input sections which
2514 		 * are mapped readonly, and the output image has not
2515 		 * been created yet. So, we defer this operation,
2516 		 * using the rel_raddend field of the relocation
2517 		 * which is normally 0 on a REL platform, to pass the
2518 		 * new "addend" value to ld_perform_outreloc() or
2519 		 * ld_do_activerelocs(). The FLG_REL_NADDEND flag
2520 		 * tells them that this is the case.
2521 		 */
2522 		if ((rsp->rel_flags & FLG_REL_RELA) == 0)   /* REL */
2523 			rsp->rel_flags |= FLG_REL_NADDEND;
2524 		rsp->rel_raddend = (Sxword)stoff;
2525 
2526 		/*
2527 		 * Change the descriptor name to reflect the fact that it
2528 		 * points at our merged section. This shows up in debug
2529 		 * output and helps show how the relocation has changed
2530 		 * from its original input section to our merged one.
2531 		 */
2532 		rsp->rel_sname = ld_stt_section_sym_name(mstrsec);
2533 		if (rsp->rel_sname == NULL)
2534 			goto return_s_error;
2535 	}
2536 
2537 	/*
2538 	 * Pass 3:
2539 	 *
2540 	 * Modify the symbols referenced by the relocation descriptors
2541 	 * so that they reference the new input section containing the
2542 	 * merged strings instead of the original input sections.
2543 	 */
2544 	for (APLIST_TRAVERSE(*sym_alpp, idx, sdp)) {
2545 		/*
2546 		 * If we've already processed this symbol, don't do it
2547 		 * twice. strmerge_pass1() uses a heuristic (relocations to
2548 		 * the same symbol clump together) to avoid inserting a
2549 		 * given symbol more than once, but repeat symbols in
2550 		 * the list can occur.
2551 		 */
2552 		if ((sdp->sd_isc->is_flags & FLG_IS_INSTRMRG) == 0)
2553 			continue;
2554 
2555 		if (ELF_ST_TYPE(sdp->sd_sym->st_info) != STT_SECTION) {
2556 			/*
2557 			 * This is not an STT_SECTION symbol, so its
2558 			 * value is the offset of the string within the
2559 			 * input section. Update the address to reflect
2560 			 * the address in our new merged section.
2561 			 */
2562 			const char *name = sdp->sd_sym->st_value +
2563 			    (char *)sdp->sd_isc->is_indata->d_buf;
2564 
2565 			st_setstring_status =
2566 			    st_setstring(mstrtab, name, &stoff);
2567 			if (st_setstring_status == -1) {
2568 				/*
2569 				 * A failure to insert at this point means
2570 				 * something is corrupt. This isn't a
2571 				 * resource issue.
2572 				 */
2573 				assert(st_setstring_status != -1);
2574 				goto return_s_error;
2575 			}
2576 
2577 			if (ld_sym_copy(sdp) == S_ERROR)
2578 				goto return_s_error;
2579 			sdp->sd_sym->st_value = (Word)stoff;
2580 		}
2581 
2582 		/* Redirect the symbol to our new merged section */
2583 		sdp->sd_isc = mstrsec;
2584 	}
2585 
2586 	/*
2587 	 * There are no references left to the original input string sections.
2588 	 * Mark them as discarded so they don't go into the output image.
2589 	 * At the same time, add up the sizes of the replaced sections.
2590 	 */
2591 	data_size = 0;
2592 	for (APLIST_TRAVERSE(osp->os_mstrisdescs, idx, isp)) {
2593 		if (isp->is_flags & (FLG_IS_DISCARD | FLG_IS_GNSTRMRG))
2594 			continue;
2595 
2596 		data_size += isp->is_indata->d_size;
2597 
2598 		isp->is_flags |= FLG_IS_DISCARD;
2599 		DBG_CALL(Dbg_sec_discarded(ofl->ofl_lml, isp, mstrsec));
2600 	}
2601 
2602 	/* Report how much space we saved in the output section */
2603 	Dbg_sec_genstr_compress(ofl->ofl_lml, osp->os_name, data_size,
2604 	    mstr_data->d_size);
2605 
2606 	st_destroy(mstrtab);
2607 	return (1);
2608 
2609 return_s_error:
2610 	st_destroy(mstrtab);
2611 	return (S_ERROR);
2612 }
2613 
2614 /*
2615  * Update a data buffers size.  A number of sections have to be created, and
2616  * the sections header contributes to the size of the eventual section.  Thus,
2617  * a section may be created, and once all associated sections have been created,
2618  * we return to establish the required section size.
2619  */
2620 inline static void
2621 update_data_size(Os_desc *osp, ulong_t cnt)
2622 {
2623 	Is_desc		*isec = ld_os_first_isdesc(osp);
2624 	Elf_Data	*data = isec->is_indata;
2625 	Shdr		*shdr = osp->os_shdr;
2626 	size_t		size = cnt * shdr->sh_entsize;
2627 
2628 	shdr->sh_size = (Xword)size;
2629 	data->d_size = size;
2630 }
2631 
2632 /*
2633  * The following sections are built after all input file processing and symbol
2634  * validation has been carried out.  The order is important (because the
2635  * addition of a section adds a new symbol there is a chicken and egg problem
2636  * of maintaining the appropriate counts).  By maintaining a known order the
2637  * individual routines can compensate for later, known, additions.
2638  */
2639 uintptr_t
2640 ld_make_sections(Ofl_desc *ofl)
2641 {
2642 	ofl_flag_t	flags = ofl->ofl_flags;
2643 	Sg_desc		*sgp;
2644 
2645 	/*
2646 	 * Generate any special sections.
2647 	 */
2648 	if (flags & FLG_OF_ADDVERS)
2649 		if (make_comment(ofl) == S_ERROR)
2650 			return (S_ERROR);
2651 
2652 	if (make_interp(ofl) == S_ERROR)
2653 		return (S_ERROR);
2654 
2655 	if (make_cap(ofl) == S_ERROR)
2656 		return (S_ERROR);
2657 
2658 	if (make_array(ofl, SHT_INIT_ARRAY, MSG_ORIG(MSG_SCN_INITARRAY),
2659 	    ofl->ofl_initarray) == S_ERROR)
2660 		return (S_ERROR);
2661 
2662 	if (make_array(ofl, SHT_FINI_ARRAY, MSG_ORIG(MSG_SCN_FINIARRAY),
2663 	    ofl->ofl_finiarray) == S_ERROR)
2664 		return (S_ERROR);
2665 
2666 	if (make_array(ofl, SHT_PREINIT_ARRAY, MSG_ORIG(MSG_SCN_PREINITARRAY),
2667 	    ofl->ofl_preiarray) == S_ERROR)
2668 		return (S_ERROR);
2669 
2670 	/*
2671 	 * Make the .plt section.  This occurs after any other relocation
2672 	 * sections are generated (see reloc_init()) to ensure that the
2673 	 * associated relocation section is after all the other relocation
2674 	 * sections.
2675 	 */
2676 	if ((ofl->ofl_pltcnt) || (ofl->ofl_pltpad))
2677 		if (make_plt(ofl) == S_ERROR)
2678 			return (S_ERROR);
2679 
2680 	/*
2681 	 * Determine whether any sections or files are not referenced.  Under
2682 	 * -Dunused a diagnostic for any unused components is generated, under
2683 	 * -zignore the component is removed from the final output.
2684 	 */
2685 	if (DBG_ENABLED || (ofl->ofl_flags1 & FLG_OF1_IGNPRC)) {
2686 		if (ignore_section_processing(ofl) == S_ERROR)
2687 			return (S_ERROR);
2688 	}
2689 
2690 	/*
2691 	 * If we have detected a situation in which previously placed
2692 	 * output sections may have been discarded, perform the necessary
2693 	 * readjustment.
2694 	 */
2695 	if (ofl->ofl_flags & FLG_OF_ADJOSCNT)
2696 		adjust_os_count(ofl);
2697 
2698 	/*
2699 	 * Do any of the output sections contain input sections that
2700 	 * are candidates for string table merging? For each such case,
2701 	 * we create a replacement section, insert it, and discard the
2702 	 * originals.
2703 	 *
2704 	 * rel_alpp and sym_alpp are used by ld_make_strmerge()
2705 	 * for its internal processing. We are responsible for the
2706 	 * initialization and cleanup, and ld_make_strmerge() handles the rest.
2707 	 * This allows us to reuse a single pair of memory buffers, allocated
2708 	 * for this processing, for all the output sections.
2709 	 */
2710 	if ((ofl->ofl_flags1 & FLG_OF1_NCSTTAB) == 0) {
2711 		int	error_seen = 0;
2712 		APlist	*rel_alpp = NULL;
2713 		APlist	*sym_alpp = NULL;
2714 		Aliste	idx1;
2715 
2716 		for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
2717 			Os_desc	*osp;
2718 			Aliste	idx2;
2719 
2720 			for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp))
2721 				if ((osp->os_mstrisdescs != NULL) &&
2722 				    (ld_make_strmerge(ofl, osp,
2723 				    &rel_alpp, &sym_alpp) ==
2724 				    S_ERROR)) {
2725 					error_seen = 1;
2726 					break;
2727 				}
2728 		}
2729 		if (rel_alpp != NULL)
2730 			free(rel_alpp);
2731 		if (sym_alpp != NULL)
2732 			free(sym_alpp);
2733 		if (error_seen != 0)
2734 			return (S_ERROR);
2735 	}
2736 
2737 	/*
2738 	 * Add any necessary versioning information.
2739 	 */
2740 	if (!(flags & FLG_OF_NOVERSEC)) {
2741 		if ((flags & FLG_OF_VERNEED) &&
2742 		    (make_verneed(ofl) == S_ERROR))
2743 			return (S_ERROR);
2744 		if ((flags & FLG_OF_VERDEF) &&
2745 		    (make_verdef(ofl) == S_ERROR))
2746 			return (S_ERROR);
2747 		if ((flags & (FLG_OF_VERNEED | FLG_OF_VERDEF)) &&
2748 		    ((ofl->ofl_osversym = make_sym_sec(ofl,
2749 		    MSG_ORIG(MSG_SCN_SUNWVERSYM), SHT_SUNW_versym,
2750 		    ld_targ.t_id.id_version)) == (Os_desc*)S_ERROR))
2751 			return (S_ERROR);
2752 	}
2753 
2754 	/*
2755 	 * Create a syminfo section if necessary.
2756 	 */
2757 	if (flags & FLG_OF_SYMINFO) {
2758 		if ((ofl->ofl_ossyminfo = make_sym_sec(ofl,
2759 		    MSG_ORIG(MSG_SCN_SUNWSYMINFO), SHT_SUNW_syminfo,
2760 		    ld_targ.t_id.id_syminfo)) == (Os_desc *)S_ERROR)
2761 			return (S_ERROR);
2762 	}
2763 
2764 	if (flags & FLG_OF_COMREL) {
2765 		/*
2766 		 * If -zcombreloc is enabled then all relocations (except for
2767 		 * the PLT's) are coalesced into a single relocation section.
2768 		 */
2769 		if (ofl->ofl_reloccnt) {
2770 			if (make_reloc(ofl, NULL) == S_ERROR)
2771 				return (S_ERROR);
2772 		}
2773 	} else {
2774 		Aliste	idx1;
2775 
2776 		/*
2777 		 * Create the required output relocation sections.  Note, new
2778 		 * sections may be added to the section list that is being
2779 		 * traversed.  These insertions can move the elements of the
2780 		 * Alist such that a section descriptor is re-read.  Recursion
2781 		 * is prevented by maintaining a previous section pointer and
2782 		 * insuring that this pointer isn't re-examined.
2783 		 */
2784 		for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
2785 			Os_desc	*osp, *posp = 0;
2786 			Aliste	idx2;
2787 
2788 			for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
2789 				if ((osp != posp) && osp->os_szoutrels &&
2790 				    (osp != ofl->ofl_osplt)) {
2791 					if (make_reloc(ofl, osp) == S_ERROR)
2792 						return (S_ERROR);
2793 				}
2794 				posp = osp;
2795 			}
2796 		}
2797 
2798 		/*
2799 		 * If we're not building a combined relocation section, then
2800 		 * build a .rel[a] section as required.
2801 		 */
2802 		if (ofl->ofl_relocrelsz) {
2803 			if (make_reloc(ofl, NULL) == S_ERROR)
2804 				return (S_ERROR);
2805 		}
2806 	}
2807 
2808 	/*
2809 	 * The PLT relocations are always in their own section, and we try to
2810 	 * keep them at the end of the PLT table.  We do this to keep the hot
2811 	 * "data" PLT's at the head of the table nearer the .dynsym & .hash.
2812 	 */
2813 	if (ofl->ofl_osplt && ofl->ofl_relocpltsz) {
2814 		if (make_reloc(ofl, ofl->ofl_osplt) == S_ERROR)
2815 			return (S_ERROR);
2816 	}
2817 
2818 	/*
2819 	 * Finally build the symbol and section header sections.
2820 	 */
2821 	if (flags & FLG_OF_DYNAMIC) {
2822 		if (make_dynamic(ofl) == S_ERROR)
2823 			return (S_ERROR);
2824 
2825 		/*
2826 		 * A number of sections aren't necessary within a relocatable
2827 		 * object, even if -dy has been used.
2828 		 */
2829 		if (!(flags & FLG_OF_RELOBJ)) {
2830 			if (make_hash(ofl) == S_ERROR)
2831 				return (S_ERROR);
2832 			if (make_dynstr(ofl) == S_ERROR)
2833 				return (S_ERROR);
2834 			if (make_dynsym(ofl) == S_ERROR)
2835 				return (S_ERROR);
2836 			if (ld_unwind_make_hdr(ofl) == S_ERROR)
2837 				return (S_ERROR);
2838 			if (make_dynsort(ofl) == S_ERROR)
2839 				return (S_ERROR);
2840 		}
2841 	}
2842 
2843 	if (!(flags & FLG_OF_STRIP) || (flags & FLG_OF_RELOBJ) ||
2844 	    ((flags & FLG_OF_STATIC) && ofl->ofl_osversym)) {
2845 		/*
2846 		 * Do we need to make a SHT_SYMTAB_SHNDX section
2847 		 * for the dynsym.  If so - do it now.
2848 		 */
2849 		if (ofl->ofl_osdynsym &&
2850 		    ((ofl->ofl_shdrcnt + 3) >= SHN_LORESERVE)) {
2851 			if (make_dynsym_shndx(ofl) == S_ERROR)
2852 				return (S_ERROR);
2853 		}
2854 
2855 		if (make_strtab(ofl) == S_ERROR)
2856 			return (S_ERROR);
2857 		if (make_symtab(ofl) == S_ERROR)
2858 			return (S_ERROR);
2859 	} else {
2860 		/*
2861 		 * Do we need to make a SHT_SYMTAB_SHNDX section
2862 		 * for the dynsym.  If so - do it now.
2863 		 */
2864 		if (ofl->ofl_osdynsym &&
2865 		    ((ofl->ofl_shdrcnt + 1) >= SHN_LORESERVE)) {
2866 			if (make_dynsym_shndx(ofl) == S_ERROR)
2867 				return (S_ERROR);
2868 		}
2869 	}
2870 
2871 	if (make_shstrtab(ofl) == S_ERROR)
2872 		return (S_ERROR);
2873 
2874 	/*
2875 	 * Now that we've created all output sections, adjust the size of the
2876 	 * SHT_SUNW_versym and SHT_SUNW_syminfo section, which are dependent on
2877 	 * the associated symbol table sizes.
2878 	 */
2879 	if (ofl->ofl_osversym || ofl->ofl_ossyminfo) {
2880 		ulong_t		cnt;
2881 		Is_desc		*isp;
2882 		Os_desc		*osp;
2883 
2884 		if (OFL_IS_STATIC_OBJ(ofl))
2885 			osp = ofl->ofl_ossymtab;
2886 		else
2887 			osp = ofl->ofl_osdynsym;
2888 
2889 		isp = ld_os_first_isdesc(osp);
2890 		cnt = (isp->is_shdr->sh_size / isp->is_shdr->sh_entsize);
2891 
2892 		if (ofl->ofl_osversym)
2893 			update_data_size(ofl->ofl_osversym, cnt);
2894 
2895 		if (ofl->ofl_ossyminfo)
2896 			update_data_size(ofl->ofl_ossyminfo, cnt);
2897 	}
2898 
2899 	return (1);
2900 }
2901 
2902 /*
2903  * Build an additional data section - used to back OBJT symbol definitions
2904  * added with a mapfile.
2905  */
2906 Is_desc *
2907 ld_make_data(Ofl_desc *ofl, size_t size)
2908 {
2909 	Shdr		*shdr;
2910 	Elf_Data	*data;
2911 	Is_desc		*isec;
2912 
2913 	if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_DATA), 0,
2914 	    &isec, &shdr, &data) == S_ERROR)
2915 		return ((Is_desc *)S_ERROR);
2916 
2917 	data->d_size = size;
2918 	shdr->sh_size = (Xword)size;
2919 	shdr->sh_flags |= SHF_WRITE;
2920 
2921 	if (aplist_append(&ofl->ofl_mapdata, isec, AL_CNT_OFL_MAPSECS) == NULL)
2922 		return ((Is_desc *)S_ERROR);
2923 
2924 	return (isec);
2925 }
2926 
2927 /*
2928  * Build an additional text section - used to back FUNC symbol definitions
2929  * added with a mapfile.
2930  */
2931 Is_desc *
2932 ld_make_text(Ofl_desc *ofl, size_t size)
2933 {
2934 	Shdr		*shdr;
2935 	Elf_Data	*data;
2936 	Is_desc		*isec;
2937 
2938 	/*
2939 	 * Insure the size is sufficient to contain the minimum return
2940 	 * instruction.
2941 	 */
2942 	if (size < ld_targ.t_nf.nf_size)
2943 		size = ld_targ.t_nf.nf_size;
2944 
2945 	if (new_section(ofl, SHT_PROGBITS, MSG_ORIG(MSG_SCN_TEXT), 0,
2946 	    &isec, &shdr, &data) == S_ERROR)
2947 		return ((Is_desc *)S_ERROR);
2948 
2949 	data->d_size = size;
2950 	shdr->sh_size = (Xword)size;
2951 	shdr->sh_flags |= SHF_EXECINSTR;
2952 
2953 	/*
2954 	 * Fill the buffer with the appropriate return instruction.
2955 	 * Note that there is no need to swap bytes on a non-native,
2956 	 * link, as the data being copied is given in bytes.
2957 	 */
2958 	if ((data->d_buf = libld_calloc(size, 1)) == NULL)
2959 		return ((Is_desc *)S_ERROR);
2960 	(void) memcpy(data->d_buf, ld_targ.t_nf.nf_template,
2961 	    ld_targ.t_nf.nf_size);
2962 
2963 	/*
2964 	 * If size was larger than required, and the target supplies
2965 	 * a fill function, use it to fill the balance. If there is no
2966 	 * fill function, we accept the 0-fill supplied by libld_calloc().
2967 	 */
2968 	if ((ld_targ.t_ff.ff_execfill != NULL) && (size > ld_targ.t_nf.nf_size))
2969 		ld_targ.t_ff.ff_execfill(data->d_buf, ld_targ.t_nf.nf_size,
2970 		    size - ld_targ.t_nf.nf_size);
2971 
2972 	if (aplist_append(&ofl->ofl_maptext, isec, AL_CNT_OFL_MAPSECS) == NULL)
2973 		return ((Is_desc *)S_ERROR);
2974 
2975 	return (isec);
2976 }
2977