xref: /titanic_50/usr/src/cmd/sgs/libld/common/files.c (revision 7932179448259e425d93162dedd251930575d83e)
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 (c) 2012, Joyent, Inc. All rights reserved.
28  */
29 
30 /*
31  * Processing of relocatable objects and shared objects.
32  */
33 
34 #define	ELF_TARGET_AMD64
35 #define	ELF_TARGET_SPARC
36 
37 #include	<stdio.h>
38 #include	<string.h>
39 #include	<fcntl.h>
40 #include	<unistd.h>
41 #include	<link.h>
42 #include	<limits.h>
43 #include	<sys/stat.h>
44 #include	<sys/systeminfo.h>
45 #include	<debug.h>
46 #include	<msg.h>
47 #include	<_libld.h>
48 
49 /*
50  * Decide if we can link against this input file.
51  */
52 static int
53 ifl_verify(Ehdr *ehdr, Ofl_desc *ofl, Rej_desc *rej)
54 {
55 	/*
56 	 * Check the validity of the elf header information for compatibility
57 	 * with this machine and our own internal elf library.
58 	 */
59 	if ((ehdr->e_machine != ld_targ.t_m.m_mach) &&
60 	    ((ehdr->e_machine != ld_targ.t_m.m_machplus) &&
61 	    ((ehdr->e_flags & ld_targ.t_m.m_flagsplus) == 0))) {
62 		rej->rej_type = SGS_REJ_MACH;
63 		rej->rej_info = (uint_t)ehdr->e_machine;
64 		return (0);
65 	}
66 	if (ehdr->e_ident[EI_DATA] != ld_targ.t_m.m_data) {
67 		rej->rej_type = SGS_REJ_DATA;
68 		rej->rej_info = (uint_t)ehdr->e_ident[EI_DATA];
69 		return (0);
70 	}
71 	if (ehdr->e_version > ofl->ofl_dehdr->e_version) {
72 		rej->rej_type = SGS_REJ_VERSION;
73 		rej->rej_info = (uint_t)ehdr->e_version;
74 		return (0);
75 	}
76 	return (1);
77 }
78 
79 /*
80  * Check sanity of file header and allocate an infile descriptor
81  * for the file being processed.
82  */
83 static Ifl_desc *
84 ifl_setup(const char *name, Ehdr *ehdr, Elf *elf, Word flags, Ofl_desc *ofl,
85     Rej_desc *rej)
86 {
87 	Ifl_desc	*ifl;
88 	Rej_desc	_rej = { 0 };
89 
90 	if (ifl_verify(ehdr, ofl, &_rej) == 0) {
91 		_rej.rej_name = name;
92 		DBG_CALL(Dbg_file_rejected(ofl->ofl_lml, &_rej,
93 		    ld_targ.t_m.m_mach));
94 		if (rej->rej_type == 0) {
95 			*rej = _rej;
96 			rej->rej_name = strdup(_rej.rej_name);
97 		}
98 		return (0);
99 	}
100 
101 	if ((ifl = libld_calloc(1, sizeof (Ifl_desc))) == NULL)
102 		return ((Ifl_desc *)S_ERROR);
103 	ifl->ifl_name = name;
104 	ifl->ifl_ehdr = ehdr;
105 	ifl->ifl_elf = elf;
106 	ifl->ifl_flags = flags;
107 
108 	/*
109 	 * Is this file using 'extended Section Indexes'.  If so, use the
110 	 * e_shnum & e_shstrndx which can be found at:
111 	 *
112 	 *	e_shnum == Shdr[0].sh_size
113 	 *	e_shstrndx == Shdr[0].sh_link
114 	 */
115 	if ((ehdr->e_shnum == 0) && (ehdr->e_shoff != 0)) {
116 		Elf_Scn	*scn;
117 		Shdr	*shdr0;
118 
119 		if ((scn = elf_getscn(elf, 0)) == NULL) {
120 			ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_GETSCN),
121 			    name);
122 			return ((Ifl_desc *)S_ERROR);
123 		}
124 		if ((shdr0 = elf_getshdr(scn)) == NULL) {
125 			ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_GETSHDR),
126 			    name);
127 			return ((Ifl_desc *)S_ERROR);
128 		}
129 		ifl->ifl_shnum = (Word)shdr0->sh_size;
130 		if (ehdr->e_shstrndx == SHN_XINDEX)
131 			ifl->ifl_shstrndx = shdr0->sh_link;
132 		else
133 			ifl->ifl_shstrndx = ehdr->e_shstrndx;
134 	} else {
135 		ifl->ifl_shnum = ehdr->e_shnum;
136 		ifl->ifl_shstrndx = ehdr->e_shstrndx;
137 	}
138 
139 	if ((ifl->ifl_isdesc = libld_calloc(ifl->ifl_shnum,
140 	    sizeof (Is_desc *))) == NULL)
141 		return ((Ifl_desc *)S_ERROR);
142 
143 	/*
144 	 * Record this new input file on the shared object or relocatable
145 	 * object input file list.
146 	 */
147 	if (ifl->ifl_ehdr->e_type == ET_DYN) {
148 		if (aplist_append(&ofl->ofl_sos, ifl, AL_CNT_OFL_LIBS) == NULL)
149 			return ((Ifl_desc *)S_ERROR);
150 	} else {
151 		if (aplist_append(&ofl->ofl_objs, ifl, AL_CNT_OFL_OBJS) == NULL)
152 			return ((Ifl_desc *)S_ERROR);
153 	}
154 
155 	return (ifl);
156 }
157 
158 /*
159  * Process a generic section.  The appropriate section information is added
160  * to the files input descriptor list.
161  */
162 static uintptr_t
163 process_section(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn,
164     Word ndx, int ident, Ofl_desc *ofl)
165 {
166 	Is_desc	*isp;
167 
168 	/*
169 	 * Create a new input section descriptor.  If this is a NOBITS
170 	 * section elf_getdata() will still create a data buffer (the buffer
171 	 * will be null and the size will reflect the actual memory size).
172 	 */
173 	if ((isp = libld_calloc(sizeof (Is_desc), 1)) == NULL)
174 		return (S_ERROR);
175 	isp->is_shdr = shdr;
176 	isp->is_file = ifl;
177 	isp->is_name = name;
178 	isp->is_scnndx = ndx;
179 	isp->is_flags = FLG_IS_EXTERNAL;
180 	isp->is_keyident = ident;
181 
182 	if ((isp->is_indata = elf_getdata(scn, NULL)) == NULL) {
183 		ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_GETDATA),
184 		    ifl->ifl_name);
185 		return (0);
186 	}
187 
188 	if ((shdr->sh_flags & SHF_EXCLUDE) &&
189 	    ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0)) {
190 		isp->is_flags |= FLG_IS_DISCARD;
191 	}
192 
193 	/*
194 	 * Add the new input section to the files input section list and
195 	 * flag whether the section needs placing in an output section.  This
196 	 * placement is deferred until all input section processing has been
197 	 * completed, as SHT_GROUP sections can provide information that will
198 	 * affect how other sections within the file should be placed.
199 	 */
200 	ifl->ifl_isdesc[ndx] = isp;
201 
202 	if (ident) {
203 		if (shdr->sh_flags & ALL_SHF_ORDER) {
204 			isp->is_flags |= FLG_IS_ORDERED;
205 			ifl->ifl_flags |= FLG_IF_ORDERED;
206 		}
207 		isp->is_flags |= FLG_IS_PLACE;
208 	}
209 	return (1);
210 }
211 
212 /*
213  * Determine the software capabilities of the object being built from the
214  * capabilities of the input relocatable objects.   One software capability
215  * is presently recognized, and represented with the following (sys/elf.h):
216  *
217  *   SF1_SUNW_FPKNWN	use/non-use of frame pointer is known, and
218  *   SF1_SUNW_FPUSED    the frame pointer is in use.
219  *
220  * The resolution of the present fame pointer state, and the capabilities
221  * provided by a new input relocatable object are:
222  *
223  *                              new input relocatable object
224  *
225  *      present      |  SF1_SUNW_FPKNWN  |  SF1_SUNW_FPKNWN  |    <unknown>
226  *       state       |  SF1_SUNW_FPUSED  |                   |
227  *  ---------------------------------------------------------------------------
228  *  SF1_SUNW_FPKNWN  |  SF1_SUNW_FPKNWN  |  SF1_SUNW_FPKNWN  |  SF1_SUNW_FPKNWN
229  *  SF1_SUNW_FPUSED  |  SF1_SUNW_FPUSED  |                   |  SF1_SUNW_FPUSED
230  *  ---------------------------------------------------------------------------
231  *  SF1_SUNW_FPKNWN  |  SF1_SUNW_FPKNWN  |  SF1_SUNW_FPKNWN  |  SF1_SUNW_FPKNWN
232  *                   |                   |                   |
233  *  ---------------------------------------------------------------------------
234  *     <unknown>     |  SF1_SUNW_FPKNWN  |  SF1_SUNW_FPKNWN  |    <unknown>
235  *                   |  SF1_SUNW_FPUSED  |                   |
236  */
237 static void
238 sf1_cap(Ofl_desc *ofl, Xword val, Ifl_desc *ifl, Is_desc *cisp)
239 {
240 #define	FP_FLAGS	(SF1_SUNW_FPKNWN | SF1_SUNW_FPUSED)
241 
242 	Xword	badval;
243 
244 	/*
245 	 * If a mapfile has established definitions to override any object
246 	 * capabilities, ignore any new object capabilities.
247 	 */
248 	if (ofl->ofl_flags1 & FLG_OF1_OVSFCAP1) {
249 		DBG_CALL(Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_IGNORED,
250 		    CA_SUNW_SF_1, val, ld_targ.t_m.m_mach));
251 		return;
252 	}
253 
254 #if	!defined(_ELF64)
255 	if (ifl && (ifl->ifl_ehdr->e_type == ET_REL)) {
256 		/*
257 		 * The SF1_SUNW_ADDR32 is only meaningful when building a 64-bit
258 		 * object.  Warn the user, and remove the setting, if we're
259 		 * building a 32-bit object.
260 		 */
261 		if (val & SF1_SUNW_ADDR32) {
262 			ld_eprintf(ofl, ERR_WARNING,
263 			    MSG_INTL(MSG_FIL_INADDR32SF1), ifl->ifl_name,
264 			    EC_WORD(cisp->is_scnndx), cisp->is_name);
265 			val &= ~SF1_SUNW_ADDR32;
266 		}
267 	}
268 #endif
269 	/*
270 	 * If this object doesn't specify any capabilities, ignore it, and
271 	 * leave the state as is.
272 	 */
273 	if (val == 0)
274 		return;
275 
276 	/*
277 	 * Make sure we only accept known software capabilities.  Note, that
278 	 * an F1_SUNW_FPUSED by itself is viewed as bad practice.
279 	 */
280 	if ((badval = (val & ~SF1_SUNW_MASK)) != 0) {
281 		ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_FIL_BADSF1),
282 		    ifl->ifl_name, EC_WORD(cisp->is_scnndx), cisp->is_name,
283 		    EC_XWORD(badval));
284 		val &= SF1_SUNW_MASK;
285 	}
286 	if ((val & FP_FLAGS) == SF1_SUNW_FPUSED) {
287 		ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_FIL_BADSF1),
288 		    ifl->ifl_name, EC_WORD(cisp->is_scnndx), cisp->is_name,
289 		    EC_XWORD(val));
290 		return;
291 	}
292 
293 	/*
294 	 * If the input file is not a relocatable object, then we're only here
295 	 * to warn the user of any questionable capabilities.
296 	 */
297 	if (ifl->ifl_ehdr->e_type != ET_REL) {
298 #if	defined(_ELF64)
299 		/*
300 		 * If we're building a 64-bit executable, and we come across a
301 		 * dependency that requires a restricted address space, then
302 		 * that dependencies requirement can only be satisfied if the
303 		 * executable triggers the restricted address space.  This is a
304 		 * warning rather than a fatal error, as the possibility exists
305 		 * that an appropriate dependency will be provided at runtime.
306 		 * The runtime linker will refuse to use this dependency.
307 		 */
308 		if ((val & SF1_SUNW_ADDR32) && (ofl->ofl_flags & FLG_OF_EXEC) &&
309 		    ((ofl->ofl_ocapset.oc_sf_1.cm_val &
310 		    SF1_SUNW_ADDR32) == 0)) {
311 			ld_eprintf(ofl, ERR_WARNING,
312 			    MSG_INTL(MSG_FIL_EXADDR32SF1), ifl->ifl_name,
313 			    EC_WORD(cisp->is_scnndx), cisp->is_name);
314 		}
315 #endif
316 		return;
317 	}
318 
319 	if (DBG_ENABLED) {
320 		Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_CURRENT, CA_SUNW_SF_1,
321 		    ofl->ofl_ocapset.oc_sf_1.cm_val, ld_targ.t_m.m_mach);
322 		Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_NEW, CA_SUNW_SF_1,
323 		    val, ld_targ.t_m.m_mach);
324 	}
325 
326 	/*
327 	 * Determine the resolution of the present frame pointer and the
328 	 * new input relocatable objects frame pointer.
329 	 */
330 	if ((ofl->ofl_ocapset.oc_sf_1.cm_val & FP_FLAGS) == FP_FLAGS) {
331 		/*
332 		 * If the new relocatable object isn't using a frame pointer,
333 		 * reduce the present state to unused.
334 		 */
335 		if ((val & FP_FLAGS) != FP_FLAGS)
336 			ofl->ofl_ocapset.oc_sf_1.cm_val &= ~SF1_SUNW_FPUSED;
337 
338 		/*
339 		 * Having processed the frame pointer bits, remove them from
340 		 * the value so they don't get OR'd in below.
341 		 */
342 		val &= ~FP_FLAGS;
343 
344 	} else if ((ofl->ofl_ocapset.oc_sf_1.cm_val & SF1_SUNW_FPKNWN) == 0) {
345 		/*
346 		 * If the present frame pointer state is unknown, mask it out
347 		 * and allow the values from the new relocatable object
348 		 * to overwrite them.
349 		 */
350 		ofl->ofl_ocapset.oc_sf_1.cm_val &= ~FP_FLAGS;
351 	} else {
352 		/* Do not take the frame pointer flags from the object */
353 		val &= ~FP_FLAGS;
354 	}
355 
356 	ofl->ofl_ocapset.oc_sf_1.cm_val |= val;
357 
358 	DBG_CALL(Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_RESOLVED,
359 	    CA_SUNW_SF_1, ofl->ofl_ocapset.oc_sf_1.cm_val, ld_targ.t_m.m_mach));
360 
361 #undef FP_FLAGS
362 }
363 
364 /*
365  * Determine the hardware capabilities of the object being built from the
366  * capabilities of the input relocatable objects.  There's really little to
367  * do here, other than to offer diagnostics, hardware capabilities are simply
368  * additive.
369  */
370 static void
371 hw_cap(Ofl_desc *ofl, Xword tag, Xword val)
372 {
373 	elfcap_mask_t	*hwcap;
374 	ofl_flag_t	flags1;
375 
376 	if (tag == CA_SUNW_HW_1) {
377 		hwcap = &ofl->ofl_ocapset.oc_hw_1.cm_val;
378 		flags1 = FLG_OF1_OVHWCAP1;
379 	} else {
380 		hwcap = &ofl->ofl_ocapset.oc_hw_2.cm_val;
381 		flags1 = FLG_OF1_OVHWCAP2;
382 	}
383 
384 	/*
385 	 * If a mapfile has established definitions to override any object
386 	 * capabilities, ignore any new object capabilities.
387 	 */
388 	if (ofl->ofl_flags1 & flags1) {
389 		DBG_CALL(Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_IGNORED,
390 		    tag, val, ld_targ.t_m.m_mach));
391 		return;
392 	}
393 
394 	/*
395 	 * If this object doesn't specify any capabilities, ignore it, and
396 	 * leave the state as is.
397 	 */
398 	if (val == 0)
399 		return;
400 
401 	if (DBG_ENABLED) {
402 		Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_CURRENT, CA_SUNW_HW_1,
403 		    ofl->ofl_ocapset.oc_hw_1.cm_val, ld_targ.t_m.m_mach);
404 		Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_NEW, CA_SUNW_HW_1,
405 		    val, ld_targ.t_m.m_mach);
406 	}
407 
408 	*hwcap |= val;
409 
410 	DBG_CALL(Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_RESOLVED, tag,
411 	    *hwcap, ld_targ.t_m.m_mach));
412 }
413 
414 /*
415  * Promote a machine capability or platform capability to the output file.
416  * Multiple instances of these names can be defined.
417  */
418 static void
419 str_cap(Ofl_desc *ofl, char *pstr, ofl_flag_t flags, Xword tag, Caplist *list)
420 {
421 	Capstr		*capstr;
422 	Aliste		idx;
423 	Boolean		found = FALSE;
424 
425 	/*
426 	 * If a mapfile has established definitions to override this capability,
427 	 * ignore any new capability.
428 	 */
429 	if (ofl->ofl_flags1 & flags) {
430 		DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml, DBG_STATE_IGNORED,
431 		    tag, pstr));
432 		return;
433 	}
434 
435 	for (ALIST_TRAVERSE(list->cl_val, idx, capstr)) {
436 		DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml,
437 		    DBG_STATE_CURRENT, tag, capstr->cs_str));
438 		if (strcmp(capstr->cs_str, pstr) == 0)
439 			found = TRUE;
440 	}
441 
442 	DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml, DBG_STATE_NEW, tag, pstr));
443 
444 	if (found == FALSE) {
445 		if ((capstr = alist_append(&list->cl_val, NULL,
446 		    sizeof (Capstr), AL_CNT_CAP_NAMES)) == NULL) {
447 			ofl->ofl_flags |= FLG_OF_FATAL;
448 			return;
449 		}
450 		capstr->cs_str = pstr;
451 	}
452 
453 	if (DBG_ENABLED) {
454 		for (ALIST_TRAVERSE(list->cl_val, idx, capstr)) {
455 			DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml,
456 			    DBG_STATE_RESOLVED, tag, capstr->cs_str));
457 		}
458 	}
459 }
460 
461 /*
462  * Promote a capability identifier to the output file.  A capability group can
463  * only have one identifier, and thus only the first identifier seen from any
464  * input relocatable objects is retained.  An explicit user defined identifier,
465  * rather than an an identifier fabricated by ld(1) with -z symbcap processing,
466  * takes precedence.  Note, a user may have defined an identifier via a mapfile,
467  * in which case the mapfile identifier is retained.
468  */
469 static void
470 id_cap(Ofl_desc *ofl, char *pstr, oc_flag_t flags)
471 {
472 	Objcapset	*ocapset = &ofl->ofl_ocapset;
473 
474 	if (ocapset->oc_id.cs_str) {
475 		DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml, DBG_STATE_CURRENT,
476 		    CA_SUNW_ID, ocapset->oc_id.cs_str));
477 
478 		if ((ocapset->oc_flags & FLG_OCS_USRDEFID) ||
479 		    ((flags & FLG_OCS_USRDEFID) == 0)) {
480 			DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml,
481 			    DBG_STATE_IGNORED, CA_SUNW_ID, pstr));
482 			return;
483 		}
484 	}
485 
486 	DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml, DBG_STATE_NEW,
487 	    CA_SUNW_ID, pstr));
488 
489 	ocapset->oc_id.cs_str = pstr;
490 	ocapset->oc_flags |= flags;
491 
492 	DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml, DBG_STATE_RESOLVED,
493 	    CA_SUNW_ID, pstr));
494 }
495 
496 /*
497  * Promote a capabilities group to the object capabilities.  This catches a
498  * corner case.  An object capabilities file can be converted to symbol
499  * capabilities with -z symbolcap.  However, if the user has indicated that all
500  * the symbols should be demoted, we'd be left with a symbol capabilities file,
501  * with no associated symbols.  Catch this case by promoting the symbol
502  * capabilities back to object capabilities.
503  */
504 void
505 ld_cap_move_symtoobj(Ofl_desc *ofl)
506 {
507 	Cap_group	*cgp;
508 	Aliste		idx1;
509 
510 	for (APLIST_TRAVERSE(ofl->ofl_capgroups, idx1, cgp)) {
511 		Objcapset	*scapset = &cgp->cg_set;
512 		Capstr		*capstr;
513 		Aliste		idx2;
514 
515 		if (scapset->oc_id.cs_str) {
516 			if (scapset->oc_flags & FLG_OCS_USRDEFID)
517 				id_cap(ofl, scapset->oc_id.cs_str,
518 				    scapset->oc_flags);
519 		}
520 		if (scapset->oc_plat.cl_val) {
521 			for (ALIST_TRAVERSE(scapset->oc_plat.cl_val, idx2,
522 			    capstr)) {
523 				str_cap(ofl, capstr->cs_str, FLG_OF1_OVPLATCAP,
524 				    CA_SUNW_PLAT, &ofl->ofl_ocapset.oc_plat);
525 			}
526 		}
527 		if (scapset->oc_mach.cl_val) {
528 			for (ALIST_TRAVERSE(scapset->oc_mach.cl_val, idx2,
529 			    capstr)) {
530 				str_cap(ofl, capstr->cs_str, FLG_OF1_OVMACHCAP,
531 				    CA_SUNW_MACH, &ofl->ofl_ocapset.oc_mach);
532 			}
533 		}
534 		if (scapset->oc_hw_2.cm_val)
535 			hw_cap(ofl, CA_SUNW_HW_2, scapset->oc_hw_2.cm_val);
536 
537 		if (scapset->oc_hw_1.cm_val)
538 			hw_cap(ofl, CA_SUNW_HW_1, scapset->oc_hw_1.cm_val);
539 
540 		if (scapset->oc_sf_1.cm_val)
541 			sf1_cap(ofl, scapset->oc_sf_1.cm_val, NULL, NULL);
542 	}
543 }
544 
545 /*
546  * Determine whether a capabilities group already exists that describes this
547  * new capabilities group.
548  *
549  * Note, a capability group identifier, CA_SUNW_ID, isn't used as part of the
550  * comparison.  This attribute simply assigns a diagnostic name to the group,
551  * and in the case of multiple identifiers, the first will be taken.
552  */
553 static Cap_group *
554 get_cap_group(Objcapset *ocapset, Word cnum, Ofl_desc *ofl, Is_desc *isp)
555 {
556 	Aliste		idx;
557 	Cap_group	*cgp;
558 	Word		ccnum = cnum;
559 
560 	/*
561 	 * If the new capabilities contains a CA_SUNW_ID, drop the count of the
562 	 * number of comparable items.
563 	 */
564 	if (ocapset->oc_id.cs_str)
565 		ccnum--;
566 
567 	/*
568 	 * Traverse the existing symbols capabilities groups.
569 	 */
570 	for (APLIST_TRAVERSE(ofl->ofl_capgroups, idx, cgp)) {
571 		Word	onum = cgp->cg_num;
572 		Alist	*calp, *oalp;
573 
574 		if (cgp->cg_set.oc_id.cs_str)
575 			onum--;
576 
577 		if (onum != ccnum)
578 			continue;
579 
580 		if (cgp->cg_set.oc_hw_1.cm_val != ocapset->oc_hw_1.cm_val)
581 			continue;
582 		if (cgp->cg_set.oc_sf_1.cm_val != ocapset->oc_sf_1.cm_val)
583 			continue;
584 		if (cgp->cg_set.oc_hw_2.cm_val != ocapset->oc_hw_2.cm_val)
585 			continue;
586 
587 		calp = cgp->cg_set.oc_plat.cl_val;
588 		oalp = ocapset->oc_plat.cl_val;
589 		if ((calp == NULL) && oalp)
590 			continue;
591 		if (calp && ((oalp == NULL) || cap_names_match(calp, oalp)))
592 			continue;
593 
594 		calp = cgp->cg_set.oc_mach.cl_val;
595 		oalp = ocapset->oc_mach.cl_val;
596 		if ((calp == NULL) && oalp)
597 			continue;
598 		if (calp && ((oalp == NULL) || cap_names_match(calp, oalp)))
599 			continue;
600 
601 		/*
602 		 * If a matching group is found, then this new group has
603 		 * already been supplied by a previous file, and hence the
604 		 * existing group can be used.  Record this new input section,
605 		 * from which we can also derive the input file name, on the
606 		 * existing groups input sections.
607 		 */
608 		if (aplist_append(&(cgp->cg_secs), isp,
609 		    AL_CNT_CAP_SECS) == NULL)
610 			return (NULL);
611 		return (cgp);
612 	}
613 
614 	/*
615 	 * If a capabilities group is not found, create a new one.
616 	 */
617 	if (((cgp = libld_calloc(sizeof (Cap_group), 1)) == NULL) ||
618 	    (aplist_append(&(ofl->ofl_capgroups), cgp,
619 	    AL_CNT_CAP_DESCS) == NULL))
620 		return (NULL);
621 
622 	/*
623 	 * If we're converting object capabilities to symbol capabilities and
624 	 * no CA_SUNW_ID is defined, fabricate one.  This identifier is appended
625 	 * to all symbol names that are converted into capabilities symbols,
626 	 * see ld_sym_process().
627 	 */
628 	if ((isp->is_file->ifl_flags & FLG_IF_OTOSCAP) &&
629 	    (ocapset->oc_id.cs_str == NULL)) {
630 		size_t	len;
631 
632 		/*
633 		 * Create an identifier using the group number together with a
634 		 * default template.  We allocate a buffer large enough for any
635 		 * possible number of items (way more than we need).
636 		 */
637 		len = MSG_STR_CAPGROUPID_SIZE + CONV_INV_BUFSIZE;
638 		if ((ocapset->oc_id.cs_str = libld_malloc(len)) == NULL)
639 			return (NULL);
640 
641 		(void) snprintf(ocapset->oc_id.cs_str, len,
642 		    MSG_ORIG(MSG_STR_CAPGROUPID),
643 		    aplist_nitems(ofl->ofl_capgroups));
644 		cnum++;
645 	}
646 
647 	cgp->cg_set = *ocapset;
648 	cgp->cg_num = cnum;
649 
650 	/*
651 	 * Null the callers alist's as they've effectively been transferred
652 	 * to this new Cap_group.
653 	 */
654 	ocapset->oc_plat.cl_val = ocapset->oc_mach.cl_val = NULL;
655 
656 	/*
657 	 * Keep track of which input section, and hence input file, established
658 	 * this group.
659 	 */
660 	if (aplist_append(&(cgp->cg_secs), isp, AL_CNT_CAP_SECS) == NULL)
661 		return (NULL);
662 
663 	/*
664 	 * Keep track of the number of symbol capabilities entries that will be
665 	 * required in the output file.  Each group requires a terminating
666 	 * CA_SUNW_NULL.
667 	 */
668 	ofl->ofl_capsymcnt += (cnum + 1);
669 	return (cgp);
670 }
671 
672 /*
673  * Capture symbol capability family information.  This data structure is focal
674  * in maintaining all symbol capability relationships, and provides for the
675  * eventual creation of a capabilities information section, and possibly a
676  * capabilities chain section.
677  *
678  * Capabilities families are lead by a CAPINFO_SUNW_GLOB symbol.  This symbol
679  * provides the visible global symbol that is referenced by all external
680  * callers.  This symbol may have aliases.  For example, a weak/global symbol
681  * pair, such as memcpy()/_memcpy() may lead the same capabilities family.
682  * Each family contains one or more local symbol members.  These members provide
683  * the capabilities specific functions, and are associated to a capabilities
684  * group.  For example, the capability members memcpy%sun4u and memcpy%sun4v
685  * might be associated with the memcpy() capability family.
686  *
687  * This routine is called when a relocatable object that provides object
688  * capabilities is transformed into a symbol capabilities object, using the
689  * -z symbolcap option.
690  *
691  * This routine is also called to collect the SUNW_capinfo section information
692  * of a relocatable object that contains symbol capability definitions.
693  */
694 uintptr_t
695 ld_cap_add_family(Ofl_desc *ofl, Sym_desc *lsdp, Sym_desc *csdp, Cap_group *cgp,
696     APlist **csyms)
697 {
698 	Cap_avlnode	qcav, *cav;
699 	avl_tree_t	*avlt;
700 	avl_index_t	where = 0;
701 	Cap_sym		*mcsp;
702 	Aliste		idx;
703 
704 	/*
705 	 * Make sure the capability families have an initialized AVL tree.
706 	 */
707 	if ((avlt = ofl->ofl_capfamilies) == NULL) {
708 		if ((avlt = libld_calloc(sizeof (avl_tree_t), 1)) == NULL)
709 			return (S_ERROR);
710 		avl_create(avlt, &ld_sym_avl_comp, sizeof (Cap_avlnode),
711 		    SGSOFFSETOF(Cap_avlnode, cn_symavlnode.sav_node));
712 		ofl->ofl_capfamilies = avlt;
713 
714 		/*
715 		 * When creating a dynamic object, capability family members
716 		 * are maintained in a .SUNW_capchain, the first entry of
717 		 * which is the version number of the chain.
718 		 */
719 		ofl->ofl_capchaincnt = 1;
720 	}
721 
722 	/*
723 	 * Determine whether a family already exists, and if not, create one
724 	 * using the lead family symbol.
725 	 */
726 	qcav.cn_symavlnode.sav_hash = (Word)elf_hash(lsdp->sd_name);
727 	qcav.cn_symavlnode.sav_name = lsdp->sd_name;
728 
729 	if ((cav = avl_find(avlt, &qcav, &where)) == NULL) {
730 		if ((cav = libld_calloc(sizeof (Cap_avlnode), 1)) == NULL)
731 			return (S_ERROR);
732 		cav->cn_symavlnode.sav_hash = qcav.cn_symavlnode.sav_hash;
733 		cav->cn_symavlnode.sav_name = qcav.cn_symavlnode.sav_name;
734 		cav->cn_symavlnode.sav_sdp = lsdp;
735 
736 		avl_insert(avlt, cav, where);
737 
738 		/*
739 		 * When creating a dynamic object, capability family members
740 		 * are maintained in a .SUNW_capchain, each family starts with
741 		 * this lead symbol, and is terminated with a 0 element.
742 		 */
743 		ofl->ofl_capchaincnt += 2;
744 	}
745 
746 	/*
747 	 * If no group information is provided then this request is to add a
748 	 * lead capability symbol, or lead symbol alias.  If this is the lead
749 	 * symbol there's nothing more to do.  Otherwise save the alias.
750 	 */
751 	if (cgp == NULL) {
752 		if ((lsdp != csdp) && (aplist_append(&cav->cn_aliases, csdp,
753 		    AL_CNT_CAP_ALIASES) == NULL))
754 			return (S_ERROR);
755 
756 		return (0);
757 	}
758 
759 	/*
760 	 * Determine whether a member of the same group as this new member is
761 	 * already defined within this family.  If so, we have a multiply
762 	 * defined symbol.
763 	 */
764 	for (APLIST_TRAVERSE(cav->cn_members, idx, mcsp)) {
765 		Sym_desc	*msdp;
766 
767 		if (cgp != mcsp->cs_group)
768 			continue;
769 
770 		/*
771 		 * Diagnose that a multiple symbol definition exists.
772 		 */
773 		msdp = mcsp->cs_sdp;
774 
775 		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_CAP_MULDEF),
776 		    demangle(lsdp->sd_name));
777 		ld_eprintf(ofl, ERR_NONE, MSG_INTL(MSG_CAP_MULDEFSYMS),
778 		    msdp->sd_file->ifl_name, msdp->sd_name,
779 		    csdp->sd_file->ifl_name, csdp->sd_name);
780 	}
781 
782 	/*
783 	 * Add this capabilities symbol member to the family.
784 	 */
785 	if (((mcsp = libld_malloc(sizeof (Cap_sym))) == NULL) ||
786 	    (aplist_append(&cav->cn_members, mcsp, AL_CNT_CAP_MEMS) == NULL))
787 		return (S_ERROR);
788 
789 	mcsp->cs_sdp = csdp;
790 	mcsp->cs_group = cgp;
791 
792 	/*
793 	 * When creating a dynamic object, capability family members are
794 	 * maintained in a .SUNW_capchain.  Account for this family member.
795 	 */
796 	ofl->ofl_capchaincnt++;
797 
798 	/*
799 	 * If this input file is undergoing object capabilities to symbol
800 	 * capabilities conversion, then this member is a new local symbol
801 	 * that has been generated from an original global symbol.  Keep track
802 	 * of this symbol so that the output file symbol table can be populated
803 	 * with these new symbol entries.
804 	 */
805 	if (csyms && (aplist_append(csyms, mcsp, AL_CNT_CAP_SYMS) == NULL))
806 		return (S_ERROR);
807 
808 	return (0);
809 }
810 
811 /*
812  * Process a SHT_SUNW_cap capabilities section.
813  */
814 static uintptr_t
815 process_cap(Ofl_desc *ofl, Ifl_desc *ifl, Is_desc *cisp)
816 {
817 	Objcapset	ocapset = { 0 };
818 	Cap_desc	*cdp;
819 	Cap		*data, *cdata;
820 	char		*strs;
821 	Word		ndx, cnum;
822 	int		objcapndx, descapndx, symcapndx;
823 	int		nulls, capstrs = 0;
824 
825 	/*
826 	 * Determine the capabilities data and size.
827 	 */
828 	cdata = (Cap *)cisp->is_indata->d_buf;
829 	cnum = (Word)(cisp->is_shdr->sh_size / cisp->is_shdr->sh_entsize);
830 
831 	if ((cdata == NULL) || (cnum == 0))
832 		return (0);
833 
834 	DBG_CALL(Dbg_cap_sec_title(ofl->ofl_lml, ifl->ifl_name));
835 
836 	/*
837 	 * Traverse the section to determine what capabilities groups are
838 	 * available.
839 	 *
840 	 * A capabilities section can contain one or more, CA_SUNW_NULL
841 	 * terminated groups.
842 	 *
843 	 *  -	The first group defines the object capabilities.
844 	 *  -	Additional groups define symbol capabilities.
845 	 *  -	Since the initial group is always reserved for object
846 	 *	capabilities, any object with symbol capabilities must also
847 	 *	have an object capabilities group.  If the object has no object
848 	 *	capabilities, an empty object group is defined, consisting of a
849 	 *	CA_SUNW_NULL element in index [0].
850 	 *  -	If any capabilities require references to a named string, then
851 	 *	the section header sh_info points to the associated string
852 	 *	table.
853 	 *  -	If an object contains symbol capability groups, then the
854 	 *	section header sh_link points to the associated capinfo table.
855 	 */
856 	objcapndx = 0;
857 	descapndx = symcapndx = -1;
858 	nulls = 0;
859 
860 	for (ndx = 0, data = cdata; ndx < cnum; ndx++, data++) {
861 		switch (data->c_tag) {
862 		case CA_SUNW_NULL:
863 			/*
864 			 * If this is the first CA_SUNW_NULL entry, and no
865 			 * capabilities group has been found, then this object
866 			 * does not define any object capabilities.
867 			 */
868 			if (nulls++ == 0) {
869 				if (ndx == 0)
870 					objcapndx = -1;
871 			} else if ((symcapndx == -1) && (descapndx != -1))
872 				symcapndx = descapndx;
873 
874 			break;
875 
876 		case CA_SUNW_PLAT:
877 		case CA_SUNW_MACH:
878 		case CA_SUNW_ID:
879 			capstrs++;
880 			/* FALLTHROUGH */
881 
882 		case CA_SUNW_HW_1:
883 		case CA_SUNW_SF_1:
884 		case CA_SUNW_HW_2:
885 			/*
886 			 * If this is the start of a new group, save it.
887 			 */
888 			if (descapndx == -1)
889 				descapndx = ndx;
890 			break;
891 
892 		default:
893 			ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_FIL_UNKCAP),
894 			    ifl->ifl_name, EC_WORD(cisp->is_scnndx),
895 			    cisp->is_name, data->c_tag);
896 		}
897 	}
898 
899 	/*
900 	 * If a string capabilities entry has been found, the capabilities
901 	 * section must reference the associated string table.
902 	 */
903 	if (capstrs) {
904 		Word	info = cisp->is_shdr->sh_info;
905 
906 		if ((info == 0) || (info > ifl->ifl_shnum)) {
907 			ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_INVSHINFO),
908 			    ifl->ifl_name, EC_WORD(cisp->is_scnndx),
909 			    cisp->is_name, EC_XWORD(info));
910 			return (S_ERROR);
911 		}
912 		strs = (char *)ifl->ifl_isdesc[info]->is_indata->d_buf;
913 	}
914 
915 	/*
916 	 * The processing of capabilities groups is as follows:
917 	 *
918 	 *  -	if a relocatable object provides only object capabilities, and
919 	 *	the -z symbolcap option is in effect, then the object
920 	 *	capabilities are transformed into symbol capabilities and the
921 	 *	symbol capabilities are carried over to the output file.
922 	 *  -	in all other cases, any capabilities present in an input
923 	 *	relocatable object are carried from the input object to the
924 	 *	output without any transformation or conversion.
925 	 *
926 	 * Capture any object capabilities that are to be carried over to the
927 	 * output file.
928 	 */
929 	if ((objcapndx == 0) &&
930 	    ((symcapndx != -1) || ((ofl->ofl_flags & FLG_OF_OTOSCAP) == 0))) {
931 		for (ndx = 0, data = cdata; ndx < cnum; ndx++, data++) {
932 			/*
933 			 * Object capabilities end at the first null.
934 			 */
935 			if (data->c_tag == CA_SUNW_NULL)
936 				break;
937 
938 			/*
939 			 * Only the object software capabilities that are
940 			 * defined in a relocatable object become part of the
941 			 * object software capabilities in the output file.
942 			 * However, check the validity of any object software
943 			 * capabilities of any dependencies.
944 			 */
945 			if (data->c_tag == CA_SUNW_SF_1) {
946 				sf1_cap(ofl, data->c_un.c_val, ifl, cisp);
947 				continue;
948 			}
949 
950 			/*
951 			 * The remaining capability types must come from a
952 			 * relocatable object in order to contribute to the
953 			 * output.
954 			 */
955 			if (ifl->ifl_ehdr->e_type != ET_REL)
956 				continue;
957 
958 			switch (data->c_tag) {
959 			case CA_SUNW_HW_1:
960 			case CA_SUNW_HW_2:
961 				hw_cap(ofl, data->c_tag, data->c_un.c_val);
962 				break;
963 
964 			case CA_SUNW_PLAT:
965 				str_cap(ofl, strs + data->c_un.c_ptr,
966 				    FLG_OF1_OVPLATCAP, CA_SUNW_PLAT,
967 				    &ofl->ofl_ocapset.oc_plat);
968 				break;
969 
970 			case CA_SUNW_MACH:
971 				str_cap(ofl, strs + data->c_un.c_ptr,
972 				    FLG_OF1_OVMACHCAP, CA_SUNW_MACH,
973 				    &ofl->ofl_ocapset.oc_mach);
974 				break;
975 
976 			case CA_SUNW_ID:
977 				id_cap(ofl, strs + data->c_un.c_ptr,
978 				    FLG_OCS_USRDEFID);
979 				break;
980 
981 			default:
982 				assert(0);	/* Unknown capability type */
983 			}
984 		}
985 
986 		/*
987 		 * If there are no symbol capabilities, or this objects
988 		 * capabilities aren't being transformed into a symbol
989 		 * capabilities, then we're done.
990 		 */
991 		if ((symcapndx == -1) &&
992 		    ((ofl->ofl_flags & FLG_OF_OTOSCAP) == 0))
993 			return (1);
994 	}
995 
996 	/*
997 	 * If these capabilities don't originate from a relocatable object
998 	 * there's no further processing required.
999 	 */
1000 	if (ifl->ifl_ehdr->e_type != ET_REL)
1001 		return (1);
1002 
1003 	/*
1004 	 * If this object only defines an object capabilities group, and the
1005 	 * -z symbolcap option is in effect, then all global function symbols
1006 	 * and initialized global data symbols are renamed and assigned to the
1007 	 * transformed symbol capabilities group.
1008 	 */
1009 	if ((objcapndx == 0) &&
1010 	    (symcapndx == -1) && (ofl->ofl_flags & FLG_OF_OTOSCAP))
1011 		ifl->ifl_flags |= FLG_IF_OTOSCAP;
1012 
1013 	/*
1014 	 * Allocate a capabilities descriptor to collect the capabilities data
1015 	 * for this input file.  Allocate a mirror of the raw capabilities data
1016 	 * that points to the individual symbol capabilities groups.  An APlist
1017 	 * is used, although it will be sparsely populated, as the list provides
1018 	 * a convenient mechanism for traversal later.
1019 	 */
1020 	if (((cdp = libld_calloc(sizeof (Cap_desc), 1)) == NULL) ||
1021 	    (aplist_append(&(cdp->ca_groups), NULL, cnum) == NULL))
1022 		return (S_ERROR);
1023 
1024 	/*
1025 	 * Clear the allocated APlist data array, and assign the number of
1026 	 * items as the total number of array items.
1027 	 */
1028 	(void) memset(&cdp->ca_groups->apl_data[0], 0,
1029 	    (cnum * sizeof (void *)));
1030 	cdp->ca_groups->apl_nitems = cnum;
1031 
1032 	ifl->ifl_caps = cdp;
1033 
1034 	/*
1035 	 * Traverse the capabilities data, unpacking the data into a
1036 	 * capabilities set.  Process each capabilities set as a unique group.
1037 	 */
1038 	descapndx = -1;
1039 	nulls = 0;
1040 
1041 	for (ndx = 0, data = cdata; ndx < cnum; ndx++, data++) {
1042 		Capstr	*capstr;
1043 
1044 		switch (data->c_tag) {
1045 		case CA_SUNW_NULL:
1046 			nulls++;
1047 
1048 			/*
1049 			 * Process the capabilities group that this null entry
1050 			 * terminates.  The capabilities group that is returned
1051 			 * will either point to this file's data, or to a
1052 			 * matching capabilities group that has already been
1053 			 * processed.
1054 			 *
1055 			 * Note, if this object defines object capabilities,
1056 			 * the first group descriptor points to these object
1057 			 * capabilities.  It is only necessary to save this
1058 			 * descriptor when object capabilities are being
1059 			 * transformed into symbol capabilities (-z symbolcap).
1060 			 */
1061 			if (descapndx != -1) {
1062 				if ((nulls > 1) ||
1063 				    (ifl->ifl_flags & FLG_IF_OTOSCAP)) {
1064 					APlist	*alp = cdp->ca_groups;
1065 
1066 					if ((alp->apl_data[descapndx] =
1067 					    get_cap_group(&ocapset,
1068 					    (ndx - descapndx), ofl,
1069 					    cisp)) == NULL)
1070 						return (S_ERROR);
1071 				}
1072 
1073 				/*
1074 				 * Clean up the capabilities data in preparation
1075 				 * for processing additional groups.  If the
1076 				 * collected capabilities strings were used to
1077 				 * establish a new output group, they will have
1078 				 * been saved in get_cap_group().  If these
1079 				 * descriptors still exist, then an existing
1080 				 * descriptor has been used to associate with
1081 				 * this file, and these string descriptors can
1082 				 * be freed.
1083 				 */
1084 				ocapset.oc_hw_1.cm_val =
1085 				    ocapset.oc_sf_1.cm_val =
1086 				    ocapset.oc_hw_2.cm_val = 0;
1087 				if (ocapset.oc_plat.cl_val) {
1088 					free((void *)ocapset.oc_plat.cl_val);
1089 					ocapset.oc_plat.cl_val = NULL;
1090 				}
1091 				if (ocapset.oc_mach.cl_val) {
1092 					free((void *)ocapset.oc_mach.cl_val);
1093 					ocapset.oc_mach.cl_val = NULL;
1094 				}
1095 				descapndx = -1;
1096 			}
1097 			continue;
1098 
1099 		case CA_SUNW_HW_1:
1100 			ocapset.oc_hw_1.cm_val = data->c_un.c_val;
1101 			DBG_CALL(Dbg_cap_val_entry(ofl->ofl_lml,
1102 			    DBG_STATE_ORIGINAL, CA_SUNW_HW_1,
1103 			    ocapset.oc_hw_1.cm_val, ld_targ.t_m.m_mach));
1104 			break;
1105 
1106 		case CA_SUNW_SF_1:
1107 			ocapset.oc_sf_1.cm_val = data->c_un.c_val;
1108 			DBG_CALL(Dbg_cap_val_entry(ofl->ofl_lml,
1109 			    DBG_STATE_ORIGINAL, CA_SUNW_SF_1,
1110 			    ocapset.oc_sf_1.cm_val, ld_targ.t_m.m_mach));
1111 			break;
1112 
1113 		case CA_SUNW_HW_2:
1114 			ocapset.oc_hw_2.cm_val = data->c_un.c_val;
1115 			DBG_CALL(Dbg_cap_val_entry(ofl->ofl_lml,
1116 			    DBG_STATE_ORIGINAL, CA_SUNW_HW_2,
1117 			    ocapset.oc_hw_2.cm_val, ld_targ.t_m.m_mach));
1118 			break;
1119 
1120 		case CA_SUNW_PLAT:
1121 			if ((capstr = alist_append(&ocapset.oc_plat.cl_val,
1122 			    NULL, sizeof (Capstr), AL_CNT_CAP_NAMES)) == NULL)
1123 				return (S_ERROR);
1124 			capstr->cs_str = strs + data->c_un.c_ptr;
1125 			DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml,
1126 			    DBG_STATE_ORIGINAL, CA_SUNW_PLAT, capstr->cs_str));
1127 			break;
1128 
1129 		case CA_SUNW_MACH:
1130 			if ((capstr = alist_append(&ocapset.oc_mach.cl_val,
1131 			    NULL, sizeof (Capstr), AL_CNT_CAP_NAMES)) == NULL)
1132 				return (S_ERROR);
1133 			capstr->cs_str = strs + data->c_un.c_ptr;
1134 			DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml,
1135 			    DBG_STATE_ORIGINAL, CA_SUNW_MACH, capstr->cs_str));
1136 			break;
1137 
1138 		case CA_SUNW_ID:
1139 			ocapset.oc_id.cs_str = strs + data->c_un.c_ptr;
1140 			DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml,
1141 			    DBG_STATE_ORIGINAL, CA_SUNW_ID,
1142 			    ocapset.oc_id.cs_str));
1143 			break;
1144 		}
1145 
1146 		/*
1147 		 * Save the start of this new group.
1148 		 */
1149 		if (descapndx == -1)
1150 			descapndx = ndx;
1151 	}
1152 	return (1);
1153 }
1154 
1155 /*
1156  * Capture any symbol capabilities symbols.  An object file that contains symbol
1157  * capabilities has an associated .SUNW_capinfo section.  This section
1158  * identifies which symbols are associated to which capabilities, together with
1159  * their associated lead symbol.  Each of these symbol pairs are recorded for
1160  * processing later.
1161  */
1162 static uintptr_t
1163 process_capinfo(Ofl_desc *ofl, Ifl_desc *ifl, Is_desc *isp)
1164 {
1165 	Cap_desc	*cdp = ifl->ifl_caps;
1166 	Capinfo		*capinfo = isp->is_indata->d_buf;
1167 	Shdr		*shdr = isp->is_shdr;
1168 	Word		cndx, capinfonum;
1169 
1170 	capinfonum = (Word)(shdr->sh_size / shdr->sh_entsize);
1171 
1172 	if ((cdp == NULL) || (capinfo == NULL) || (capinfonum == 0))
1173 		return (0);
1174 
1175 	for (cndx = 1, capinfo++; cndx < capinfonum; cndx++, capinfo++) {
1176 		Sym_desc	*sdp, *lsdp;
1177 		Word		lndx;
1178 		uchar_t		gndx;
1179 
1180 		if ((gndx = (uchar_t)ELF_C_GROUP(*capinfo)) == 0)
1181 			continue;
1182 		lndx = (Word)ELF_C_SYM(*capinfo);
1183 
1184 		/*
1185 		 * Catch any anomalies.  A capabilities symbol should be valid,
1186 		 * and the capabilities lead symbol should also be global.
1187 		 * Note, ld(1) -z symbolcap would create local capabilities
1188 		 * symbols, but we don't enforce this so as to give the
1189 		 * compilation environment a little more freedom.
1190 		 */
1191 		if ((sdp = ifl->ifl_oldndx[cndx]) == NULL) {
1192 			ld_eprintf(ofl, ERR_WARNING,
1193 			    MSG_INTL(MSG_CAPINFO_INVALSYM), ifl->ifl_name,
1194 			    EC_WORD(isp->is_scnndx), isp->is_name, cndx,
1195 			    MSG_INTL(MSG_STR_UNKNOWN));
1196 			continue;
1197 		}
1198 		if ((lndx == 0) || (lndx >= ifl->ifl_symscnt) ||
1199 		    ((lsdp = ifl->ifl_oldndx[lndx]) == NULL) ||
1200 		    (ELF_ST_BIND(lsdp->sd_sym->st_info) != STB_GLOBAL)) {
1201 			ld_eprintf(ofl, ERR_WARNING,
1202 			    MSG_INTL(MSG_CAPINFO_INVALLEAD), ifl->ifl_name,
1203 			    EC_WORD(isp->is_scnndx), isp->is_name, cndx, lsdp ?
1204 			    demangle(lsdp->sd_name) : MSG_INTL(MSG_STR_UNKNOWN),
1205 			    lndx);
1206 			continue;
1207 		}
1208 
1209 		/*
1210 		 * Indicate that this is a capabilities symbol.
1211 		 */
1212 		sdp->sd_flags |= FLG_SY_CAP;
1213 
1214 		/*
1215 		 * Save any global capability symbols.  Global capability
1216 		 * symbols are identified with a CAPINFO_SUNW_GLOB group id.
1217 		 * The lead symbol for this global capability symbol is either
1218 		 * the symbol itself, or an alias.
1219 		 */
1220 		if (gndx == CAPINFO_SUNW_GLOB) {
1221 			if (ld_cap_add_family(ofl, lsdp, sdp,
1222 			    NULL, NULL) == S_ERROR)
1223 				return (S_ERROR);
1224 			continue;
1225 		}
1226 
1227 		/*
1228 		 * Track the number of non-global capabilities symbols, as these
1229 		 * are used to size any symbol tables.  If we're generating a
1230 		 * dynamic object, this symbol will be added to the dynamic
1231 		 * symbol table, therefore ensure there is space in the dynamic
1232 		 * string table.
1233 		 */
1234 		ofl->ofl_caploclcnt++;
1235 		if (((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) &&
1236 		    (st_insert(ofl->ofl_dynstrtab, sdp->sd_name) == -1))
1237 			return (S_ERROR);
1238 
1239 		/*
1240 		 * As we're tracking this local symbol as a capabilities symbol,
1241 		 * reduce the local symbol count to compensate.
1242 		 */
1243 		ofl->ofl_locscnt--;
1244 
1245 		/*
1246 		 * Determine whether the associated lead symbol indicates
1247 		 * NODYNSORT.  If so, remove this local entry from the
1248 		 * SUNW_dynsort section too.  NODYNSORT tagging can only be
1249 		 * obtained from a mapfile symbol definition, and thus any
1250 		 * global definition that has this tagging has already been
1251 		 * instantiated and this instance resolved to it.
1252 		 */
1253 		if (lsdp->sd_flags & FLG_SY_NODYNSORT) {
1254 			Sym	*lsym = lsdp->sd_sym;
1255 			uchar_t ltype = ELF_ST_TYPE(lsym->st_info);
1256 
1257 			DYNSORT_COUNT(lsdp, lsym, ltype, --);
1258 			lsdp->sd_flags |= FLG_SY_NODYNSORT;
1259 		}
1260 
1261 		/*
1262 		 * Track this family member, together with its associated group.
1263 		 */
1264 		if (ld_cap_add_family(ofl, lsdp, sdp,
1265 		    cdp->ca_groups->apl_data[gndx], NULL) == S_ERROR)
1266 			return (S_ERROR);
1267 	}
1268 
1269 	return (0);
1270 }
1271 
1272 /*
1273  * Simply process the section so that we have pointers to the data for use
1274  * in later routines, however don't add the section to the output section
1275  * list as we will be creating our own replacement sections later (ie.
1276  * symtab and relocation).
1277  */
1278 static uintptr_t
1279 /* ARGSUSED5 */
1280 process_input(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn,
1281     Word ndx, int ident, Ofl_desc *ofl)
1282 {
1283 	return (process_section(name, ifl, shdr, scn, ndx,
1284 	    ld_targ.t_id.id_null, ofl));
1285 }
1286 
1287 /*
1288  * Keep a running count of relocation entries from input relocatable objects for
1289  * sizing relocation buckets later.  If we're building an executable, save any
1290  * relocations from shared objects to determine if any copy relocation symbol
1291  * has a displacement relocation against it.
1292  */
1293 static uintptr_t
1294 /* ARGSUSED5 */
1295 process_reloc(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn,
1296     Word ndx, int ident, Ofl_desc *ofl)
1297 {
1298 	if (process_section(name, ifl,
1299 	    shdr, scn, ndx, ld_targ.t_id.id_null, ofl) == S_ERROR)
1300 		return (S_ERROR);
1301 
1302 	if (ifl->ifl_ehdr->e_type == ET_REL) {
1303 		if (shdr->sh_entsize && (shdr->sh_entsize <= shdr->sh_size))
1304 			/* LINTED */
1305 			ofl->ofl_relocincnt +=
1306 			    (Word)(shdr->sh_size / shdr->sh_entsize);
1307 	} else if (ofl->ofl_flags & FLG_OF_EXEC) {
1308 		if (aplist_append(&ifl->ifl_relsect, ifl->ifl_isdesc[ndx],
1309 		    AL_CNT_IFL_RELSECS) == NULL)
1310 			return (S_ERROR);
1311 	}
1312 	return (1);
1313 }
1314 
1315 /*
1316  * Process a string table section.  A valid section contains an initial and
1317  * final null byte.
1318  */
1319 static uintptr_t
1320 process_strtab(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn,
1321     Word ndx, int ident, Ofl_desc *ofl)
1322 {
1323 	char		*data;
1324 	size_t		size;
1325 	Is_desc		*isp;
1326 	uintptr_t	error;
1327 
1328 	/*
1329 	 * Never include .stab.excl sections in any output file.
1330 	 * If the -s flag has been specified strip any .stab sections.
1331 	 */
1332 	if (((ofl->ofl_flags & FLG_OF_STRIP) && ident &&
1333 	    (strncmp(name, MSG_ORIG(MSG_SCN_STAB), MSG_SCN_STAB_SIZE) == 0)) ||
1334 	    (strcmp(name, MSG_ORIG(MSG_SCN_STABEXCL)) == 0) && ident)
1335 		return (1);
1336 
1337 	/*
1338 	 * If we got here to process a .shstrtab or .dynstr table, `ident' will
1339 	 * be null.  Otherwise make sure we don't have a .strtab section as this
1340 	 * should not be added to the output section list either.
1341 	 */
1342 	if ((ident != ld_targ.t_id.id_null) &&
1343 	    (strcmp(name, MSG_ORIG(MSG_SCN_STRTAB)) == 0))
1344 		ident = ld_targ.t_id.id_null;
1345 
1346 	error = process_section(name, ifl, shdr, scn, ndx, ident, ofl);
1347 	if ((error == 0) || (error == S_ERROR))
1348 		return (error);
1349 
1350 	/*
1351 	 * String tables should start and end with a NULL byte.  Note, it has
1352 	 * been known for the assembler to create empty string tables, so check
1353 	 * the size before attempting to verify the data itself.
1354 	 */
1355 	isp = ifl->ifl_isdesc[ndx];
1356 	size = isp->is_indata->d_size;
1357 	if (size) {
1358 		data = isp->is_indata->d_buf;
1359 		if (data[0] != '\0' || data[size - 1] != '\0')
1360 			ld_eprintf(ofl, ERR_WARNING,
1361 			    MSG_INTL(MSG_FIL_MALSTR), ifl->ifl_name,
1362 			    EC_WORD(isp->is_scnndx), name);
1363 	} else
1364 		isp->is_indata->d_buf = (void *)MSG_ORIG(MSG_STR_EMPTY);
1365 
1366 	ifl->ifl_flags |= FLG_IF_HSTRTAB;
1367 	return (1);
1368 }
1369 
1370 /*
1371  * Invalid sections produce a warning and are skipped.
1372  */
1373 static uintptr_t
1374 /* ARGSUSED3 */
1375 invalid_section(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn,
1376     Word ndx, int ident, Ofl_desc *ofl)
1377 {
1378 	Conv_inv_buf_t inv_buf;
1379 
1380 	ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_FIL_INVALSEC),
1381 	    ifl->ifl_name, EC_WORD(ndx), name,
1382 	    conv_sec_type(ifl->ifl_ehdr->e_ident[EI_OSABI],
1383 	    ifl->ifl_ehdr->e_machine, shdr->sh_type, 0, &inv_buf));
1384 	return (1);
1385 }
1386 
1387 /*
1388  * Compare an input section name to a given string, taking the ELF '%'
1389  * section naming convention into account. If an input section name
1390  * contains a '%' character, the '%' and all following characters are
1391  * ignored in the comparison.
1392  *
1393  * entry:
1394  *	is_name - Name of input section
1395  *	match_name - Name to compare to
1396  *	match_len - strlen(match_name)
1397  *
1398  * exit:
1399  *	Returns True (1) if the names match, and False (0) otherwise.
1400  */
1401 inline static int
1402 is_name_cmp(const char *is_name, const char *match_name, size_t match_len)
1403 {
1404 	/*
1405 	 * If the start of is_name is not a match for name,
1406 	 * the match fails.
1407 	 */
1408 	if (strncmp(is_name, match_name, match_len) != 0)
1409 		return (0);
1410 
1411 	/*
1412 	 * The prefix matched. The next character must be either '%', or
1413 	 * NULL, in order for a match to be true.
1414 	 */
1415 	is_name += match_len;
1416 	return ((*is_name == '\0') || (*is_name == '%'));
1417 }
1418 
1419 /*
1420  * Helper routine for process_progbits() to process allocable sections.
1421  *
1422  * entry:
1423  *	name, ifl, shdr, ndx, ident, ofl - As passed to process_progbits().
1424  *	is_stab_index - TRUE if section is .index.
1425  *	is_flags - Additional flags to be added to the input section.
1426  *
1427  * exit:
1428  *	The allocable section has been processed. *ident and *is_flags
1429  *	are updated as necessary to reflect the changes. Returns TRUE
1430  *	for success, FALSE for failure.
1431  */
1432 /*ARGSUSED*/
1433 inline static Boolean
1434 process_progbits_alloc(const char *name, Ifl_desc *ifl, Shdr *shdr,
1435     Word ndx, int *ident, Ofl_desc *ofl, Boolean is_stab_index,
1436     Word *is_flags)
1437 {
1438 	Boolean done = FALSE;
1439 
1440 	if (name[0] == '.') {
1441 		switch (name[1]) {
1442 		case 'e':
1443 			if (!is_name_cmp(name, MSG_ORIG(MSG_SCN_EHFRAME),
1444 			    MSG_SCN_EHFRAME_SIZE))
1445 				break;
1446 
1447 			*ident = ld_targ.t_id.id_unwind;
1448 			*is_flags |= FLG_IS_EHFRAME;
1449 			done = TRUE;
1450 
1451 			/*
1452 			 * Historically, the section containing the logic to
1453 			 * unwind stack frames -- the .eh_frame section -- was
1454 			 * of type SHT_PROGBITS.  Apparently the most
1455 			 * aesthetically galling aspect of this was not the
1456 			 * .eh_frame section's dubious purpose or its filthy
1457 			 * implementation, but rather its section type; with the
1458 			 * introduction of the AMD64 ABI, a new section header
1459 			 * type (SHT_AMD64_UNWIND) was introduced for (and
1460 			 * dedicated to) this section.  When both the Sun
1461 			 * compilers and the GNU compilers had been modified to
1462 			 * generate this new section type, the linker became
1463 			 * much more pedantic about .eh_frame: it refused to
1464 			 * link an AMD64 object that contained a .eh_frame with
1465 			 * the legacy SHT_PROGBITS.  That this was too fussy is
1466 			 * evidenced by searching the net for the error message
1467 			 * that it generated ("section type is SHT_PROGBITS:
1468 			 * expected SHT_AMD64_UNWIND"), which reveals a myriad
1469 			 * of problems, including legacy objects, hand-coded
1470 			 * assembly and otherwise cross-platform objects
1471 			 * created on other platforms (the GNU toolchain was
1472 			 * only modified to create the new section type on
1473 			 * Solaris and derivatives).  We therefore always accept
1474 			 * a .eh_frame of SHT_PROGBITS -- regardless of
1475 			 * m_sht_unwind.
1476 			 */
1477 			break;
1478 		case 'g':
1479 			if (is_name_cmp(name, MSG_ORIG(MSG_SCN_GOT),
1480 			    MSG_SCN_GOT_SIZE)) {
1481 				*ident = ld_targ.t_id.id_null;
1482 				done = TRUE;
1483 				break;
1484 			}
1485 			if ((ld_targ.t_m.m_sht_unwind == SHT_PROGBITS) &&
1486 			    is_name_cmp(name, MSG_ORIG(MSG_SCN_GCC_X_TBL),
1487 			    MSG_SCN_GCC_X_TBL_SIZE)) {
1488 				*ident = ld_targ.t_id.id_unwind;
1489 				done = TRUE;
1490 				break;
1491 			}
1492 			break;
1493 		case 'p':
1494 			if (is_name_cmp(name, MSG_ORIG(MSG_SCN_PLT),
1495 			    MSG_SCN_PLT_SIZE)) {
1496 				*ident = ld_targ.t_id.id_null;
1497 				done = TRUE;
1498 			}
1499 			break;
1500 		}
1501 	}
1502 	if (!done) {
1503 		if (is_stab_index) {
1504 			/*
1505 			 * This is a work-around for x86 compilers that have
1506 			 * set SHF_ALLOC for the .stab.index section.
1507 			 *
1508 			 * Because of this, make sure that the .stab.index
1509 			 * does not end up as the last section in the text
1510 			 * segment. Older linkers can produce segmentation
1511 			 * violations when they strip (ld -s) against a
1512 			 * shared object whose last section in the text
1513 			 * segment is a .stab.
1514 			 */
1515 			*ident = ld_targ.t_id.id_interp;
1516 		} else {
1517 			*ident = ld_targ.t_id.id_data;
1518 		}
1519 	}
1520 
1521 	return (TRUE);
1522 }
1523 
1524 /*
1525  * Process a progbits section.
1526  */
1527 static uintptr_t
1528 process_progbits(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn,
1529     Word ndx, int ident, Ofl_desc *ofl)
1530 {
1531 	Boolean		is_stab_index = FALSE;
1532 	Word		is_flags = 0;
1533 	uintptr_t	r;
1534 
1535 	/*
1536 	 * Never include .stab.excl sections in any output file.
1537 	 * If the -s flag has been specified strip any .stab sections.
1538 	 */
1539 	if (ident && (strncmp(name, MSG_ORIG(MSG_SCN_STAB),
1540 	    MSG_SCN_STAB_SIZE) == 0)) {
1541 		if ((ofl->ofl_flags & FLG_OF_STRIP) ||
1542 		    (strcmp((name + MSG_SCN_STAB_SIZE),
1543 		    MSG_ORIG(MSG_SCN_EXCL)) == 0))
1544 			return (1);
1545 
1546 		if (strcmp((name + MSG_SCN_STAB_SIZE),
1547 		    MSG_ORIG(MSG_SCN_INDEX)) == 0)
1548 			is_stab_index = TRUE;
1549 	}
1550 
1551 	if ((ofl->ofl_flags & FLG_OF_STRIP) && ident) {
1552 		if ((strncmp(name, MSG_ORIG(MSG_SCN_DEBUG),
1553 		    MSG_SCN_DEBUG_SIZE) == 0) ||
1554 		    (strcmp(name, MSG_ORIG(MSG_SCN_LINE)) == 0))
1555 			return (1);
1556 	}
1557 
1558 	/*
1559 	 * Update the ident to reflect the type of section we've got.
1560 	 *
1561 	 * If there is any .plt or .got section to generate we'll be creating
1562 	 * our own version, so don't allow any input sections of these types to
1563 	 * be added to the output section list (why a relocatable object would
1564 	 * have a .plt or .got is a mystery, but stranger things have occurred).
1565 	 *
1566 	 * If there are any unwind sections, and this is a platform that uses
1567 	 * SHT_PROGBITS for unwind sections, then set their ident to reflect
1568 	 * that.
1569 	 */
1570 	if (ident) {
1571 		if (shdr->sh_flags & SHF_TLS) {
1572 			ident = ld_targ.t_id.id_tls;
1573 		} else if ((shdr->sh_flags & ~ALL_SHF_IGNORE) ==
1574 		    (SHF_ALLOC | SHF_EXECINSTR)) {
1575 			ident = ld_targ.t_id.id_text;
1576 		} else if (shdr->sh_flags & SHF_ALLOC) {
1577 			if (process_progbits_alloc(name, ifl, shdr, ndx,
1578 			    &ident, ofl, is_stab_index, &is_flags) == FALSE)
1579 				return (S_ERROR);
1580 		} else {
1581 			ident = ld_targ.t_id.id_note;
1582 		}
1583 	}
1584 
1585 	r = process_section(name, ifl, shdr, scn, ndx, ident, ofl);
1586 
1587 	/*
1588 	 * On success, process_section() creates an input section descriptor.
1589 	 * Now that it exists, we can add any pending input section flags.
1590 	 */
1591 	if ((is_flags != 0) && (r == 1))
1592 		ifl->ifl_isdesc[ndx]->is_flags |= is_flags;
1593 
1594 	return (r);
1595 }
1596 
1597 /*
1598  * Handles the SHT_SUNW_{DEBUG,DEBUGSTR) sections.
1599  */
1600 static uintptr_t
1601 process_debug(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn,
1602     Word ndx, int ident, Ofl_desc *ofl)
1603 {
1604 	/*
1605 	 * Debug information is discarded when the 'ld -s' flag is invoked.
1606 	 */
1607 	if (ofl->ofl_flags & FLG_OF_STRIP) {
1608 		return (1);
1609 	}
1610 	return (process_progbits(name, ifl, shdr, scn, ndx, ident, ofl));
1611 }
1612 
1613 /*
1614  * Process a nobits section.
1615  */
1616 static uintptr_t
1617 process_nobits(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn,
1618     Word ndx, int ident, Ofl_desc *ofl)
1619 {
1620 	if (ident) {
1621 		if (shdr->sh_flags & SHF_TLS)
1622 			ident = ld_targ.t_id.id_tlsbss;
1623 #if	defined(_ELF64)
1624 		else if ((shdr->sh_flags & SHF_AMD64_LARGE) &&
1625 		    (ld_targ.t_m.m_mach == EM_AMD64))
1626 			ident = ld_targ.t_id.id_lbss;
1627 #endif
1628 		else
1629 			ident = ld_targ.t_id.id_bss;
1630 	}
1631 	return (process_section(name, ifl, shdr, scn, ndx, ident, ofl));
1632 }
1633 
1634 /*
1635  * Process a SHT_*_ARRAY section.
1636  */
1637 static uintptr_t
1638 process_array(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn,
1639     Word ndx, int ident, Ofl_desc *ofl)
1640 {
1641 	uintptr_t	error;
1642 
1643 	if (ident)
1644 		ident = ld_targ.t_id.id_array;
1645 
1646 	error = process_section(name, ifl, shdr, scn, ndx, ident, ofl);
1647 	if ((error == 0) || (error == S_ERROR))
1648 		return (error);
1649 
1650 	return (1);
1651 }
1652 
1653 static uintptr_t
1654 /* ARGSUSED1 */
1655 array_process(Is_desc *isc, Ifl_desc *ifl, Ofl_desc *ofl)
1656 {
1657 	Os_desc	*osp;
1658 	Shdr	*shdr;
1659 
1660 	if ((isc == NULL) || ((osp = isc->is_osdesc) == NULL))
1661 		return (0);
1662 
1663 	shdr = isc->is_shdr;
1664 
1665 	if ((shdr->sh_type == SHT_FINI_ARRAY) &&
1666 	    (ofl->ofl_osfiniarray == NULL))
1667 		ofl->ofl_osfiniarray = osp;
1668 	else if ((shdr->sh_type == SHT_INIT_ARRAY) &&
1669 	    (ofl->ofl_osinitarray == NULL))
1670 		ofl->ofl_osinitarray = osp;
1671 	else if ((shdr->sh_type == SHT_PREINIT_ARRAY) &&
1672 	    (ofl->ofl_ospreinitarray == NULL))
1673 		ofl->ofl_ospreinitarray = osp;
1674 
1675 	return (1);
1676 }
1677 
1678 /*
1679  * Process a SHT_SYMTAB_SHNDX section.
1680  */
1681 static uintptr_t
1682 process_sym_shndx(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn,
1683     Word ndx, int ident, Ofl_desc *ofl)
1684 {
1685 	if (process_input(name, ifl, shdr, scn, ndx, ident, ofl) == S_ERROR)
1686 		return (S_ERROR);
1687 
1688 	/*
1689 	 * Have we already seen the related SYMTAB - if so verify it now.
1690 	 */
1691 	if (shdr->sh_link < ndx) {
1692 		Is_desc	*isp = ifl->ifl_isdesc[shdr->sh_link];
1693 
1694 		if ((isp == NULL) || ((isp->is_shdr->sh_type != SHT_SYMTAB) &&
1695 		    (isp->is_shdr->sh_type != SHT_DYNSYM))) {
1696 			ld_eprintf(ofl, ERR_FATAL,
1697 			    MSG_INTL(MSG_FIL_INVSHLINK), ifl->ifl_name,
1698 			    EC_WORD(ndx), name, EC_XWORD(shdr->sh_link));
1699 			return (S_ERROR);
1700 		}
1701 		isp->is_symshndx = ifl->ifl_isdesc[ndx];
1702 	}
1703 	return (1);
1704 }
1705 
1706 /*
1707  * Final processing for SHT_SYMTAB_SHNDX section.
1708  */
1709 static uintptr_t
1710 /* ARGSUSED2 */
1711 sym_shndx_process(Is_desc *isc, Ifl_desc *ifl, Ofl_desc *ofl)
1712 {
1713 	if (isc->is_shdr->sh_link > isc->is_scnndx) {
1714 		Is_desc	*isp = ifl->ifl_isdesc[isc->is_shdr->sh_link];
1715 
1716 		if ((isp == NULL) || ((isp->is_shdr->sh_type != SHT_SYMTAB) &&
1717 		    (isp->is_shdr->sh_type != SHT_DYNSYM))) {
1718 			ld_eprintf(ofl, ERR_FATAL,
1719 			    MSG_INTL(MSG_FIL_INVSHLINK), isc->is_file->ifl_name,
1720 			    EC_WORD(isc->is_scnndx), isc->is_name,
1721 			    EC_XWORD(isc->is_shdr->sh_link));
1722 			return (S_ERROR);
1723 		}
1724 		isp->is_symshndx = isc;
1725 	}
1726 	return (1);
1727 }
1728 
1729 /*
1730  * Process .dynamic section from a relocatable object.
1731  *
1732  * Note: That the .dynamic section is only considered interesting when
1733  *	 dlopen()ing a relocatable object (thus FLG_OF1_RELDYN can only get
1734  *	 set when libld is called from ld.so.1).
1735  */
1736 /*ARGSUSED*/
1737 static uintptr_t
1738 process_rel_dynamic(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn,
1739     Word ndx, int ident, Ofl_desc *ofl)
1740 {
1741 	Dyn		*dyn;
1742 	Elf_Scn		*strscn;
1743 	Elf_Data	*dp;
1744 	char		*str;
1745 
1746 	/*
1747 	 * Process .dynamic sections from relocatable objects ?
1748 	 */
1749 	if ((ofl->ofl_flags1 & FLG_OF1_RELDYN) == 0)
1750 		return (1);
1751 
1752 	/*
1753 	 * Find the string section associated with the .dynamic section.
1754 	 */
1755 	if ((strscn = elf_getscn(ifl->ifl_elf, shdr->sh_link)) == NULL) {
1756 		ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_GETSCN),
1757 		    ifl->ifl_name);
1758 		return (0);
1759 	}
1760 	dp = elf_getdata(strscn, NULL);
1761 	str = (char *)dp->d_buf;
1762 
1763 	/*
1764 	 * And get the .dynamic data
1765 	 */
1766 	dp = elf_getdata(scn, NULL);
1767 
1768 	for (dyn = (Dyn *)dp->d_buf; dyn->d_tag != DT_NULL; dyn++) {
1769 		Ifl_desc	*difl;
1770 
1771 		switch (dyn->d_tag) {
1772 		case DT_NEEDED:
1773 		case DT_USED:
1774 			if (((difl = libld_calloc(1,
1775 			    sizeof (Ifl_desc))) == NULL) ||
1776 			    (aplist_append(&ofl->ofl_sos, difl,
1777 			    AL_CNT_OFL_LIBS) == NULL))
1778 				return (S_ERROR);
1779 
1780 			difl->ifl_name = MSG_ORIG(MSG_STR_DYNAMIC);
1781 			difl->ifl_soname = str + (size_t)dyn->d_un.d_val;
1782 			difl->ifl_flags = FLG_IF_NEEDSTR;
1783 			break;
1784 		case DT_RPATH:
1785 		case DT_RUNPATH:
1786 			if ((ofl->ofl_rpath = add_string(ofl->ofl_rpath,
1787 			    (str + (size_t)dyn->d_un.d_val))) ==
1788 			    (const char *)S_ERROR)
1789 				return (S_ERROR);
1790 			break;
1791 		case DT_VERSYM:
1792 			/*
1793 			 * The Solaris ld does not put DT_VERSYM in the
1794 			 * dynamic section. If the object has DT_VERSYM,
1795 			 * then it must have been produced by the GNU ld,
1796 			 * and is using the GNU style of versioning.
1797 			 */
1798 			ifl->ifl_flags |= FLG_IF_GNUVER;
1799 			break;
1800 		}
1801 	}
1802 	return (1);
1803 }
1804 
1805 /*
1806  * Expand implicit references.  Dependencies can be specified in terms of the
1807  * $ORIGIN, $MACHINE, $PLATFORM, $OSREL and $OSNAME tokens, either from their
1808  * needed name, or via a runpath.  In addition runpaths may also specify the
1809  * $ISALIST token.
1810  *
1811  * Probably the most common reference to explicit dependencies (via -L) will be
1812  * sufficient to find any associated implicit dependencies, but just in case we
1813  * expand any occurrence of these known tokens here.
1814  *
1815  * Note, if any errors occur we simply return the original name.
1816  *
1817  * This code is remarkably similar to expand() in rtld/common/paths.c.
1818  */
1819 static char		*machine = NULL;
1820 static size_t		machine_sz = 0;
1821 static char		*platform = NULL;
1822 static size_t		platform_sz = 0;
1823 static Isa_desc		*isa = NULL;
1824 static Uts_desc		*uts = NULL;
1825 
1826 static char *
1827 expand(const char *parent, const char *name, char **next)
1828 {
1829 	char		_name[PATH_MAX], *nptr, *_next;
1830 	const char	*optr;
1831 	size_t		nrem = PATH_MAX - 1;
1832 	int		expanded = 0, _expanded, isaflag = 0;
1833 
1834 	optr = name;
1835 	nptr = _name;
1836 
1837 	while (*optr) {
1838 		if (nrem == 0)
1839 			return ((char *)name);
1840 
1841 		if (*optr != '$') {
1842 			*nptr++ = *optr++, nrem--;
1843 			continue;
1844 		}
1845 
1846 		_expanded = 0;
1847 
1848 		if (strncmp(optr, MSG_ORIG(MSG_STR_ORIGIN),
1849 		    MSG_STR_ORIGIN_SIZE) == 0) {
1850 			char *eptr;
1851 
1852 			/*
1853 			 * For $ORIGIN, expansion is really just a concatenation
1854 			 * of the parents directory name.  For example, an
1855 			 * explicit dependency foo/bar/lib1.so with a dependency
1856 			 * on $ORIGIN/lib2.so would be expanded to
1857 			 * foo/bar/lib2.so.
1858 			 */
1859 			if ((eptr = strrchr(parent, '/')) == NULL) {
1860 				*nptr++ = '.';
1861 				nrem--;
1862 			} else {
1863 				size_t	len = eptr - parent;
1864 
1865 				if (len >= nrem)
1866 					return ((char *)name);
1867 
1868 				(void) strncpy(nptr, parent, len);
1869 				nptr = nptr + len;
1870 				nrem -= len;
1871 			}
1872 			optr += MSG_STR_ORIGIN_SIZE;
1873 			expanded = _expanded = 1;
1874 
1875 		} else if (strncmp(optr, MSG_ORIG(MSG_STR_MACHINE),
1876 		    MSG_STR_MACHINE_SIZE) == 0) {
1877 			/*
1878 			 * Establish the machine from sysconf - like uname -i.
1879 			 */
1880 			if ((machine == NULL) && (machine_sz == 0)) {
1881 				char	info[SYS_NMLN];
1882 				long	size;
1883 
1884 				size = sysinfo(SI_MACHINE, info, SYS_NMLN);
1885 				if ((size != -1) &&
1886 				    (machine = libld_malloc((size_t)size))) {
1887 					(void) strcpy(machine, info);
1888 					machine_sz = (size_t)size - 1;
1889 				} else
1890 					machine_sz = 1;
1891 			}
1892 			if (machine) {
1893 				if (machine_sz >= nrem)
1894 					return ((char *)name);
1895 
1896 				(void) strncpy(nptr, machine, machine_sz);
1897 				nptr = nptr + machine_sz;
1898 				nrem -= machine_sz;
1899 
1900 				optr += MSG_STR_MACHINE_SIZE;
1901 				expanded = _expanded = 1;
1902 			}
1903 
1904 		} else if (strncmp(optr, MSG_ORIG(MSG_STR_PLATFORM),
1905 		    MSG_STR_PLATFORM_SIZE) == 0) {
1906 			/*
1907 			 * Establish the platform from sysconf - like uname -i.
1908 			 */
1909 			if ((platform == NULL) && (platform_sz == 0)) {
1910 				char	info[SYS_NMLN];
1911 				long	size;
1912 
1913 				size = sysinfo(SI_PLATFORM, info, SYS_NMLN);
1914 				if ((size != -1) &&
1915 				    (platform = libld_malloc((size_t)size))) {
1916 					(void) strcpy(platform, info);
1917 					platform_sz = (size_t)size - 1;
1918 				} else
1919 					platform_sz = 1;
1920 			}
1921 			if (platform) {
1922 				if (platform_sz >= nrem)
1923 					return ((char *)name);
1924 
1925 				(void) strncpy(nptr, platform, platform_sz);
1926 				nptr = nptr + platform_sz;
1927 				nrem -= platform_sz;
1928 
1929 				optr += MSG_STR_PLATFORM_SIZE;
1930 				expanded = _expanded = 1;
1931 			}
1932 
1933 		} else if (strncmp(optr, MSG_ORIG(MSG_STR_OSNAME),
1934 		    MSG_STR_OSNAME_SIZE) == 0) {
1935 			/*
1936 			 * Establish the os name - like uname -s.
1937 			 */
1938 			if (uts == NULL)
1939 				uts = conv_uts();
1940 
1941 			if (uts && uts->uts_osnamesz) {
1942 				if (uts->uts_osnamesz >= nrem)
1943 					return ((char *)name);
1944 
1945 				(void) strncpy(nptr, uts->uts_osname,
1946 				    uts->uts_osnamesz);
1947 				nptr = nptr + uts->uts_osnamesz;
1948 				nrem -= uts->uts_osnamesz;
1949 
1950 				optr += MSG_STR_OSNAME_SIZE;
1951 				expanded = _expanded = 1;
1952 			}
1953 
1954 		} else if (strncmp(optr, MSG_ORIG(MSG_STR_OSREL),
1955 		    MSG_STR_OSREL_SIZE) == 0) {
1956 			/*
1957 			 * Establish the os release - like uname -r.
1958 			 */
1959 			if (uts == NULL)
1960 				uts = conv_uts();
1961 
1962 			if (uts && uts->uts_osrelsz) {
1963 				if (uts->uts_osrelsz >= nrem)
1964 					return ((char *)name);
1965 
1966 				(void) strncpy(nptr, uts->uts_osrel,
1967 				    uts->uts_osrelsz);
1968 				nptr = nptr + uts->uts_osrelsz;
1969 				nrem -= uts->uts_osrelsz;
1970 
1971 				optr += MSG_STR_OSREL_SIZE;
1972 				expanded = _expanded = 1;
1973 			}
1974 
1975 		} else if ((strncmp(optr, MSG_ORIG(MSG_STR_ISALIST),
1976 		    MSG_STR_ISALIST_SIZE) == 0) && next && (isaflag++ == 0)) {
1977 			/*
1978 			 * Establish instruction sets from sysconf.  Note that
1979 			 * this is only meaningful from runpaths.
1980 			 */
1981 			if (isa == NULL)
1982 				isa = conv_isalist();
1983 
1984 			if (isa && isa->isa_listsz &&
1985 			    (nrem > isa->isa_opt->isa_namesz)) {
1986 				size_t		mlen, tlen, hlen = optr - name;
1987 				size_t		no;
1988 				char		*lptr;
1989 				Isa_opt		*opt = isa->isa_opt;
1990 
1991 				(void) strncpy(nptr, opt->isa_name,
1992 				    opt->isa_namesz);
1993 				nptr = nptr + opt->isa_namesz;
1994 				nrem -= opt->isa_namesz;
1995 
1996 				optr += MSG_STR_ISALIST_SIZE;
1997 				expanded = _expanded = 1;
1998 
1999 				tlen = strlen(optr);
2000 
2001 				/*
2002 				 * As ISALIST expands to a number of elements,
2003 				 * establish a new list to return to the caller.
2004 				 * This will contain the present path being
2005 				 * processed redefined for each isalist option,
2006 				 * plus the original remaining list entries.
2007 				 */
2008 				mlen = ((hlen + tlen) * (isa->isa_optno - 1)) +
2009 				    isa->isa_listsz - opt->isa_namesz;
2010 				if (*next)
2011 					mlen += strlen(*next);
2012 				if ((_next = lptr = libld_malloc(mlen)) == NULL)
2013 					return (0);
2014 
2015 				for (no = 1, opt++; no < isa->isa_optno;
2016 				    no++, opt++) {
2017 					(void) strncpy(lptr, name, hlen);
2018 					lptr = lptr + hlen;
2019 					(void) strncpy(lptr, opt->isa_name,
2020 					    opt->isa_namesz);
2021 					lptr = lptr + opt->isa_namesz;
2022 					(void) strncpy(lptr, optr, tlen);
2023 					lptr = lptr + tlen;
2024 					*lptr++ = ':';
2025 				}
2026 				if (*next)
2027 					(void) strcpy(lptr, *next);
2028 				else
2029 					*--lptr = '\0';
2030 			}
2031 		}
2032 
2033 		/*
2034 		 * If no expansion occurred skip the $ and continue.
2035 		 */
2036 		if (_expanded == 0)
2037 			*nptr++ = *optr++, nrem--;
2038 	}
2039 
2040 	/*
2041 	 * If any ISALIST processing has occurred not only do we return the
2042 	 * expanded node we're presently working on, but we must also update the
2043 	 * remaining list so that it is effectively prepended with this node
2044 	 * expanded to all remaining isalist options.  Note that we can only
2045 	 * handle one ISALIST per node.  For more than one ISALIST to be
2046 	 * processed we'd need a better algorithm than above to replace the
2047 	 * newly generated list.  Whether we want to encourage the number of
2048 	 * pathname permutations this would provide is another question. So, for
2049 	 * now if more than one ISALIST is encountered we return the original
2050 	 * node untouched.
2051 	 */
2052 	if (isaflag) {
2053 		if (isaflag == 1)
2054 			*next = _next;
2055 		else
2056 			return ((char *)name);
2057 	}
2058 
2059 	*nptr = '\0';
2060 
2061 	if (expanded) {
2062 		if ((nptr = libld_malloc(strlen(_name) + 1)) == NULL)
2063 			return ((char *)name);
2064 		(void) strcpy(nptr, _name);
2065 		return (nptr);
2066 	}
2067 	return ((char *)name);
2068 }
2069 
2070 /*
2071  * The Solaris ld does not put DT_VERSYM in the dynamic section, but the
2072  * GNU ld does, and it is used by the runtime linker to implement their
2073  * versioning scheme. Use this fact to determine if the sharable object
2074  * was produced by the GNU ld rather than the Solaris one, and to set
2075  * FLG_IF_GNUVER if so. This needs to be done before the symbols are
2076  * processed, since the answer determines whether we interpret the
2077  * symbols versions according to Solaris or GNU rules.
2078  */
2079 /*ARGSUSED*/
2080 static uintptr_t
2081 process_dynamic_isgnu(const char *name, Ifl_desc *ifl, Shdr *shdr,
2082     Elf_Scn *scn, Word ndx, int ident, Ofl_desc *ofl)
2083 {
2084 	Dyn		*dyn;
2085 	Elf_Data	*dp;
2086 	uintptr_t	error;
2087 
2088 	error = process_section(name, ifl, shdr, scn, ndx, ident, ofl);
2089 	if ((error == 0) || (error == S_ERROR))
2090 		return (error);
2091 
2092 	/* Get the .dynamic data */
2093 	dp = elf_getdata(scn, NULL);
2094 
2095 	for (dyn = (Dyn *)dp->d_buf; dyn->d_tag != DT_NULL; dyn++) {
2096 		if (dyn->d_tag == DT_VERSYM) {
2097 			ifl->ifl_flags |= FLG_IF_GNUVER;
2098 			break;
2099 		}
2100 	}
2101 	return (1);
2102 }
2103 
2104 /*
2105  * Process a dynamic section.  If we are processing an explicit shared object
2106  * then we need to determine if it has a recorded SONAME, if so, this name will
2107  * be recorded in the output file being generated as the NEEDED entry rather
2108  * than the shared objects filename itself.
2109  * If the mode of the link-edit indicates that no undefined symbols should
2110  * remain, then we also need to build up a list of any additional shared object
2111  * dependencies this object may have.  In this case save any NEEDED entries
2112  * together with any associated run-path specifications.  This information is
2113  * recorded on the `ofl_soneed' list and will be analyzed after all explicit
2114  * file processing has been completed (refer finish_libs()).
2115  */
2116 static uintptr_t
2117 process_dynamic(Is_desc *isc, Ifl_desc *ifl, Ofl_desc *ofl)
2118 {
2119 	Dyn		*data, *dyn;
2120 	char		*str, *rpath = NULL;
2121 	const char	*soname, *needed;
2122 	Boolean		no_undef;
2123 
2124 	data = (Dyn *)isc->is_indata->d_buf;
2125 	str = (char *)ifl->ifl_isdesc[isc->is_shdr->sh_link]->is_indata->d_buf;
2126 
2127 	/* Determine if we need to examine the runpaths and NEEDED entries */
2128 	no_undef = (ofl->ofl_flags & (FLG_OF_NOUNDEF | FLG_OF_SYMBOLIC)) ||
2129 	    OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS);
2130 
2131 	/*
2132 	 * First loop through the dynamic section looking for a run path.
2133 	 */
2134 	if (no_undef) {
2135 		for (dyn = data; dyn->d_tag != DT_NULL; dyn++) {
2136 			if ((dyn->d_tag != DT_RPATH) &&
2137 			    (dyn->d_tag != DT_RUNPATH))
2138 				continue;
2139 			if ((rpath = str + (size_t)dyn->d_un.d_val) == NULL)
2140 				continue;
2141 			break;
2142 		}
2143 	}
2144 
2145 	/*
2146 	 * Now look for any needed dependencies (which may use the rpath)
2147 	 * or a new SONAME.
2148 	 */
2149 	for (dyn = data; dyn->d_tag != DT_NULL; dyn++) {
2150 		if (dyn->d_tag == DT_SONAME) {
2151 			if ((soname = str + (size_t)dyn->d_un.d_val) == NULL)
2152 				continue;
2153 
2154 			/*
2155 			 * Update the input file structure with this new name.
2156 			 */
2157 			ifl->ifl_soname = soname;
2158 
2159 		} else if ((dyn->d_tag == DT_NEEDED) ||
2160 		    (dyn->d_tag == DT_USED)) {
2161 			Sdf_desc	*sdf;
2162 
2163 			if (!no_undef)
2164 				continue;
2165 			if ((needed = str + (size_t)dyn->d_un.d_val) == NULL)
2166 				continue;
2167 
2168 			/*
2169 			 * Determine if this needed entry is already recorded on
2170 			 * the shared object needed list, if not create a new
2171 			 * definition for later processing (see finish_libs()).
2172 			 */
2173 			needed = expand(ifl->ifl_name, needed, NULL);
2174 
2175 			if ((sdf = sdf_find(needed, ofl->ofl_soneed)) == NULL) {
2176 				if ((sdf = sdf_add(needed,
2177 				    &ofl->ofl_soneed)) == (Sdf_desc *)S_ERROR)
2178 					return (S_ERROR);
2179 				sdf->sdf_rfile = ifl->ifl_name;
2180 			}
2181 
2182 			/*
2183 			 * Record the runpath (Note that we take the first
2184 			 * runpath which is exactly what ld.so.1 would do during
2185 			 * its dependency processing).
2186 			 */
2187 			if (rpath && (sdf->sdf_rpath == NULL))
2188 				sdf->sdf_rpath = rpath;
2189 
2190 		} else if (dyn->d_tag == DT_FLAGS_1) {
2191 			if (dyn->d_un.d_val & (DF_1_INITFIRST | DF_1_INTERPOSE))
2192 				ifl->ifl_flags &= ~FLG_IF_LAZYLD;
2193 			if (dyn->d_un.d_val & DF_1_DISPRELPND)
2194 				ifl->ifl_flags |= FLG_IF_DISPPEND;
2195 			if (dyn->d_un.d_val & DF_1_DISPRELDNE)
2196 				ifl->ifl_flags |= FLG_IF_DISPDONE;
2197 			if (dyn->d_un.d_val & DF_1_NODIRECT)
2198 				ifl->ifl_flags |= FLG_IF_NODIRECT;
2199 
2200 			/*
2201 			 * If we are building an executable, and this
2202 			 * dependency is tagged as an interposer, then
2203 			 * assume that it is required even if symbol
2204 			 * resolution uncovers no evident use.
2205 			 *
2206 			 * If we are building a shared object, then an
2207 			 * interposer dependency has no special meaning, and we
2208 			 * treat it as a regular dependency. By definition, all
2209 			 * interposers must be visible to the runtime linker
2210 			 * at initialization time, and cannot be added later.
2211 			 */
2212 			if ((dyn->d_un.d_val & DF_1_INTERPOSE) &&
2213 			    (ofl->ofl_flags & FLG_OF_EXEC))
2214 				ifl->ifl_flags |= FLG_IF_DEPREQD;
2215 
2216 		} else if ((dyn->d_tag == DT_AUDIT) &&
2217 		    (ifl->ifl_flags & FLG_IF_NEEDED)) {
2218 			/*
2219 			 * Record audit string as DT_DEPAUDIT.
2220 			 */
2221 			if ((ofl->ofl_depaudit = add_string(ofl->ofl_depaudit,
2222 			    (str + (size_t)dyn->d_un.d_val))) ==
2223 			    (const char *)S_ERROR)
2224 				return (S_ERROR);
2225 
2226 		} else if (dyn->d_tag == DT_SUNW_RTLDINF) {
2227 			/*
2228 			 * If this dependency has the DT_SUNW_RTLDINF .dynamic
2229 			 * entry, then ensure no specialized dependency
2230 			 * processing is in effect.  This tag identifies libc,
2231 			 * which provides critical startup information (TLS
2232 			 * routines, threads initialization, etc.) that must
2233 			 * be exercised as part of process initialization.
2234 			 */
2235 			ifl->ifl_flags &= ~MSK_IF_POSFLAG1;
2236 
2237 			/*
2238 			 * libc is not subject to the usual guidance checks
2239 			 * for lazy loading. It cannot be lazy loaded, libld
2240 			 * ignores the request, and rtld would ignore the
2241 			 * setting if it were present.
2242 			 */
2243 			ifl->ifl_flags |= FLG_IF_RTLDINF;
2244 		}
2245 	}
2246 
2247 	/*
2248 	 * Perform some SONAME sanity checks.
2249 	 */
2250 	if (ifl->ifl_flags & FLG_IF_NEEDED) {
2251 		Ifl_desc	*sifl;
2252 		Aliste		idx;
2253 
2254 		/*
2255 		 * Determine if anyone else will cause the same SONAME to be
2256 		 * used (this is either caused by two different files having the
2257 		 * same SONAME, or by one file SONAME actually matching another
2258 		 * file basename (if no SONAME is specified within a shared
2259 		 * library its basename will be used)). Probably rare, but some
2260 		 * idiot will do it.
2261 		 */
2262 		for (APLIST_TRAVERSE(ofl->ofl_sos, idx, sifl)) {
2263 			if ((strcmp(ifl->ifl_soname, sifl->ifl_soname) == 0) &&
2264 			    (ifl != sifl)) {
2265 				const char	*hint, *iflb, *siflb;
2266 
2267 				/*
2268 				 * Determine the basename of each file. Perhaps
2269 				 * there are multiple copies of the same file
2270 				 * being brought in using different -L search
2271 				 * paths, and if so give an extra hint in the
2272 				 * error message.
2273 				 */
2274 				iflb = strrchr(ifl->ifl_name, '/');
2275 				if (iflb == NULL)
2276 					iflb = ifl->ifl_name;
2277 				else
2278 					iflb++;
2279 
2280 				siflb = strrchr(sifl->ifl_name, '/');
2281 				if (siflb == NULL)
2282 					siflb = sifl->ifl_name;
2283 				else
2284 					siflb++;
2285 
2286 				if (strcmp(iflb, siflb) == 0)
2287 					hint = MSG_INTL(MSG_REC_CNFLTHINT);
2288 				else
2289 					hint = MSG_ORIG(MSG_STR_EMPTY);
2290 
2291 				ld_eprintf(ofl, ERR_FATAL,
2292 				    MSG_INTL(MSG_REC_OBJCNFLT), sifl->ifl_name,
2293 				    ifl->ifl_name, sifl->ifl_soname, hint);
2294 				return (0);
2295 			}
2296 		}
2297 
2298 		/*
2299 		 * If the SONAME is the same as the name the user wishes to
2300 		 * record when building a dynamic library (refer -h option),
2301 		 * we also have a name clash.
2302 		 */
2303 		if (ofl->ofl_soname &&
2304 		    (strcmp(ofl->ofl_soname, ifl->ifl_soname) == 0)) {
2305 			ld_eprintf(ofl, ERR_FATAL,
2306 			    MSG_INTL(MSG_REC_OPTCNFLT), ifl->ifl_name,
2307 			    MSG_INTL(MSG_MARG_SONAME), ifl->ifl_soname);
2308 			return (0);
2309 		}
2310 	}
2311 	return (1);
2312 }
2313 
2314 /*
2315  * Process a progbits section from a relocatable object (ET_REL).
2316  * This is used on non-amd64 objects to recognize .eh_frame sections.
2317  */
2318 /*ARGSUSED1*/
2319 static uintptr_t
2320 process_progbits_final(Is_desc *isc, Ifl_desc *ifl, Ofl_desc *ofl)
2321 {
2322 	if (isc->is_osdesc && (isc->is_flags & FLG_IS_EHFRAME) &&
2323 	    (ld_unwind_register(isc->is_osdesc, ofl) == S_ERROR))
2324 		return (S_ERROR);
2325 
2326 	return (1);
2327 }
2328 
2329 /*
2330  * Process a group section.
2331  */
2332 static uintptr_t
2333 process_group(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn,
2334     Word ndx, int ident, Ofl_desc *ofl)
2335 {
2336 	uintptr_t	error;
2337 
2338 	error = process_section(name, ifl, shdr, scn, ndx, ident, ofl);
2339 	if ((error == 0) || (error == S_ERROR))
2340 		return (error);
2341 
2342 	/*
2343 	 * Indicate that this input file has groups to process.  Groups are
2344 	 * processed after all input sections have been processed.
2345 	 */
2346 	ifl->ifl_flags |= FLG_IS_GROUPS;
2347 
2348 	return (1);
2349 }
2350 
2351 /*
2352  * Process a relocation entry. At this point all input sections from this
2353  * input file have been assigned an input section descriptor which is saved
2354  * in the `ifl_isdesc' array.
2355  */
2356 static uintptr_t
2357 rel_process(Is_desc *isc, Ifl_desc *ifl, Ofl_desc *ofl)
2358 {
2359 	Word 	rndx;
2360 	Is_desc	*risc;
2361 	Os_desc	*osp;
2362 	Shdr	*shdr = isc->is_shdr;
2363 	Conv_inv_buf_t inv_buf;
2364 
2365 	/*
2366 	 * Make sure this is a valid relocation we can handle.
2367 	 */
2368 	if (shdr->sh_type != ld_targ.t_m.m_rel_sht_type) {
2369 		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_INVALSEC),
2370 		    ifl->ifl_name, EC_WORD(isc->is_scnndx), isc->is_name,
2371 		    conv_sec_type(ifl->ifl_ehdr->e_ident[EI_OSABI],
2372 		    ifl->ifl_ehdr->e_machine, shdr->sh_type, 0, &inv_buf));
2373 		return (0);
2374 	}
2375 
2376 	/*
2377 	 * From the relocation section header information determine which
2378 	 * section needs the actual relocation.  Determine which output section
2379 	 * this input section has been assigned to and add to its relocation
2380 	 * list.  Note that the relocation section may be null if it is not
2381 	 * required (ie. .debug, .stabs, etc).
2382 	 */
2383 	rndx = shdr->sh_info;
2384 	if (rndx >= ifl->ifl_shnum) {
2385 		/*
2386 		 * Broken input file.
2387 		 */
2388 		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_INVSHINFO),
2389 		    ifl->ifl_name, EC_WORD(isc->is_scnndx), isc->is_name,
2390 		    EC_XWORD(rndx));
2391 		return (0);
2392 	}
2393 	if (rndx == 0) {
2394 		if (aplist_append(&ofl->ofl_extrarels, isc,
2395 		    AL_CNT_OFL_RELS) == NULL)
2396 			return (S_ERROR);
2397 
2398 	} else if ((risc = ifl->ifl_isdesc[rndx]) != NULL) {
2399 		/*
2400 		 * Discard relocations if they are against a section
2401 		 * which has been discarded.
2402 		 */
2403 		if (risc->is_flags & FLG_IS_DISCARD)
2404 			return (1);
2405 
2406 		if ((osp = risc->is_osdesc) == NULL) {
2407 			if (risc->is_shdr->sh_type == SHT_SUNW_move) {
2408 				/*
2409 				 * This section is processed later in
2410 				 * process_movereloc().
2411 				 */
2412 				if (aplist_append(&ofl->ofl_ismoverel,
2413 				    isc, AL_CNT_OFL_MOVE) == NULL)
2414 					return (S_ERROR);
2415 				return (1);
2416 			}
2417 			ld_eprintf(ofl, ERR_FATAL,
2418 			    MSG_INTL(MSG_FIL_INVRELOC1), ifl->ifl_name,
2419 			    EC_WORD(isc->is_scnndx), isc->is_name,
2420 			    EC_WORD(risc->is_scnndx), risc->is_name);
2421 			return (0);
2422 		}
2423 		if (aplist_append(&osp->os_relisdescs, isc,
2424 		    AL_CNT_OS_RELISDESCS) == NULL)
2425 			return (S_ERROR);
2426 	}
2427 	return (1);
2428 }
2429 
2430 /*
2431  * SHF_EXCLUDE flags is set for this section.
2432  */
2433 static uintptr_t
2434 process_exclude(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn,
2435     Word ndx, Ofl_desc *ofl)
2436 {
2437 	/*
2438 	 * Sections SHT_SYMTAB and SHT_DYNDYM, even if SHF_EXCLUDE is on, might
2439 	 * be needed for ld processing.  These sections need to be in the
2440 	 * internal table.  Later it will be determined whether they can be
2441 	 * eliminated or not.
2442 	 */
2443 	if (shdr->sh_type == SHT_SYMTAB || shdr->sh_type == SHT_DYNSYM)
2444 		return (0);
2445 
2446 	/*
2447 	 * Other checks
2448 	 */
2449 	if (shdr->sh_flags & SHF_ALLOC) {
2450 		/*
2451 		 * A conflict, issue an warning message, and ignore the section.
2452 		 */
2453 		ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_FIL_EXCLUDE),
2454 		    ifl->ifl_name, EC_WORD(ndx), name);
2455 		return (0);
2456 	}
2457 
2458 	/*
2459 	 * This sections is not going to the output file.
2460 	 */
2461 	return (process_section(name, ifl, shdr, scn, ndx, 0, ofl));
2462 }
2463 
2464 /*
2465  * Section processing state table.  `Initial' describes the required initial
2466  * procedure to be called (if any), `Final' describes the final processing
2467  * procedure (ie. things that can only be done when all required sections
2468  * have been collected).
2469  */
2470 typedef uintptr_t	(* initial_func_t)(const char *, Ifl_desc *, Shdr *,
2471 			    Elf_Scn *, Word, int, Ofl_desc *);
2472 
2473 static initial_func_t Initial[SHT_NUM][2] = {
2474 /*			ET_REL			ET_DYN			*/
2475 
2476 /* SHT_NULL	*/	invalid_section,	invalid_section,
2477 /* SHT_PROGBITS	*/	process_progbits,	process_progbits,
2478 /* SHT_SYMTAB	*/	process_input,		process_input,
2479 /* SHT_STRTAB	*/	process_strtab,		process_strtab,
2480 /* SHT_RELA	*/	process_reloc,		process_reloc,
2481 /* SHT_HASH	*/	invalid_section,	NULL,
2482 /* SHT_DYNAMIC	*/	process_rel_dynamic,	process_dynamic_isgnu,
2483 /* SHT_NOTE	*/	process_section,	NULL,
2484 /* SHT_NOBITS	*/	process_nobits,		process_nobits,
2485 /* SHT_REL	*/	process_reloc,		process_reloc,
2486 /* SHT_SHLIB	*/	process_section,	invalid_section,
2487 /* SHT_DYNSYM	*/	invalid_section,	process_input,
2488 /* SHT_UNKNOWN12 */	process_progbits,	process_progbits,
2489 /* SHT_UNKNOWN13 */	process_progbits,	process_progbits,
2490 /* SHT_INIT_ARRAY */	process_array,		NULL,
2491 /* SHT_FINI_ARRAY */	process_array,		NULL,
2492 /* SHT_PREINIT_ARRAY */	process_array,		NULL,
2493 /* SHT_GROUP */		process_group,		invalid_section,
2494 /* SHT_SYMTAB_SHNDX */	process_sym_shndx,	NULL
2495 };
2496 
2497 typedef uintptr_t	(* final_func_t)(Is_desc *, Ifl_desc *, Ofl_desc *);
2498 
2499 static final_func_t Final[SHT_NUM][2] = {
2500 /*			ET_REL			ET_DYN			*/
2501 
2502 /* SHT_NULL	*/	NULL,			NULL,
2503 /* SHT_PROGBITS	*/	process_progbits_final,	NULL,
2504 /* SHT_SYMTAB	*/	ld_sym_process,		ld_sym_process,
2505 /* SHT_STRTAB	*/	NULL,			NULL,
2506 /* SHT_RELA	*/	rel_process,		NULL,
2507 /* SHT_HASH	*/	NULL,			NULL,
2508 /* SHT_DYNAMIC	*/	NULL,			process_dynamic,
2509 /* SHT_NOTE	*/	NULL,			NULL,
2510 /* SHT_NOBITS	*/	NULL,			NULL,
2511 /* SHT_REL	*/	rel_process,		NULL,
2512 /* SHT_SHLIB	*/	NULL,			NULL,
2513 /* SHT_DYNSYM	*/	NULL,			ld_sym_process,
2514 /* SHT_UNKNOWN12 */	NULL,			NULL,
2515 /* SHT_UNKNOWN13 */	NULL,			NULL,
2516 /* SHT_INIT_ARRAY */	array_process,		NULL,
2517 /* SHT_FINI_ARRAY */	array_process,		NULL,
2518 /* SHT_PREINIT_ARRAY */	array_process,		NULL,
2519 /* SHT_GROUP */		NULL,			NULL,
2520 /* SHT_SYMTAB_SHNDX */	sym_shndx_process,	NULL
2521 };
2522 
2523 #define	MAXNDXSIZE	10
2524 
2525 /*
2526  * Process an elf file.  Each section is compared against the section state
2527  * table to determine whether it should be processed (saved), ignored, or
2528  * is invalid for the type of input file being processed.
2529  */
2530 static uintptr_t
2531 process_elf(Ifl_desc *ifl, Elf *elf, Ofl_desc *ofl)
2532 {
2533 	Elf_Scn		*scn;
2534 	Shdr		*shdr;
2535 	Word		ndx, sndx, ordndx = 0, ordcnt = 0;
2536 	char		*str, *name;
2537 	Word		row, column;
2538 	int		ident;
2539 	uintptr_t	error;
2540 	Is_desc		*vdfisp, *vndisp, *vsyisp, *sifisp;
2541 	Is_desc		*capinfoisp, *capisp;
2542 	Sdf_desc	*sdf;
2543 	Place_path_info	path_info_buf, *path_info;
2544 
2545 	/*
2546 	 * Path information buffer used by ld_place_section() and related
2547 	 * routines. This information is used to evaluate entrance criteria
2548 	 * with non-empty file matching lists (ec_files).
2549 	 */
2550 	path_info = ld_place_path_info_init(ofl, ifl, &path_info_buf);
2551 
2552 	/*
2553 	 * First process the .shstrtab section so that later sections can
2554 	 * reference their name.
2555 	 */
2556 	ld_sup_file(ofl, ifl->ifl_name, elf_kind(elf), ifl->ifl_flags, elf);
2557 
2558 	sndx = ifl->ifl_shstrndx;
2559 	if ((scn = elf_getscn(elf, (size_t)sndx)) == NULL) {
2560 		ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_GETSCN),
2561 		    ifl->ifl_name);
2562 		return (0);
2563 	}
2564 	if ((shdr = elf_getshdr(scn)) == NULL) {
2565 		ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_GETSHDR),
2566 		    ifl->ifl_name);
2567 		return (0);
2568 	}
2569 	if ((name = elf_strptr(elf, (size_t)sndx, (size_t)shdr->sh_name)) ==
2570 	    NULL) {
2571 		ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_STRPTR),
2572 		    ifl->ifl_name);
2573 		return (0);
2574 	}
2575 
2576 	if (ld_sup_input_section(ofl, ifl, name, &shdr, sndx, scn,
2577 	    elf) == S_ERROR)
2578 		return (S_ERROR);
2579 
2580 	/*
2581 	 * Reset the name since the shdr->sh_name could have been changed as
2582 	 * part of ld_sup_input_section().
2583 	 */
2584 	if ((name = elf_strptr(elf, (size_t)sndx, (size_t)shdr->sh_name)) ==
2585 	    NULL) {
2586 		ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_STRPTR),
2587 		    ifl->ifl_name);
2588 		return (0);
2589 	}
2590 
2591 	error = process_strtab(name, ifl, shdr, scn, sndx, FALSE, ofl);
2592 	if ((error == 0) || (error == S_ERROR))
2593 		return (error);
2594 	str = ifl->ifl_isdesc[sndx]->is_indata->d_buf;
2595 
2596 	/*
2597 	 * Determine the state table column from the input file type.  Note,
2598 	 * shared library sections are not added to the output section list.
2599 	 */
2600 	if (ifl->ifl_ehdr->e_type == ET_DYN) {
2601 		column = 1;
2602 		ofl->ofl_soscnt++;
2603 		ident = ld_targ.t_id.id_null;
2604 	} else {
2605 		column = 0;
2606 		ofl->ofl_objscnt++;
2607 		ident = ld_targ.t_id.id_unknown;
2608 	}
2609 
2610 	DBG_CALL(Dbg_file_generic(ofl->ofl_lml, ifl));
2611 	ndx = 0;
2612 	vdfisp = vndisp = vsyisp = sifisp = capinfoisp = capisp = NULL;
2613 	scn = NULL;
2614 	while (scn = elf_nextscn(elf, scn)) {
2615 		ndx++;
2616 
2617 		/*
2618 		 * As we've already processed the .shstrtab don't do it again.
2619 		 */
2620 		if (ndx == sndx)
2621 			continue;
2622 
2623 		if ((shdr = elf_getshdr(scn)) == NULL) {
2624 			ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_GETSHDR),
2625 			    ifl->ifl_name);
2626 			return (0);
2627 		}
2628 		name = str + (size_t)(shdr->sh_name);
2629 
2630 		if (ld_sup_input_section(ofl, ifl, name, &shdr, ndx, scn,
2631 		    elf) == S_ERROR)
2632 			return (S_ERROR);
2633 
2634 		/*
2635 		 * Reset the name since the shdr->sh_name could have been
2636 		 * changed as part of ld_sup_input_section().
2637 		 */
2638 		name = str + (size_t)(shdr->sh_name);
2639 
2640 		row = shdr->sh_type;
2641 
2642 		/*
2643 		 * If the section has the SHF_EXCLUDE flag on, and we're not
2644 		 * generating a relocatable object, exclude the section.
2645 		 */
2646 		if (((shdr->sh_flags & SHF_EXCLUDE) != 0) &&
2647 		    ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0)) {
2648 			if ((error = process_exclude(name, ifl, shdr, scn,
2649 			    ndx, ofl)) == S_ERROR)
2650 				return (S_ERROR);
2651 			if (error == 1)
2652 				continue;
2653 		}
2654 
2655 		/*
2656 		 * If this is a standard section type process it via the
2657 		 * appropriate action routine.
2658 		 */
2659 		if (row < SHT_NUM) {
2660 			if (Initial[row][column] != NULL) {
2661 				if (Initial[row][column](name, ifl, shdr, scn,
2662 				    ndx, ident, ofl) == S_ERROR)
2663 					return (S_ERROR);
2664 			}
2665 		} else {
2666 			/*
2667 			 * If this section is below SHT_LOSUNW then we don't
2668 			 * really know what to do with it, issue a warning
2669 			 * message but do the basic section processing anyway.
2670 			 */
2671 			if (row < (Word)SHT_LOSUNW) {
2672 				Conv_inv_buf_t inv_buf;
2673 
2674 				ld_eprintf(ofl, ERR_WARNING,
2675 				    MSG_INTL(MSG_FIL_INVALSEC), ifl->ifl_name,
2676 				    EC_WORD(ndx), name, conv_sec_type(
2677 				    ifl->ifl_ehdr->e_ident[EI_OSABI],
2678 				    ifl->ifl_ehdr->e_machine,
2679 				    shdr->sh_type, 0, &inv_buf));
2680 			}
2681 
2682 			/*
2683 			 * Handle sections greater than SHT_LOSUNW.
2684 			 */
2685 			switch (row) {
2686 			case SHT_SUNW_dof:
2687 				if (process_section(name, ifl, shdr, scn,
2688 				    ndx, ident, ofl) == S_ERROR)
2689 					return (S_ERROR);
2690 				break;
2691 			case SHT_SUNW_cap:
2692 				if (process_section(name, ifl, shdr, scn, ndx,
2693 				    ld_targ.t_id.id_null, ofl) == S_ERROR)
2694 					return (S_ERROR);
2695 				capisp = ifl->ifl_isdesc[ndx];
2696 				break;
2697 			case SHT_SUNW_capinfo:
2698 				if (process_section(name, ifl, shdr, scn, ndx,
2699 				    ld_targ.t_id.id_null, ofl) == S_ERROR)
2700 					return (S_ERROR);
2701 				capinfoisp = ifl->ifl_isdesc[ndx];
2702 				break;
2703 			case SHT_SUNW_DEBUGSTR:
2704 			case SHT_SUNW_DEBUG:
2705 				if (process_debug(name, ifl, shdr, scn,
2706 				    ndx, ident, ofl) == S_ERROR)
2707 					return (S_ERROR);
2708 				break;
2709 			case SHT_SUNW_move:
2710 				if (process_section(name, ifl, shdr, scn, ndx,
2711 				    ld_targ.t_id.id_null, ofl) == S_ERROR)
2712 					return (S_ERROR);
2713 				break;
2714 			case SHT_SUNW_syminfo:
2715 				if (process_section(name, ifl, shdr, scn, ndx,
2716 				    ld_targ.t_id.id_null, ofl) == S_ERROR)
2717 					return (S_ERROR);
2718 				sifisp = ifl->ifl_isdesc[ndx];
2719 				break;
2720 			case SHT_SUNW_ANNOTATE:
2721 				if (process_progbits(name, ifl, shdr, scn,
2722 				    ndx, ident, ofl) == S_ERROR)
2723 					return (S_ERROR);
2724 				break;
2725 			case SHT_SUNW_COMDAT:
2726 				if (process_progbits(name, ifl, shdr, scn,
2727 				    ndx, ident, ofl) == S_ERROR)
2728 					return (S_ERROR);
2729 				ifl->ifl_isdesc[ndx]->is_flags |= FLG_IS_COMDAT;
2730 				break;
2731 			case SHT_SUNW_verdef:
2732 				if (process_section(name, ifl, shdr, scn, ndx,
2733 				    ld_targ.t_id.id_null, ofl) == S_ERROR)
2734 					return (S_ERROR);
2735 				vdfisp = ifl->ifl_isdesc[ndx];
2736 				break;
2737 			case SHT_SUNW_verneed:
2738 				if (process_section(name, ifl, shdr, scn, ndx,
2739 				    ld_targ.t_id.id_null, ofl) == S_ERROR)
2740 					return (S_ERROR);
2741 				vndisp = ifl->ifl_isdesc[ndx];
2742 				break;
2743 			case SHT_SUNW_versym:
2744 				if (process_section(name, ifl, shdr, scn, ndx,
2745 				    ld_targ.t_id.id_null, ofl) == S_ERROR)
2746 					return (S_ERROR);
2747 				vsyisp = ifl->ifl_isdesc[ndx];
2748 				break;
2749 			case SHT_SPARC_GOTDATA:
2750 				/*
2751 				 * SHT_SPARC_GOTDATA (0x70000000) is in the
2752 				 * SHT_LOPROC - SHT_HIPROC range reserved
2753 				 * for processor-specific semantics. It is
2754 				 * only meaningful for sparc targets.
2755 				 */
2756 				if (ld_targ.t_m.m_mach !=
2757 				    LD_TARG_BYCLASS(EM_SPARC, EM_SPARCV9))
2758 					goto do_default;
2759 				if (process_section(name, ifl, shdr, scn, ndx,
2760 				    ld_targ.t_id.id_gotdata, ofl) == S_ERROR)
2761 					return (S_ERROR);
2762 				break;
2763 #if	defined(_ELF64)
2764 			case SHT_AMD64_UNWIND:
2765 				/*
2766 				 * SHT_AMD64_UNWIND (0x70000001) is in the
2767 				 * SHT_LOPROC - SHT_HIPROC range reserved
2768 				 * for processor-specific semantics. It is
2769 				 * only meaningful for amd64 targets.
2770 				 */
2771 				if (ld_targ.t_m.m_mach != EM_AMD64)
2772 					goto do_default;
2773 
2774 				/*
2775 				 * Target is x86, so this really is
2776 				 * SHT_AMD64_UNWIND
2777 				 */
2778 				if (column == 0) {
2779 					/*
2780 					 * column == ET_REL
2781 					 */
2782 					if (process_section(name, ifl, shdr,
2783 					    scn, ndx, ld_targ.t_id.id_unwind,
2784 					    ofl) == S_ERROR)
2785 						return (S_ERROR);
2786 					ifl->ifl_isdesc[ndx]->is_flags |=
2787 					    FLG_IS_EHFRAME;
2788 				}
2789 				break;
2790 #endif
2791 			default:
2792 			do_default:
2793 				if (process_section(name, ifl, shdr, scn, ndx,
2794 				    ((ident == ld_targ.t_id.id_null) ?
2795 				    ident : ld_targ.t_id.id_user), ofl) ==
2796 				    S_ERROR)
2797 					return (S_ERROR);
2798 				break;
2799 			}
2800 		}
2801 	}
2802 
2803 	/*
2804 	 * Now that all input sections have been analyzed, and prior to placing
2805 	 * any input sections to their output sections, process any groups.
2806 	 * Groups can contribute COMDAT items, which may get discarded as part
2807 	 * of placement.  In addition, COMDAT names may require transformation
2808 	 * to indicate different output section placement.
2809 	 */
2810 	if (ifl->ifl_flags & FLG_IS_GROUPS) {
2811 		for (ndx = 1; ndx < ifl->ifl_shnum; ndx++) {
2812 			Is_desc	*isp;
2813 
2814 			if (((isp = ifl->ifl_isdesc[ndx]) == NULL) ||
2815 			    (isp->is_shdr->sh_type != SHT_GROUP))
2816 				continue;
2817 
2818 			if (ld_group_process(isp, ofl) == S_ERROR)
2819 				return (S_ERROR);
2820 		}
2821 	}
2822 
2823 	/*
2824 	 * Now that all of the input sections have been processed, place
2825 	 * them in the appropriate output sections.
2826 	 */
2827 	for (ndx = 1; ndx < ifl->ifl_shnum; ndx++) {
2828 		Is_desc	*isp;
2829 
2830 		if (((isp = ifl->ifl_isdesc[ndx]) == NULL) ||
2831 		    ((isp->is_flags & FLG_IS_PLACE) == 0))
2832 			continue;
2833 
2834 		/*
2835 		 * Place all non-ordered sections within their appropriate
2836 		 * output section.
2837 		 */
2838 		if ((isp->is_flags & FLG_IS_ORDERED) == 0) {
2839 			if (ld_place_section(ofl, isp, path_info,
2840 			    isp->is_keyident, NULL) == (Os_desc *)S_ERROR)
2841 				return (S_ERROR);
2842 			continue;
2843 		}
2844 
2845 		/*
2846 		 * Count the number of ordered sections and retain the first
2847 		 * ordered section index. This will be used to optimize the
2848 		 * ordered section loop that immediately follows this one.
2849 		 */
2850 		ordcnt++;
2851 		if (ordndx == 0)
2852 			ordndx = ndx;
2853 	}
2854 
2855 	/*
2856 	 * Having placed all the non-ordered sections, it is now
2857 	 * safe to place SHF_ORDERED/SHF_LINK_ORDER sections.
2858 	 */
2859 	if (ifl->ifl_flags & FLG_IF_ORDERED) {
2860 		for (ndx = ordndx; ndx < ifl->ifl_shnum; ndx++) {
2861 			Is_desc	*isp;
2862 
2863 			if (((isp = ifl->ifl_isdesc[ndx]) == NULL) ||
2864 			    ((isp->is_flags &
2865 			    (FLG_IS_PLACE | FLG_IS_ORDERED)) !=
2866 			    (FLG_IS_PLACE | FLG_IS_ORDERED)))
2867 				continue;
2868 
2869 			/* ld_process_ordered() calls ld_place_section() */
2870 			if (ld_process_ordered(ofl, ifl, path_info, ndx) ==
2871 			    S_ERROR)
2872 				return (S_ERROR);
2873 
2874 			/* If we've done them all, stop searching */
2875 			if (--ordcnt == 0)
2876 				break;
2877 		}
2878 	}
2879 
2880 	/*
2881 	 * If this is a shared object explicitly specified on the command
2882 	 * line (as opposed to being a dependency of such an object),
2883 	 * determine if the user has specified a control definition. This
2884 	 * descriptor may specify which version definitions can be used
2885 	 * from this object. It may also update the dependency to USED and
2886 	 * supply an alternative SONAME.
2887 	 */
2888 	sdf = NULL;
2889 	if (column && (ifl->ifl_flags & FLG_IF_NEEDED)) {
2890 		const char	*base;
2891 
2892 		/*
2893 		 * Use the basename of the input file (typically this is the
2894 		 * compilation environment name, ie. libfoo.so).
2895 		 */
2896 		if ((base = strrchr(ifl->ifl_name, '/')) == NULL)
2897 			base = ifl->ifl_name;
2898 		else
2899 			base++;
2900 
2901 		if ((sdf = sdf_find(base, ofl->ofl_socntl)) != NULL) {
2902 			sdf->sdf_file = ifl;
2903 			ifl->ifl_sdfdesc = sdf;
2904 		}
2905 	}
2906 
2907 	/*
2908 	 * Before symbol processing, process any capabilities.  Capabilities
2909 	 * can reference a string table, which is why this processing is
2910 	 * carried out after the initial section processing.  Capabilities,
2911 	 * together with -z symbolcap, can require the conversion of global
2912 	 * symbols to local symbols.
2913 	 */
2914 	if (capisp && (process_cap(ofl, ifl, capisp) == S_ERROR))
2915 		return (S_ERROR);
2916 
2917 	/*
2918 	 * Process any version dependencies.  These will establish shared object
2919 	 * `needed' entries in the same manner as will be generated from the
2920 	 * .dynamic's NEEDED entries.
2921 	 */
2922 	if (vndisp && ((ofl->ofl_flags & (FLG_OF_NOUNDEF | FLG_OF_SYMBOLIC)) ||
2923 	    OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS)))
2924 		if (ld_vers_need_process(vndisp, ifl, ofl) == S_ERROR)
2925 			return (S_ERROR);
2926 
2927 	/*
2928 	 * Before processing any symbol resolution or relocations process any
2929 	 * version sections.
2930 	 */
2931 	if (vsyisp)
2932 		(void) ld_vers_sym_process(ofl, vsyisp, ifl);
2933 
2934 	if (ifl->ifl_versym &&
2935 	    (vdfisp || (sdf && (sdf->sdf_flags & FLG_SDF_SELECT))))
2936 		if (ld_vers_def_process(vdfisp, ifl, ofl) == S_ERROR)
2937 			return (S_ERROR);
2938 
2939 	/*
2940 	 * Having collected the appropriate sections carry out any additional
2941 	 * processing if necessary.
2942 	 */
2943 	for (ndx = 0; ndx < ifl->ifl_shnum; ndx++) {
2944 		Is_desc	*isp;
2945 
2946 		if ((isp = ifl->ifl_isdesc[ndx]) == NULL)
2947 			continue;
2948 		row = isp->is_shdr->sh_type;
2949 
2950 		if ((isp->is_flags & FLG_IS_DISCARD) == 0)
2951 			ld_sup_section(ofl, isp->is_name, isp->is_shdr, ndx,
2952 			    isp->is_indata, elf);
2953 
2954 		/*
2955 		 * If this is a SHT_SUNW_move section from a relocatable file,
2956 		 * keep track of the section for later processing.
2957 		 */
2958 		if ((row == SHT_SUNW_move) && (column == 0)) {
2959 			if (aplist_append(&(ofl->ofl_ismove), isp,
2960 			    AL_CNT_OFL_MOVE) == NULL)
2961 				return (S_ERROR);
2962 		}
2963 
2964 		/*
2965 		 * If this is a standard section type process it via the
2966 		 * appropriate action routine.
2967 		 */
2968 		if (row < SHT_NUM) {
2969 			if (Final[row][column] != NULL) {
2970 				if (Final[row][column](isp, ifl,
2971 				    ofl) == S_ERROR)
2972 					return (S_ERROR);
2973 			}
2974 #if	defined(_ELF64)
2975 		} else if ((row == SHT_AMD64_UNWIND) && (column == 0)) {
2976 			Os_desc	*osp = isp->is_osdesc;
2977 
2978 			/*
2979 			 * SHT_AMD64_UNWIND (0x70000001) is in the SHT_LOPROC -
2980 			 * SHT_HIPROC range reserved for processor-specific
2981 			 * semantics, and is only meaningful for amd64 targets.
2982 			 *
2983 			 * Only process unwind contents from relocatable
2984 			 * objects.
2985 			 */
2986 			if (osp && (ld_targ.t_m.m_mach == EM_AMD64) &&
2987 			    (ld_unwind_register(osp, ofl) == S_ERROR))
2988 				return (S_ERROR);
2989 #endif
2990 		}
2991 	}
2992 
2993 	/*
2994 	 * Following symbol processing, if this relocatable object input file
2995 	 * provides symbol capabilities, tag the associated symbols so that
2996 	 * the symbols can be re-assigned to the new capabilities symbol
2997 	 * section that will be created for the output file.
2998 	 */
2999 	if (capinfoisp && (ifl->ifl_ehdr->e_type == ET_REL) &&
3000 	    (process_capinfo(ofl, ifl, capinfoisp) == S_ERROR))
3001 		return (S_ERROR);
3002 
3003 	/*
3004 	 * After processing any symbol resolution, and if this dependency
3005 	 * indicates it contains symbols that can't be directly bound to,
3006 	 * set the symbols appropriately.
3007 	 */
3008 	if (sifisp && ((ifl->ifl_flags & (FLG_IF_NEEDED | FLG_IF_NODIRECT)) ==
3009 	    (FLG_IF_NEEDED | FLG_IF_NODIRECT)))
3010 		(void) ld_sym_nodirect(sifisp, ifl, ofl);
3011 
3012 	return (1);
3013 }
3014 
3015 /*
3016  * Process the current input file.  There are basically three types of files
3017  * that come through here:
3018  *
3019  *  -	files explicitly defined on the command line (ie. foo.o or bar.so),
3020  *	in this case only the `name' field is valid.
3021  *
3022  *  -	libraries determined from the -l command line option (ie. -lbar),
3023  *	in this case the `soname' field contains the basename of the located
3024  *	file.
3025  *
3026  * Any shared object specified via the above two conventions must be recorded
3027  * as a needed dependency.
3028  *
3029  *  -	libraries specified as dependencies of those libraries already obtained
3030  *	via the command line (ie. bar.so has a DT_NEEDED entry of fred.so.1),
3031  *	in this case the `soname' field contains either a full pathname (if the
3032  *	needed entry contained a `/'), or the basename of the located file.
3033  *	These libraries are processed to verify symbol binding but are not
3034  *	recorded as dependencies of the output file being generated.
3035  *
3036  * entry:
3037  *	name - File name
3038  *	soname - SONAME for needed sharable library, as described above
3039  *	fd - Open file descriptor
3040  *	elf - Open ELF handle
3041  *	flags - FLG_IF_ flags applicable to file
3042  *	ofl - Output file descriptor
3043  *	rej - Rejection descriptor used to record rejection reason
3044  *	ifl_ret - NULL, or address of pointer to receive reference to
3045  *		resulting input descriptor for file. If ifl_ret is non-NULL,
3046  *		the file cannot be an archive or it will be rejected.
3047  *
3048  * exit:
3049  *	If a error occurs in examining the file, S_ERROR is returned.
3050  *	If the file can be examined, but is not suitable, *rej is updated,
3051  *	and 0 is returned. If the file is acceptable, 1 is returned, and if
3052  *	ifl_ret is non-NULL, *ifl_ret is set to contain the pointer to the
3053  *	resulting input descriptor.
3054  */
3055 uintptr_t
3056 ld_process_ifl(const char *name, const char *soname, int fd, Elf *elf,
3057     Word flags, Ofl_desc *ofl, Rej_desc *rej, Ifl_desc **ifl_ret)
3058 {
3059 	Ifl_desc	*ifl;
3060 	Ehdr		*ehdr;
3061 	uintptr_t	error = 0;
3062 	struct stat	status;
3063 	Ar_desc		*adp;
3064 	Rej_desc	_rej;
3065 
3066 	/*
3067 	 * If this file was not extracted from an archive obtain its device
3068 	 * information.  This will be used to determine if the file has already
3069 	 * been processed (rather than simply comparing filenames, the device
3070 	 * information provides a quicker comparison and detects linked files).
3071 	 */
3072 	if (fd && ((flags & FLG_IF_EXTRACT) == 0))
3073 		(void) fstat(fd, &status);
3074 	else {
3075 		status.st_dev = 0;
3076 		status.st_ino = 0;
3077 	}
3078 
3079 	switch (elf_kind(elf)) {
3080 	case ELF_K_AR:
3081 		/*
3082 		 * If the caller has supplied a non-NULL ifl_ret, then
3083 		 * we cannot process archives, for there will be no
3084 		 * input file descriptor for us to return. In this case,
3085 		 * reject the attempt.
3086 		 */
3087 		if (ifl_ret != NULL) {
3088 			_rej.rej_type = SGS_REJ_ARCHIVE;
3089 			_rej.rej_name = name;
3090 			DBG_CALL(Dbg_file_rejected(ofl->ofl_lml, &_rej,
3091 			    ld_targ.t_m.m_mach));
3092 			if (rej->rej_type == 0) {
3093 				*rej = _rej;
3094 				rej->rej_name = strdup(_rej.rej_name);
3095 			}
3096 			return (0);
3097 		}
3098 
3099 		/*
3100 		 * Determine if we've already come across this archive file.
3101 		 */
3102 		if (!(flags & FLG_IF_EXTRACT)) {
3103 			Aliste	idx;
3104 
3105 			for (APLIST_TRAVERSE(ofl->ofl_ars, idx, adp)) {
3106 				if ((adp->ad_stdev != status.st_dev) ||
3107 				    (adp->ad_stino != status.st_ino))
3108 					continue;
3109 
3110 				/*
3111 				 * We've seen this file before so reuse the
3112 				 * original archive descriptor and discard the
3113 				 * new elf descriptor.  Note that a file
3114 				 * descriptor is unnecessary, as the file is
3115 				 * already available in memory.
3116 				 */
3117 				DBG_CALL(Dbg_file_reuse(ofl->ofl_lml, name,
3118 				    adp->ad_name));
3119 				(void) elf_end(elf);
3120 				if (!ld_process_archive(name, -1, adp, ofl))
3121 					return (S_ERROR);
3122 				return (1);
3123 			}
3124 		}
3125 
3126 		/*
3127 		 * As we haven't processed this file before establish a new
3128 		 * archive descriptor.
3129 		 */
3130 		adp = ld_ar_setup(name, elf, ofl);
3131 		if ((adp == NULL) || (adp == (Ar_desc *)S_ERROR))
3132 			return ((uintptr_t)adp);
3133 		adp->ad_stdev = status.st_dev;
3134 		adp->ad_stino = status.st_ino;
3135 
3136 		ld_sup_file(ofl, name, ELF_K_AR, flags, elf);
3137 
3138 		/*
3139 		 * Indicate that the ELF descriptor no longer requires a file
3140 		 * descriptor by reading the entire file.  The file is already
3141 		 * read via the initial mmap(2) behind elf_begin(3elf), thus
3142 		 * this operation is effectively a no-op.  However, a side-
3143 		 * effect is that the internal file descriptor, maintained in
3144 		 * the ELF descriptor, is set to -1.  This setting will not
3145 		 * be compared with any file descriptor that is passed to
3146 		 * elf_begin(), should this archive, or one of the archive
3147 		 * members, be processed again from the command line or
3148 		 * because of a -z rescan.
3149 		 */
3150 		if (elf_cntl(elf, ELF_C_FDREAD) == -1) {
3151 			ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_CNTL),
3152 			    name);
3153 			return (0);
3154 		}
3155 
3156 		if (!ld_process_archive(name, -1, adp, ofl))
3157 			return (S_ERROR);
3158 		return (1);
3159 
3160 	case ELF_K_ELF:
3161 		/*
3162 		 * Obtain the elf header so that we can determine what type of
3163 		 * elf ELF_K_ELF file this is.
3164 		 */
3165 		if ((ehdr = elf_getehdr(elf)) == NULL) {
3166 			int	_class = gelf_getclass(elf);
3167 
3168 			/*
3169 			 * This can fail for a number of reasons. Typically
3170 			 * the object class is incorrect (ie. user is building
3171 			 * 64-bit but managed to point at 32-bit libraries).
3172 			 * Other ELF errors can include a truncated or corrupt
3173 			 * file. Try to get the best error message possible.
3174 			 */
3175 			if (ld_targ.t_m.m_class != _class) {
3176 				_rej.rej_type = SGS_REJ_CLASS;
3177 				_rej.rej_info = (uint_t)_class;
3178 			} else {
3179 				_rej.rej_type = SGS_REJ_STR;
3180 				_rej.rej_str = elf_errmsg(-1);
3181 			}
3182 			_rej.rej_name = name;
3183 			DBG_CALL(Dbg_file_rejected(ofl->ofl_lml, &_rej,
3184 			    ld_targ.t_m.m_mach));
3185 			if (rej->rej_type == 0) {
3186 				*rej = _rej;
3187 				rej->rej_name = strdup(_rej.rej_name);
3188 			}
3189 			return (0);
3190 		}
3191 
3192 		/*
3193 		 * Determine if we've already come across this file.
3194 		 */
3195 		if (!(flags & FLG_IF_EXTRACT)) {
3196 			APlist	*apl;
3197 			Aliste	idx;
3198 
3199 			if (ehdr->e_type == ET_REL)
3200 				apl = ofl->ofl_objs;
3201 			else
3202 				apl = ofl->ofl_sos;
3203 
3204 			/*
3205 			 * Traverse the appropriate file list and determine if
3206 			 * a dev/inode match is found.
3207 			 */
3208 			for (APLIST_TRAVERSE(apl, idx, ifl)) {
3209 				/*
3210 				 * Ifl_desc generated via -Nneed, therefore no
3211 				 * actual file behind it.
3212 				 */
3213 				if (ifl->ifl_flags & FLG_IF_NEEDSTR)
3214 					continue;
3215 
3216 				if ((ifl->ifl_stino != status.st_ino) ||
3217 				    (ifl->ifl_stdev != status.st_dev))
3218 					continue;
3219 
3220 				/*
3221 				 * Disregard (skip) this image.
3222 				 */
3223 				DBG_CALL(Dbg_file_skip(ofl->ofl_lml,
3224 				    ifl->ifl_name, name));
3225 				(void) elf_end(elf);
3226 
3227 				/*
3228 				 * If the file was explicitly defined on the
3229 				 * command line (this is always the case for
3230 				 * relocatable objects, and is true for shared
3231 				 * objects when they weren't specified via -l or
3232 				 * were dragged in as an implicit dependency),
3233 				 * then warn the user.
3234 				 */
3235 				if ((flags & FLG_IF_CMDLINE) ||
3236 				    (ifl->ifl_flags & FLG_IF_CMDLINE)) {
3237 					const char	*errmsg;
3238 
3239 					/*
3240 					 * Determine whether this is the same
3241 					 * file name as originally encountered
3242 					 * so as to provide the most
3243 					 * descriptive diagnostic.
3244 					 */
3245 					errmsg =
3246 					    (strcmp(name, ifl->ifl_name) == 0) ?
3247 					    MSG_INTL(MSG_FIL_MULINC_1) :
3248 					    MSG_INTL(MSG_FIL_MULINC_2);
3249 					ld_eprintf(ofl, ERR_WARNING,
3250 					    errmsg, name, ifl->ifl_name);
3251 				}
3252 				if (ifl_ret)
3253 					*ifl_ret = ifl;
3254 				return (1);
3255 			}
3256 		}
3257 
3258 		/*
3259 		 * At this point, we know we need the file.  Establish an input
3260 		 * file descriptor and continue processing.
3261 		 */
3262 		ifl = ifl_setup(name, ehdr, elf, flags, ofl, rej);
3263 		if ((ifl == NULL) || (ifl == (Ifl_desc *)S_ERROR))
3264 			return ((uintptr_t)ifl);
3265 		ifl->ifl_stdev = status.st_dev;
3266 		ifl->ifl_stino = status.st_ino;
3267 
3268 		/*
3269 		 * If -zignore is in effect, mark this file as a potential
3270 		 * candidate (the files use isn't actually determined until
3271 		 * symbol resolution and relocation processing are completed).
3272 		 */
3273 		if (ofl->ofl_flags1 & FLG_OF1_IGNORE)
3274 			ifl->ifl_flags |= FLG_IF_IGNORE;
3275 
3276 		switch (ehdr->e_type) {
3277 		case ET_REL:
3278 			(*ld_targ.t_mr.mr_mach_eflags)(ehdr, ofl);
3279 			error = process_elf(ifl, elf, ofl);
3280 			break;
3281 		case ET_DYN:
3282 			if ((ofl->ofl_flags & FLG_OF_STATIC) ||
3283 			    !(ofl->ofl_flags & FLG_OF_DYNLIBS)) {
3284 				ld_eprintf(ofl, ERR_FATAL,
3285 				    MSG_INTL(MSG_FIL_SOINSTAT), name);
3286 				return (0);
3287 			}
3288 
3289 			/*
3290 			 * Record any additional shared object information.
3291 			 * If no soname is specified (eg. this file was
3292 			 * derived from a explicit filename declaration on the
3293 			 * command line, ie. bar.so) use the pathname.
3294 			 * This entry may be overridden if the files dynamic
3295 			 * section specifies an DT_SONAME value.
3296 			 */
3297 			if (soname == NULL)
3298 				ifl->ifl_soname = ifl->ifl_name;
3299 			else
3300 				ifl->ifl_soname = soname;
3301 
3302 			/*
3303 			 * If direct bindings, lazy loading, group permissions,
3304 			 * or deferred dependencies need to be established, mark
3305 			 * this object.
3306 			 */
3307 			if (ofl->ofl_flags1 & FLG_OF1_ZDIRECT)
3308 				ifl->ifl_flags |= FLG_IF_DIRECT;
3309 			if (ofl->ofl_flags1 & FLG_OF1_LAZYLD)
3310 				ifl->ifl_flags |= FLG_IF_LAZYLD;
3311 			if (ofl->ofl_flags1 & FLG_OF1_GRPPRM)
3312 				ifl->ifl_flags |= FLG_IF_GRPPRM;
3313 			if (ofl->ofl_flags1 & FLG_OF1_DEFERRED)
3314 				ifl->ifl_flags |=
3315 				    (FLG_IF_LAZYLD | FLG_IF_DEFERRED);
3316 
3317 			error = process_elf(ifl, elf, ofl);
3318 
3319 			/*
3320 			 * Determine whether this dependency requires a syminfo.
3321 			 */
3322 			if (ifl->ifl_flags & MSK_IF_SYMINFO)
3323 				ofl->ofl_flags |= FLG_OF_SYMINFO;
3324 
3325 			/*
3326 			 * Guidance: Use -z lazyload/nolazyload.
3327 			 * libc is exempt from this advice, because it cannot
3328 			 * be lazy loaded, and requests to do so are ignored.
3329 			 */
3330 			if (OFL_GUIDANCE(ofl, FLG_OFG_NO_LAZY) &&
3331 			    ((ifl->ifl_flags & FLG_IF_RTLDINF) == 0)) {
3332 				ld_eprintf(ofl, ERR_GUIDANCE,
3333 				    MSG_INTL(MSG_GUIDE_LAZYLOAD));
3334 				ofl->ofl_guideflags |= FLG_OFG_NO_LAZY;
3335 			}
3336 
3337 			/*
3338 			 * Guidance: Use -B direct/nodirect or
3339 			 * -z direct/nodirect.
3340 			 */
3341 			if (OFL_GUIDANCE(ofl, FLG_OFG_NO_DB)) {
3342 				ld_eprintf(ofl, ERR_GUIDANCE,
3343 				    MSG_INTL(MSG_GUIDE_DIRECT));
3344 				ofl->ofl_guideflags |= FLG_OFG_NO_DB;
3345 			}
3346 
3347 			break;
3348 		default:
3349 			(void) elf_errno();
3350 			_rej.rej_type = SGS_REJ_UNKFILE;
3351 			_rej.rej_name = name;
3352 			DBG_CALL(Dbg_file_rejected(ofl->ofl_lml, &_rej,
3353 			    ld_targ.t_m.m_mach));
3354 			if (rej->rej_type == 0) {
3355 				*rej = _rej;
3356 				rej->rej_name = strdup(_rej.rej_name);
3357 			}
3358 			return (0);
3359 		}
3360 		break;
3361 	default:
3362 		(void) elf_errno();
3363 		_rej.rej_type = SGS_REJ_UNKFILE;
3364 		_rej.rej_name = name;
3365 		DBG_CALL(Dbg_file_rejected(ofl->ofl_lml, &_rej,
3366 		    ld_targ.t_m.m_mach));
3367 		if (rej->rej_type == 0) {
3368 			*rej = _rej;
3369 			rej->rej_name = strdup(_rej.rej_name);
3370 		}
3371 		return (0);
3372 	}
3373 	if ((error == 0) || (error == S_ERROR))
3374 		return (error);
3375 
3376 	if (ifl_ret)
3377 		*ifl_ret = ifl;
3378 	return (1);
3379 }
3380 
3381 /*
3382  * Having successfully opened a file, set up the necessary elf structures to
3383  * process it further.  This small section of processing is slightly different
3384  * from the elf initialization required to process a relocatable object from an
3385  * archive (see libs.c: ld_process_archive()).
3386  */
3387 uintptr_t
3388 ld_process_open(const char *opath, const char *ofile, int *fd, Ofl_desc *ofl,
3389     Word flags, Rej_desc *rej, Ifl_desc **ifl_ret)
3390 {
3391 	Elf		*elf;
3392 	const char	*npath = opath;
3393 	const char	*nfile = ofile;
3394 
3395 	if ((elf = elf_begin(*fd, ELF_C_READ, NULL)) == NULL) {
3396 		ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_BEGIN), npath);
3397 		return (0);
3398 	}
3399 
3400 	/*
3401 	 * Determine whether the support library wishes to process this open.
3402 	 * The support library may return:
3403 	 *   .	a different ELF descriptor (in which case they should have
3404 	 *	closed the original)
3405 	 *   .	a different file descriptor (in which case they should have
3406 	 *	closed the original)
3407 	 *   .	a different path and file name (presumably associated with
3408 	 *	a different file descriptor)
3409 	 *
3410 	 * A file descriptor of -1, or and ELF descriptor of zero indicates
3411 	 * the file should be ignored.
3412 	 */
3413 	ld_sup_open(ofl, &npath, &nfile, fd, flags, &elf, NULL, 0,
3414 	    elf_kind(elf));
3415 
3416 	if ((*fd == -1) || (elf == NULL))
3417 		return (0);
3418 
3419 	return (ld_process_ifl(npath, nfile, *fd, elf, flags, ofl, rej,
3420 	    ifl_ret));
3421 }
3422 
3423 /*
3424  * Having successfully mapped a file, set up the necessary elf structures to
3425  * process it further.  This routine is patterned after ld_process_open() and
3426  * is only called by ld.so.1(1) to process a relocatable object.
3427  */
3428 Ifl_desc *
3429 ld_process_mem(const char *path, const char *file, char *addr, size_t size,
3430     Ofl_desc *ofl, Rej_desc *rej)
3431 {
3432 	Elf		*elf;
3433 	uintptr_t	open_ret;
3434 	Ifl_desc	*ifl;
3435 
3436 	if ((elf = elf_memory(addr, size)) == NULL) {
3437 		ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_MEMORY), path);
3438 		return (0);
3439 	}
3440 
3441 	open_ret = ld_process_ifl(path, file, 0, elf, 0, ofl, rej, &ifl);
3442 	if (open_ret != 1)
3443 		return ((Ifl_desc *) open_ret);
3444 	return (ifl);
3445 }
3446 
3447 /*
3448  * Process a required library (i.e. the dependency of a shared object).
3449  * Combine the directory and filename, check the resultant path size, and try
3450  * opening the pathname.
3451  */
3452 static Ifl_desc *
3453 process_req_lib(Sdf_desc *sdf, const char *dir, const char *file,
3454     Ofl_desc *ofl, Rej_desc *rej)
3455 {
3456 	size_t		dlen, plen;
3457 	int		fd;
3458 	char		path[PATH_MAX];
3459 	const char	*_dir = dir;
3460 
3461 	/*
3462 	 * Determine the sizes of the directory and filename to insure we don't
3463 	 * exceed our buffer.
3464 	 */
3465 	if ((dlen = strlen(dir)) == 0) {
3466 		_dir = MSG_ORIG(MSG_STR_DOT);
3467 		dlen = 1;
3468 	}
3469 	dlen++;
3470 	plen = dlen + strlen(file) + 1;
3471 	if (plen > PATH_MAX) {
3472 		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_PTHTOLONG),
3473 		    _dir, file);
3474 		return (0);
3475 	}
3476 
3477 	/*
3478 	 * Build the entire pathname and try and open the file.
3479 	 */
3480 	(void) strcpy(path, _dir);
3481 	(void) strcat(path, MSG_ORIG(MSG_STR_SLASH));
3482 	(void) strcat(path, file);
3483 	DBG_CALL(Dbg_libs_req(ofl->ofl_lml, sdf->sdf_name,
3484 	    sdf->sdf_rfile, path));
3485 
3486 	if ((fd = open(path, O_RDONLY)) == -1)
3487 		return (0);
3488 	else {
3489 		uintptr_t	open_ret;
3490 		Ifl_desc	*ifl;
3491 		char		*_path;
3492 
3493 		if ((_path = libld_malloc(strlen(path) + 1)) == NULL)
3494 			return ((Ifl_desc *)S_ERROR);
3495 		(void) strcpy(_path, path);
3496 		open_ret = ld_process_open(_path, &_path[dlen], &fd, ofl,
3497 		    0, rej, &ifl);
3498 		if (fd != -1)
3499 			(void) close(fd);
3500 		if (open_ret != 1)
3501 			return ((Ifl_desc *)open_ret);
3502 		return (ifl);
3503 	}
3504 }
3505 
3506 /*
3507  * Finish any library processing.  Walk the list of so's that have been listed
3508  * as "included" by shared objects we have previously processed.  Examine them,
3509  * without adding them as explicit dependents of this program, in order to
3510  * complete our symbol definition process.  The search path rules are:
3511  *
3512  *  -	use any user supplied paths, i.e. LD_LIBRARY_PATH and -L, then
3513  *
3514  *  -	use any RPATH defined within the parent shared object, then
3515  *
3516  *  -	use the default directories, i.e. LIBPATH or -YP.
3517  */
3518 uintptr_t
3519 ld_finish_libs(Ofl_desc *ofl)
3520 {
3521 	Aliste		idx1;
3522 	Sdf_desc	*sdf;
3523 	Rej_desc	rej = { 0 };
3524 
3525 	/*
3526 	 * Make sure we are back in dynamic mode.
3527 	 */
3528 	ofl->ofl_flags |= FLG_OF_DYNLIBS;
3529 
3530 	for (APLIST_TRAVERSE(ofl->ofl_soneed, idx1, sdf)) {
3531 		Aliste		idx2;
3532 		char		*path, *slash = NULL;
3533 		int		fd;
3534 		Ifl_desc	*ifl;
3535 		char		*file = (char *)sdf->sdf_name;
3536 
3537 		/*
3538 		 * See if this file has already been processed.  At the time
3539 		 * this implicit dependency was determined there may still have
3540 		 * been more explicit dependencies to process.  Note, if we ever
3541 		 * do parse the command line three times we would be able to
3542 		 * do all this checking when processing the dynamic section.
3543 		 */
3544 		if (sdf->sdf_file)
3545 			continue;
3546 
3547 		for (APLIST_TRAVERSE(ofl->ofl_sos, idx2, ifl)) {
3548 			if (!(ifl->ifl_flags & FLG_IF_NEEDSTR) &&
3549 			    (strcmp(file, ifl->ifl_soname) == 0)) {
3550 				sdf->sdf_file = ifl;
3551 				break;
3552 			}
3553 		}
3554 		if (sdf->sdf_file)
3555 			continue;
3556 
3557 		/*
3558 		 * If the current path name element embeds a "/", then it's to
3559 		 * be taken "as is", with no searching involved.  Process all
3560 		 * "/" occurrences, so that we can deduce the base file name.
3561 		 */
3562 		for (path = file; *path; path++) {
3563 			if (*path == '/')
3564 				slash = path;
3565 		}
3566 		if (slash) {
3567 			DBG_CALL(Dbg_libs_req(ofl->ofl_lml, sdf->sdf_name,
3568 			    sdf->sdf_rfile, file));
3569 			if ((fd = open(file, O_RDONLY)) == -1) {
3570 				ld_eprintf(ofl, ERR_WARNING,
3571 				    MSG_INTL(MSG_FIL_NOTFOUND), file,
3572 				    sdf->sdf_rfile);
3573 			} else {
3574 				uintptr_t	open_ret;
3575 				Rej_desc	_rej = { 0 };
3576 
3577 				open_ret = ld_process_open(file, ++slash,
3578 				    &fd, ofl, 0, &_rej, &ifl);
3579 				if (fd != -1)
3580 					(void) close(fd);
3581 				if (open_ret == S_ERROR)
3582 					return (S_ERROR);
3583 
3584 				if (_rej.rej_type) {
3585 					Conv_reject_desc_buf_t rej_buf;
3586 
3587 					ld_eprintf(ofl, ERR_WARNING,
3588 					    MSG_INTL(reject[_rej.rej_type]),
3589 					    _rej.rej_name ? rej.rej_name :
3590 					    MSG_INTL(MSG_STR_UNKNOWN),
3591 					    conv_reject_desc(&_rej, &rej_buf,
3592 					    ld_targ.t_m.m_mach));
3593 				} else
3594 					sdf->sdf_file = ifl;
3595 			}
3596 			continue;
3597 		}
3598 
3599 		/*
3600 		 * Now search for this file in any user defined directories.
3601 		 */
3602 		for (APLIST_TRAVERSE(ofl->ofl_ulibdirs, idx2, path)) {
3603 			Rej_desc	_rej = { 0 };
3604 
3605 			ifl = process_req_lib(sdf, path, file, ofl, &_rej);
3606 			if (ifl == (Ifl_desc *)S_ERROR) {
3607 				return (S_ERROR);
3608 			}
3609 			if (_rej.rej_type) {
3610 				if (rej.rej_type == 0) {
3611 					rej = _rej;
3612 					rej.rej_name = strdup(_rej.rej_name);
3613 				}
3614 			}
3615 			if (ifl) {
3616 				sdf->sdf_file = ifl;
3617 				break;
3618 			}
3619 		}
3620 		if (sdf->sdf_file)
3621 			continue;
3622 
3623 		/*
3624 		 * Next use the local rules defined within the parent shared
3625 		 * object.
3626 		 */
3627 		if (sdf->sdf_rpath != NULL) {
3628 			char	*rpath, *next;
3629 
3630 			rpath = libld_malloc(strlen(sdf->sdf_rpath) + 1);
3631 			if (rpath == NULL)
3632 				return (S_ERROR);
3633 			(void) strcpy(rpath, sdf->sdf_rpath);
3634 			DBG_CALL(Dbg_libs_path(ofl->ofl_lml, rpath,
3635 			    LA_SER_RUNPATH, sdf->sdf_rfile));
3636 			if ((path = strtok_r(rpath,
3637 			    MSG_ORIG(MSG_STR_COLON), &next)) != NULL) {
3638 				do {
3639 					Rej_desc	_rej = { 0 };
3640 
3641 					path = expand(sdf->sdf_rfile, path,
3642 					    &next);
3643 
3644 					ifl = process_req_lib(sdf, path,
3645 					    file, ofl, &_rej);
3646 					if (ifl == (Ifl_desc *)S_ERROR) {
3647 						return (S_ERROR);
3648 					}
3649 					if ((_rej.rej_type) &&
3650 					    (rej.rej_type == 0)) {
3651 						rej = _rej;
3652 						rej.rej_name =
3653 						    strdup(_rej.rej_name);
3654 					}
3655 					if (ifl) {
3656 						sdf->sdf_file = ifl;
3657 						break;
3658 					}
3659 				} while ((path = strtok_r(NULL,
3660 				    MSG_ORIG(MSG_STR_COLON), &next)) != NULL);
3661 			}
3662 		}
3663 		if (sdf->sdf_file)
3664 			continue;
3665 
3666 		/*
3667 		 * Finally try the default library search directories.
3668 		 */
3669 		for (APLIST_TRAVERSE(ofl->ofl_dlibdirs, idx2, path)) {
3670 			Rej_desc	_rej = { 0 };
3671 
3672 			ifl = process_req_lib(sdf, path, file, ofl, &rej);
3673 			if (ifl == (Ifl_desc *)S_ERROR) {
3674 				return (S_ERROR);
3675 			}
3676 			if (_rej.rej_type) {
3677 				if (rej.rej_type == 0) {
3678 					rej = _rej;
3679 					rej.rej_name = strdup(_rej.rej_name);
3680 				}
3681 			}
3682 			if (ifl) {
3683 				sdf->sdf_file = ifl;
3684 				break;
3685 			}
3686 		}
3687 		if (sdf->sdf_file)
3688 			continue;
3689 
3690 		/*
3691 		 * If we've got this far we haven't found the shared object.
3692 		 * If an object was found, but was rejected for some reason,
3693 		 * print a diagnostic to that effect, otherwise generate a
3694 		 * generic "not found" diagnostic.
3695 		 */
3696 		if (rej.rej_type) {
3697 			Conv_reject_desc_buf_t rej_buf;
3698 
3699 			ld_eprintf(ofl, ERR_WARNING,
3700 			    MSG_INTL(reject[rej.rej_type]),
3701 			    rej.rej_name ? rej.rej_name :
3702 			    MSG_INTL(MSG_STR_UNKNOWN),
3703 			    conv_reject_desc(&rej, &rej_buf,
3704 			    ld_targ.t_m.m_mach));
3705 		} else {
3706 			ld_eprintf(ofl, ERR_WARNING,
3707 			    MSG_INTL(MSG_FIL_NOTFOUND), file, sdf->sdf_rfile);
3708 		}
3709 	}
3710 
3711 	/*
3712 	 * Finally, now that all objects have been input, make sure any version
3713 	 * requirements have been met.
3714 	 */
3715 	return (ld_vers_verify(ofl));
3716 }
3717