xref: /titanic_51/usr/src/cmd/sgs/libld/common/sections.c (revision bdfc6d18da790deeec2e0eb09c625902defe2498)
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, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  *	Copyright (c) 1988 AT&T
24  *	  All Rights Reserved
25  *
26  *
27  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
28  * Use is subject to license terms.
29  */
30 #pragma ident	"%Z%%M%	%I%	%E% SMI"
31 
32 /*
33  * Module sections. Initialize special sections
34  */
35 #include	<string.h>
36 #include	<strings.h>
37 #include	<stdio.h>
38 #include	<unistd.h>
39 #include	<link.h>
40 #include	"debug.h"
41 #include	"msg.h"
42 #include	"_libld.h"
43 
44 
45 /*
46  * If -zignore is in effect, scan all input sections to see if there are any
47  * which haven't been referenced (and hence can be discarded).  If sections are
48  * to be discarded, rescan the output relocations and the symbol table and
49  * remove the relocations and symbol entries that are no longer required.
50  *
51  * Note:  It's possible that a section which is being discarded has contributed
52  *	  to the GOT table or the PLT table.  However, we can't at this point
53  *	  eliminate the corresponding entries.  This is because there could well
54  *	  be other sections referencing those same entries, but we don't have
55  *	  the infrastructure to determine this.  So, keep the PLT and GOT
56  *	  entries in the table in case someone wants them.
57  * Note:  The section to be affected needs to be allocatable.
58  *	  So even if -zignore is in effect, if the section is not allocatable,
59  *	  we do not eliminate it.
60  */
61 uintptr_t
62 ignore_section_processing(Ofl_desc *ofl)
63 {
64 	Listnode	*lnp;
65 	Ifl_desc	*ifl;
66 	Rel_cache	*rcp;
67 
68 	for (LIST_TRAVERSE(&ofl->ofl_objs, lnp, ifl)) {
69 		uint_t		num, discard;
70 
71 		/*
72 		 * Diagnose (-D unused) a completely unreferenced file.
73 		 */
74 		if ((ifl->ifl_flags & FLG_IF_FILEREF) == 0)
75 			DBG_CALL(Dbg_unused_file(ifl->ifl_name, 0));
76 		if ((ifl->ifl_flags & FLG_IF_IGNORE) == 0)
77 			continue;
78 
79 		/*
80 		 * Before scanning the whole symbol table to determine
81 		 * if we have symbols to discard - let's do a (relatively)
82 		 * quick scan of the sections and determine if we've discarded
83 		 * any sections.
84 		 */
85 		for (discard = 0, num = 1; num < ifl->ifl_shnum; num++) {
86 			Is_desc	*isp;
87 			Os_desc *osp;
88 
89 			if (((isp = ifl->ifl_isdesc[num]) != 0) &&
90 			    ((isp->is_flags & FLG_IS_SECTREF) == 0) &&
91 			    ((osp = isp->is_osdesc) != 0) &&
92 			    (osp->os_sgdesc->sg_phdr.p_type == PT_LOAD)) {
93 				discard++;
94 				break;
95 			}
96 		}
97 		/*
98 		 * No sections are to be 'ignored'
99 		 */
100 		if ((!discard) || ((ifl->ifl_flags & FLG_IF_FILEREF) == 0))
101 			continue;
102 
103 		/*
104 		 * We know that we have discarded sections - now we
105 		 * scan the symtable for the file in question to determine
106 		 * if we need to discard associated with the 'ignored'
107 		 * sections.
108 		 */
109 		for (num = 1; num < ifl->ifl_symscnt; num++) {
110 			Sym_desc	*sdp;
111 			Sym		*symp;
112 			Os_desc		*osp;
113 			/* LINTED - only used for assert() */
114 			int		err;
115 
116 			sdp = ifl->ifl_oldndx[num];
117 			symp = sdp->sd_sym;
118 
119 			/*
120 			 * Skip any undefined, reserved section symbols, already
121 			 * discarded or eliminated symbols.  Also skip any
122 			 * symbols that don't originate from a section, or
123 			 * aren't defined from the file being examined.
124 			 */
125 			if ((symp->st_shndx == SHN_UNDEF) ||
126 			    (symp->st_shndx >= SHN_LORESERVE) ||
127 			    (ELF_ST_TYPE(symp->st_info) == STT_SECTION) ||
128 			    (sdp->sd_flags & FLG_SY_ISDISC) ||
129 			    (sdp->sd_flags1 & FLG_SY1_ELIM) ||
130 			    (sdp->sd_isc == 0) || (sdp->sd_file != ifl))
131 				continue;
132 
133 			/*
134 			 * If any references were made against the section
135 			 * the symbol is being defined in - skip it.
136 			 */
137 			if ((sdp->sd_isc->is_flags & FLG_IS_SECTREF) ||
138 			    (((ifl->ifl_flags & FLG_IF_FILEREF) &&
139 			    ((osp = sdp->sd_isc->is_osdesc) != 0) &&
140 			    (osp->os_sgdesc->sg_phdr.p_type != PT_LOAD))))
141 				continue;
142 
143 			if (ELF_ST_BIND(symp->st_info) == STB_LOCAL) {
144 				if (!(ofl->ofl_flags1 & FLG_OF1_REDLSYM)) {
145 					ofl->ofl_locscnt--;
146 
147 					err = st_delstring(ofl->ofl_strtab,
148 					    sdp->sd_name);
149 					assert(err != -1);
150 				}
151 				sdp->sd_flags |= FLG_SY_ISDISC;
152 				DBG_CALL(Dbg_syms_discarded(sdp, sdp->sd_isc));
153 				continue;
154 			}
155 
156 			if (sdp->sd_flags1 & FLG_SY1_LOCL) {
157 				ofl->ofl_scopecnt--;
158 				ofl->ofl_elimcnt++;
159 
160 				err = st_delstring(ofl->ofl_strtab,
161 				    sdp->sd_name);
162 				assert(err != -1);
163 
164 				sdp->sd_flags1 |= FLG_SY1_ELIM;
165 				DBG_CALL(Dbg_syms_discarded(sdp, sdp->sd_isc));
166 				continue;
167 			}
168 		}
169 	}
170 
171 	/*
172 	 * Scan all output relocations - searching for relocations
173 	 * against discarded/ignored sections.  If we find one - subtract it
174 	 * from out total outrel count.
175 	 */
176 	for (LIST_TRAVERSE(&ofl->ofl_outrels, lnp, rcp)) {
177 		Rel_desc	*orsp;
178 		Os_desc		*relosp;
179 
180 		/* LINTED */
181 		for (orsp = (Rel_desc *)(rcp + 1);
182 		    orsp < rcp->rc_free; orsp++) {
183 			Is_desc	*	_isdesc = orsp->rel_isdesc;
184 			uint_t		flags, entsize;
185 			Shdr *		shdr;
186 			Ifl_desc *	ifl;
187 
188 			if ((_isdesc == 0) ||
189 			    ((_isdesc->is_flags & (FLG_IS_SECTREF))) ||
190 			    ((ifl = _isdesc->is_file) == 0) ||
191 			    ((ifl->ifl_flags & FLG_IF_IGNORE) == 0) ||
192 			    ((shdr = _isdesc->is_shdr) == 0) ||
193 			    ((shdr->sh_flags & SHF_ALLOC) == 0))
194 				continue;
195 
196 			flags = orsp->rel_flags;
197 
198 			if (flags & (FLG_REL_GOT | FLG_REL_BSS |
199 			    FLG_REL_NOINFO | FLG_REL_PLT))
200 				continue;
201 
202 			relosp = orsp->rel_osdesc;
203 
204 			if (orsp->rel_flags & FLG_REL_RELA)
205 				entsize = sizeof (Rela);
206 			else
207 				entsize = sizeof (Rel);
208 
209 
210 			assert(relosp->os_szoutrels > 0);
211 			relosp->os_szoutrels -= entsize;
212 
213 			if (!(flags & FLG_REL_PLT))
214 				ofl->ofl_reloccntsub++;
215 
216 			if (orsp->rel_rtype == M_R_RELATIVE)
217 				ofl->ofl_relocrelcnt--;
218 		}
219 	}
220 
221 	return (1);
222 }
223 
224 
225 /*
226  * Build a .bss section for allocation of tentative definitions.  Any `static'
227  * .bss definitions would have been associated to their own .bss sections and
228  * thus collected from the input files.  `global' .bss definitions are tagged
229  * as COMMON and do not cause any associated .bss section elements to be
230  * generated.  Here we add up all these COMMON symbols and generate the .bss
231  * section required to represent them.
232  */
233 uintptr_t
234 make_bss(Ofl_desc *ofl, Xword size, Xword align, uint_t tls)
235 {
236 	Shdr		*shdr;
237 	Elf_Data	*data;
238 	Is_desc		*isec;
239 	Os_desc		*osp;
240 	uint_t		ident;
241 	Xword		rsize = (Xword)ofl->ofl_relocbsssz;
242 
243 	/*
244 	 * Allocate and initialize the Elf_Data structure.
245 	 */
246 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == 0)
247 		return (S_ERROR);
248 	data->d_type = ELF_T_BYTE;
249 	data->d_size = (size_t)size;
250 	data->d_align = (size_t)align;
251 	data->d_version = ofl->ofl_libver;
252 
253 	/*
254 	 * Allocate and initialize the Shdr structure.
255 	 */
256 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
257 		return (S_ERROR);
258 	shdr->sh_type = SHT_NOBITS;
259 	shdr->sh_flags = SHF_ALLOC | SHF_WRITE;
260 	if (tls)
261 		shdr->sh_flags |= SHF_TLS;
262 	shdr->sh_size = size;
263 	shdr->sh_addralign = align;
264 
265 	/*
266 	 * Allocate and initialize the Is_desc structure.
267 	 */
268 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == 0)
269 		return (S_ERROR);
270 
271 	isec->is_shdr = shdr;
272 	isec->is_indata = data;
273 
274 	if (tls) {
275 		isec->is_name = MSG_ORIG(MSG_SCN_TBSS);
276 		ident = M_ID_TLSBSS;
277 		ofl->ofl_istlsbss = isec;
278 	} else {
279 		isec->is_name = MSG_ORIG(MSG_SCN_BSS);
280 		ident = M_ID_BSS;
281 		ofl->ofl_isbss = isec;
282 	}
283 	/*
284 	 * Retain this .bss input section as this will be where global
285 	 * symbol references are added.
286 	 */
287 	if ((osp = place_section(ofl, isec, ident, 0)) == (Os_desc *)S_ERROR)
288 		return (S_ERROR);
289 
290 	/*
291 	 * If relocations exist against .*bss section, a
292 	 * section symbol must be created for the section in
293 	 * the .dynsym symbol table.
294 	 */
295 	if (!(osp->os_flags & FLG_OS_OUTREL)) {
296 		Word	flagtotest;
297 		if (tls)
298 			flagtotest = FLG_OF1_TLSOREL;
299 		else
300 			flagtotest = FLG_OF1_BSSOREL;
301 
302 		if (ofl->ofl_flags1 & flagtotest) {
303 			ofl->ofl_dynshdrcnt++;
304 			osp->os_flags |= FLG_OS_OUTREL;
305 		}
306 	}
307 
308 	osp->os_szoutrels = rsize;
309 
310 	return (1);
311 }
312 
313 
314 /*
315  * Build a SHT_{INIT|FINI|PREINIT}ARRAY section (specified via
316  * ld -z *array=name
317  */
318 uintptr_t
319 make_array(Ofl_desc *ofl, Word shtype, const char *sectname, List *list)
320 {
321 	uint_t		entcount;
322 	Listnode	*lnp;
323 	Elf_Data	*data;
324 	Is_desc		*isec;
325 	Shdr		*shdr;
326 	Sym_desc	*sdp;
327 	Rel_desc	reld;
328 	Rela		reloc;
329 	Os_desc		*osp;
330 
331 	if (list->head == NULL)
332 		return (1);
333 
334 	entcount = 0;
335 	for (LIST_TRAVERSE(list, lnp, sdp))
336 		entcount++;
337 
338 	/*
339 	 * Allocate and initialize the Elf_Data structure.
340 	 */
341 	if (((data = libld_calloc(sizeof (Elf_Data), 1)) == 0) ||
342 	    ((data->d_buf = libld_calloc(sizeof (Addr), entcount)) == 0))
343 		return (S_ERROR);
344 
345 	data->d_type = ELF_T_ADDR;
346 	data->d_size = sizeof (Addr) * entcount;
347 	data->d_align = sizeof (Addr);
348 	data->d_version = ofl->ofl_libver;
349 
350 	/*
351 	 * Allocate and initialize the Shdr structure.
352 	 */
353 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
354 		return (S_ERROR);
355 	shdr->sh_type = shtype;
356 	shdr->sh_size = (Xword)data->d_size;
357 	shdr->sh_entsize = sizeof (Addr);
358 	shdr->sh_addralign = (Xword)data->d_align;
359 	shdr->sh_flags = SHF_ALLOC | SHF_WRITE;
360 
361 	/*
362 	 * Allocate and initialize the Is_desc structure.
363 	 */
364 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == 0)
365 		return (S_ERROR);
366 	isec->is_name = sectname;
367 	isec->is_shdr = shdr;
368 	isec->is_indata = data;
369 
370 	if (place_section(ofl, isec, M_ID_ARRAY, 0) == (Os_desc *)S_ERROR)
371 		return (S_ERROR);
372 
373 	osp = isec->is_osdesc;
374 
375 	if ((ofl->ofl_osinitarray == 0) && (shtype == SHT_INIT_ARRAY))
376 		ofl->ofl_osinitarray = osp;
377 	if ((ofl->ofl_ospreinitarray == 0) && (shtype == SHT_PREINIT_ARRAY))
378 		ofl->ofl_ospreinitarray = osp;
379 	else if ((ofl->ofl_osfiniarray == 0) && (shtype == SHT_FINI_ARRAY))
380 		ofl->ofl_osfiniarray = osp;
381 
382 	/*
383 	 * Create relocations against this section to initialize it to the
384 	 * function addresses.
385 	 */
386 	reld.rel_osdesc = osp;
387 	reld.rel_isdesc = isec;
388 	reld.rel_move = 0;
389 	reld.rel_flags = FLG_REL_LOAD;
390 
391 	/*
392 	 * Fabricate the relocation information (as if a relocation record had
393 	 * been input - see init_rel()).
394 	 */
395 	reld.rel_rtype = M_R_ARRAYADDR;
396 	reld.rel_roffset = 0;
397 	reld.rel_raddend = 0;
398 	reld.rel_typedata = 0;
399 
400 	/*
401 	 * Create a minimal relocation record to satisfy process_sym_reloc()
402 	 * debugging requirements.
403 	 */
404 	reloc.r_offset = 0;
405 	reloc.r_info = ELF_R_INFO(0, M_R_ARRAYADDR);
406 	reloc.r_addend = 0;
407 
408 	DBG_CALL(Dbg_reloc_generate(osp, M_REL_SHT_TYPE));
409 	for (LIST_TRAVERSE(list, lnp, sdp)) {
410 		reld.rel_sname = sdp->sd_name;
411 		reld.rel_sym = sdp;
412 
413 		if (process_sym_reloc(ofl, &reld, (Rel *)&reloc, isec,
414 		    MSG_INTL(MSG_STR_COMMAND)) == S_ERROR)
415 			return (S_ERROR);
416 
417 		reld.rel_roffset += (Xword)sizeof (Addr);
418 		reloc.r_offset = reld.rel_roffset;
419 	}
420 
421 	return (1);
422 }
423 
424 /*
425  * Build a comment section (-Qy option).
426  */
427 uintptr_t
428 make_comment(Ofl_desc *ofl)
429 {
430 	Shdr		*shdr;
431 	Elf_Data	*data;
432 	Is_desc		*isec;
433 
434 	/*
435 	 * Allocate and initialize the Elf_Data structure.
436 	 */
437 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == 0)
438 		return (S_ERROR);
439 	data->d_type = ELF_T_BYTE;
440 	data->d_buf = (void *)ofl->ofl_sgsid;
441 	data->d_size = strlen(ofl->ofl_sgsid) + 1;
442 	data->d_align = 1;
443 	data->d_version = ofl->ofl_libver;
444 
445 	/*
446 	 * Allocate and initialize the Shdr structure.
447 	 */
448 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
449 		return (S_ERROR);
450 	shdr->sh_type = SHT_PROGBITS;
451 	shdr->sh_size = (Xword)data->d_size;
452 	shdr->sh_addralign = 1;
453 
454 	/*
455 	 * Allocate and initialize the Is_desc structure.
456 	 */
457 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == 0)
458 		return (S_ERROR);
459 	isec->is_name = MSG_ORIG(MSG_SCN_COMMENT);
460 	isec->is_shdr = shdr;
461 	isec->is_indata = data;
462 
463 	return ((uintptr_t)place_section(ofl, isec, M_ID_NOTE, 0));
464 }
465 
466 /*
467  * Make the dynamic section.  Calculate the size of any strings referenced
468  * within this structure, they will be added to the global string table
469  * (.dynstr).  This routine should be called before make_dynstr().
470  */
471 uintptr_t
472 make_dynamic(Ofl_desc *ofl)
473 {
474 	Shdr		*shdr;
475 	Os_desc		*osp;
476 	Elf_Data	*data;
477 	Is_desc		*isec;
478 	size_t		cnt = 0;
479 	Listnode	*lnp;
480 	Ifl_desc	*ifl;
481 	Sym_desc	*sdp;
482 	size_t		size;
483 	Word		flags = ofl->ofl_flags;
484 	int		unused = 0;
485 
486 	/*
487 	 * Allocate and initialize the Shdr structure.
488 	 */
489 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
490 		return (S_ERROR);
491 	shdr->sh_type = SHT_DYNAMIC;
492 	shdr->sh_flags = SHF_WRITE;
493 	if (!(flags & FLG_OF_RELOBJ))
494 		shdr->sh_flags |= SHF_ALLOC;
495 	shdr->sh_addralign = M_WORD_ALIGN;
496 	shdr->sh_entsize = (Xword)elf_fsize(ELF_T_DYN, 1, ofl->ofl_libver);
497 	if (shdr->sh_entsize == 0) {
498 		eprintf(ERR_ELF, MSG_INTL(MSG_ELF_FSIZE), ofl->ofl_name);
499 		return (S_ERROR);
500 	}
501 
502 
503 	/*
504 	 * Allocate and initialize the Elf_Data structure.
505 	 */
506 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == 0)
507 		return (S_ERROR);
508 	data->d_type = ELF_T_DYN;
509 	data->d_size = 0;
510 	data->d_align = M_WORD_ALIGN;
511 	data->d_version = ofl->ofl_libver;
512 
513 	/*
514 	 * Allocate and initialize the Is_desc structure.
515 	 */
516 	if ((isec = libld_calloc(1, sizeof (Is_desc))) ==
517 	    (Is_desc *)0)
518 		return (S_ERROR);
519 	isec->is_name = MSG_ORIG(MSG_SCN_DYNAMIC);
520 	isec->is_shdr = shdr;
521 	isec->is_indata = data;
522 
523 	osp = ofl->ofl_osdynamic = place_section(ofl, isec, M_ID_DYNAMIC, 0);
524 
525 	/*
526 	 * Reserve entries for any needed dependencies.
527 	 */
528 	for (LIST_TRAVERSE(&ofl->ofl_sos, lnp, ifl)) {
529 		Sdf_desc *	sdf;
530 
531 		if (!(ifl->ifl_flags & (FLG_IF_NEEDED | FLG_IF_NEEDSTR)))
532 			continue;
533 
534 		/*
535 		 * If this dependency didn't satisfy any symbol references
536 		 * generate a debugging diagnostic (ld(1) -Dunused can be used
537 		 * to display these).  If this is a standard needed dependency,
538 		 * and -z ignore is in effect, drop the dependency.  Explicitly
539 		 * defined dependencies (i.e., -N dep) don't get dropped, and
540 		 * are flagged as being required to simplify update_odynamic()
541 		 * processing.
542 		 */
543 		if (!(ifl->ifl_flags & FLG_IF_DEPREQD)) {
544 			if (unused++ == 0)
545 				DBG_CALL(Dbg_util_nl());
546 			DBG_CALL(Dbg_unused_file(ifl->ifl_soname, 0));
547 
548 			if (ifl->ifl_flags & FLG_IF_NEEDSTR)
549 				ifl->ifl_flags |= FLG_IF_DEPREQD;
550 			else if (ifl->ifl_flags & FLG_IF_IGNORE)
551 				continue;
552 		}
553 
554 		/*
555 		 * If this object has an accompanying shared object definition
556 		 * determine if an alternative shared object name has been
557 		 * specified.
558 		 */
559 		if (((sdf = ifl->ifl_sdfdesc) != 0) &&
560 		    (sdf->sdf_flags & FLG_SDF_SONAME))
561 			ifl->ifl_soname = sdf->sdf_soname;
562 
563 		/*
564 		 * If this object is a lazyload reserve a DT_POSFLAG1 entry.
565 		 */
566 		if (ifl->ifl_flags & (FLG_IF_LAZYLD | FLG_IF_GRPPRM))
567 			cnt++;
568 
569 		if (st_insert(ofl->ofl_dynstrtab, ifl->ifl_soname) == -1)
570 			return (S_ERROR);
571 		cnt++;
572 
573 		/*
574 		 * If the needed entry contains the $ORIGIN token make sure
575 		 * the associated DT_1_FLAGS entry is created.
576 		 */
577 		if (strstr(ifl->ifl_soname, MSG_ORIG(MSG_STR_ORIGIN))) {
578 			ofl->ofl_dtflags_1 |= DF_1_ORIGIN;
579 			ofl->ofl_dtflags |= DF_ORIGIN;
580 		}
581 	}
582 
583 	if (unused)
584 		DBG_CALL(Dbg_util_nl());
585 
586 	/*
587 	 * Reserve entries for any per-symbol auxiliary/filter strings.
588 	 */
589 	if (ofl->ofl_dtsfltrs) {
590 		/* LINTED */
591 		Dfltr_desc *	dftp;
592 		Aliste		off;
593 
594 		for (ALIST_TRAVERSE(ofl->ofl_dtsfltrs, off, dftp))
595 			cnt++;
596 	}
597 
598 	/*
599 	 * Reserve entries for any _init() and _fini() section addresses.
600 	 */
601 	if (((sdp = sym_find(MSG_ORIG(MSG_SYM_INIT_U),
602 	    SYM_NOHASH, 0, ofl)) != NULL) && sdp->sd_ref == REF_REL_NEED) {
603 		sdp->sd_flags |= FLG_SY_UPREQD;
604 		cnt++;
605 	}
606 	if (((sdp = sym_find(MSG_ORIG(MSG_SYM_FINI_U),
607 	    SYM_NOHASH, 0, ofl)) != NULL) && sdp->sd_ref == REF_REL_NEED) {
608 		sdp->sd_flags |= FLG_SY_UPREQD;
609 		cnt++;
610 	}
611 
612 	/*
613 	 * Reserve entries for any soname, filter name (shared libs only),
614 	 * run-path pointers, cache names and audit requirements..
615 	 */
616 	if (ofl->ofl_soname) {
617 		cnt++;
618 		if (st_insert(ofl->ofl_dynstrtab, ofl->ofl_soname) == -1)
619 			return (S_ERROR);
620 	}
621 	if (ofl->ofl_filtees) {
622 		cnt++;
623 		if (st_insert(ofl->ofl_dynstrtab, ofl->ofl_filtees) == -1)
624 			return (S_ERROR);
625 
626 		/*
627 		 * If the filtees entry contains the $ORIGIN token make sure
628 		 * the associated DT_1_FLAGS entry is created.
629 		 */
630 		if (strstr(ofl->ofl_filtees, MSG_ORIG(MSG_STR_ORIGIN))) {
631 			ofl->ofl_dtflags_1 |= DF_1_ORIGIN;
632 			ofl->ofl_dtflags |= DF_ORIGIN;
633 		}
634 	}
635 	if (ofl->ofl_rpath) {
636 		cnt += 2;	/* DT_RPATH & DT_RUNPATH */
637 		if (st_insert(ofl->ofl_dynstrtab, ofl->ofl_rpath) == -1)
638 			return (S_ERROR);
639 
640 		/*
641 		 * If the rpath entry contains the $ORIGIN token make sure
642 		 * the associated DT_1_FLAGS entry is created.
643 		 */
644 		if (strstr(ofl->ofl_rpath, MSG_ORIG(MSG_STR_ORIGIN))) {
645 			ofl->ofl_dtflags_1 |= DF_1_ORIGIN;
646 			ofl->ofl_dtflags |= DF_ORIGIN;
647 		}
648 	}
649 	if (ofl->ofl_config) {
650 		cnt++;
651 		if (st_insert(ofl->ofl_dynstrtab, ofl->ofl_config) == -1)
652 			return (S_ERROR);
653 
654 		/*
655 		 * If the config entry contains the $ORIGIN token make sure
656 		 * the associated DT_1_FLAGS entry is created.
657 		 */
658 		if (strstr(ofl->ofl_config, MSG_ORIG(MSG_STR_ORIGIN))) {
659 			ofl->ofl_dtflags_1 |= DF_1_ORIGIN;
660 			ofl->ofl_dtflags |= DF_ORIGIN;
661 		}
662 	}
663 	if (ofl->ofl_depaudit) {
664 		cnt++;
665 		if (st_insert(ofl->ofl_dynstrtab, ofl->ofl_depaudit) == -1)
666 			return (S_ERROR);
667 	}
668 	if (ofl->ofl_audit) {
669 		cnt++;
670 		if (st_insert(ofl->ofl_dynstrtab, ofl->ofl_audit) == -1)
671 			return (S_ERROR);
672 	}
673 
674 
675 	/*
676 	 * The following DT_* entries do not apply to relocatable objects
677 	 */
678 	if (!(ofl->ofl_flags & FLG_OF_RELOBJ)) {
679 		/*
680 		 * Reserve entries for the HASH, STRTAB, STRSZ, SYMTAB, SYMENT,
681 		 * and CHECKSUM.
682 		 */
683 		cnt += 6;
684 
685 		if ((flags & (FLG_OF_VERDEF | FLG_OF_NOVERSEC)) ==
686 		    FLG_OF_VERDEF)
687 			cnt += 2;		/* DT_VERDEF & DT_VERDEFNUM */
688 
689 		if ((flags & (FLG_OF_VERNEED | FLG_OF_NOVERSEC)) ==
690 		    FLG_OF_VERNEED)
691 			cnt += 2;		/* DT_VERNEED & DT_VERNEEDNUM */
692 
693 		if ((ofl->ofl_flags1 & FLG_OF1_RELCNT) &&
694 		    ofl->ofl_relocrelcnt)	/* RELACOUNT */
695 			cnt++;
696 
697 		if (flags & FLG_OF_TEXTREL)	/* TEXTREL */
698 			cnt++;
699 
700 		if (ofl->ofl_osfiniarray)	/* FINI_ARRAY & FINI_ARRAYSZ */
701 			cnt += 2;
702 
703 		if (ofl->ofl_osinitarray)	/* INIT_ARRAY & INIT_ARRAYSZ */
704 			cnt += 2;
705 
706 		if (ofl->ofl_ospreinitarray)	/* PREINIT_ARRAY & */
707 			cnt += 2;		/*	PREINIT_ARRAYSZ */
708 
709 		/*
710 		 * If we have plt's reserve a PLT, PLTSZ, PLTREL and JMPREL.
711 		 */
712 		if (ofl->ofl_pltcnt)
713 			cnt += 3;
714 
715 		/*
716 		 * If pltpadding is needed (Sparcv9)
717 		 */
718 		if (ofl->ofl_pltpad)
719 			cnt += 2;		/* DT_PLTPAD & DT_PLTPADSZ */
720 
721 		/*
722 		 * If we have any relocations reserve a REL, RELSZ and
723 		 * RELENT entry.
724 		 */
725 		if (ofl->ofl_relocsz)
726 			cnt += 3;
727 
728 		/*
729 		 * If a syminfo section is required create SYMINFO, SYMINSZ,
730 		 * and SYMINENT entries.
731 		 */
732 		if (ofl->ofl_flags & FLG_OF_SYMINFO)
733 			cnt += 3;
734 
735 		/*
736 		 * If there are any partially initialized sections allocate
737 		 * MOVEENT, MOVESZ and MOVETAB.
738 		 */
739 		if (ofl->ofl_osmove)
740 			cnt += 3;
741 
742 		/*
743 		 * Allocate one DT_REGISTER entry for ever register symbol.
744 		 */
745 		cnt += ofl->ofl_regsymcnt;
746 
747 		/*
748 		 * Reserve a entry for each '-zrtldinfo=...' specified
749 		 * on the command line.
750 		 */
751 		for (LIST_TRAVERSE(&ofl->ofl_rtldinfo, lnp, sdp))
752 			cnt++;
753 
754 		/*
755 		 * These two entries should only be placed in a segment
756 		 * which is writable.  If it's a read-only segment
757 		 * (due to mapfile magic, e.g. libdl.so.1) then don't allocate
758 		 * these entries.
759 		 */
760 		if ((osp->os_sgdesc) &&
761 		    (osp->os_sgdesc->sg_phdr.p_flags & PF_W)) {
762 			cnt++;			/* FEATURE_1 */
763 
764 			if (ofl->ofl_osinterp)
765 				cnt++;		/* DEBUG */
766 		}
767 
768 		/*
769 		 * Any hardware/software capabilities?
770 		 */
771 		if (ofl->ofl_oscap)
772 			cnt++;			/* SUNW_CAP */
773 	}
774 
775 	if (flags & FLG_OF_SYMBOLIC)
776 		cnt++;				/* SYMBOLIC */
777 
778 	/*
779 	 * Account for Architecture dependent .dynamic entries, and defaults
780 	 */
781 	mach_make_dynamic(ofl, &cnt);
782 
783 	cnt += 3;				/* DT_FLAGS, DT_FLAGS_1, */
784 						/*   and DT_NULL */
785 
786 	/*
787 	 * Determine the size of the section from the number of entries.
788 	 */
789 	size = cnt * (size_t)shdr->sh_entsize;
790 
791 	shdr->sh_size = (Xword)size;
792 	data->d_size = size;
793 
794 	return ((uintptr_t)ofl->ofl_osdynamic);
795 }
796 
797 /*
798  * Build the GOT section and its associated relocation entries.
799  */
800 uintptr_t
801 make_got(Ofl_desc *ofl)
802 {
803 	Shdr		*shdr;
804 	Elf_Data	*data;
805 	Is_desc		*isec;
806 	size_t		size = (size_t)ofl->ofl_gotcnt * M_GOT_ENTSIZE;
807 	size_t		rsize = (size_t)ofl->ofl_relocgotsz;
808 
809 	/*
810 	 * Allocate and initialize the Elf_Data structure.
811 	 */
812 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == 0)
813 		return (S_ERROR);
814 	data->d_type = ELF_T_BYTE;
815 	data->d_size = size;
816 	data->d_align = M_WORD_ALIGN;
817 	data->d_version = ofl->ofl_libver;
818 
819 	/*
820 	 * Allocate and initialize the Shdr structure.
821 	 */
822 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
823 		return (S_ERROR);
824 	shdr->sh_type = SHT_PROGBITS;
825 	shdr->sh_flags = SHF_ALLOC | SHF_WRITE;
826 	shdr->sh_size = (Xword)size;
827 	shdr->sh_addralign = M_WORD_ALIGN;
828 	shdr->sh_entsize = M_GOT_ENTSIZE;
829 
830 	/*
831 	 * Allocate and initialize the Is_desc structure.
832 	 */
833 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == 0)
834 		return (S_ERROR);
835 	isec->is_name = MSG_ORIG(MSG_SCN_GOT);
836 	isec->is_shdr = shdr;
837 	isec->is_indata = data;
838 
839 	if ((ofl->ofl_osgot = place_section(ofl, isec, M_ID_GOT, 0)) ==
840 	    (Os_desc *)S_ERROR)
841 		return (S_ERROR);
842 
843 	ofl->ofl_osgot->os_szoutrels = (Xword)rsize;
844 
845 	return (1);
846 }
847 
848 /*
849  * Build an interp section.
850  */
851 uintptr_t
852 make_interp(Ofl_desc *ofl)
853 {
854 	Shdr		*shdr;
855 	Elf_Data	*data;
856 	Is_desc		*isec;
857 	const char	*iname = ofl->ofl_interp;
858 	size_t		size;
859 
860 	/*
861 	 * We always build an .interp section for dynamic executables.  However
862 	 * if the user has specifically specified an interpretor we'll build
863 	 * this section for any output (presumably the user knows what they are
864 	 * doing. refer ABI section 5-4, and ld.1 man page use of -I).
865 	 */
866 	if (((ofl->ofl_flags & (FLG_OF_DYNAMIC | FLG_OF_EXEC |
867 	    FLG_OF_RELOBJ)) != (FLG_OF_DYNAMIC | FLG_OF_EXEC)) && !iname)
868 		return (1);
869 
870 	/*
871 	 * In the case of a dynamic executable supply a default interpretor
872 	 * if a specific interpreter has not been specified.
873 	 */
874 	if (!iname) {
875 		if (ofl->ofl_e_machine == EM_SPARCV9)
876 			iname = ofl->ofl_interp =
877 				MSG_ORIG(MSG_PTH_RTLD_SPARCV9);
878 		else if (ofl->ofl_e_machine == EM_AMD64)
879 			iname = ofl->ofl_interp =
880 				MSG_ORIG(MSG_PTH_RTLD_AMD64);
881 		else
882 			iname = ofl->ofl_interp = MSG_ORIG(MSG_PTH_RTLD);
883 	}
884 
885 	size = strlen(iname) + 1;
886 
887 	/*
888 	 * Allocate and initialize the Elf_Data structure.
889 	 */
890 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == 0)
891 		return (S_ERROR);
892 	data->d_type = ELF_T_BYTE;
893 	data->d_size = size;
894 	data->d_version = ofl->ofl_libver;
895 
896 	/*
897 	 * Allocate and initialize the Shdr structure.
898 	 */
899 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
900 		return (S_ERROR);
901 	shdr->sh_type = SHT_PROGBITS;
902 	shdr->sh_flags = SHF_ALLOC;
903 	shdr->sh_size = (Xword)size;
904 
905 	/*
906 	 * Allocate and initialize the Is_desc structure.
907 	 */
908 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == 0)
909 		return (S_ERROR);
910 	isec->is_name = MSG_ORIG(MSG_SCN_INTERP);
911 	isec->is_shdr = shdr;
912 	isec->is_indata = data;
913 
914 	ofl->ofl_osinterp = place_section(ofl, isec, M_ID_INTERP, 0);
915 	return ((uintptr_t)ofl->ofl_osinterp);
916 }
917 
918 /*
919  * Build a hardware/software capabilities section.
920  */
921 uintptr_t
922 make_cap(Ofl_desc *ofl)
923 {
924 	Shdr		*shdr;
925 	Elf_Data	*data;
926 	Is_desc		*isec;
927 	Os_desc		*osec;
928 	Cap		*cap;
929 	size_t		size = 0;
930 
931 	/*
932 	 * Determine how many entries are required.
933 	 */
934 	if (ofl->ofl_hwcap_1)
935 		size++;
936 	if (ofl->ofl_sfcap_1)
937 		size++;
938 	if (size == 0)
939 		return (1);
940 	size++;				/* Add CA_SUNW_NULL */
941 
942 	/*
943 	 * Allocate and initialize the Elf_Data structure.
944 	 */
945 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == 0)
946 		return (S_ERROR);
947 	data->d_type = ELF_T_CAP;
948 	data->d_version = ofl->ofl_libver;
949 	data->d_align = M_WORD_ALIGN;
950 
951 	/*
952 	 * Allocate and initialize the Shdr structure.
953 	 */
954 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
955 		return (S_ERROR);
956 	shdr->sh_type = SHT_SUNW_cap;
957 	shdr->sh_flags = SHF_ALLOC;
958 	shdr->sh_addralign = M_WORD_ALIGN;
959 	shdr->sh_entsize = (Xword)elf_fsize(ELF_T_CAP, 1, ofl->ofl_libver);
960 	if (shdr->sh_entsize == 0) {
961 		eprintf(ERR_ELF, MSG_INTL(MSG_ELF_FSIZE), ofl->ofl_name);
962 		return (S_ERROR);
963 	}
964 
965 	/*
966 	 * Allocate and initialize the Is_desc structure.
967 	 */
968 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == 0)
969 		return (S_ERROR);
970 	isec->is_name = MSG_ORIG(MSG_SCN_SUNWCAP);
971 	isec->is_shdr = shdr;
972 	isec->is_indata = data;
973 
974 	/*
975 	 * Determine the size of the section, and create the data.
976 	 */
977 	size = size * (size_t)shdr->sh_entsize;
978 	shdr->sh_size = (Xword)size;
979 	data->d_size = size;
980 	if ((data->d_buf = libld_malloc(size)) == 0)
981 		return (S_ERROR);
982 
983 	cap = (Cap *)data->d_buf;
984 	if (ofl->ofl_hwcap_1) {
985 		cap->c_tag = CA_SUNW_HW_1;
986 		cap->c_un.c_val = ofl->ofl_hwcap_1;
987 		cap++;
988 	}
989 	if (ofl->ofl_sfcap_1) {
990 		cap->c_tag = CA_SUNW_SF_1;
991 		cap->c_un.c_val = ofl->ofl_sfcap_1;
992 		cap++;
993 	}
994 	cap->c_tag = CA_SUNW_NULL;
995 	cap->c_un.c_val = 0;
996 
997 	/*
998 	 * If we're not creating a relocatable object, save the output section
999 	 * to trigger the creation of an associated  a program header.
1000 	 */
1001 	osec = place_section(ofl, isec, M_ID_CAP, 0);
1002 	if ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0)
1003 		ofl->ofl_oscap = osec;
1004 
1005 	return ((uintptr_t)osec);
1006 }
1007 
1008 /*
1009  * Build the PLT section and its associated relocation entries.
1010  */
1011 uintptr_t
1012 make_plt(Ofl_desc *ofl)
1013 {
1014 	Shdr		*shdr;
1015 	Elf_Data	*data;
1016 	Is_desc		*isec;
1017 	size_t		size = (size_t)M_PLT_RESERVSZ +
1018 				(((size_t)ofl->ofl_pltcnt +
1019 				(size_t)ofl->ofl_pltpad) * M_PLT_ENTSIZE);
1020 	size_t		rsize = (size_t)ofl->ofl_relocpltsz;
1021 
1022 #if defined(sparc)
1023 	/*
1024 	 * Account for the NOP at the end of the plt.
1025 	 */
1026 	size += sizeof (Word);
1027 #endif
1028 
1029 	/*
1030 	 * Allocate and initialize the Elf_Data structure.
1031 	 */
1032 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == 0)
1033 		return (S_ERROR);
1034 	data->d_type = ELF_T_BYTE;
1035 	data->d_size = size;
1036 	data->d_align = M_PLT_ALIGN;
1037 	data->d_version = ofl->ofl_libver;
1038 
1039 	/*
1040 	 * Allocate and initialize the Shdr structure.
1041 	 */
1042 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
1043 		return (S_ERROR);
1044 	shdr->sh_type = SHT_PROGBITS;
1045 	shdr->sh_flags = M_PLT_SHF_FLAGS;
1046 	shdr->sh_size = (Xword)size;
1047 	shdr->sh_addralign = M_PLT_ALIGN;
1048 	shdr->sh_entsize = M_PLT_ENTSIZE;
1049 
1050 	/*
1051 	 * Allocate and initialize the Is_desc structure.
1052 	 */
1053 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == (Is_desc *)0)
1054 		return (S_ERROR);
1055 	isec->is_name = MSG_ORIG(MSG_SCN_PLT);
1056 	isec->is_shdr = shdr;
1057 	isec->is_indata = data;
1058 
1059 	if ((ofl->ofl_osplt = place_section(ofl, isec, M_ID_PLT, 0)) ==
1060 	    (Os_desc *)S_ERROR)
1061 		return (S_ERROR);
1062 
1063 	ofl->ofl_osplt->os_szoutrels = (Xword)rsize;
1064 
1065 	return (1);
1066 }
1067 
1068 /*
1069  * Make the hash table.  Only built for dynamic executables and shared
1070  * libraries, and provides hashed lookup into the global symbol table
1071  * (.dynsym) for the run-time linker to resolve symbol lookups.
1072  */
1073 uintptr_t
1074 make_hash(Ofl_desc *ofl)
1075 {
1076 	Shdr		*shdr;
1077 	Elf_Data	*data;
1078 	Is_desc		*isec;
1079 	size_t		size;
1080 	Word		nsyms = ofl->ofl_globcnt;
1081 	size_t		cnt;
1082 
1083 	/*
1084 	 * Allocate and initialize the Elf_Data structure.
1085 	 */
1086 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == 0)
1087 		return (S_ERROR);
1088 	data->d_type = ELF_T_WORD;
1089 	data->d_align = M_WORD_ALIGN;
1090 	data->d_version = ofl->ofl_libver;
1091 
1092 	/*
1093 	 * Allocate and initialize the Shdr structure.
1094 	 */
1095 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
1096 		return (S_ERROR);
1097 	shdr->sh_type = SHT_HASH;
1098 	shdr->sh_flags = SHF_ALLOC;
1099 	shdr->sh_addralign = M_WORD_ALIGN;
1100 	shdr->sh_entsize = (Xword)elf_fsize(ELF_T_WORD, 1, ofl->ofl_libver);
1101 	if (shdr->sh_entsize == 0) {
1102 		eprintf(ERR_ELF, MSG_INTL(MSG_ELF_FSIZE), ofl->ofl_name);
1103 		return (S_ERROR);
1104 	}
1105 
1106 	/*
1107 	 * Allocate and initialize the Is_desc structure.
1108 	 */
1109 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == 0)
1110 		return (S_ERROR);
1111 	isec->is_name = MSG_ORIG(MSG_SCN_HASH);
1112 	isec->is_shdr = shdr;
1113 	isec->is_indata = data;
1114 
1115 	/*
1116 	 * Place the section first since it will affect the local symbol
1117 	 * count.
1118 	 */
1119 	if ((ofl->ofl_oshash = place_section(ofl, isec, M_ID_HASH, 0)) ==
1120 	    (Os_desc *)S_ERROR)
1121 		return (S_ERROR);
1122 
1123 	/*
1124 	 * Calculate the number of output hash buckets.
1125 	 */
1126 	ofl->ofl_hashbkts = findprime(nsyms);
1127 
1128 	/*
1129 	 * The size of the hash table is determined by
1130 	 *
1131 	 *	i.	the initial nbucket and nchain entries (2)
1132 	 *	ii.	the number of buckets (calculated above)
1133 	 *	iii.	the number of chains (this is based on the number of
1134 	 *		symbols in the .dynsym array + NULL symbol).
1135 	 */
1136 	cnt = 2 + ofl->ofl_hashbkts + (ofl->ofl_dynshdrcnt +
1137 		ofl->ofl_globcnt + ofl->ofl_lregsymcnt + 1);
1138 	size = cnt * shdr->sh_entsize;
1139 
1140 	/*
1141 	 * Finalize the section header and data buffer initialization.
1142 	 */
1143 	if ((data->d_buf = libld_calloc(size, 1)) == 0)
1144 		return (S_ERROR);
1145 	data->d_size = size;
1146 	shdr->sh_size = (Xword)size;
1147 
1148 	return (1);
1149 }
1150 
1151 /*
1152  * Generate the standard symbol table.  Contains all locals and globals,
1153  * and resides in a non-allocatable section (ie. it can be stripped).
1154  */
1155 uintptr_t
1156 make_symtab(Ofl_desc *ofl)
1157 {
1158 	Shdr		*shdr;
1159 	Elf_Data	*data;
1160 	Is_desc		*isec;
1161 	Is_desc		*xisec = 0;
1162 	size_t		size;
1163 	Word		symcnt;
1164 
1165 	/*
1166 	 * Allocate and initialize the Elf_Data structure.
1167 	 */
1168 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == 0)
1169 		return (S_ERROR);
1170 	data->d_type = ELF_T_SYM;
1171 	data->d_align = M_WORD_ALIGN;
1172 	data->d_version = ofl->ofl_libver;
1173 
1174 	/*
1175 	 * Allocate and initialize the Shdr structure.
1176 	 */
1177 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
1178 		return (S_ERROR);
1179 	shdr->sh_type = SHT_SYMTAB;
1180 	shdr->sh_addralign = M_WORD_ALIGN;
1181 	shdr->sh_entsize = (Xword)elf_fsize(ELF_T_SYM, 1, ofl->ofl_libver);
1182 	if (shdr->sh_entsize == 0) {
1183 		eprintf(ERR_ELF, MSG_INTL(MSG_ELF_FSIZE), ofl->ofl_name);
1184 		return (S_ERROR);
1185 	}
1186 
1187 	/*
1188 	 * Allocate and initialize the Is_desc structure.
1189 	 */
1190 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == 0)
1191 		return (S_ERROR);
1192 	isec->is_name = MSG_ORIG(MSG_SCN_SYMTAB);
1193 	isec->is_shdr = shdr;
1194 	isec->is_indata = data;
1195 
1196 	/*
1197 	 * Place the section first since it will affect the local symbol
1198 	 * count.
1199 	 */
1200 	if ((ofl->ofl_ossymtab = place_section(ofl, isec, M_ID_SYMTAB, 0)) ==
1201 	    (Os_desc *)S_ERROR)
1202 		return (S_ERROR);
1203 
1204 	/*
1205 	 * At this point we've created all but the 'shstrtab' section.
1206 	 * Determine if we have to use 'Extended Sections'.  If so - then
1207 	 * also create a SHT_SYMTAB_SHNDX section.
1208 	 */
1209 	if ((ofl->ofl_shdrcnt + 1) >= SHN_LORESERVE) {
1210 		Shdr		*xshdr;
1211 		Elf_Data	*xdata;
1212 
1213 		if ((xdata = libld_calloc(sizeof (Elf_Data), 1)) == 0)
1214 			return (S_ERROR);
1215 		xdata->d_type = ELF_T_WORD;
1216 		xdata->d_align = M_WORD_ALIGN;
1217 		xdata->d_version = ofl->ofl_libver;
1218 		if ((xshdr = libld_calloc(sizeof (Shdr), 1)) == 0)
1219 			return (S_ERROR);
1220 		xshdr->sh_type = SHT_SYMTAB_SHNDX;
1221 		xshdr->sh_addralign = M_WORD_ALIGN;
1222 		xshdr->sh_entsize = sizeof (Word);
1223 		if ((xisec = libld_calloc(1, sizeof (Is_desc))) == 0)
1224 			return (S_ERROR);
1225 		xisec->is_name = MSG_ORIG(MSG_SCN_SYMTAB_SHNDX);
1226 		xisec->is_shdr = xshdr;
1227 		xisec->is_indata = xdata;
1228 		if ((ofl->ofl_ossymshndx = place_section(ofl, xisec,
1229 		    M_ID_SYMTAB_NDX, 0)) == (Os_desc *)S_ERROR)
1230 			return (S_ERROR);
1231 	}
1232 	/*
1233 	 * Calculated number of symbols, which need to be augmented by
1234 	 * the null first entry, the FILE symbol, and the .shstrtab entry.
1235 	 */
1236 	symcnt = (size_t)(3 + ofl->ofl_shdrcnt + ofl->ofl_scopecnt +
1237 		ofl->ofl_locscnt + ofl->ofl_globcnt);
1238 	size = symcnt * shdr->sh_entsize;
1239 
1240 	/*
1241 	 * Finalize the section header and data buffer initialization.
1242 	 */
1243 	data->d_size = size;
1244 	shdr->sh_size = (Xword)size;
1245 
1246 	/*
1247 	 * If we created a SHT_SYMTAB_SHNDX - then set it's sizes too.
1248 	 */
1249 	if (xisec) {
1250 		size_t	xsize = symcnt * sizeof (Word);
1251 
1252 		xisec->is_indata->d_size = xsize;
1253 		xisec->is_shdr->sh_size = (Xword)xsize;
1254 	}
1255 
1256 	return (1);
1257 }
1258 
1259 
1260 /*
1261  * Build a dynamic symbol table.  Contains only globals symbols and resides
1262  * in the text segment of a dynamic executable or shared library.
1263  */
1264 uintptr_t
1265 make_dynsym(Ofl_desc *ofl)
1266 {
1267 	Shdr		*shdr;
1268 	Elf_Data	*data;
1269 	Is_desc		*isec;
1270 	size_t		size;
1271 	Xword		cnt;
1272 
1273 	/*
1274 	 * Allocate and initialize the Elf_Data structure.
1275 	 */
1276 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == 0)
1277 		return (S_ERROR);
1278 	data->d_type = ELF_T_SYM;
1279 	data->d_align = M_WORD_ALIGN;
1280 	data->d_version = ofl->ofl_libver;
1281 
1282 	/*
1283 	 * Allocate and initialize the Shdr structure.
1284 	 */
1285 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
1286 		return (S_ERROR);
1287 	shdr->sh_type = SHT_DYNSYM;
1288 	shdr->sh_flags = SHF_ALLOC;
1289 	shdr->sh_addralign = M_WORD_ALIGN;
1290 	shdr->sh_entsize = (Xword)elf_fsize(ELF_T_SYM, 1, ofl->ofl_libver);
1291 	if (shdr->sh_entsize == 0) {
1292 		eprintf(ERR_ELF, MSG_INTL(MSG_ELF_FSIZE), ofl->ofl_name);
1293 		return (S_ERROR);
1294 	}
1295 
1296 	/*
1297 	 * Allocate and initialize the Is_desc structure.
1298 	 */
1299 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == 0)
1300 		return (S_ERROR);
1301 	isec->is_name = MSG_ORIG(MSG_SCN_DYNSYM);
1302 	isec->is_shdr = shdr;
1303 	isec->is_indata = data;
1304 
1305 	/*
1306 	 * Place the section first since it will affect the local symbol
1307 	 * count.
1308 	 */
1309 	if ((ofl->ofl_osdynsym = place_section(ofl, isec, M_ID_DYNSYM, 0)) ==
1310 	    (Os_desc *)S_ERROR)
1311 		return (S_ERROR);
1312 
1313 	/*
1314 	 * One extra section header entry for the 'null' entry.
1315 	 */
1316 	cnt = 1 + ofl->ofl_dynshdrcnt + ofl->ofl_globcnt + ofl->ofl_lregsymcnt;
1317 	size = (size_t)cnt * shdr->sh_entsize;
1318 
1319 	/*
1320 	 * Finalize the section header and data buffer initialization.
1321 	 */
1322 	data->d_size = size;
1323 	shdr->sh_size = (Xword)size;
1324 
1325 	return (1);
1326 }
1327 
1328 /*
1329  * Build a SHT_SYMTAB_SHNDX for the .dynsym
1330  */
1331 uintptr_t
1332 make_dynsym_shndx(Ofl_desc *ofl)
1333 {
1334 	Is_desc		*isec;
1335 	Is_desc		*dynsymisp;
1336 	Shdr		*shdr, *dynshdr;
1337 	Elf_Data	*data;
1338 
1339 	/*
1340 	 * Allocate the Elf_Data structure.
1341 	 */
1342 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == 0)
1343 		return (S_ERROR);
1344 	data->d_type = ELF_T_WORD;
1345 	data->d_align = M_WORD_ALIGN;
1346 	data->d_version = ofl->ofl_libver;
1347 
1348 	/*
1349 	 * Allocate the Shdr structure.
1350 	 */
1351 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
1352 		return (S_ERROR);
1353 	shdr->sh_type = SHT_SYMTAB_SHNDX;
1354 	shdr->sh_addralign = M_WORD_ALIGN;
1355 	shdr->sh_entsize = sizeof (Word);
1356 
1357 	/*
1358 	 * Allocate the Is_desc structure.
1359 	 */
1360 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == 0)
1361 		return (S_ERROR);
1362 	isec->is_name = MSG_ORIG(MSG_SCN_DYNSYM_SHNDX);
1363 	isec->is_shdr = shdr;
1364 	isec->is_indata = data;
1365 
1366 	if ((ofl->ofl_osdynshndx = place_section(ofl, isec,
1367 	    M_ID_DYNSYM_NDX, 0)) == (Os_desc *)S_ERROR)
1368 		return (S_ERROR);
1369 
1370 	assert(ofl->ofl_osdynsym);
1371 	dynsymisp = (Is_desc *)ofl->ofl_osdynsym->os_isdescs.head->data;
1372 	dynshdr = dynsymisp->is_shdr;
1373 	shdr->sh_size = (Xword)((dynshdr->sh_size / dynshdr->sh_entsize) *
1374 		sizeof (Word));
1375 	data->d_size = shdr->sh_size;
1376 
1377 	return (1);
1378 }
1379 
1380 
1381 /*
1382  * Build a string table for the section headers.
1383  */
1384 uintptr_t
1385 make_shstrtab(Ofl_desc *ofl)
1386 {
1387 	Shdr		*shdr;
1388 	Elf_Data	*data;
1389 	Is_desc		*isec;
1390 	size_t		size;
1391 
1392 	/*
1393 	 * Allocate the Elf_Data structure.
1394 	 */
1395 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == 0)
1396 		return (S_ERROR);
1397 	data->d_type = ELF_T_BYTE;
1398 	data->d_align = 1;
1399 	data->d_version = ofl->ofl_libver;
1400 
1401 	/*
1402 	 * Allocate the Shdr structure.
1403 	 */
1404 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
1405 		return (S_ERROR);
1406 	shdr->sh_type = SHT_STRTAB;
1407 	shdr->sh_flags |= SHF_STRINGS;
1408 	shdr->sh_addralign = 1;
1409 
1410 	/*
1411 	 * Allocate the Is_desc structure.
1412 	 */
1413 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == 0)
1414 		return (S_ERROR);
1415 	isec->is_name = MSG_ORIG(MSG_SCN_SHSTRTAB);
1416 	isec->is_shdr = shdr;
1417 	isec->is_indata = data;
1418 
1419 	/*
1420 	 * Place the section first, as it may effect the number of section
1421 	 * headers to account for.
1422 	 */
1423 	if ((ofl->ofl_osshstrtab = place_section(ofl, isec, M_ID_NOTE, 0)) ==
1424 	    (Os_desc *)S_ERROR)
1425 		return (S_ERROR);
1426 
1427 	size = st_getstrtab_sz(ofl->ofl_shdrsttab);
1428 	assert(size > 0);
1429 
1430 	assert(size > 0);
1431 
1432 	data->d_size = size;
1433 	shdr->sh_size = (Xword)size;
1434 
1435 	return (1);
1436 }
1437 
1438 /*
1439  * Build a string section for the standard symbol table.
1440  */
1441 uintptr_t
1442 make_strtab(Ofl_desc *ofl)
1443 {
1444 	Shdr		*shdr;
1445 	Elf_Data	*data;
1446 	Is_desc		*isec;
1447 	size_t		size;
1448 
1449 	/*
1450 	 * This string table consists of all the global and local symbols.
1451 	 * Account for null bytes at end of the file name and the beginning
1452 	 * of section.
1453 	 */
1454 	if (st_insert(ofl->ofl_strtab, ofl->ofl_name) == -1)
1455 		return (S_ERROR);
1456 
1457 	size = st_getstrtab_sz(ofl->ofl_strtab);
1458 	assert(size > 0);
1459 
1460 	/*
1461 	 * Allocate the Elf_Data structure.
1462 	 */
1463 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == 0)
1464 		return (S_ERROR);
1465 	data->d_size = size;
1466 	data->d_type = ELF_T_BYTE;
1467 	data->d_align = 1;
1468 	data->d_version = ofl->ofl_libver;
1469 
1470 	/*
1471 	 * Allocate the Shdr structure.
1472 	 */
1473 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
1474 		return (S_ERROR);
1475 	shdr->sh_size = (Xword)size;
1476 	shdr->sh_addralign = 1;
1477 	shdr->sh_type = SHT_STRTAB;
1478 	shdr->sh_flags |= SHF_STRINGS;
1479 
1480 	/*
1481 	 * Allocate and initialize the Is_desc structure.
1482 	 */
1483 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == 0)
1484 		return (S_ERROR);
1485 	isec->is_name = MSG_ORIG(MSG_SCN_STRTAB);
1486 	isec->is_shdr = shdr;
1487 	isec->is_indata = data;
1488 
1489 	ofl->ofl_osstrtab = place_section(ofl, isec, M_ID_STRTAB, 0);
1490 	return ((uintptr_t)ofl->ofl_osstrtab);
1491 }
1492 
1493 /*
1494  * Build a string table for the dynamic symbol table.
1495  */
1496 uintptr_t
1497 make_dynstr(Ofl_desc *ofl)
1498 {
1499 	Shdr		*shdr;
1500 	Elf_Data	*data;
1501 	Is_desc		*isec;
1502 	size_t		size;
1503 
1504 	/*
1505 	 * Account for any local, named register symbols.  These locals are
1506 	 * required for reference from DT_REGISTER .dynamic entries.
1507 	 */
1508 	if (ofl->ofl_regsyms) {
1509 		int	ndx;
1510 
1511 		for (ndx = 0; ndx < ofl->ofl_regsymsno; ndx++) {
1512 			Sym_desc *	sdp;
1513 
1514 			if ((sdp = ofl->ofl_regsyms[ndx]) == 0)
1515 				continue;
1516 
1517 			if (((sdp->sd_flags1 & FLG_SY1_LOCL) == 0) &&
1518 			    (ELF_ST_BIND(sdp->sd_sym->st_info) != STB_LOCAL))
1519 				continue;
1520 
1521 			if (sdp->sd_sym->st_name == 0)
1522 				continue;
1523 
1524 			if (st_insert(ofl->ofl_dynstrtab, sdp->sd_name) == -1)
1525 				return (S_ERROR);
1526 		}
1527 	}
1528 
1529 	/*
1530 	 * Reserve entries for any per-symbol auxiliary/filter strings.
1531 	 */
1532 	if (ofl->ofl_dtsfltrs) {
1533 		Dfltr_desc *	dftp;
1534 		Aliste		off;
1535 
1536 		for (ALIST_TRAVERSE(ofl->ofl_dtsfltrs, off, dftp))
1537 			if (st_insert(ofl->ofl_dynstrtab, dftp->dft_str) == -1)
1538 				return (S_ERROR);
1539 	}
1540 
1541 	size = st_getstrtab_sz(ofl->ofl_dynstrtab);
1542 	assert(size > 0);
1543 
1544 	/*
1545 	 * Allocate the Elf_Data structure.
1546 	 */
1547 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == 0)
1548 		return (S_ERROR);
1549 	data->d_type = ELF_T_BYTE;
1550 	data->d_size = size;
1551 	data->d_align = 1;
1552 	data->d_version = ofl->ofl_libver;
1553 
1554 	/*
1555 	 * Allocate the Shdr structure.
1556 	 */
1557 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
1558 		return (S_ERROR);
1559 	if (!(ofl->ofl_flags & FLG_OF_RELOBJ))
1560 		shdr->sh_flags = SHF_ALLOC;
1561 
1562 	shdr->sh_type = SHT_STRTAB;
1563 	shdr->sh_flags |= SHF_STRINGS;
1564 	shdr->sh_size = (Xword)size;
1565 	shdr->sh_addralign = 1;
1566 
1567 	/*
1568 	 * Allocate and initialize the Is_desc structure.
1569 	 */
1570 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == 0)
1571 		return (S_ERROR);
1572 	isec->is_name = MSG_ORIG(MSG_SCN_DYNSTR);
1573 	isec->is_shdr = shdr;
1574 	isec->is_indata = data;
1575 
1576 	ofl->ofl_osdynstr = place_section(ofl, isec, M_ID_DYNSTR, 0);
1577 	return ((uintptr_t)ofl->ofl_osdynstr);
1578 }
1579 
1580 /*
1581  * Generate an output relocation section which will contain the relocation
1582  * information to be applied to the `osp' section.
1583  *
1584  * If (osp == NULL) then we are creating the coalesced relocation section
1585  * for an executable and/or a shared object.
1586  */
1587 uintptr_t
1588 make_reloc(Ofl_desc *ofl, Os_desc *osp)
1589 {
1590 	Shdr		*shdr;
1591 	Elf_Data	*data;
1592 	Is_desc		*isec;
1593 	size_t		size;
1594 	Xword		sh_flags;
1595 	char 		*sectname;
1596 	Os_desc		*rosp;
1597 	Word		relsize;
1598 	const char	*rel_prefix;
1599 
1600 	/* LINTED */
1601 	if (M_REL_SHT_TYPE == SHT_REL) {
1602 		/* REL */
1603 		relsize = sizeof (Rel);
1604 		rel_prefix = MSG_ORIG(MSG_SCN_REL);
1605 	} else {
1606 		/* RELA */
1607 		relsize = sizeof (Rela);
1608 		rel_prefix = MSG_ORIG(MSG_SCN_RELA);
1609 	}
1610 
1611 	if (osp) {
1612 		size = osp->os_szoutrels;
1613 		sh_flags = osp->os_shdr->sh_flags;
1614 		if ((sectname = libld_malloc(strlen(rel_prefix) +
1615 		    strlen(osp->os_name) + 1)) == 0)
1616 			return (S_ERROR);
1617 		(void) strcpy(sectname, rel_prefix);
1618 		(void) strcat(sectname, osp->os_name);
1619 	} else if (ofl->ofl_flags1 & FLG_OF1_RELCNT) {
1620 		size = (ofl->ofl_reloccnt - ofl->ofl_reloccntsub) * relsize;
1621 		sh_flags = SHF_ALLOC;
1622 		sectname = (char *)MSG_ORIG(MSG_SCN_SUNWRELOC);
1623 	} else {
1624 		size = ofl->ofl_relocrelsz;
1625 		sh_flags = SHF_ALLOC;
1626 		sectname = (char *)rel_prefix;
1627 	}
1628 
1629 	/*
1630 	 * Keep track of total size of 'output relocations' (to be stored
1631 	 * in .dynamic)
1632 	 */
1633 	/* LINTED */
1634 	ofl->ofl_relocsz += (Xword)size;
1635 
1636 	/*
1637 	 * Allocate and initialize the Elf_Data structure.
1638 	 */
1639 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == 0)
1640 		return (S_ERROR);
1641 	data->d_type = M_REL_ELF_TYPE;
1642 	data->d_size = size;
1643 	data->d_align = M_WORD_ALIGN;
1644 	data->d_version = ofl->ofl_libver;
1645 
1646 	/*
1647 	 * Allocate and initialize the Shdr structure.
1648 	 */
1649 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
1650 		return (S_ERROR);
1651 	shdr->sh_type = M_REL_SHT_TYPE;
1652 	shdr->sh_size = (Xword)size;
1653 	shdr->sh_addralign = M_WORD_ALIGN;
1654 	shdr->sh_entsize = relsize;
1655 
1656 	if ((ofl->ofl_flags & FLG_OF_DYNAMIC) &&
1657 	    !(ofl->ofl_flags & FLG_OF_RELOBJ) &&
1658 	    (sh_flags & SHF_ALLOC))
1659 		shdr->sh_flags = SHF_ALLOC;
1660 
1661 	if (osp) {
1662 		/*
1663 		 * The sh_info field of the SHT_REL* sections points to the
1664 		 * section the relocations are to be applied to.
1665 		 */
1666 		shdr->sh_flags |= SHF_INFO_LINK;
1667 	}
1668 
1669 
1670 	/*
1671 	 * Allocate and initialize the Is_desc structure.
1672 	 */
1673 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == 0)
1674 		return (S_ERROR);
1675 	isec->is_shdr = shdr;
1676 	isec->is_indata = data;
1677 	isec->is_name = sectname;
1678 
1679 
1680 	/*
1681 	 * Associate this relocation section to the section its going to
1682 	 * relocate.
1683 	 */
1684 	if ((rosp = place_section(ofl, isec, M_ID_REL, 0)) ==
1685 	    (Os_desc *)S_ERROR)
1686 		return (S_ERROR);
1687 
1688 	if (osp) {
1689 		Listnode *	lnp;
1690 		Is_desc *	risp;
1691 		/*
1692 		 * We associate the input relocation sections - with
1693 		 * the newly created output relocation section.
1694 		 *
1695 		 * This is used primarily so that we can update
1696 		 * SHT_GROUP[sect_no] entries to point to the
1697 		 * created output relocation sections.
1698 		 */
1699 		for (LIST_TRAVERSE(&(osp->os_relisdescs), lnp, risp)) {
1700 			risp->is_osdesc = rosp;
1701 			/*
1702 			 * If the input relocation section had
1703 			 * the SHF_GROUP flag set - propogate it to
1704 			 * the output relocation section.
1705 			 */
1706 			if (risp->is_shdr->sh_flags & SHF_GROUP) {
1707 				rosp->os_shdr->sh_flags |= SHF_GROUP;
1708 				break;
1709 			}
1710 		}
1711 		osp->os_relosdesc = rosp;
1712 	} else
1713 		ofl->ofl_osrel = rosp;
1714 
1715 	/*
1716 	 * If this is the first relocation section we've encountered save it
1717 	 * so that the .dynamic entry can be initialized accordingly.
1718 	 */
1719 	if (ofl->ofl_osrelhead == (Os_desc *)0)
1720 		ofl->ofl_osrelhead = rosp;
1721 
1722 	return (1);
1723 }
1724 
1725 /*
1726  * Generate version needed section.
1727  */
1728 uintptr_t
1729 make_verneed(Ofl_desc *ofl)
1730 {
1731 	Shdr		*shdr;
1732 	Elf_Data	*data;
1733 	Is_desc		*isec;
1734 	size_t		size = ofl->ofl_verneedsz;
1735 
1736 	/*
1737 	 * Allocate and initialize the Elf_Data structure.
1738 	 */
1739 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == 0)
1740 		return (S_ERROR);
1741 	data->d_type = ELF_T_BYTE;
1742 	data->d_size = size;
1743 	data->d_align = M_WORD_ALIGN;
1744 	data->d_version = ofl->ofl_libver;
1745 
1746 	/*
1747 	 * Allocate and initialize the Shdr structure.
1748 	 */
1749 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
1750 		return (S_ERROR);
1751 	shdr->sh_type = (Word)SHT_SUNW_verneed;
1752 	shdr->sh_flags = SHF_ALLOC;
1753 	shdr->sh_size = (Xword)size;
1754 	shdr->sh_addralign = M_WORD_ALIGN;
1755 
1756 	/*
1757 	 * Allocate and initialize the Is_desc structure.
1758 	 */
1759 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == 0)
1760 		return (S_ERROR);
1761 	isec->is_name = MSG_ORIG(MSG_SCN_SUNWVERSION);
1762 	isec->is_shdr = shdr;
1763 	isec->is_indata = data;
1764 
1765 	ofl->ofl_osverneed = place_section(ofl, isec, M_ID_VERSION, 0);
1766 	return ((uintptr_t)ofl->ofl_osverneed);
1767 }
1768 
1769 /*
1770  * Generate a version definition section.
1771  *
1772  *  o	the SHT_SUNW_verdef section defines the versions that exist within this
1773  *	image.
1774  */
1775 uintptr_t
1776 make_verdef(Ofl_desc *ofl)
1777 {
1778 	Shdr		*shdr;
1779 	Elf_Data	*data;
1780 	Is_desc		*isec;
1781 	Ver_desc	*vdp;
1782 	size_t		size;
1783 
1784 	/*
1785 	 * Reserve a string table entry for the base version dependency (other
1786 	 * dependencies have symbol representations, which will already be
1787 	 * accounted for during symbol processing).
1788 	 */
1789 	vdp = (Ver_desc *)ofl->ofl_verdesc.head->data;
1790 	size = strlen(vdp->vd_name) + 1;
1791 
1792 	if (ofl->ofl_flags & FLG_OF_DYNAMIC) {
1793 		if (st_insert(ofl->ofl_dynstrtab, vdp->vd_name) == -1)
1794 			return (S_ERROR);
1795 	} else {
1796 		if (st_insert(ofl->ofl_strtab, vdp->vd_name) == -1)
1797 			return (S_ERROR);
1798 	}
1799 
1800 	/*
1801 	 * During version processing we calculated the total number of entries.
1802 	 * Allocate and initialize the Elf_Data structure.
1803 	 */
1804 	size = ofl->ofl_verdefsz;
1805 
1806 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == 0)
1807 		return (S_ERROR);
1808 	data->d_type = ELF_T_BYTE;
1809 	data->d_size = size;
1810 	data->d_align = M_WORD_ALIGN;
1811 	data->d_version = ofl->ofl_libver;
1812 
1813 	/*
1814 	 * Allocate and initialize the Shdr structure.
1815 	 */
1816 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
1817 		return (S_ERROR);
1818 	shdr->sh_type = (Word)SHT_SUNW_verdef;
1819 	shdr->sh_flags = SHF_ALLOC;
1820 	shdr->sh_size = (Xword)size;
1821 	shdr->sh_addralign = M_WORD_ALIGN;
1822 
1823 	/*
1824 	 * Allocate and initialize the Is_desc structure.
1825 	 */
1826 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == 0)
1827 		return (S_ERROR);
1828 	isec->is_name = MSG_ORIG(MSG_SCN_SUNWVERSION);
1829 	isec->is_shdr = shdr;
1830 	isec->is_indata = data;
1831 
1832 	ofl->ofl_osverdef = place_section(ofl, isec, M_ID_VERSION, 0);
1833 	return ((uintptr_t)ofl->ofl_osverdef);
1834 }
1835 
1836 /*
1837  * Common function used to build both the SHT_SUNW_versym
1838  * section and the SHT_SUNW_syminfo section.  Each of these sections
1839  * provides additional symbol information.
1840  */
1841 Os_desc *
1842 make_sym_sec(Ofl_desc *ofl, const char *sectname, Word entsize,
1843     Word stype, int ident)
1844 {
1845 	Shdr		*shdr;
1846 	Elf_Data	*data;
1847 	Is_desc		*isec;
1848 
1849 	/*
1850 	 * Allocate and initialize the Elf_Data structures for the symbol index
1851 	 * array.
1852 	 */
1853 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == 0)
1854 		return ((Os_desc *)S_ERROR);
1855 	data->d_type = ELF_T_BYTE;
1856 	data->d_align = M_WORD_ALIGN;
1857 	data->d_version = ofl->ofl_libver;
1858 
1859 	/*
1860 	 * Allocate and initialize the Shdr structure.
1861 	 */
1862 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
1863 		return ((Os_desc *)S_ERROR);
1864 	shdr->sh_type = (Word)stype;
1865 	shdr->sh_flags = SHF_ALLOC;
1866 	shdr->sh_addralign = M_WORD_ALIGN;
1867 	shdr->sh_entsize = entsize;
1868 
1869 	if (stype == SHT_SUNW_syminfo) {
1870 		/*
1871 		 * The sh_info field of the SHT_*_syminfo section points
1872 		 * to the header index of the associated .dynamic section.
1873 		 */
1874 		shdr->sh_flags |= SHF_INFO_LINK;
1875 	}
1876 
1877 	/*
1878 	 * Allocate and initialize the Is_desc structure.
1879 	 */
1880 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == 0)
1881 		return ((Os_desc *)S_ERROR);
1882 	isec->is_name = sectname;
1883 	isec->is_shdr = shdr;
1884 	isec->is_indata = data;
1885 
1886 	return (place_section(ofl, isec, ident, 0));
1887 }
1888 
1889 /*
1890  * Build a .sunwbss section for allocation of tentative definitions.
1891  */
1892 uintptr_t
1893 make_sunwbss(Ofl_desc *ofl, size_t size, Xword align)
1894 {
1895 	Shdr		*shdr;
1896 	Elf_Data	*data;
1897 	Is_desc		*isec;
1898 
1899 	/*
1900 	 * Allocate and initialize the Elf_Data structure.
1901 	 */
1902 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == 0)
1903 		return (S_ERROR);
1904 	data->d_type = ELF_T_BYTE;
1905 	data->d_size = size;
1906 	data->d_align = align;
1907 	data->d_version = ofl->ofl_libver;
1908 
1909 	/*
1910 	 * Allocate and initialize the Shdr structure.
1911 	 */
1912 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
1913 		return (S_ERROR);
1914 	shdr->sh_type = SHT_NOBITS;
1915 	shdr->sh_flags = SHF_ALLOC | SHF_WRITE;
1916 	shdr->sh_size = (Xword)size;
1917 	shdr->sh_addralign = align;
1918 
1919 	/*
1920 	 * Allocate and initialize the Is_desc structure.
1921 	 */
1922 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == 0)
1923 		return (S_ERROR);
1924 	isec->is_name = MSG_ORIG(MSG_SCN_SUNWBSS);
1925 	isec->is_shdr = shdr;
1926 	isec->is_indata = data;
1927 
1928 	/*
1929 	 * Retain this .sunwbss input section as this will be where global
1930 	 * symbol references are added.
1931 	 */
1932 	ofl->ofl_issunwbss = isec;
1933 	if (place_section(ofl, isec, 0, 0) == (Os_desc *)S_ERROR)
1934 		return (S_ERROR);
1935 
1936 	return (1);
1937 }
1938 
1939 /*
1940  * This routine is called when -z nopartial is in effect.
1941  */
1942 uintptr_t
1943 make_sunwdata(Ofl_desc *ofl, size_t size, Xword align)
1944 {
1945 	Shdr		*shdr;
1946 	Elf_Data	*data;
1947 	Is_desc		*isec;
1948 	Os_desc		*osp;
1949 
1950 	/*
1951 	 * Allocate and initialize the Elf_Data structure.
1952 	 */
1953 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == 0)
1954 		return (S_ERROR);
1955 	data->d_type = ELF_T_BYTE;
1956 	data->d_size = size;
1957 	if ((data->d_buf = libld_calloc(size, 1)) == 0)
1958 		return (S_ERROR);
1959 	data->d_align = (size_t)M_WORD_ALIGN;
1960 	data->d_version = ofl->ofl_libver;
1961 
1962 	/*
1963 	 * Allocate and initialize the Shdr structure.
1964 	 */
1965 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
1966 		return (S_ERROR);
1967 	shdr->sh_type = SHT_PROGBITS;
1968 	shdr->sh_flags = SHF_ALLOC | SHF_WRITE;
1969 	shdr->sh_size = (Xword)size;
1970 	if (align == 0)
1971 		shdr->sh_addralign = M_WORD_ALIGN;
1972 	else
1973 		shdr->sh_addralign = align;
1974 
1975 	/*
1976 	 * Allocate and initialize the Is_desc structure.
1977 	 */
1978 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == 0)
1979 		return (S_ERROR);
1980 	isec->is_name = MSG_ORIG(MSG_SCN_SUNWDATA1);
1981 	isec->is_shdr = shdr;
1982 	isec->is_indata = data;
1983 
1984 	/*
1985 	 * Retain this .sunwdata1 input section as this will
1986 	 * be where global
1987 	 * symbol references are added.
1988 	 */
1989 	ofl->ofl_issunwdata1 = isec;
1990 	if ((osp = place_section(ofl, isec, M_ID_DATA, 0)) ==
1991 	    (Os_desc *)S_ERROR)
1992 		return (S_ERROR);
1993 
1994 	if (!(osp->os_flags & FLG_OS_OUTREL)) {
1995 		ofl->ofl_dynshdrcnt++;
1996 		osp->os_flags |= FLG_OS_OUTREL;
1997 	}
1998 	return (1);
1999 }
2000 
2001 /*
2002  * Make .sunwmove section
2003  */
2004 uintptr_t
2005 make_sunwmove(Ofl_desc *ofl, int mv_nums)
2006 {
2007 	Shdr		*shdr;
2008 	Elf_Data	*data;
2009 	Is_desc		*isec;
2010 	size_t		size;
2011 	Listnode	*lnp1;
2012 	Psym_info	*psym;
2013 	int 		cnt = 1;
2014 
2015 	/*
2016 	 * Generate the move input sections and output sections
2017 	 */
2018 	size = mv_nums * sizeof (Move);
2019 
2020 	/*
2021 	 * Allocate and initialize the Elf_Data structure.
2022 	 */
2023 	if ((data = libld_calloc(sizeof (Elf_Data), 1)) == 0)
2024 		return (S_ERROR);
2025 	data->d_type = ELF_T_BYTE;
2026 	if ((data->d_buf = libld_calloc(size, 1)) == 0)
2027 		return (S_ERROR);
2028 	data->d_size = size;
2029 	data->d_align = sizeof (Lword);
2030 	data->d_version = ofl->ofl_libver;
2031 
2032 	/*
2033 	 * Allocate and initialize the Shdr structure.
2034 	 */
2035 	if ((shdr = libld_calloc(sizeof (Shdr), 1)) == 0)
2036 		return (S_ERROR);
2037 	shdr->sh_link = 0;
2038 	shdr->sh_info = 0;
2039 	shdr->sh_type = SHT_SUNW_move;
2040 	shdr->sh_size = (Xword)size;
2041 	shdr->sh_flags = SHF_ALLOC | SHF_WRITE;
2042 	shdr->sh_addralign = sizeof (Lword);
2043 	shdr->sh_entsize = sizeof (Move);
2044 
2045 	/*
2046 	 * Allocate and initialize the Is_desc structure.
2047 	 */
2048 	if ((isec = libld_calloc(1, sizeof (Is_desc))) == 0)
2049 		return (S_ERROR);
2050 	isec->is_name = MSG_ORIG(MSG_SCN_SUNWMOVE);
2051 	isec->is_shdr = shdr;
2052 	isec->is_indata = data;
2053 	isec->is_file = 0;
2054 
2055 	/*
2056 	 * Copy move entries
2057 	 */
2058 	for (LIST_TRAVERSE(&ofl->ofl_parsym, lnp1, psym)) {
2059 		Listnode *	lnp2;
2060 		Mv_itm *	mvitm;
2061 
2062 		if (psym->psym_symd->sd_flags & FLG_SY_PAREXPN)
2063 			continue;
2064 		for (LIST_TRAVERSE(&(psym->psym_mvs), lnp2, mvitm)) {
2065 			if ((mvitm->mv_flag & FLG_MV_OUTSECT) == 0)
2066 				continue;
2067 			mvitm->mv_oidx = cnt;
2068 			cnt++;
2069 		}
2070 	}
2071 	if ((ofl->ofl_osmove = place_section(ofl, isec, 0, 0)) ==
2072 	    (Os_desc *)S_ERROR)
2073 		return (S_ERROR);
2074 
2075 	return (1);
2076 }
2077 
2078 
2079 /*
2080  * The following sections are built after all input file processing and symbol
2081  * validation has been carried out.  The order is important (because the
2082  * addition of a section adds a new symbol there is a chicken and egg problem
2083  * of maintaining the appropriate counts).  By maintaining a known order the
2084  * individual routines can compensate for later, known, additions.
2085  */
2086 uintptr_t
2087 make_sections(Ofl_desc *ofl)
2088 {
2089 	Word		flags = ofl->ofl_flags;
2090 	Listnode	*lnp1;
2091 	Sg_desc		*sgp;
2092 
2093 	/*
2094 	 * Generate any special sections.
2095 	 */
2096 	if (flags & FLG_OF_ADDVERS)
2097 		if (make_comment(ofl) == S_ERROR)
2098 			return (S_ERROR);
2099 
2100 	if (make_interp(ofl) == S_ERROR)
2101 		return (S_ERROR);
2102 
2103 	if (make_cap(ofl) == S_ERROR)
2104 		return (S_ERROR);
2105 
2106 	if (make_array(ofl, SHT_INIT_ARRAY, MSG_ORIG(MSG_SCN_INITARRAY),
2107 	    &ofl->ofl_initarray) == S_ERROR)
2108 		return (S_ERROR);
2109 
2110 	if (make_array(ofl, SHT_FINI_ARRAY, MSG_ORIG(MSG_SCN_FINIARRAY),
2111 	    &ofl->ofl_finiarray) == S_ERROR)
2112 		return (S_ERROR);
2113 
2114 	if (make_array(ofl, SHT_PREINIT_ARRAY, MSG_ORIG(MSG_SCN_PREINITARRAY),
2115 	    &ofl->ofl_preiarray) == S_ERROR)
2116 		return (S_ERROR);
2117 
2118 	/*
2119 	 * Make the .plt section.  This occurs after any other relocation
2120 	 * sections are generated (see reloc_init()) to ensure that the
2121 	 * associated relocation section is after all the other relocation
2122 	 * sections.
2123 	 */
2124 	if ((ofl->ofl_pltcnt) || (ofl->ofl_pltpad))
2125 		if (make_plt(ofl) == S_ERROR)
2126 			return (S_ERROR);
2127 
2128 	if (ofl->ofl_flags1 & FLG_OF1_IGNPRC) {
2129 		if (ignore_section_processing(ofl) == S_ERROR)
2130 			return (S_ERROR);
2131 	}
2132 
2133 	/*
2134 	 * Add any necessary versioning information.
2135 	 */
2136 	if ((flags & (FLG_OF_VERNEED | FLG_OF_NOVERSEC)) == FLG_OF_VERNEED) {
2137 		if (make_verneed(ofl) == S_ERROR)
2138 			return (S_ERROR);
2139 	}
2140 	if ((flags & (FLG_OF_VERDEF | FLG_OF_NOVERSEC)) == FLG_OF_VERDEF) {
2141 		if (make_verdef(ofl) == S_ERROR)
2142 			return (S_ERROR);
2143 		if ((ofl->ofl_osversym = make_sym_sec(ofl,
2144 		    MSG_ORIG(MSG_SCN_SUNWVERSYM), sizeof (Versym),
2145 		    SHT_SUNW_versym, M_ID_VERSION)) == (Os_desc*)S_ERROR)
2146 			return (S_ERROR);
2147 	}
2148 
2149 	/*
2150 	 * Create a syminfo section is necessary.
2151 	 */
2152 	if (ofl->ofl_flags & FLG_OF_SYMINFO) {
2153 		if ((ofl->ofl_ossyminfo = make_sym_sec(ofl,
2154 		    MSG_ORIG(MSG_SCN_SUNWSYMINFO), sizeof (Syminfo),
2155 		    SHT_SUNW_syminfo, M_ID_SYMINFO)) == (Os_desc *)S_ERROR)
2156 			return (S_ERROR);
2157 	}
2158 
2159 	if (ofl->ofl_flags1 & FLG_OF1_RELCNT) {
2160 		/*
2161 		 * If -zcombreloc is enabled then all relocations (except for
2162 		 * the PLT's) are coalesced into a single relocation section.
2163 		 */
2164 		if (ofl->ofl_reloccnt) {
2165 			if (make_reloc(ofl, NULL) == S_ERROR)
2166 				return (S_ERROR);
2167 		}
2168 	} else {
2169 		size_t	reloc_size = 0;
2170 
2171 		/*
2172 		 * Create the required output relocation sections.
2173 		 */
2174 		for (LIST_TRAVERSE(&ofl->ofl_segs, lnp1, sgp)) {
2175 			Os_desc		*osp;
2176 			Listnode	*lnp2;
2177 
2178 			for (LIST_TRAVERSE(&(sgp->sg_osdescs), lnp2, osp)) {
2179 				if (osp->os_szoutrels &&
2180 				    (osp != ofl->ofl_osplt)) {
2181 					if (make_reloc(ofl, osp) == S_ERROR)
2182 						return (S_ERROR);
2183 					reloc_size += reloc_size;
2184 				}
2185 			}
2186 		}
2187 
2188 		/*
2189 		 * If we're not building a combined relocation section, then
2190 		 * build a .rel[a] section as required.
2191 		 */
2192 		if (ofl->ofl_relocrelsz) {
2193 			if (make_reloc(ofl, NULL) == S_ERROR)
2194 				return (S_ERROR);
2195 		}
2196 	}
2197 
2198 	/*
2199 	 * The PLT relocations are always in their own section, and we try to
2200 	 * keep them at the end of the PLT table.  We do this to keep the hot
2201 	 * "data" PLT's at the head of the table nearer the .dynsym & .hash.
2202 	 */
2203 	if (ofl->ofl_osplt && ofl->ofl_relocpltsz) {
2204 		if (make_reloc(ofl, ofl->ofl_osplt) == S_ERROR)
2205 			return (S_ERROR);
2206 	}
2207 
2208 	/*
2209 	 * Finally build the symbol and section header sections.
2210 	 */
2211 	if (flags & FLG_OF_DYNAMIC) {
2212 		if (make_dynamic(ofl) == S_ERROR)
2213 			return (S_ERROR);
2214 		if (make_dynstr(ofl) == S_ERROR)
2215 			return (S_ERROR);
2216 		/*
2217 		 * There is no use for .hash and .dynsym sections in a
2218 		 * relocatable object.
2219 		 */
2220 		if (!(flags & FLG_OF_RELOBJ)) {
2221 			if (make_hash(ofl) == S_ERROR)
2222 				return (S_ERROR);
2223 			if (make_dynsym(ofl) == S_ERROR)
2224 				return (S_ERROR);
2225 #if	(defined(__i386) || defined(__amd64)) && defined(_ELF64)
2226 			if (make_amd64_unwindhdr(ofl) == S_ERROR)
2227 				return (S_ERROR);
2228 #endif
2229 		}
2230 	}
2231 
2232 	if (!(flags & FLG_OF_STRIP) || (flags & FLG_OF_RELOBJ) ||
2233 	    ((flags & FLG_OF_STATIC) && ofl->ofl_osversym)) {
2234 		/*
2235 		 * Do we need to make a SHT_SYMTAB_SHNDX section
2236 		 * for the dynsym.  If so - do it now.
2237 		 */
2238 		if (ofl->ofl_osdynsym &&
2239 		    ((ofl->ofl_shdrcnt + 3) >= SHN_LORESERVE)) {
2240 			if (make_dynsym_shndx(ofl) == S_ERROR)
2241 				return (S_ERROR);
2242 		}
2243 
2244 		if (make_strtab(ofl) == S_ERROR)
2245 			return (S_ERROR);
2246 		if (make_symtab(ofl) == S_ERROR)
2247 			return (S_ERROR);
2248 	} else {
2249 		/*
2250 		 * Do we need to make a SHT_SYMTAB_SHNDX section
2251 		 * for the dynsym.  If so - do it now.
2252 		 */
2253 		if (ofl->ofl_osdynsym &&
2254 		    ((ofl->ofl_shdrcnt + 1) >= SHN_LORESERVE)) {
2255 			if (make_dynsym_shndx(ofl) == S_ERROR)
2256 				return (S_ERROR);
2257 		}
2258 	}
2259 
2260 	if (make_shstrtab(ofl) == S_ERROR)
2261 		return (S_ERROR);
2262 
2263 	/*
2264 	 * Now that we've created all of our sections adjust the size
2265 	 * of SHT_SUNW_versym & SHT_SUNW_syminfo which are dependent on
2266 	 * the symbol table sizes.
2267 	 */
2268 	if (ofl->ofl_osversym || ofl->ofl_ossyminfo) {
2269 		Shdr *		shdr;
2270 		Is_desc *	isec;
2271 		Elf_Data *	data;
2272 		size_t		size;
2273 		ulong_t		cnt;
2274 
2275 		if ((flags & FLG_OF_RELOBJ) || (flags & FLG_OF_STATIC))
2276 			isec = (Is_desc *)ofl->ofl_ossymtab->
2277 				os_isdescs.head->data;
2278 		else
2279 			isec = (Is_desc *)ofl->ofl_osdynsym->
2280 				os_isdescs.head->data;
2281 		cnt = isec->is_shdr->sh_size / isec->is_shdr->sh_entsize;
2282 
2283 		if (ofl->ofl_osversym) {
2284 			isec = (Is_desc *)ofl->ofl_osversym->os_isdescs.
2285 				head->data;
2286 			data = isec->is_indata;
2287 			shdr = ofl->ofl_osversym->os_shdr;
2288 			size = cnt * shdr->sh_entsize;
2289 			shdr->sh_size = (Xword)size;
2290 			data->d_size = size;
2291 		}
2292 		if (ofl->ofl_ossyminfo) {
2293 			isec = (Is_desc *)ofl->ofl_ossyminfo->os_isdescs.
2294 				head->data;
2295 			data = isec->is_indata;
2296 			shdr = ofl->ofl_ossyminfo->os_shdr;
2297 			size = cnt * shdr->sh_entsize;
2298 			shdr->sh_size = (Xword)size;
2299 			data->d_size = size;
2300 		}
2301 	}
2302 
2303 	return (1);
2304 }
2305