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