xref: /illumos-gate/usr/src/cmd/sgs/libld/common/place.c (revision a196c3ff)
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) 1991, 2010, Oracle and/or its affiliates. All rights reserved.
27  * Copyright (c) 2012, Joyent, Inc. All rights reserved.
28  */
29 
30 /*
31  * Map file parsing and input section to output segment mapping.
32  */
33 #include	<stdio.h>
34 #include	<string.h>
35 #include	<debug.h>
36 #include	"msg.h"
37 #include	"_libld.h"
38 
39 /*
40  * Each time a section is placed, the function set_addralign()
41  * is called.  This function performs:
42  *
43  * -	if the section is from an external file, check if this is empty or not.
44  *	If not, we know the segment this section will belong needs a program
45  *	header. (Of course, the program is needed only if this section falls
46  *	into a loadable segment.)
47  * -	compute the Least Common Multiplier for setting the segment alignment.
48  */
49 static void
set_addralign(Ofl_desc * ofl,Os_desc * osp,Is_desc * isp)50 set_addralign(Ofl_desc *ofl, Os_desc *osp, Is_desc *isp)
51 {
52 	Shdr	*shdr = isp->is_shdr;
53 
54 	/* A discarded section has no influence on the output */
55 	if (isp->is_flags & FLG_IS_DISCARD)
56 		return;
57 
58 	/*
59 	 * If this section has data or will be assigned data
60 	 * later, mark this segment not-empty.
61 	 */
62 	if ((shdr->sh_size != 0) ||
63 	    ((isp->is_flags & FLG_IS_EXTERNAL) == 0))
64 		osp->os_sgdesc->sg_flags |= FLG_SG_PHREQ;
65 
66 	if ((ofl->ofl_dtflags_1 & DF_1_NOHDR) &&
67 	    (osp->os_sgdesc->sg_phdr).p_type != PT_LOAD)
68 		return;
69 
70 	osp->os_sgdesc->sg_align =
71 	    ld_lcm(osp->os_sgdesc->sg_align, shdr->sh_addralign);
72 }
73 
74 /*
75  * Return the first input descriptor for a given output descriptor,
76  * or NULL if there are none.
77  */
78 
79 Is_desc *
ld_os_first_isdesc(Os_desc * osp)80 ld_os_first_isdesc(Os_desc *osp)
81 {
82 	int i;
83 
84 	for (i = 0; i < OS_ISD_NUM; i++) {
85 		APlist *ap_isdesc = osp->os_isdescs[i];
86 
87 		if (aplist_nitems(ap_isdesc) > 0)
88 			return ((Is_desc *)ap_isdesc->apl_data[0]);
89 	}
90 
91 	return (NULL);
92 }
93 
94 /*
95  * Attach an input section to an output section
96  *
97  * entry:
98  *	ofl - File descriptor
99  *	osp - Output section descriptor
100  *	isp - Input section descriptor
101  *	mapfile_sort - True (1) if segment supports mapfile specified ordering
102  *		of otherwise unordered input sections, and False (0) otherwise.
103  *
104  * exit:
105  *	- The input section has been attached to the output section
106  *	- If the input section is a candidate for string table merging,
107  *		then it is appended to the output section's list of merge
108  *		candidates (os_mstridescs).
109  *
110  *	On success, returns True (1). On failure, False (0).
111  */
112 static int
os_attach_isp(Ofl_desc * ofl,Os_desc * osp,Is_desc * isp,int mapfile_sort)113 os_attach_isp(Ofl_desc *ofl, Os_desc *osp, Is_desc *isp, int mapfile_sort)
114 {
115 	Aliste	init_arritems;
116 	int	os_isdescs_idx, do_append = 1;
117 
118 	if ((isp->is_flags & FLG_IS_ORDERED) == 0) {
119 		init_arritems = AL_CNT_OS_ISDESCS;
120 		os_isdescs_idx = OS_ISD_DEFAULT;
121 
122 		/*
123 		 * If section ordering was specified for an unordered section
124 		 * via the mapfile, then search in the OS_ISD_DEFAULT list
125 		 * and insert it in the specified position. Ordered sections
126 		 * are placed in ascending order before unordered sections
127 		 * (sections with an is_ordndx value of zero).
128 		 *
129 		 * If no mapfile ordering was specified, we append it in
130 		 * the usual way below.
131 		 */
132 		if (mapfile_sort && (isp->is_ordndx > 0)) {
133 			APlist *ap_isdesc = osp->os_isdescs[OS_ISD_DEFAULT];
134 			Aliste	idx2;
135 			Is_desc	*isp2;
136 
137 			for (APLIST_TRAVERSE(ap_isdesc, idx2, isp2)) {
138 				if (isp2->is_ordndx &&
139 				    (isp2->is_ordndx <= isp->is_ordndx))
140 						continue;
141 
142 				if (aplist_insert(
143 				    &osp->os_isdescs[OS_ISD_DEFAULT],
144 				    isp, init_arritems, idx2) == NULL)
145 					return (0);
146 				do_append = 0;
147 				break;
148 			}
149 		}
150 	} else {		/* Ordered section (via shdr flags) */
151 		Word shndx;
152 
153 		/* SHF_ORDERED uses sh_info, SHF_LINK_ORDERED uses sh_link */
154 		shndx = (isp->is_shdr->sh_flags & SHF_ORDERED) ?
155 		    isp->is_shdr->sh_info : isp->is_shdr->sh_link;
156 
157 		if (shndx == SHN_BEFORE) {
158 			init_arritems = AL_CNT_OS_ISDESCS_BA;
159 			os_isdescs_idx = OS_ISD_BEFORE;
160 		} else if (shndx == SHN_AFTER) {
161 			init_arritems = AL_CNT_OS_ISDESCS_BA;
162 			os_isdescs_idx = OS_ISD_AFTER;
163 		} else {
164 			init_arritems = AL_CNT_OS_ISDESCS;
165 			os_isdescs_idx = OS_ISD_ORDERED;
166 		}
167 	}
168 
169 	/*
170 	 * If we didn't insert a section into the default list using
171 	 * mapfile specified ordering above, then append the input
172 	 * section to the appropriate list.
173 	 */
174 	if (do_append && aplist_append(&(osp->os_isdescs[os_isdescs_idx]),
175 	    isp, init_arritems) == NULL)
176 		return (0);
177 	isp->is_osdesc = osp;
178 
179 	/*
180 	 * A section can be merged if the following are true:
181 	 * -	The SHF_MERGE|SHF_STRINGS flags must be set
182 	 * -	String table compression must not be disabled (-znocompstrtab)
183 	 * -	Mapfile ordering must not have been used.
184 	 * -	The section must not be ordered via section header flags.
185 	 * -	It must not be the generated section being built to
186 	 *	replace the sections on this list.
187 	 */
188 	if (((isp->is_shdr->sh_flags & (SHF_MERGE | SHF_STRINGS)) !=
189 	    (SHF_MERGE | SHF_STRINGS)) ||
190 	    ((ofl->ofl_flags1 & FLG_OF1_NCSTTAB) != 0) ||
191 	    !do_append ||
192 	    ((isp->is_flags & (FLG_IS_ORDERED | FLG_IS_GNSTRMRG)) != 0))
193 		return (1);
194 
195 	/*
196 	 * Skip sections with (sh_entsize > 1) or (sh_addralign > 1).
197 	 *
198 	 * sh_entsize:
199 	 *	We are currently only able to merge string tables containing
200 	 *	strings with 1-byte (char) characters. Support for wide
201 	 *	characters will require our string table compression code
202 	 *	to be extended to handle larger character sizes.
203 	 *
204 	 * sh_addralign:
205 	 *	Alignments greater than 1 would require our string table
206 	 *	compression code to insert null bytes to move each
207 	 *	string to the required alignment.
208 	 */
209 	if ((isp->is_shdr->sh_entsize > 1) ||
210 	    (isp->is_shdr->sh_addralign > 1)) {
211 		DBG_CALL(Dbg_sec_unsup_strmerge(ofl->ofl_lml, isp));
212 		return (1);
213 	}
214 
215 	if (aplist_append(&osp->os_mstrisdescs, isp,
216 	    AL_CNT_OS_MSTRISDESCS) == NULL)
217 		return (0);
218 
219 	/*
220 	 * The SHF_MERGE|SHF_STRINGS flags tell us that the program that
221 	 * created the section intended it to be mergeable. The
222 	 * FLG_IS_INSTRMRG flag says that we have done validity testing
223 	 * and decided that it is safe to act on that hint.
224 	 */
225 	isp->is_flags |= FLG_IS_INSTRMRG;
226 
227 	return (1);
228 }
229 
230 /*
231  * Determine whether this input COMDAT section already exists for the associated
232  * output section.  If so, then discard this input section.  Otherwise, this
233  * must be the first COMDAT section, thus it is kept for future comparisons.
234  */
235 static uintptr_t
add_comdat(Ofl_desc * ofl,Os_desc * osp,Is_desc * isp)236 add_comdat(Ofl_desc *ofl, Os_desc *osp, Is_desc *isp)
237 {
238 	Isd_node	isd, *isdp;
239 	avl_tree_t	*avlt;
240 	avl_index_t	where;
241 	Group_desc	*gr;
242 
243 	/*
244 	 * Sections to which COMDAT groups apply are FLG_IS_COMDAT but are
245 	 * discarded separately by the group logic so should never be
246 	 * discarded here.
247 	 */
248 	if ((isp->is_shdr->sh_flags & SHF_GROUP) &&
249 	    ((gr = ld_get_group(ofl, isp)) != NULL) &&
250 	    (gr->gd_data[0] & GRP_COMDAT))
251 		return (1);
252 
253 	/*
254 	 * Create a COMDAT avl tree for this output section if required.
255 	 */
256 	if ((avlt = osp->os_comdats) == NULL) {
257 		if ((avlt = libld_calloc(1, sizeof (avl_tree_t))) == NULL)
258 			return (S_ERROR);
259 		avl_create(avlt, isdavl_compare, sizeof (Isd_node),
260 		    SGSOFFSETOF(Isd_node, isd_avl));
261 		osp->os_comdats = avlt;
262 	}
263 
264 	/*
265 	 * A standard COMDAT section uses the section name as search key.
266 	 */
267 	isd.isd_name = isp->is_name;
268 	isd.isd_hash = sgs_str_hash(isd.isd_name);
269 
270 	if ((isdp = avl_find(avlt, &isd, &where)) != NULL) {
271 		isp->is_osdesc = osp;
272 
273 		/*
274 		 * If this section hasn't already been identified as discarded,
275 		 * generate a suitable diagnostic.
276 		 */
277 		if ((isp->is_flags & FLG_IS_DISCARD) == 0) {
278 			isp->is_flags |= FLG_IS_DISCARD;
279 			isp->is_comdatkeep = isdp->isd_isp;
280 			DBG_CALL(Dbg_sec_discarded(ofl->ofl_lml, isp,
281 			    isdp->isd_isp));
282 		}
283 
284 		/*
285 		 * A discarded section does not require assignment to an output
286 		 * section.  However, if relaxed relocations have been enabled
287 		 * (either from -z relaxreloc, or asserted with .gnu.linkonce
288 		 * processing), then this section must still be assigned to an
289 		 * output section so that the sloppy relocation logic will have
290 		 * the information necessary to do its work.
291 		 */
292 		return (0);
293 	}
294 
295 	/*
296 	 * This is a new COMDAT section - so keep it.
297 	 */
298 	if ((isdp = libld_calloc(1, sizeof (Isd_node))) == NULL)
299 		return (S_ERROR);
300 
301 	isdp->isd_name = isd.isd_name;
302 	isdp->isd_hash = isd.isd_hash;
303 	isdp->isd_isp = isp;
304 
305 	avl_insert(avlt, isdp, where);
306 	return (1);
307 }
308 
309 /*
310  * Determine whether a GNU group COMDAT section name follows the convention
311  *
312  *	section-name.symbol-name
313  *
314  * Each section within the input file is compared to see if the full section
315  * name matches the beginning of the COMDAT section, with a following '.'.
316  * A pointer to the symbol name, starting with the '.' is returned so that the
317  * caller can strip off the required section name.
318  */
319 static char *
gnu_comdat_sym(Ifl_desc * ifl,Is_desc * gisp)320 gnu_comdat_sym(Ifl_desc *ifl, Is_desc *gisp)
321 {
322 	size_t	ndx;
323 
324 	for (ndx = 1; ndx < ifl->ifl_shnum; ndx++) {
325 		Is_desc	*isp;
326 		size_t	ssize;
327 
328 		if (((isp = ifl->ifl_isdesc[ndx]) == NULL) ||
329 		    (isp == gisp) || (isp->is_name == NULL))
330 			continue;
331 
332 		/*
333 		 * It's questionable whether this size should be cached in the
334 		 * Is_desc.  However, this seems an infrequent operation and
335 		 * adding Is_desc members can escalate memory usage for large
336 		 * link-edits.  For now, size the section name dynamically.
337 		 */
338 		ssize = strlen(isp->is_name);
339 		if ((strncmp(isp->is_name, gisp->is_name, ssize) == 0) &&
340 		    (gisp->is_name[ssize] == '.'))
341 			return ((char *)&gisp->is_name[ssize]);
342 	}
343 	return (NULL);
344 }
345 
346 /*
347  * GNU .gnu.linkonce sections follow a naming convention that indicates the
348  * required association with an output section.  Determine whether this input
349  * section follows the convention, and if so return the appropriate output
350  * section name.
351  *
352  *	.gnu.linkonce.b.*    ->	.bss
353  *	.gnu.linkonce.d.*    ->	.data
354  *	.gnu.linkonce.l.*    ->	.ldata
355  *	.gnu.linkonce.lb.*   ->	.lbss
356  *	.gnu.linkonce.lr.*   ->	.lrodata
357  *	.gnu.linkonce.r.*    ->	.rodata
358  *	.gnu.linkonce.s.*    ->	.sdata
359  *	.gnu.linkonce.s2.*   ->	.sdata2
360  *	.gnu.linkonce.sb.*   ->	.sbss
361  *	.gnu.linkonce.sb2.*  ->	.sbss2
362  *	.gnu.linkonce.t.*    ->	.text
363  *	.gnu.linkonce.tb.*   ->	.tbss
364  *	.gnu.linkonce.td.*   ->	.tdata
365  *	.gnu.linkonce.wi.*   ->	.debug_info
366  */
367 #define	NSTR_CH1(ch) (*(nstr + 1) == (ch))
368 #define	NSTR_CH2(ch) (*(nstr + 2) == (ch))
369 #define	NSTR_CH3(ch) (*(nstr + 3) == (ch))
370 
371 static const char *
gnu_linkonce_sec(const char * ostr)372 gnu_linkonce_sec(const char *ostr)
373 {
374 	const char	*nstr = &ostr[MSG_SCN_GNU_LINKONCE_SIZE];
375 
376 	switch (*nstr) {
377 	case 'b':
378 		if (NSTR_CH1('.'))
379 			return (MSG_ORIG(MSG_SCN_BSS));
380 		break;
381 	case 'd':
382 		if (NSTR_CH1('.'))
383 			return (MSG_ORIG(MSG_SCN_DATA));
384 		break;
385 	case 'l':
386 		if (NSTR_CH1('.'))
387 			return (MSG_ORIG(MSG_SCN_LDATA));
388 		else if (NSTR_CH1('b') && NSTR_CH2('.'))
389 			return (MSG_ORIG(MSG_SCN_LBSS));
390 		else if (NSTR_CH1('r') && NSTR_CH2('.'))
391 			return (MSG_ORIG(MSG_SCN_LRODATA));
392 		break;
393 	case 'r':
394 		if (NSTR_CH1('.'))
395 			return (MSG_ORIG(MSG_SCN_RODATA));
396 		break;
397 	case 's':
398 		if (NSTR_CH1('.'))
399 			return (MSG_ORIG(MSG_SCN_SDATA));
400 		else if (NSTR_CH1('2') && NSTR_CH2('.'))
401 			return (MSG_ORIG(MSG_SCN_SDATA2));
402 		else if (NSTR_CH1('b') && NSTR_CH2('.'))
403 			return (MSG_ORIG(MSG_SCN_SBSS));
404 		else if (NSTR_CH1('b') && NSTR_CH2('2') && NSTR_CH3('.'))
405 			return (MSG_ORIG(MSG_SCN_SBSS2));
406 		break;
407 	case 't':
408 		if (NSTR_CH1('.'))
409 			return (MSG_ORIG(MSG_SCN_TEXT));
410 		else if (NSTR_CH1('b') && NSTR_CH2('.'))
411 			return (MSG_ORIG(MSG_SCN_TBSS));
412 		else if (NSTR_CH1('d') && NSTR_CH2('.'))
413 			return (MSG_ORIG(MSG_SCN_TDATA));
414 		break;
415 	case 'w':
416 		if (NSTR_CH1('i') && NSTR_CH2('.'))
417 			return (MSG_ORIG(MSG_SCN_DEBUG_INFO));
418 		break;
419 	default:
420 		break;
421 	}
422 
423 	/*
424 	 * No special name match found.
425 	 */
426 	return (ostr);
427 }
428 #undef	NSTR_CH1
429 #undef	NSTR_CH2
430 #undef	NSTR_CH3
431 
432 /*
433  * The GNU link-editor maps sections generated by the GNU compiler separately
434  * due to -ffunction-sections, -fdata-sections or for other reasons into the
435  * "normal" section represented.
436  *
437  * Sections are named .<main>.<symbol> where <main> is the usual section to
438  * which it should be mapped, and <symbol> is providing the unique name for
439  * the original section.  Both parts of the name may contain periods, in cases
440  * where the unique part of the name contains a '.' and/or the section it
441  * contributes to does (such as .data.rel.ro)
442  *
443  * .rodata.str* and .rodata.cst* are mapped to .rodata.
444  *
445  * As a further complication, the GNU link-editor may or may not merge
446  * .ctors.* and .dtors.* into init_array and fini_array, rather than ctors and
447  * dtors.  We do not implement this at this time.
448  *
449  * The GNU link editor may also arrange for sections with .local in their name
450  * to be mapped as above, but grouped together.  We do not implement this (and
451  * do not merge them at all, to make this clear)
452  *
453  * This table is processed in order.  Longer mappings must come first.
454  */
455 static struct split_sec_mapping {
456 	char *leader;
457 	char *section;
458 	boolean_t precise;
459 } split_sec_mapping[] = {
460 	{ ".bss.",			".bss",			B_FALSE },
461 	{ ".ctors.",			".ctors",		B_FALSE },
462 	{ ".data.rel.local.",		".data.rel.local",	B_FALSE },
463 	{ ".data.rel.local",		".data.rel.local",	B_TRUE },
464 	{ ".data.rel.ro.local.",	".data.rel.ro",		B_FALSE },
465 	{ ".data.rel.ro.",		".data.rel.ro",		B_FALSE },
466 	{ ".data.rel.ro",		".data.rel.ro",		B_TRUE },
467 	{ ".data.rel.",			".data.rel",		B_FALSE },
468 	{ ".data.rel",			".data.rel",		B_TRUE },
469 	{ ".data.",			".data",		B_FALSE },
470 	{ ".dtors.",			".dtors",		B_FALSE },
471 	{ ".fini_array.",		".fini_array",		B_FALSE },
472 	{ ".init_array.",		".init_array",		B_FALSE },
473 	{ ".lbss.",			".lbss",		B_FALSE },
474 	{ ".ldata.",			".ldata",		B_FALSE },
475 	{ ".lrodata.",			".lrodata",		B_FALSE },
476 	/* This intentionally applies to .rodata.cstN and .rodata.strN, too */
477 	{ ".rodata.",			".rodata",		B_FALSE },
478 	{ ".sbss2.",			".sbss2",		B_FALSE },
479 	{ ".sbss.",			".sbss",		B_FALSE },
480 	{ ".sdata2.",			".sdata2",		B_FALSE },
481 	{ ".sdata.",			".sdata",		B_FALSE },
482 	{ ".tbss.",			".tbss",		B_FALSE },
483 	{ ".tdata.",			".tdata",		B_FALSE },
484 	{ ".text.",			".text",		B_FALSE },
485 	{ NULL,				NULL,			B_FALSE }
486 };
487 
488 static const char *
gnu_split_sec(const char * ostr)489 gnu_split_sec(const char *ostr)
490 {
491 	struct split_sec_mapping *mp;
492 
493 	for (mp = split_sec_mapping; mp->leader != NULL; mp++) {
494 		if (mp->precise) {
495 			if (strcmp(ostr, mp->leader) == 0)
496 				return (mp->section);
497 		} else if (strncmp(ostr, mp->leader, strlen(mp->leader)) == 0) {
498 			return (mp->section);
499 		}
500 	}
501 
502 	return (ostr);
503 }
504 
505 /*
506  * Initialize a path info buffer for use with ld_place_section().
507  *
508  * entry:
509  *	ofl - Output descriptor
510  *	ifl - Descriptor for input file, or NULL if there is none.
511  *	info - Address of buffer to be initialized.
512  *
513  * exit:
514  *	If this is an input file, and if the entrance criteria list
515  *	contains at least one criteria that has a non-empty file string
516  *	match list (ec_files), then the block pointed at by info is
517  *	initialized, and info is returned.
518  *
519  *	If there is no input file, and/or no entrance criteria containing
520  *	a non-empty ec_files list, then NULL is returned. This is not
521  *	an error --- the NULL is simply an optimization, understood by
522  *	ld_place_path(), that allows it to skip unnecessary work.
523  */
524 Place_path_info *
ld_place_path_info_init(Ofl_desc * ofl,Ifl_desc * ifl,Place_path_info * info)525 ld_place_path_info_init(Ofl_desc *ofl, Ifl_desc *ifl, Place_path_info *info)
526 {
527 	/*
528 	 * Return NULL if there is no input file (internally generated section)
529 	 * or if the entrance criteria list does not contain any items that will
530 	 * need to be compared to the path (all the ec_files lists are empty).
531 	 */
532 	if ((ifl == NULL) || !(ofl->ofl_flags & FLG_OF_EC_FILES))
533 		return (NULL);
534 
535 	info->ppi_path = ifl->ifl_name;
536 	info->ppi_path_len = strlen(info->ppi_path);
537 	info->ppi_isar = (ifl->ifl_flags & FLG_IF_EXTRACT) != 0;
538 
539 	/*
540 	 * The basename is the final segment of the path, equivalent to
541 	 * the path itself if there are no '/' delimiters.
542 	 */
543 	info->ppi_bname = strrchr(info->ppi_path, '/');
544 	if (info->ppi_bname == NULL)
545 		info->ppi_bname = info->ppi_path;
546 	else
547 		info->ppi_bname++;	/* Skip leading '/' */
548 	info->ppi_bname_len =
549 	    info->ppi_path_len - (info->ppi_bname - info->ppi_path);
550 
551 	/*
552 	 * For an archive, the object name is the member name, which is
553 	 * enclosed in () at the end of the name string. Otherwise, it is
554 	 * the same as the basename.
555 	 */
556 	if (info->ppi_isar) {
557 		info->ppi_oname = strrchr(info->ppi_bname, '(');
558 		/* There must be an archive member suffix delimited by parens */
559 		assert((info->ppi_bname[info->ppi_bname_len - 1] == ')') &&
560 		    (info->ppi_oname != NULL));
561 		info->ppi_oname++;	/* skip leading '(' */
562 		info->ppi_oname_len = info->ppi_bname_len -
563 		    (info->ppi_oname - info->ppi_bname + 1);
564 	} else {
565 		info->ppi_oname = info->ppi_bname;
566 		info->ppi_oname_len = info->ppi_bname_len;
567 	}
568 
569 	return (info);
570 }
571 
572 /*
573  * Compare an input section path to the file comparison list the given
574  * entrance criteria.
575  *
576  * entry:
577  *	path_info - A non-NULL Place_path_info block for the file
578  *		containing the input section, initialized by
579  *		ld_place_path_info_init()
580  *	enp - Entrance criteria with a non-empty ec_files list of file
581  *		comparisons to be carried out.
582  *
583  * exit:
584  *	Return TRUE if a match is seen, and FALSE otherwise.
585  */
586 static Boolean
eval_ec_files(Place_path_info * path_info,Ent_desc * enp)587 eval_ec_files(Place_path_info *path_info, Ent_desc *enp)
588 {
589 	Aliste		idx;
590 	Ent_desc_file	*edfp;
591 	size_t		cmp_len;
592 	const char	*cmp_str;
593 
594 	for (ALIST_TRAVERSE(enp->ec_files, idx, edfp)) {
595 		Word	type = edfp->edf_flags & TYP_ECF_MASK;
596 
597 		/*
598 		 * Determine the starting character, and # of characters,
599 		 * from the file path to compare against this entrance criteria
600 		 * file string.
601 		 */
602 		if (type == TYP_ECF_OBJNAME) {
603 			cmp_str = path_info->ppi_oname;
604 			cmp_len = path_info->ppi_oname_len;
605 		} else {
606 			int ar_stat_diff = path_info->ppi_isar !=
607 			    ((edfp->edf_flags & FLG_ECF_ARMEMBER) != 0);
608 
609 			/*
610 			 * If the entrance criteria specifies an archive member
611 			 * and the file does not, then there can be no match.
612 			 */
613 
614 			if (ar_stat_diff && !path_info->ppi_isar)
615 				continue;
616 
617 			if (type == TYP_ECF_PATH) {
618 				cmp_str = path_info->ppi_path;
619 				cmp_len = path_info->ppi_path_len;
620 			} else {	/* TYP_ECF_BASENAME */
621 				cmp_str = path_info->ppi_bname;
622 				cmp_len = path_info->ppi_bname_len;
623 			}
624 
625 			/*
626 			 * If the entrance criteria does not specify an archive
627 			 * member and the file does, then a match just requires
628 			 * the paths (without the archive member) to match.
629 			 * Reduce the length to not include the ar member or
630 			 * the '(' that precedes it.
631 			 */
632 			if (ar_stat_diff && path_info->ppi_isar)
633 				cmp_len = path_info->ppi_oname - cmp_str - 1;
634 		}
635 
636 		/*
637 		 * Compare the resulting string to the one from the
638 		 * entrance criteria.
639 		 */
640 		if ((cmp_len == edfp->edf_name_len) &&
641 		    (strncmp(edfp->edf_name, cmp_str, cmp_len) == 0))
642 			return (TRUE);
643 	}
644 
645 	return (FALSE);
646 }
647 
648 /*
649  * Replace the section header for the given input section with a new section
650  * header of the specified type. All values in the replacement header other
651  * than the type retain their previous values.
652  *
653  * entry:
654  *	isp - Input section to replace
655  *	sh_type - New section type to apply
656  *
657  * exit:
658  *	Returns the pointer to the new section header on success, and
659  *	NULL for failure.
660  */
661 static Shdr *
isp_convert_type(Is_desc * isp,Word sh_type)662 isp_convert_type(Is_desc *isp, Word sh_type)
663 {
664 	Shdr	*shdr;
665 
666 	if ((shdr = libld_malloc(sizeof (Shdr))) == NULL)
667 		return (NULL);
668 	*shdr = *isp->is_shdr;
669 	isp->is_shdr = shdr;
670 	shdr->sh_type = sh_type;
671 	return (shdr);
672 }
673 
674 /*
675  * Issue a fatal warning for the given .eh_frame section, which
676  * cannot be merged with the existing .eh_frame output section.
677  */
678 static void
eh_frame_muldef(Ofl_desc * ofl,Is_desc * isp)679 eh_frame_muldef(Ofl_desc *ofl, Is_desc *isp)
680 {
681 	Sg_desc	*sgp;
682 	Is_desc *isp1;
683 	Os_desc	*osp;
684 	Aliste	idx1, idx2, idx3;
685 
686 	/*
687 	 * Locate the .eh_frame output section, and use the first section
688 	 * assigned to it in the error message. The user can then compare
689 	 * the two sections to determine what attribute prevented the merge.
690 	 */
691 	for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
692 		for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
693 			if ((osp->os_flags & FLG_OS_EHFRAME) == 0)
694 				continue;
695 
696 			for (idx3 = 0; idx3 < OS_ISD_NUM; idx3++) {
697 				APlist *lst = osp->os_isdescs[idx3];
698 
699 				if (aplist_nitems(lst) == 0)
700 					continue;
701 
702 				isp1 = lst->apl_data[0];
703 				ld_eprintf(ofl, ERR_FATAL,
704 				    MSG_INTL(MSG_UPD_MULEHFRAME),
705 				    isp1->is_file->ifl_name,
706 				    EC_WORD(isp1->is_scnndx), isp1->is_name,
707 				    isp->is_file->ifl_name,
708 				    EC_WORD(isp->is_scnndx), isp->is_name);
709 				return;
710 			}
711 		}
712 	}
713 }
714 
715 /*
716  * Place a section into the appropriate segment and output section.
717  *
718  * entry:
719  *	ofl - File descriptor
720  *	isp - Input section descriptor of section to be placed.
721  *	path_info - NULL, or pointer to Place_path_info buffer initialized
722  *		by ld_place_path_info_init() for the file associated to isp,
723  *		for use in processing entrance criteria with non-empty
724  *		file matching string list (ec_files)
725  *	ident - Section identifier, used to order sections relative to
726  *		others within the output segment.
727  *	alt_os_name - If non-NULL, the name of the output section to place
728  *		isp into. If NULL, input sections go to an output section
729  *		with the same name as the input section.
730  */
731 Os_desc *
ld_place_section(Ofl_desc * ofl,Is_desc * isp,Place_path_info * path_info,int ident,const char * alt_os_name)732 ld_place_section(Ofl_desc *ofl, Is_desc *isp, Place_path_info *path_info,
733     int ident, const char *alt_os_name)
734 {
735 	Ent_desc	*enp;
736 	Sg_desc		*sgp;
737 	Os_desc		*osp;
738 	Aliste		idx1, iidx;
739 	int		os_ndx;
740 	Shdr		*shdr = isp->is_shdr;
741 	Xword		shflagmask, shflags = shdr->sh_flags;
742 	Ifl_desc	*ifl = isp->is_file;
743 	char		*oname, *sname;
744 	uint_t		onamehash;
745 	Boolean		is_ehframe = (isp->is_flags & FLG_IS_EHFRAME) != 0;
746 
747 	/*
748 	 * Define any sections that must be thought of as referenced.  These
749 	 * sections may not be referenced externally in a manner ld(1) can
750 	 * discover, but they must be retained (ie. not removed by -zignore).
751 	 */
752 	static const Msg RefSecs[] = {
753 		MSG_SCN_INIT,		/* MSG_ORIG(MSG_SCN_INIT) */
754 		MSG_SCN_FINI,		/* MSG_ORIG(MSG_SCN_FINI) */
755 		MSG_SCN_EX_RANGES,	/* MSG_ORIG(MSG_SCN_EX_RANGES) */
756 		MSG_SCN_EX_SHARED,	/* MSG_ORIG(MSG_SCN_EX_SHARED) */
757 		MSG_SCN_CTORS,		/* MSG_ORIG(MSG_SCN_CTORS) */
758 		MSG_SCN_DTORS,		/* MSG_ORIG(MSG_SCN_DTORS) */
759 		MSG_SCN_EHFRAME,	/* MSG_ORIG(MSG_SCN_EHFRAME) */
760 		MSG_SCN_EHFRAME_HDR,	/* MSG_ORIG(MSG_SCN_EHFRAME_HDR) */
761 		MSG_SCN_JCR,		/* MSG_ORIG(MSG_SCN_JCR) */
762 		MSG_SCN_INITARRAY,	/* MSG_ORIG(MSG_SCN_INITARRAY) */
763 		MSG_SCN_FINIARRAY,	/* MSG_ORIG(MSG_SCN_FINIARRAY) */
764 		MSG_SCN_PREINITARRAY,	/* MSG_ORIG(MSG_SCN_PREINITARRAY) */
765 		0
766 	};
767 
768 	DBG_CALL(Dbg_sec_in(ofl->ofl_lml, isp));
769 
770 	/*
771 	 * If this section identifies group members, or this section indicates
772 	 * that it is a member of a group, determine whether the section is
773 	 * still required.
774 	 */
775 	if ((shflags & SHF_GROUP) || (shdr->sh_type == SHT_GROUP)) {
776 		Group_desc	*gdesc;
777 
778 		if ((gdesc = ld_get_group(ofl, isp)) != NULL) {
779 			DBG_CALL(Dbg_sec_group(ofl->ofl_lml, isp, gdesc));
780 
781 			/*
782 			 * If this group has been replaced by another group,
783 			 * then this section needs to be discarded.
784 			 */
785 			if (gdesc->gd_oisc) {
786 				isp->is_flags |= FLG_IS_DISCARD;
787 
788 				/*
789 				 * Since we're discarding the section, we
790 				 * can skip assigning it to an output section.
791 				 * The exception is that if the user
792 				 * specifies -z relaxreloc, then
793 				 * we need to assign the output section so
794 				 * that the sloppy relocation logic will have
795 				 * the information necessary to do its work.
796 				 */
797 				if (!(ofl->ofl_flags1 & FLG_OF1_RLXREL))
798 					return (NULL);
799 			}
800 		}
801 
802 		/*
803 		 * SHT_GROUP sections can only be included into relocatable
804 		 * objects.
805 		 */
806 		if (shdr->sh_type == SHT_GROUP) {
807 			if ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) {
808 				isp->is_flags |= FLG_IS_DISCARD;
809 				return (NULL);
810 			}
811 		}
812 	}
813 
814 	/*
815 	 * Always assign SHF_TLS sections to the DATA segment (and then the
816 	 * PT_TLS embedded inside of there).
817 	 */
818 	if (shflags & SHF_TLS)
819 		shflags |= SHF_WRITE;
820 
821 	/*
822 	 * Traverse the entrance criteria list searching for a segment that
823 	 * matches the input section we have.  If an entrance criterion is set
824 	 * then there must be an exact match.  If we complete the loop without
825 	 * finding a segment, then sgp will be NULL.
826 	 */
827 	sgp = NULL;
828 	for (APLIST_TRAVERSE(ofl->ofl_ents, idx1, enp)) {
829 
830 		/* Disabled segments are not available for assignment */
831 		if (enp->ec_segment->sg_flags & FLG_SG_DISABLED)
832 			continue;
833 
834 		/*
835 		 * If an entrance criteria doesn't have any of its fields
836 		 * set, it will match any section it is tested against.
837 		 * We set the FLG_EC_CATCHALL flag on these, primarily because
838 		 * it helps readers of our debug output to understand what
839 		 * the criteria means --- otherwise the user would just see
840 		 * that every field is 0, but might not understand the
841 		 * significance of that.
842 		 *
843 		 * Given that we set this flag, we can use it here as an
844 		 * optimization to short circuit all of the tests in this
845 		 * loop. Note however, that if we did not do this, the end
846 		 * result would be the same --- the empty criteria will sail
847 		 * past the following tests and reach the end of the loop.
848 		 */
849 		if (enp->ec_flags & FLG_EC_CATCHALL) {
850 			sgp = enp->ec_segment;
851 			break;
852 		}
853 
854 		if (enp->ec_type && (enp->ec_type != shdr->sh_type))
855 			continue;
856 		if (enp->ec_attrmask &&
857 		    /* LINTED */
858 		    (enp->ec_attrmask & enp->ec_attrbits) !=
859 		    (enp->ec_attrmask & shflags))
860 			continue;
861 		if (enp->ec_is_name &&
862 		    (strcmp(enp->ec_is_name, isp->is_name) != 0))
863 			continue;
864 
865 		if ((alist_nitems(enp->ec_files) > 0) &&
866 		    ((path_info == NULL) || !eval_ec_files(path_info, enp)))
867 			continue;
868 
869 		/* All entrance criteria tests passed */
870 		sgp = enp->ec_segment;
871 		break;
872 	}
873 
874 	/*
875 	 * The final entrance criteria record is a FLG_EC_CATCHALL that points
876 	 * at the final predefined segment "extra", and this final segment is
877 	 * tagged FLG_SG_NODISABLE. Therefore, the above loop must always find
878 	 * a segment.
879 	 */
880 	assert(sgp != NULL);
881 
882 	/*
883 	 * Transfer the input section sorting key from the entrance criteria
884 	 * to the input section. A non-zero value means that the section
885 	 * will be sorted on this key amoung the other sections that have a
886 	 * non-zero key. These sorted sections are collectively placed at the
887 	 * head of the output section.
888 	 *
889 	 * If the sort key is 0, the section is placed after the sorted
890 	 * sections in the order they are encountered.
891 	 */
892 	isp->is_ordndx = enp->ec_ordndx;
893 
894 	/* Remember that this entrance criteria has placed a section */
895 	enp->ec_flags |= FLG_EC_USED;
896 
897 	/*
898 	 * If our caller has supplied an alternative name for the output
899 	 * section, then we defer to their request. Otherwise, the default
900 	 * is to use the same name as that of the input section being placed.
901 	 *
902 	 * The COMDAT, SHT_GROUP and GNU name translations that follow have
903 	 * the potential to alter this initial name.
904 	 */
905 	oname = (char *)((alt_os_name == NULL) ? isp->is_name : alt_os_name);
906 
907 	/*
908 	 * Solaris section names may follow the convention:
909 	 *
910 	 *	section-name%symbol-name
911 	 *
912 	 * This convention has been used to order the layout of sections within
913 	 * segments for objects built with the compilers -xF option.  However,
914 	 * the final object should not contain individual section headers for
915 	 * all such input sections, instead the symbol name is stripped from the
916 	 * name to establish the final output section name.
917 	 *
918 	 * This convention has also been followed for COMDAT and sections
919 	 * identified though SHT_GROUP data.
920 	 *
921 	 * Strip out the % from the section name for:
922 	 *	- Non-relocatable objects
923 	 *	- Relocatable objects if input section sorting is
924 	 *	  in force for the segment in question.
925 	 */
926 	if (((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) ||
927 	    (sgp->sg_flags & FLG_SG_IS_ORDER)) {
928 		if ((sname = strchr(isp->is_name, '%')) != NULL) {
929 			size_t	size = sname - isp->is_name;
930 
931 			if ((oname = libld_malloc(size + 1)) == NULL)
932 				return ((Os_desc *)S_ERROR);
933 			(void) strncpy(oname, isp->is_name, size);
934 			oname[size] = '\0';
935 			DBG_CALL(Dbg_sec_redirected(ofl->ofl_lml, isp, oname));
936 		}
937 	}
938 
939 	/*
940 	 * When building relocatable objects, we must not redirect COMDAT
941 	 * section names into their outputs, such that our output object may
942 	 * be successfully used as an input object also requiring COMDAT
943 	 * processing
944 	 */
945 
946 	/*
947 	 * GNU section names may follow the convention:
948 	 *
949 	 *	.gnu.linkonce.*
950 	 *
951 	 * The .gnu.linkonce is a section naming convention that indicates a
952 	 * COMDAT requirement.  Determine whether this section follows the GNU
953 	 * pattern, and if so, determine whether this section should be
954 	 * discarded or retained.  The comparison of is_name[1] with 'g'
955 	 * is an optimization to skip using strncmp() too much. This is safe,
956 	 * because we know the name is not NULL, and therefore must have
957 	 * at least one character plus a NULL termination.
958 	 */
959 	if ((isp->is_name == oname) && (isp->is_name[1] == 'g') &&
960 	    (strncmp(MSG_ORIG(MSG_SCN_GNU_LINKONCE), isp->is_name,
961 	    MSG_SCN_GNU_LINKONCE_SIZE) == 0)) {
962 		if ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) {
963 			if ((oname = (char *)gnu_linkonce_sec(isp->is_name)) !=
964 			    isp->is_name) {
965 				DBG_CALL(Dbg_sec_redirected(ofl->ofl_lml, isp,
966 				    oname));
967 			}
968 		}
969 
970 		/*
971 		 * Explicitly identify this section type as COMDAT.  Also,
972 		 * enable relaxed relocation processing, as this is typically
973 		 * a requirement with .gnu.linkonce sections.
974 		 */
975 		isp->is_flags |= FLG_IS_COMDAT;
976 		if ((ofl->ofl_flags1 & FLG_OF1_NRLXREL) == 0)
977 			ofl->ofl_flags1 |= FLG_OF1_RLXREL;
978 		DBG_CALL(Dbg_sec_gnu_comdat(ofl->ofl_lml, isp, TRUE,
979 		    (ofl->ofl_flags1 & FLG_OF1_RLXREL) != 0));
980 	}
981 
982 	/*
983 	 * GNU section names may also follow the convention:
984 	 *
985 	 *	section-name.symbol-name
986 	 *
987 	 * This convention is used when defining SHT_GROUP sections of type
988 	 * COMDAT.  Thus, any group processing will have discovered any group
989 	 * sections, and this identification can be triggered by a pattern
990 	 * match section names.
991 	 */
992 	if ((isp->is_name == oname) && (isp->is_flags & FLG_IS_COMDAT) &&
993 	    ((sname = gnu_comdat_sym(ifl, isp)) != NULL)) {
994 		size_t	size = sname - isp->is_name;
995 
996 		if ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) {
997 			if ((oname = libld_malloc(size + 1)) == NULL)
998 				return ((Os_desc *)S_ERROR);
999 			(void) strncpy(oname, isp->is_name, size);
1000 			oname[size] = '\0';
1001 			DBG_CALL(Dbg_sec_redirected(ofl->ofl_lml, isp, oname));
1002 		}
1003 
1004 		/*
1005 		 * Enable relaxed relocation processing, as this is
1006 		 * typically a requirement with GNU COMDAT sections.
1007 		 */
1008 		if ((ofl->ofl_flags1 & FLG_OF1_NRLXREL) == 0) {
1009 			ofl->ofl_flags1 |= FLG_OF1_RLXREL;
1010 			DBG_CALL(Dbg_sec_gnu_comdat(ofl->ofl_lml, isp,
1011 			    FALSE, TRUE));
1012 		}
1013 	}
1014 
1015 	/*
1016 	 * GNU section names named section-name.symbol-name which are not
1017 	 * members of COMDAT groups are merged according to the behaviour of
1018 	 * the GNU link-editor.
1019 	 *
1020 	 * See the description of gnu_split_sec().
1021 	 */
1022 	if (((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) &&
1023 	    (isp->is_name == oname) &&
1024 	    ((oname = (char *)gnu_split_sec(oname)) != isp->is_name)) {
1025 		DBG_CALL(Dbg_sec_redirected(ofl->ofl_lml, isp, oname));
1026 	}
1027 
1028 	/*
1029 	 * Assign a hash value now that the output section name has been
1030 	 * finalized.
1031 	 */
1032 	onamehash = sgs_str_hash(oname);
1033 
1034 	/*
1035 	 * Determine if output section ordering is turned on. If so, return
1036 	 * the appropriate ordering index for the section. This information
1037 	 * is derived from the Sg_desc->sg_os_order list that was built
1038 	 * up from the Mapfile.
1039 	 *
1040 	 * A value of 0 for os_ndx means that the section is not sorted
1041 	 * (i.e. is not found in the sg_os_order). The items in sg_os_order
1042 	 * are in the desired sort order, so adding 1 to their alist index
1043 	 * gives a suitable index for sorting.
1044 	 */
1045 	os_ndx = 0;
1046 	if (alist_nitems(sgp->sg_os_order) > 0) {
1047 		Sec_order	*scop;
1048 
1049 		for (ALIST_TRAVERSE(sgp->sg_os_order, idx1, scop)) {
1050 			if (strcmp(scop->sco_secname, oname) == 0) {
1051 				scop->sco_flags |= FLG_SGO_USED;
1052 				os_ndx = idx1 + 1;
1053 				break;
1054 			}
1055 		}
1056 	}
1057 
1058 	/*
1059 	 * Mask of section header flags to ignore when matching sections. We
1060 	 * are more strict with relocatable objects, ignoring only the order
1061 	 * flags, and keeping sections apart if they differ otherwise. This
1062 	 * follows the policy that sections in a relative object should only
1063 	 * be merged if their flags are the same, and avoids destroying
1064 	 * information prematurely. For final products however, we ignore all
1065 	 * flags that do not prevent a merge.
1066 	 */
1067 	shflagmask =
1068 	    (ofl->ofl_flags & FLG_OF_RELOBJ) ? ALL_SHF_ORDER : ALL_SHF_IGNORE;
1069 
1070 	/*
1071 	 * Traverse the input section list for the output section we have been
1072 	 * assigned. If we find a matching section simply add this new section.
1073 	 */
1074 	iidx = 0;
1075 	for (APLIST_TRAVERSE(sgp->sg_osdescs, idx1, osp)) {
1076 		Shdr	*os_shdr = osp->os_shdr;
1077 
1078 		/*
1079 		 * An input section matches an output section if:
1080 		 * -	The ident values match
1081 		 * -	The names match
1082 		 * -	Not a GROUP section
1083 		 * -	Not a GROUP member, if producing a relocatable object
1084 		 * -	Not a DTrace dof section
1085 		 * -	Section types match
1086 		 * -	Matching section flags, after screening out the
1087 		 *	shflagmask flags.
1088 		 *
1089 		 * Section types are considered to match if any one of
1090 		 * the following are true:
1091 		 * -	The type codes are the same
1092 		 * -	Both are .eh_frame sections (regardless of type code)
1093 		 * -	The input section is COMDAT, and the output section
1094 		 *	is SHT_PROGBITS.
1095 		 */
1096 		if ((ident == osp->os_identndx) &&
1097 		    (ident != ld_targ.t_id.id_rel) &&
1098 		    (onamehash == osp->os_namehash) &&
1099 		    (shdr->sh_type != SHT_GROUP) &&
1100 		    (((shdr->sh_flags & SHF_GROUP) == 0) ||
1101 		    ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0)) &&
1102 		    (shdr->sh_type != SHT_SUNW_dof) &&
1103 		    ((shdr->sh_type == os_shdr->sh_type) ||
1104 		    (is_ehframe && (osp->os_flags & FLG_OS_EHFRAME)) ||
1105 		    ((shdr->sh_type == SHT_SUNW_COMDAT) &&
1106 		    (os_shdr->sh_type == SHT_PROGBITS))) &&
1107 		    ((shflags & ~shflagmask) ==
1108 		    (os_shdr->sh_flags & ~shflagmask)) &&
1109 		    (strcmp(oname, osp->os_name) == 0)) {
1110 			uintptr_t	err;
1111 
1112 			/*
1113 			 * Process any COMDAT section, keeping the first and
1114 			 * discarding all others.
1115 			 */
1116 			if ((isp->is_flags & FLG_IS_COMDAT) &&
1117 			    ((err = add_comdat(ofl, osp, isp)) != 1))
1118 				return ((Os_desc *)err);
1119 
1120 			/*
1121 			 * Set alignment
1122 			 */
1123 			set_addralign(ofl, osp, isp);
1124 
1125 			/*
1126 			 * If this section is a non-empty TLS section indicate
1127 			 * that a PT_TLS program header is required.
1128 			 */
1129 			if ((shflags & SHF_TLS) && shdr->sh_size &&
1130 			    ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0))
1131 				ofl->ofl_flags |= FLG_OF_TLSPHDR;
1132 
1133 			/*
1134 			 * Insert the input section descriptor on the proper
1135 			 * output section descriptor list.
1136 			 *
1137 			 * If this segment requires input section ordering,
1138 			 * honor any mapfile specified ordering for otherwise
1139 			 * unordered sections by setting the mapfile_sort
1140 			 * argument of os_attach_isp() to True.
1141 			 */
1142 
1143 			if (os_attach_isp(ofl, osp, isp,
1144 			    (sgp->sg_flags & FLG_SG_IS_ORDER) != 0) == 0)
1145 				return ((Os_desc *)S_ERROR);
1146 
1147 			/*
1148 			 * If this input section and file is associated to an
1149 			 * artificially referenced output section, make sure
1150 			 * they are marked as referenced also. This ensures
1151 			 * that this input section and file isn't eliminated
1152 			 * when -zignore is in effect.
1153 			 *
1154 			 * See -zignore comments when creating a new output
1155 			 * section below.
1156 			 */
1157 			if (((ifl &&
1158 			    (ifl->ifl_flags & FLG_IF_IGNORE)) || DBG_ENABLED) &&
1159 			    (osp->os_flags & FLG_OS_SECTREF)) {
1160 				isp->is_flags |= FLG_IS_SECTREF;
1161 				if (ifl)
1162 					ifl->ifl_flags |= FLG_IF_FILEREF;
1163 			}
1164 
1165 			DBG_CALL(Dbg_sec_added(ofl->ofl_lml, osp, sgp));
1166 			return (osp);
1167 		}
1168 
1169 		/*
1170 		 * Do we need to worry about section ordering?
1171 		 */
1172 		if (os_ndx) {
1173 			if (osp->os_ordndx) {
1174 				if (os_ndx < osp->os_ordndx)
1175 					/* insert section here. */
1176 					break;
1177 				else {
1178 					iidx = idx1 + 1;
1179 					continue;
1180 				}
1181 			} else {
1182 				/* insert section here. */
1183 				break;
1184 			}
1185 		} else if (osp->os_ordndx) {
1186 			iidx = idx1 + 1;
1187 			continue;
1188 		}
1189 
1190 		/*
1191 		 * If the new sections identifier is less than that of the
1192 		 * present input section we need to insert the new section
1193 		 * at this point.
1194 		 */
1195 		if (ident < osp->os_identndx)
1196 			break;
1197 
1198 		iidx = idx1 + 1;
1199 	}
1200 
1201 	/*
1202 	 * We are adding a new output section.  Update the section header
1203 	 * count and associated string size.
1204 	 *
1205 	 * If the input section triggering this output section has been marked
1206 	 * for discard, and if no other non-discarded input section comes along
1207 	 * to join it, then we will over count. We cannot know if this will
1208 	 * happen or not until all input is seen. Set FLG_OF_AJDOSCNT to
1209 	 * trigger a final count readjustment.
1210 	 */
1211 	if (isp->is_flags & FLG_IS_DISCARD)
1212 		ofl->ofl_flags |= FLG_OF_ADJOSCNT;
1213 	ofl->ofl_shdrcnt++;
1214 	if (st_insert(ofl->ofl_shdrsttab, oname) == -1)
1215 		return ((Os_desc *)S_ERROR);
1216 
1217 	/*
1218 	 * Create a new output section descriptor.
1219 	 */
1220 	if ((osp = libld_calloc(1, sizeof (Os_desc))) == NULL)
1221 		return ((Os_desc *)S_ERROR);
1222 	if ((osp->os_shdr = libld_calloc(1, sizeof (Shdr))) == NULL)
1223 		return ((Os_desc *)S_ERROR);
1224 
1225 	/*
1226 	 * Convert COMDAT section to PROGBITS as this the first section of the
1227 	 * output section.  Save any COMDAT section for later processing, as
1228 	 * additional COMDAT sections that match this section need discarding.
1229 	 */
1230 	if ((shdr->sh_type == SHT_SUNW_COMDAT) &&
1231 	    ((shdr = isp_convert_type(isp, SHT_PROGBITS)) == NULL))
1232 		return ((Os_desc *)S_ERROR);
1233 	if ((isp->is_flags & FLG_IS_COMDAT) &&
1234 	    (add_comdat(ofl, osp, isp) == S_ERROR))
1235 		return ((Os_desc *)S_ERROR);
1236 
1237 	if (is_ehframe) {
1238 		/*
1239 		 * Executable or sharable objects can have at most a single
1240 		 * .eh_frame section. Detect attempts to create more than
1241 		 * one. This occurs if the input sections have incompatible
1242 		 * attributes.
1243 		 */
1244 		if ((ofl->ofl_flags & FLG_OF_EHFRAME) &&
1245 		    !(ofl->ofl_flags & FLG_OF_RELOBJ)) {
1246 			eh_frame_muldef(ofl, isp);
1247 			return ((Os_desc *)S_ERROR);
1248 		}
1249 		ofl->ofl_flags |= FLG_OF_EHFRAME;
1250 
1251 		/*
1252 		 * For .eh_frame sections, we always set the type to be the
1253 		 * type specified by the ABI.  This allows .eh_frame sections
1254 		 * of type SHT_PROGBITS to be correctly merged with .eh_frame
1255 		 * sections of the ABI-defined type (e.g. SHT_AMD64_UNWIND),
1256 		 * with the output being of the ABI-defined type.
1257 		 */
1258 		osp->os_shdr->sh_type = ld_targ.t_m.m_sht_unwind;
1259 	} else {
1260 		osp->os_shdr->sh_type = shdr->sh_type;
1261 	}
1262 
1263 	osp->os_shdr->sh_flags = shdr->sh_flags;
1264 	osp->os_shdr->sh_entsize = shdr->sh_entsize;
1265 	osp->os_name = oname;
1266 	osp->os_namehash = onamehash;
1267 	osp->os_ordndx = os_ndx;
1268 	osp->os_sgdesc = sgp;
1269 	if (is_ehframe)
1270 		osp->os_flags |= FLG_OS_EHFRAME;
1271 
1272 	if (ifl && (shdr->sh_type == SHT_PROGBITS)) {
1273 		/*
1274 		 * Try to preserve the intended meaning of sh_link/sh_info.
1275 		 * See the translate_link() in update.c.
1276 		 */
1277 		osp->os_shdr->sh_link = shdr->sh_link;
1278 		if (shdr->sh_flags & SHF_INFO_LINK)
1279 			osp->os_shdr->sh_info = shdr->sh_info;
1280 	}
1281 
1282 	/*
1283 	 * When -zignore is in effect, user supplied sections and files that are
1284 	 * not referenced from other sections, are eliminated from the object
1285 	 * being produced.  Some sections, although unreferenced, are special,
1286 	 * and must not be eliminated.  Determine if this new output section is
1287 	 * one of those special sections, and if so mark it artificially as
1288 	 * referenced.  Any input section and file associated to this output
1289 	 * section is also be marked as referenced, and thus won't be eliminated
1290 	 * from the final output.
1291 	 */
1292 	if (ifl && ((ofl->ofl_flags1 & FLG_OF1_IGNPRC) || DBG_ENABLED)) {
1293 		const Msg	*refsec;
1294 
1295 		for (refsec = RefSecs; *refsec; refsec++) {
1296 			if (strcmp(osp->os_name, MSG_ORIG(*refsec)) == 0) {
1297 				osp->os_flags |= FLG_OS_SECTREF;
1298 
1299 				if ((ifl->ifl_flags & FLG_IF_IGNORE) ||
1300 				    DBG_ENABLED) {
1301 					isp->is_flags |= FLG_IS_SECTREF;
1302 					ifl->ifl_flags |= FLG_IF_FILEREF;
1303 				}
1304 				break;
1305 			}
1306 		}
1307 	}
1308 
1309 	/*
1310 	 * Sections of type SHT_GROUP are added to the ofl->ofl_osgroups list,
1311 	 * so that they can be updated as a group later.
1312 	 */
1313 	if ((shdr->sh_type == SHT_GROUP) &&
1314 	    ((isp->is_flags & FLG_IS_DISCARD) == 0) &&
1315 	    (aplist_append(&ofl->ofl_osgroups, osp,
1316 	    AL_CNT_OFL_OSGROUPS) == NULL))
1317 		return ((Os_desc *)S_ERROR);
1318 
1319 	/*
1320 	 * If this section is a non-empty TLS section indicate that a PT_TLS
1321 	 * program header is required.
1322 	 */
1323 	if ((shflags & SHF_TLS) && shdr->sh_size &&
1324 	    ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0))
1325 		ofl->ofl_flags |= FLG_OF_TLSPHDR;
1326 
1327 	/*
1328 	 * If a non-allocatable section is going to be put into a loadable
1329 	 * segment then turn on the allocate bit for this section and warn the
1330 	 * user that we have done so.  This could only happen through the use
1331 	 * of a mapfile.
1332 	 */
1333 	if ((sgp->sg_phdr.p_type == PT_LOAD) &&
1334 	    ((osp->os_shdr->sh_flags & SHF_ALLOC) == 0)) {
1335 		ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SCN_NONALLOC),
1336 		    ofl->ofl_name, osp->os_name, sgp->sg_name);
1337 		osp->os_shdr->sh_flags |= SHF_ALLOC;
1338 	}
1339 
1340 	/*
1341 	 * Retain this sections identifier for future comparisons when placing
1342 	 * a section (after all sections have been processed this variable will
1343 	 * be used to hold the sections symbol index as we don't need to retain
1344 	 * the identifier any more).
1345 	 */
1346 	osp->os_identndx = ident;
1347 
1348 	/*
1349 	 * Set alignment.
1350 	 */
1351 	set_addralign(ofl, osp, isp);
1352 
1353 	if (os_attach_isp(ofl, osp, isp, 0) == 0)
1354 		return ((Os_desc *)S_ERROR);
1355 
1356 	DBG_CALL(Dbg_sec_created(ofl->ofl_lml, osp, sgp));
1357 
1358 	/*
1359 	 * Insert the new section at the offset given by iidx.  If no position
1360 	 * for it was identified above, this will be index 0, causing the new
1361 	 * section to be prepended to the beginning of the section list.
1362 	 * Otherwise, it is the index following the section that was identified.
1363 	 */
1364 	if (aplist_insert(&sgp->sg_osdescs, osp, AL_CNT_SG_OSDESC,
1365 	    iidx) == NULL)
1366 		return ((Os_desc *)S_ERROR);
1367 	return (osp);
1368 }
1369