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 */
52static int
53ifl_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 */
83static Ifl_desc *
84ifl_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 */
162static uintptr_t
163process_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 */
237static void
238sf1_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 */
370static void
371hw_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 */
418static void
419str_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 */
469static void
470id_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 */
504void
505ld_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 */
553static Cap_group *
554get_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 */
694uintptr_t
695ld_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 */
814static uintptr_t
815process_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 */
1162static uintptr_t
1163process_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 */
1278static uintptr_t
1279/* ARGSUSED5 */
1280process_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 */
1293static uintptr_t
1294/* ARGSUSED5 */
1295process_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 */
1319static uintptr_t
1320process_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 */
1373static uintptr_t
1374/* ARGSUSED3 */
1375invalid_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 */
1401inline static int
1402is_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*/
1433inline static Boolean
1434process_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 */
1527static uintptr_t
1528process_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 */
1600static uintptr_t
1601process_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 */
1616static uintptr_t
1617process_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 */
1637static uintptr_t
1638process_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
1653static uintptr_t
1654/* ARGSUSED1 */
1655array_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 */
1681static uintptr_t
1682process_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 */
1709static uintptr_t
1710/* ARGSUSED2 */
1711sym_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*/
1737static uintptr_t
1738process_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 */
1819static char		*machine = NULL;
1820static size_t		machine_sz = 0;
1821static char		*platform = NULL;
1822static size_t		platform_sz = 0;
1823static Isa_desc		*isa = NULL;
1824static Uts_desc		*uts = NULL;
1825
1826static char *
1827expand(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*/
2080static uintptr_t
2081process_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 */
2116static uintptr_t
2117process_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*/
2319static uintptr_t
2320process_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 */
2332static uintptr_t
2333process_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_IF_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 */
2356static uintptr_t
2357rel_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 */
2433static uintptr_t
2434process_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 */
2470typedef uintptr_t	(* initial_func_t)(const char *, Ifl_desc *, Shdr *,
2471			    Elf_Scn *, Word, int, Ofl_desc *);
2472
2473static 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
2497typedef uintptr_t	(* final_func_t)(Is_desc *, Ifl_desc *, Ofl_desc *);
2498
2499static 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 */
2530static uintptr_t
2531process_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_IF_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 group information has been processed, we can safely validate
2825	 * that nothing is fishy about the section COMDAT description.  We
2826	 * need to do this prior to placing the section (where any
2827	 * SHT_SUNW_COMDAT sections will be restored to being PROGBITS)
2828	 */
2829	ld_comdat_validate(ofl, ifl);
2830
2831	/*
2832	 * Now that all of the input sections have been processed, place
2833	 * them in the appropriate output sections.
2834	 */
2835	for (ndx = 1; ndx < ifl->ifl_shnum; ndx++) {
2836		Is_desc	*isp;
2837
2838		if (((isp = ifl->ifl_isdesc[ndx]) == NULL) ||
2839		    ((isp->is_flags & FLG_IS_PLACE) == 0))
2840			continue;
2841
2842		/*
2843		 * Place all non-ordered sections within their appropriate
2844		 * output section.
2845		 */
2846		if ((isp->is_flags & FLG_IS_ORDERED) == 0) {
2847			if (ld_place_section(ofl, isp, path_info,
2848			    isp->is_keyident, NULL) == (Os_desc *)S_ERROR)
2849				return (S_ERROR);
2850			continue;
2851		}
2852
2853		/*
2854		 * Count the number of ordered sections and retain the first
2855		 * ordered section index. This will be used to optimize the
2856		 * ordered section loop that immediately follows this one.
2857		 */
2858		ordcnt++;
2859		if (ordndx == 0)
2860			ordndx = ndx;
2861	}
2862
2863	/*
2864	 * Having placed all the non-ordered sections, it is now
2865	 * safe to place SHF_ORDERED/SHF_LINK_ORDER sections.
2866	 */
2867	if (ifl->ifl_flags & FLG_IF_ORDERED) {
2868		for (ndx = ordndx; ndx < ifl->ifl_shnum; ndx++) {
2869			Is_desc	*isp;
2870
2871			if (((isp = ifl->ifl_isdesc[ndx]) == NULL) ||
2872			    ((isp->is_flags &
2873			    (FLG_IS_PLACE | FLG_IS_ORDERED)) !=
2874			    (FLG_IS_PLACE | FLG_IS_ORDERED)))
2875				continue;
2876
2877			/* ld_process_ordered() calls ld_place_section() */
2878			if (ld_process_ordered(ofl, ifl, path_info, ndx) ==
2879			    S_ERROR)
2880				return (S_ERROR);
2881
2882			/* If we've done them all, stop searching */
2883			if (--ordcnt == 0)
2884				break;
2885		}
2886	}
2887
2888	/*
2889	 * If this is a shared object explicitly specified on the command
2890	 * line (as opposed to being a dependency of such an object),
2891	 * determine if the user has specified a control definition. This
2892	 * descriptor may specify which version definitions can be used
2893	 * from this object. It may also update the dependency to USED and
2894	 * supply an alternative SONAME.
2895	 */
2896	sdf = NULL;
2897	if (column && (ifl->ifl_flags & FLG_IF_NEEDED)) {
2898		const char	*base;
2899
2900		/*
2901		 * Use the basename of the input file (typically this is the
2902		 * compilation environment name, ie. libfoo.so).
2903		 */
2904		if ((base = strrchr(ifl->ifl_name, '/')) == NULL)
2905			base = ifl->ifl_name;
2906		else
2907			base++;
2908
2909		if ((sdf = sdf_find(base, ofl->ofl_socntl)) != NULL) {
2910			sdf->sdf_file = ifl;
2911			ifl->ifl_sdfdesc = sdf;
2912		}
2913	}
2914
2915	/*
2916	 * Before symbol processing, process any capabilities.  Capabilities
2917	 * can reference a string table, which is why this processing is
2918	 * carried out after the initial section processing.  Capabilities,
2919	 * together with -z symbolcap, can require the conversion of global
2920	 * symbols to local symbols.
2921	 */
2922	if (capisp && (process_cap(ofl, ifl, capisp) == S_ERROR))
2923		return (S_ERROR);
2924
2925	/*
2926	 * Process any version dependencies.  These will establish shared object
2927	 * `needed' entries in the same manner as will be generated from the
2928	 * .dynamic's NEEDED entries.
2929	 */
2930	if (vndisp && ((ofl->ofl_flags & (FLG_OF_NOUNDEF | FLG_OF_SYMBOLIC)) ||
2931	    OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS)))
2932		if (ld_vers_need_process(vndisp, ifl, ofl) == S_ERROR)
2933			return (S_ERROR);
2934
2935	/*
2936	 * Before processing any symbol resolution or relocations process any
2937	 * version sections.
2938	 */
2939	if (vsyisp)
2940		(void) ld_vers_sym_process(ofl, vsyisp, ifl);
2941
2942	if (ifl->ifl_versym &&
2943	    (vdfisp || (sdf && (sdf->sdf_flags & FLG_SDF_SELECT))))
2944		if (ld_vers_def_process(vdfisp, ifl, ofl) == S_ERROR)
2945			return (S_ERROR);
2946
2947	/*
2948	 * Having collected the appropriate sections carry out any additional
2949	 * processing if necessary.
2950	 */
2951	for (ndx = 0; ndx < ifl->ifl_shnum; ndx++) {
2952		Is_desc	*isp;
2953
2954		if ((isp = ifl->ifl_isdesc[ndx]) == NULL)
2955			continue;
2956		row = isp->is_shdr->sh_type;
2957
2958		if ((isp->is_flags & FLG_IS_DISCARD) == 0)
2959			ld_sup_section(ofl, isp->is_name, isp->is_shdr, ndx,
2960			    isp->is_indata, elf);
2961
2962		/*
2963		 * If this is a SHT_SUNW_move section from a relocatable file,
2964		 * keep track of the section for later processing.
2965		 */
2966		if ((row == SHT_SUNW_move) && (column == 0)) {
2967			if (aplist_append(&(ofl->ofl_ismove), isp,
2968			    AL_CNT_OFL_MOVE) == NULL)
2969				return (S_ERROR);
2970		}
2971
2972		/*
2973		 * If this is a standard section type process it via the
2974		 * appropriate action routine.
2975		 */
2976		if (row < SHT_NUM) {
2977			if (Final[row][column] != NULL) {
2978				if (Final[row][column](isp, ifl,
2979				    ofl) == S_ERROR)
2980					return (S_ERROR);
2981			}
2982#if	defined(_ELF64)
2983		} else if ((row == SHT_AMD64_UNWIND) && (column == 0)) {
2984			Os_desc	*osp = isp->is_osdesc;
2985
2986			/*
2987			 * SHT_AMD64_UNWIND (0x70000001) is in the SHT_LOPROC -
2988			 * SHT_HIPROC range reserved for processor-specific
2989			 * semantics, and is only meaningful for amd64 targets.
2990			 *
2991			 * Only process unwind contents from relocatable
2992			 * objects.
2993			 */
2994			if (osp && (ld_targ.t_m.m_mach == EM_AMD64) &&
2995			    (ld_unwind_register(osp, ofl) == S_ERROR))
2996				return (S_ERROR);
2997#endif
2998		}
2999	}
3000
3001	/*
3002	 * Following symbol processing, if this relocatable object input file
3003	 * provides symbol capabilities, tag the associated symbols so that
3004	 * the symbols can be re-assigned to the new capabilities symbol
3005	 * section that will be created for the output file.
3006	 */
3007	if (capinfoisp && (ifl->ifl_ehdr->e_type == ET_REL) &&
3008	    (process_capinfo(ofl, ifl, capinfoisp) == S_ERROR))
3009		return (S_ERROR);
3010
3011	/*
3012	 * After processing any symbol resolution, and if this dependency
3013	 * indicates it contains symbols that can't be directly bound to,
3014	 * set the symbols appropriately.
3015	 */
3016	if (sifisp && ((ifl->ifl_flags & (FLG_IF_NEEDED | FLG_IF_NODIRECT)) ==
3017	    (FLG_IF_NEEDED | FLG_IF_NODIRECT)))
3018		(void) ld_sym_nodirect(sifisp, ifl, ofl);
3019
3020	return (1);
3021}
3022
3023/*
3024 * Process the current input file.  There are basically three types of files
3025 * that come through here:
3026 *
3027 *  -	files explicitly defined on the command line (ie. foo.o or bar.so),
3028 *	in this case only the `name' field is valid.
3029 *
3030 *  -	libraries determined from the -l command line option (ie. -lbar),
3031 *	in this case the `soname' field contains the basename of the located
3032 *	file.
3033 *
3034 * Any shared object specified via the above two conventions must be recorded
3035 * as a needed dependency.
3036 *
3037 *  -	libraries specified as dependencies of those libraries already obtained
3038 *	via the command line (ie. bar.so has a DT_NEEDED entry of fred.so.1),
3039 *	in this case the `soname' field contains either a full pathname (if the
3040 *	needed entry contained a `/'), or the basename of the located file.
3041 *	These libraries are processed to verify symbol binding but are not
3042 *	recorded as dependencies of the output file being generated.
3043 *
3044 * entry:
3045 *	name - File name
3046 *	soname - SONAME for needed sharable library, as described above
3047 *	fd - Open file descriptor
3048 *	elf - Open ELF handle
3049 *	flags - FLG_IF_ flags applicable to file
3050 *	ofl - Output file descriptor
3051 *	rej - Rejection descriptor used to record rejection reason
3052 *	ifl_ret - NULL, or address of pointer to receive reference to
3053 *		resulting input descriptor for file. If ifl_ret is non-NULL,
3054 *		the file cannot be an archive or it will be rejected.
3055 *
3056 * exit:
3057 *	If a error occurs in examining the file, S_ERROR is returned.
3058 *	If the file can be examined, but is not suitable, *rej is updated,
3059 *	and 0 is returned. If the file is acceptable, 1 is returned, and if
3060 *	ifl_ret is non-NULL, *ifl_ret is set to contain the pointer to the
3061 *	resulting input descriptor.
3062 */
3063uintptr_t
3064ld_process_ifl(const char *name, const char *soname, int fd, Elf *elf,
3065    Word flags, Ofl_desc *ofl, Rej_desc *rej, Ifl_desc **ifl_ret)
3066{
3067	Ifl_desc	*ifl;
3068	Ehdr		*ehdr;
3069	uintptr_t	error = 0;
3070	struct stat	status;
3071	Ar_desc		*adp;
3072	Rej_desc	_rej;
3073
3074	/*
3075	 * If this file was not extracted from an archive obtain its device
3076	 * information.  This will be used to determine if the file has already
3077	 * been processed (rather than simply comparing filenames, the device
3078	 * information provides a quicker comparison and detects linked files).
3079	 */
3080	if (fd && ((flags & FLG_IF_EXTRACT) == 0))
3081		(void) fstat(fd, &status);
3082	else {
3083		status.st_dev = 0;
3084		status.st_ino = 0;
3085	}
3086
3087	switch (elf_kind(elf)) {
3088	case ELF_K_AR:
3089		/*
3090		 * If the caller has supplied a non-NULL ifl_ret, then
3091		 * we cannot process archives, for there will be no
3092		 * input file descriptor for us to return. In this case,
3093		 * reject the attempt.
3094		 */
3095		if (ifl_ret != NULL) {
3096			_rej.rej_type = SGS_REJ_ARCHIVE;
3097			_rej.rej_name = name;
3098			DBG_CALL(Dbg_file_rejected(ofl->ofl_lml, &_rej,
3099			    ld_targ.t_m.m_mach));
3100			if (rej->rej_type == 0) {
3101				*rej = _rej;
3102				rej->rej_name = strdup(_rej.rej_name);
3103			}
3104			return (0);
3105		}
3106
3107		/*
3108		 * Determine if we've already come across this archive file.
3109		 */
3110		if (!(flags & FLG_IF_EXTRACT)) {
3111			Aliste	idx;
3112
3113			for (APLIST_TRAVERSE(ofl->ofl_ars, idx, adp)) {
3114				if ((adp->ad_stdev != status.st_dev) ||
3115				    (adp->ad_stino != status.st_ino))
3116					continue;
3117
3118				/*
3119				 * We've seen this file before so reuse the
3120				 * original archive descriptor and discard the
3121				 * new elf descriptor.  Note that a file
3122				 * descriptor is unnecessary, as the file is
3123				 * already available in memory.
3124				 */
3125				DBG_CALL(Dbg_file_reuse(ofl->ofl_lml, name,
3126				    adp->ad_name));
3127				(void) elf_end(elf);
3128				if (!ld_process_archive(name, -1, adp, ofl))
3129					return (S_ERROR);
3130				return (1);
3131			}
3132		}
3133
3134		/*
3135		 * As we haven't processed this file before establish a new
3136		 * archive descriptor.
3137		 */
3138		adp = ld_ar_setup(name, elf, ofl);
3139		if ((adp == NULL) || (adp == (Ar_desc *)S_ERROR))
3140			return ((uintptr_t)adp);
3141		adp->ad_stdev = status.st_dev;
3142		adp->ad_stino = status.st_ino;
3143
3144		ld_sup_file(ofl, name, ELF_K_AR, flags, elf);
3145
3146		/*
3147		 * Indicate that the ELF descriptor no longer requires a file
3148		 * descriptor by reading the entire file.  The file is already
3149		 * read via the initial mmap(2) behind elf_begin(3elf), thus
3150		 * this operation is effectively a no-op.  However, a side-
3151		 * effect is that the internal file descriptor, maintained in
3152		 * the ELF descriptor, is set to -1.  This setting will not
3153		 * be compared with any file descriptor that is passed to
3154		 * elf_begin(), should this archive, or one of the archive
3155		 * members, be processed again from the command line or
3156		 * because of a -z rescan.
3157		 */
3158		if (elf_cntl(elf, ELF_C_FDREAD) == -1) {
3159			ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_CNTL),
3160			    name);
3161			return (0);
3162		}
3163
3164		if (!ld_process_archive(name, -1, adp, ofl))
3165			return (S_ERROR);
3166		return (1);
3167
3168	case ELF_K_ELF:
3169		/*
3170		 * Obtain the elf header so that we can determine what type of
3171		 * elf ELF_K_ELF file this is.
3172		 */
3173		if ((ehdr = elf_getehdr(elf)) == NULL) {
3174			int	_class = gelf_getclass(elf);
3175
3176			/*
3177			 * This can fail for a number of reasons. Typically
3178			 * the object class is incorrect (ie. user is building
3179			 * 64-bit but managed to point at 32-bit libraries).
3180			 * Other ELF errors can include a truncated or corrupt
3181			 * file. Try to get the best error message possible.
3182			 */
3183			if (ld_targ.t_m.m_class != _class) {
3184				_rej.rej_type = SGS_REJ_CLASS;
3185				_rej.rej_info = (uint_t)_class;
3186			} else {
3187				_rej.rej_type = SGS_REJ_STR;
3188				_rej.rej_str = elf_errmsg(-1);
3189			}
3190			_rej.rej_name = name;
3191			DBG_CALL(Dbg_file_rejected(ofl->ofl_lml, &_rej,
3192			    ld_targ.t_m.m_mach));
3193			if (rej->rej_type == 0) {
3194				*rej = _rej;
3195				rej->rej_name = strdup(_rej.rej_name);
3196			}
3197			return (0);
3198		}
3199
3200		if (_gelf_getdynval(elf, DT_SUNW_KMOD) > 0) {
3201			_rej.rej_name = name;
3202			DBG_CALL(Dbg_file_rejected(ofl->ofl_lml, &_rej,
3203			    ld_targ.t_m.m_mach));
3204			_rej.rej_type = SGS_REJ_KMOD;
3205			_rej.rej_str = elf_errmsg(-1);
3206			_rej.rej_name = name;
3207
3208			if (rej->rej_type == 0) {
3209				*rej = _rej;
3210				rej->rej_name = strdup(_rej.rej_name);
3211			}
3212			return (0);
3213		}
3214
3215		/*
3216		 * Determine if we've already come across this file.
3217		 */
3218		if (!(flags & FLG_IF_EXTRACT)) {
3219			APlist	*apl;
3220			Aliste	idx;
3221
3222			if (ehdr->e_type == ET_REL)
3223				apl = ofl->ofl_objs;
3224			else
3225				apl = ofl->ofl_sos;
3226
3227			/*
3228			 * Traverse the appropriate file list and determine if
3229			 * a dev/inode match is found.
3230			 */
3231			for (APLIST_TRAVERSE(apl, idx, ifl)) {
3232				/*
3233				 * Ifl_desc generated via -Nneed, therefore no
3234				 * actual file behind it.
3235				 */
3236				if (ifl->ifl_flags & FLG_IF_NEEDSTR)
3237					continue;
3238
3239				if ((ifl->ifl_stino != status.st_ino) ||
3240				    (ifl->ifl_stdev != status.st_dev))
3241					continue;
3242
3243				/*
3244				 * Disregard (skip) this image.
3245				 */
3246				DBG_CALL(Dbg_file_skip(ofl->ofl_lml,
3247				    ifl->ifl_name, name));
3248				(void) elf_end(elf);
3249
3250				/*
3251				 * If the file was explicitly defined on the
3252				 * command line (this is always the case for
3253				 * relocatable objects, and is true for shared
3254				 * objects when they weren't specified via -l or
3255				 * were dragged in as an implicit dependency),
3256				 * then warn the user.
3257				 */
3258				if ((flags & FLG_IF_CMDLINE) ||
3259				    (ifl->ifl_flags & FLG_IF_CMDLINE)) {
3260					const char	*errmsg;
3261
3262					/*
3263					 * Determine whether this is the same
3264					 * file name as originally encountered
3265					 * so as to provide the most
3266					 * descriptive diagnostic.
3267					 */
3268					errmsg =
3269					    (strcmp(name, ifl->ifl_name) == 0) ?
3270					    MSG_INTL(MSG_FIL_MULINC_1) :
3271					    MSG_INTL(MSG_FIL_MULINC_2);
3272					ld_eprintf(ofl, ERR_WARNING,
3273					    errmsg, name, ifl->ifl_name);
3274				}
3275				if (ifl_ret)
3276					*ifl_ret = ifl;
3277				return (1);
3278			}
3279		}
3280
3281		/*
3282		 * At this point, we know we need the file.  Establish an input
3283		 * file descriptor and continue processing.
3284		 */
3285		ifl = ifl_setup(name, ehdr, elf, flags, ofl, rej);
3286		if ((ifl == NULL) || (ifl == (Ifl_desc *)S_ERROR))
3287			return ((uintptr_t)ifl);
3288		ifl->ifl_stdev = status.st_dev;
3289		ifl->ifl_stino = status.st_ino;
3290
3291		/*
3292		 * If -zignore is in effect, mark this file as a potential
3293		 * candidate (the files use isn't actually determined until
3294		 * symbol resolution and relocation processing are completed).
3295		 */
3296		if (ofl->ofl_flags1 & FLG_OF1_IGNORE)
3297			ifl->ifl_flags |= FLG_IF_IGNORE;
3298
3299		switch (ehdr->e_type) {
3300		case ET_REL:
3301			(*ld_targ.t_mr.mr_mach_eflags)(ehdr, ofl);
3302			error = process_elf(ifl, elf, ofl);
3303			break;
3304		case ET_DYN:
3305			if ((ofl->ofl_flags & FLG_OF_STATIC) ||
3306			    !(ofl->ofl_flags & FLG_OF_DYNLIBS)) {
3307				ld_eprintf(ofl, ERR_FATAL,
3308				    MSG_INTL(MSG_FIL_SOINSTAT), name);
3309				return (0);
3310			}
3311
3312			/*
3313			 * Record any additional shared object information.
3314			 * If no soname is specified (eg. this file was
3315			 * derived from a explicit filename declaration on the
3316			 * command line, ie. bar.so) use the pathname.
3317			 * This entry may be overridden if the files dynamic
3318			 * section specifies an DT_SONAME value.
3319			 */
3320			if (soname == NULL)
3321				ifl->ifl_soname = ifl->ifl_name;
3322			else
3323				ifl->ifl_soname = soname;
3324
3325			/*
3326			 * If direct bindings, lazy loading, group permissions,
3327			 * or deferred dependencies need to be established, mark
3328			 * this object.
3329			 */
3330			if (ofl->ofl_flags1 & FLG_OF1_ZDIRECT)
3331				ifl->ifl_flags |= FLG_IF_DIRECT;
3332			if (ofl->ofl_flags1 & FLG_OF1_LAZYLD)
3333				ifl->ifl_flags |= FLG_IF_LAZYLD;
3334			if (ofl->ofl_flags1 & FLG_OF1_GRPPRM)
3335				ifl->ifl_flags |= FLG_IF_GRPPRM;
3336			if (ofl->ofl_flags1 & FLG_OF1_DEFERRED)
3337				ifl->ifl_flags |=
3338				    (FLG_IF_LAZYLD | FLG_IF_DEFERRED);
3339
3340			error = process_elf(ifl, elf, ofl);
3341
3342			/*
3343			 * Determine whether this dependency requires a syminfo.
3344			 */
3345			if (ifl->ifl_flags & MSK_IF_SYMINFO)
3346				ofl->ofl_flags |= FLG_OF_SYMINFO;
3347
3348			/*
3349			 * Guidance: Use -z lazyload/nolazyload.
3350			 * libc is exempt from this advice, because it cannot
3351			 * be lazy loaded, and requests to do so are ignored.
3352			 */
3353			if (OFL_GUIDANCE(ofl, FLG_OFG_NO_LAZY) &&
3354			    ((ifl->ifl_flags & FLG_IF_RTLDINF) == 0)) {
3355				ld_eprintf(ofl, ERR_GUIDANCE,
3356				    MSG_INTL(MSG_GUIDE_LAZYLOAD));
3357				ofl->ofl_guideflags |= FLG_OFG_NO_LAZY;
3358			}
3359
3360			/*
3361			 * Guidance: Use -B direct/nodirect or
3362			 * -z direct/nodirect.
3363			 */
3364			if (OFL_GUIDANCE(ofl, FLG_OFG_NO_DB)) {
3365				ld_eprintf(ofl, ERR_GUIDANCE,
3366				    MSG_INTL(MSG_GUIDE_DIRECT));
3367				ofl->ofl_guideflags |= FLG_OFG_NO_DB;
3368			}
3369
3370			break;
3371		default:
3372			(void) elf_errno();
3373			_rej.rej_type = SGS_REJ_UNKFILE;
3374			_rej.rej_name = name;
3375			DBG_CALL(Dbg_file_rejected(ofl->ofl_lml, &_rej,
3376			    ld_targ.t_m.m_mach));
3377			if (rej->rej_type == 0) {
3378				*rej = _rej;
3379				rej->rej_name = strdup(_rej.rej_name);
3380			}
3381			return (0);
3382		}
3383		break;
3384	default:
3385		(void) elf_errno();
3386		_rej.rej_type = SGS_REJ_UNKFILE;
3387		_rej.rej_name = name;
3388		DBG_CALL(Dbg_file_rejected(ofl->ofl_lml, &_rej,
3389		    ld_targ.t_m.m_mach));
3390		if (rej->rej_type == 0) {
3391			*rej = _rej;
3392			rej->rej_name = strdup(_rej.rej_name);
3393		}
3394		return (0);
3395	}
3396	if ((error == 0) || (error == S_ERROR))
3397		return (error);
3398
3399	if (ifl_ret)
3400		*ifl_ret = ifl;
3401	return (1);
3402}
3403
3404/*
3405 * Having successfully opened a file, set up the necessary elf structures to
3406 * process it further.  This small section of processing is slightly different
3407 * from the elf initialization required to process a relocatable object from an
3408 * archive (see libs.c: ld_process_archive()).
3409 */
3410uintptr_t
3411ld_process_open(const char *opath, const char *ofile, int *fd, Ofl_desc *ofl,
3412    Word flags, Rej_desc *rej, Ifl_desc **ifl_ret)
3413{
3414	Elf		*elf;
3415	const char	*npath = opath;
3416	const char	*nfile = ofile;
3417
3418	if ((elf = elf_begin(*fd, ELF_C_READ, NULL)) == NULL) {
3419		ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_BEGIN), npath);
3420		return (0);
3421	}
3422
3423	/*
3424	 * Determine whether the support library wishes to process this open.
3425	 * The support library may return:
3426	 *   .	a different ELF descriptor (in which case they should have
3427	 *	closed the original)
3428	 *   .	a different file descriptor (in which case they should have
3429	 *	closed the original)
3430	 *   .	a different path and file name (presumably associated with
3431	 *	a different file descriptor)
3432	 *
3433	 * A file descriptor of -1, or and ELF descriptor of zero indicates
3434	 * the file should be ignored.
3435	 */
3436	ld_sup_open(ofl, &npath, &nfile, fd, flags, &elf, NULL, 0,
3437	    elf_kind(elf));
3438
3439	if ((*fd == -1) || (elf == NULL))
3440		return (0);
3441
3442	return (ld_process_ifl(npath, nfile, *fd, elf, flags, ofl, rej,
3443	    ifl_ret));
3444}
3445
3446/*
3447 * Having successfully mapped a file, set up the necessary elf structures to
3448 * process it further.  This routine is patterned after ld_process_open() and
3449 * is only called by ld.so.1(1) to process a relocatable object.
3450 */
3451Ifl_desc *
3452ld_process_mem(const char *path, const char *file, char *addr, size_t size,
3453    Ofl_desc *ofl, Rej_desc *rej)
3454{
3455	Elf		*elf;
3456	uintptr_t	open_ret;
3457	Ifl_desc	*ifl;
3458
3459	if ((elf = elf_memory(addr, size)) == NULL) {
3460		ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_MEMORY), path);
3461		return (0);
3462	}
3463
3464	open_ret = ld_process_ifl(path, file, 0, elf, 0, ofl, rej, &ifl);
3465	if (open_ret != 1)
3466		return ((Ifl_desc *) open_ret);
3467	return (ifl);
3468}
3469
3470/*
3471 * Process a required library (i.e. the dependency of a shared object).
3472 * Combine the directory and filename, check the resultant path size, and try
3473 * opening the pathname.
3474 */
3475static Ifl_desc *
3476process_req_lib(Sdf_desc *sdf, const char *dir, const char *file,
3477    Ofl_desc *ofl, Rej_desc *rej)
3478{
3479	size_t		dlen, plen;
3480	int		fd;
3481	char		path[PATH_MAX];
3482	const char	*_dir = dir;
3483
3484	/*
3485	 * Determine the sizes of the directory and filename to insure we don't
3486	 * exceed our buffer.
3487	 */
3488	if ((dlen = strlen(dir)) == 0) {
3489		_dir = MSG_ORIG(MSG_STR_DOT);
3490		dlen = 1;
3491	}
3492	dlen++;
3493	plen = dlen + strlen(file) + 1;
3494	if (plen > PATH_MAX) {
3495		ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_PTHTOLONG),
3496		    _dir, file);
3497		return (0);
3498	}
3499
3500	/*
3501	 * Build the entire pathname and try and open the file.
3502	 */
3503	(void) strcpy(path, _dir);
3504	(void) strcat(path, MSG_ORIG(MSG_STR_SLASH));
3505	(void) strcat(path, file);
3506	DBG_CALL(Dbg_libs_req(ofl->ofl_lml, sdf->sdf_name,
3507	    sdf->sdf_rfile, path));
3508
3509	if ((fd = open(path, O_RDONLY)) == -1)
3510		return (0);
3511	else {
3512		uintptr_t	open_ret;
3513		Ifl_desc	*ifl;
3514		char		*_path;
3515
3516		if ((_path = libld_malloc(strlen(path) + 1)) == NULL)
3517			return ((Ifl_desc *)S_ERROR);
3518		(void) strcpy(_path, path);
3519		open_ret = ld_process_open(_path, &_path[dlen], &fd, ofl,
3520		    0, rej, &ifl);
3521		if (fd != -1)
3522			(void) close(fd);
3523		if (open_ret != 1)
3524			return ((Ifl_desc *)open_ret);
3525		return (ifl);
3526	}
3527}
3528
3529/*
3530 * Finish any library processing.  Walk the list of so's that have been listed
3531 * as "included" by shared objects we have previously processed.  Examine them,
3532 * without adding them as explicit dependents of this program, in order to
3533 * complete our symbol definition process.  The search path rules are:
3534 *
3535 *  -	use any user supplied paths, i.e. LD_LIBRARY_PATH and -L, then
3536 *
3537 *  -	use any RPATH defined within the parent shared object, then
3538 *
3539 *  -	use the default directories, i.e. LIBPATH or -YP.
3540 */
3541uintptr_t
3542ld_finish_libs(Ofl_desc *ofl)
3543{
3544	Aliste		idx1;
3545	Sdf_desc	*sdf;
3546	Rej_desc	rej = { 0 };
3547
3548	/*
3549	 * Make sure we are back in dynamic mode.
3550	 */
3551	ofl->ofl_flags |= FLG_OF_DYNLIBS;
3552
3553	for (APLIST_TRAVERSE(ofl->ofl_soneed, idx1, sdf)) {
3554		Aliste		idx2;
3555		char		*path, *slash = NULL;
3556		int		fd;
3557		Ifl_desc	*ifl;
3558		char		*file = (char *)sdf->sdf_name;
3559
3560		/*
3561		 * See if this file has already been processed.  At the time
3562		 * this implicit dependency was determined there may still have
3563		 * been more explicit dependencies to process.  Note, if we ever
3564		 * do parse the command line three times we would be able to
3565		 * do all this checking when processing the dynamic section.
3566		 */
3567		if (sdf->sdf_file)
3568			continue;
3569
3570		for (APLIST_TRAVERSE(ofl->ofl_sos, idx2, ifl)) {
3571			if (!(ifl->ifl_flags & FLG_IF_NEEDSTR) &&
3572			    (strcmp(file, ifl->ifl_soname) == 0)) {
3573				sdf->sdf_file = ifl;
3574				break;
3575			}
3576		}
3577		if (sdf->sdf_file)
3578			continue;
3579
3580		/*
3581		 * If the current path name element embeds a "/", then it's to
3582		 * be taken "as is", with no searching involved.  Process all
3583		 * "/" occurrences, so that we can deduce the base file name.
3584		 */
3585		for (path = file; *path; path++) {
3586			if (*path == '/')
3587				slash = path;
3588		}
3589		if (slash) {
3590			DBG_CALL(Dbg_libs_req(ofl->ofl_lml, sdf->sdf_name,
3591			    sdf->sdf_rfile, file));
3592			if ((fd = open(file, O_RDONLY)) == -1) {
3593				ld_eprintf(ofl, ERR_WARNING,
3594				    MSG_INTL(MSG_FIL_NOTFOUND), file,
3595				    sdf->sdf_rfile);
3596			} else {
3597				uintptr_t	open_ret;
3598				Rej_desc	_rej = { 0 };
3599
3600				open_ret = ld_process_open(file, ++slash,
3601				    &fd, ofl, 0, &_rej, &ifl);
3602				if (fd != -1)
3603					(void) close(fd);
3604				if (open_ret == S_ERROR)
3605					return (S_ERROR);
3606
3607				if (_rej.rej_type) {
3608					Conv_reject_desc_buf_t rej_buf;
3609
3610					ld_eprintf(ofl, ERR_WARNING,
3611					    MSG_INTL(reject[_rej.rej_type]),
3612					    _rej.rej_name ? rej.rej_name :
3613					    MSG_INTL(MSG_STR_UNKNOWN),
3614					    conv_reject_desc(&_rej, &rej_buf,
3615					    ld_targ.t_m.m_mach));
3616				} else
3617					sdf->sdf_file = ifl;
3618			}
3619			continue;
3620		}
3621
3622		/*
3623		 * Now search for this file in any user defined directories.
3624		 */
3625		for (APLIST_TRAVERSE(ofl->ofl_ulibdirs, idx2, path)) {
3626			Rej_desc	_rej = { 0 };
3627
3628			ifl = process_req_lib(sdf, path, file, ofl, &_rej);
3629			if (ifl == (Ifl_desc *)S_ERROR) {
3630				return (S_ERROR);
3631			}
3632			if (_rej.rej_type) {
3633				if (rej.rej_type == 0) {
3634					rej = _rej;
3635					rej.rej_name = strdup(_rej.rej_name);
3636				}
3637			}
3638			if (ifl) {
3639				sdf->sdf_file = ifl;
3640				break;
3641			}
3642		}
3643		if (sdf->sdf_file)
3644			continue;
3645
3646		/*
3647		 * Next use the local rules defined within the parent shared
3648		 * object.
3649		 */
3650		if (sdf->sdf_rpath != NULL) {
3651			char	*rpath, *next;
3652
3653			rpath = libld_malloc(strlen(sdf->sdf_rpath) + 1);
3654			if (rpath == NULL)
3655				return (S_ERROR);
3656			(void) strcpy(rpath, sdf->sdf_rpath);
3657			DBG_CALL(Dbg_libs_path(ofl->ofl_lml, rpath,
3658			    LA_SER_RUNPATH, sdf->sdf_rfile));
3659			if ((path = strtok_r(rpath,
3660			    MSG_ORIG(MSG_STR_COLON), &next)) != NULL) {
3661				do {
3662					Rej_desc	_rej = { 0 };
3663
3664					path = expand(sdf->sdf_rfile, path,
3665					    &next);
3666
3667					ifl = process_req_lib(sdf, path,
3668					    file, ofl, &_rej);
3669					if (ifl == (Ifl_desc *)S_ERROR) {
3670						return (S_ERROR);
3671					}
3672					if ((_rej.rej_type) &&
3673					    (rej.rej_type == 0)) {
3674						rej = _rej;
3675						rej.rej_name =
3676						    strdup(_rej.rej_name);
3677					}
3678					if (ifl) {
3679						sdf->sdf_file = ifl;
3680						break;
3681					}
3682				} while ((path = strtok_r(NULL,
3683				    MSG_ORIG(MSG_STR_COLON), &next)) != NULL);
3684			}
3685		}
3686		if (sdf->sdf_file)
3687			continue;
3688
3689		/*
3690		 * Finally try the default library search directories.
3691		 */
3692		for (APLIST_TRAVERSE(ofl->ofl_dlibdirs, idx2, path)) {
3693			Rej_desc	_rej = { 0 };
3694
3695			ifl = process_req_lib(sdf, path, file, ofl, &rej);
3696			if (ifl == (Ifl_desc *)S_ERROR) {
3697				return (S_ERROR);
3698			}
3699			if (_rej.rej_type) {
3700				if (rej.rej_type == 0) {
3701					rej = _rej;
3702					rej.rej_name = strdup(_rej.rej_name);
3703				}
3704			}
3705			if (ifl) {
3706				sdf->sdf_file = ifl;
3707				break;
3708			}
3709		}
3710		if (sdf->sdf_file)
3711			continue;
3712
3713		/*
3714		 * If we've got this far we haven't found the shared object.
3715		 * If an object was found, but was rejected for some reason,
3716		 * print a diagnostic to that effect, otherwise generate a
3717		 * generic "not found" diagnostic.
3718		 */
3719		if (rej.rej_type) {
3720			Conv_reject_desc_buf_t rej_buf;
3721
3722			ld_eprintf(ofl, ERR_WARNING,
3723			    MSG_INTL(reject[rej.rej_type]),
3724			    rej.rej_name ? rej.rej_name :
3725			    MSG_INTL(MSG_STR_UNKNOWN),
3726			    conv_reject_desc(&rej, &rej_buf,
3727			    ld_targ.t_m.m_mach));
3728		} else {
3729			ld_eprintf(ofl, ERR_WARNING,
3730			    MSG_INTL(MSG_FIL_NOTFOUND), file, sdf->sdf_rfile);
3731		}
3732	}
3733
3734	/*
3735	 * Finally, now that all objects have been input, make sure any version
3736	 * requirements have been met.
3737	 */
3738	return (ld_vers_verify(ofl));
3739}
3740